# zerolith Import from `zerolith`. Generated from the source; every signature below is what the published types declare. ## Functions ### onDiagnostic ```ts function onDiagnostic(listener: DiagnosticListener): () => void ``` Subscribes to warnings, deprecations, and info diagnostics. Returns an unsubscribe function. Source: `packages/zerolith/src/diagnostics.ts:174` ### batch ```ts function batch(fn: () => T): T ``` Applies several writes and runs the affected effects once, after `fn` returns. Source: `packages/zerolith/src/signals.ts:850` ### computed ```ts function computed(fn: () => T, options?: SignalOptions): ReadableSignal ``` Creates a lazily evaluated, memoized value derived from other signals. The function must not write signals. Source: `packages/zerolith/src/signals.ts:805` ### effect ```ts function effect(fn: EffectFunction): () => void ``` Runs `fn` now and again whenever a signal it read changes. A returned function is called before the next run and on dispose. Returns the dispose function; the effect is also disposed with its enclosing effect or scope. Source: `packages/zerolith/src/signals.ts:818` ### onDispose ```ts function onDispose(fn: () => void): void ``` Registers `fn` to run when the enclosing effect re-runs or is disposed, or when the enclosing scope is disposed. Source: `packages/zerolith/src/signals.ts:963` ### scope ```ts function scope(fn: () => T): Scope ``` Runs `fn` untracked as the owner of every effect and scope created inside it, so they can be disposed together. Source: `packages/zerolith/src/signals.ts:940` ### signal ```ts function signal(initial: T, options?: SignalOptions): Signal ``` Creates a writable signal. Source: `packages/zerolith/src/signals.ts:780` ### untracked ```ts function untracked(fn: () => T): T ``` Runs `fn` without subscribing the running computed value or effect to the signals it reads. Source: `packages/zerolith/src/signals.ts:868` ### resource ```ts function resource(options: ResourceOptions): Resource ``` Creates a resource owned by the current effect or scope. The resource is a read-only signal of its value, so it binds in a template and drives `when` and `each` like any other signal, with its request state beside it. Source: `packages/zerolith/src/resource.ts:48` ### each ```ts function each(items: ReadableSignal | readonly T[], key: KeyOf, row: RowOf): View ``` Renders one row per item, keyed, updating rows in place when their key survives and moving the fewest nodes when the order changes. The row function receives the item as a signal and, when it declares a second parameter, the position as a signal. Source: `packages/zerolith/src/render.ts:1670` ### html ```ts function html(strings: TemplateStringsArray, ...values: unknown[]): View ``` Describes markup with live bindings. Values are bound as content or inside attribute values. Source: `packages/zerolith/src/render.ts:157` ### hydrate ```ts function hydrate(view: unknown, target: MountTarget): HydrateResult ``` Attaches a view to markup the server rendered into `target`, an element or a selector for one, with `renderToString`, reusing the nodes and binding signals, listeners, properties, and refs. Any disagreement is repaired on the client and returned in `mismatches`. Without server-rendered markup it falls back to `render`. As with `render`, a function that returns the view is called inside the root's owner. Source: `packages/zerolith/src/render.ts:1103` ### render ```ts function render(view: unknown, target: MountTarget): Root ``` Renders a view at the end of `target`, an element or a selector for one, and returns a handle to dispose it. Given a function that returns the view, as in `render(() => App(), "#app")`, it calls the function inside the root's owner, so effects and `onDispose` cleanups the component registers belong to the root and end with `dispose()`. Source: `packages/zerolith/src/render.ts:1059` ### unsafeHtml ```ts function unsafeHtml(markup: string): View ``` Marks a string as markup to insert without escaping. This is the one way to put HTML you already trust into a view, for example content rendered from Markdown you wrote. Never pass user input. Source: `packages/zerolith/src/render.ts:121` ### when ```ts function when(condition: unknown, then: () => unknown, otherwise?: () => unknown): View ``` Renders `then()` while the condition is truthy and `otherwise()` while it is not. The condition is a signal, such as a computed value, or a plain value; a function fails with `when_condition_function`, since it would always count as true. Branches are created lazily and disposed when hidden. Source: `packages/zerolith/src/render.ts:1775` ### css ```ts function css(strings: TemplateStringsArray, ...values: ReadonlyArray): Styles ``` Declares scoped component styles. Values may be numbers or other `css` results; strings are rejected so untrusted text can never become CSS. Source: `packages/zerolith/src/css.ts:100` ### isProblem ```ts function isProblem(value: unknown): value is Problem ``` True for an object that carries at least one problem details member with the right type. Source: `packages/zerolith/src/problem.ts:32` ## Classes ### ZerolithError ```ts class ZerolithError extends Error ``` An error thrown by zerolith. The diagnostic carries the machine-readable detail. - `constructor(record: Diagnostic)`: Builds the message from the record's code, cause, fix, and URL, leaving out a cause or fix that is empty, as both are in production builds. - `readonly diagnostic: Diagnostic`: The record the error was built from, for tools that read its code and arguments as data instead of parsing the message. Source: `packages/zerolith/src/diagnostics.ts:145` ## Interfaces ### Diagnostic ```ts interface Diagnostic ``` A diagnostic as emitted by any part of zerolith. - `code: string`: Stable snake_case identifier, for example `signal_written_inside_computed`. Codes are public API; message text is not. - `severity: DiagnosticSeverity`: The diagnostic's weight; the runtime throws an `error` as a `ZerolithError` and passes every other severity to the `onDiagnostic` listeners. - `cause: string`: One sentence naming what happened. Empty in production builds. - `fix: string`: One sentence naming what to do about it. Empty in production builds. - `url: string`: Documentation page for the code, with the arguments encoded in the query string. - `location?: DiagnosticLocation`: Where the diagnostic points, when the emitter knows: a position in the source or a node in the page. - `suggestion?: DiagnosticSuggestion`: A change that would resolve the diagnostic, when the emitter can name one. - `args?: DiagnosticArgs`: The values the diagnostic is about, such as the name of a refused attribute, kept apart so a tool can word its own text; `url` carries them in its query string. Source: `packages/zerolith/src/diagnostics.ts:50` ### DiagnosticLocation ```ts interface DiagnosticLocation ``` Where a diagnostic points. Source positions are 1-based; `selector` locates a DOM node at runtime. - `file?: string`: The source file the diagnostic points into. - `line?: number`: The 1-based line within `file`. - `column?: number`: The 1-based column within `line`. - `selector?: string`: A CSS selector that finds the node in the page the diagnostic is about, for a diagnostic raised at runtime. Source: `packages/zerolith/src/diagnostics.ts:23` ### DiagnosticSuggestion ```ts interface DiagnosticSuggestion ``` A concrete change that would resolve the diagnostic. - `description: string`: One sentence describing the change. - `replacement?: string`: The replacement source text, when the change is textual. - `applicability: Applicability`: Whether a tool may make the change unreviewed: `machine_applicable` says it may, while `maybe_incorrect` and `has_placeholders` need a person to check or complete it. Source: `packages/zerolith/src/diagnostics.ts:36` ### DiagnosticText ```ts interface DiagnosticText ``` The text of one catalog entry. - `cause: string`: One sentence naming what happened, used as the diagnostic's `cause` and on the code's documentation page. - `fix: string`: One sentence naming what to do about it, used as the diagnostic's `fix` and on the code's documentation page. Source: `packages/zerolith/src/diagnostics.ts:71` ### ReadableSignal ```ts interface ReadableSignal ``` A value that can be read and tracked. - `get(): T`: Returns the current value and subscribes the running computed value or effect to it. Source: `packages/zerolith/src/signals.ts:40` ### Scope ```ts interface Scope ``` The result of `scope()`. - `readonly value: T`: The value the scope function returned. - `dispose(): void`: Disposes every effect and nested scope created inside, in reverse order of creation. Source: `packages/zerolith/src/signals.ts:57` ### Signal ```ts interface Signal extends ReadableSignal ``` A value that can be read, tracked, and written. - `set(value: T): void`: Stores a new value and queues the effects that depend on it. Writes are not allowed inside computed functions. Source: `packages/zerolith/src/signals.ts:47` ### SignalOptions ```ts interface SignalOptions ``` Options accepted by `signal()` and `computed()`. - `equals?: Equals`: Defaults to `Object.is`. - `name?: string`: A label for the dev tools; `zerolith dev` and the Vite plugin also keep a named signal's value across an edit. Source: `packages/zerolith/src/signals.ts:31` ### LoaderContext ```ts interface LoaderContext

``` What the loader receives. - `params: P`: The value `params` returned; never undefined, because undefined skips loading. - `abort: AbortSignal`: Aborted when the params change, on reload, and when the owning scope is disposed. Source: `packages/zerolith/src/resource.ts:11` ### Resource ```ts interface Resource extends ReadableSignal ``` An async value and its request state. - `readonly status: ReadableSignal`: The latest request's state: `idle` while `params` returns `undefined`, `pending` while the loader runs, then `resolved` or `error`. - `readonly pending: ReadableSignal`: True while a request is in flight. - `readonly error: ReadableSignal`: The rejection of the latest request, or undefined. - `get(): T | undefined`: The last resolved value; kept while a newer request is pending. - `reload(): void`: Runs the loader again with the current params. Source: `packages/zerolith/src/resource.ts:29` ### ResourceOptions ```ts interface ResourceOptions ``` What `resource()` takes: a tracked params function and an untracked loader. - `params: () => P | undefined`: Tracked: the signals it reads decide when the loader re-runs. Returning undefined puts the resource in the idle state. - `loader: (context: LoaderContext

) => Promise`: Untracked: fetches the value for the given params. Source: `packages/zerolith/src/resource.ts:20` ### HydrateResult ```ts interface HydrateResult extends Root ``` The handle returned by `hydrate()`. - `readonly mismatches: readonly HydrationMismatch[]`: Every disagreement found; each one was repaired by rendering on the client. Source: `packages/zerolith/src/render.ts:47` ### HydrationMismatch ```ts interface HydrationMismatch ``` One place where the server-rendered markup and the view disagreed. - `kind: "text" | "missing" | "extra" | "structure" | "root"`: `text`: a text node differed; `missing`: expected nodes were absent; `extra`: unexpected nodes were present; `structure`: a template's nodes did not line up; `root`: no server-rendered part was found. - `expected?: string`: What was expected, when known. - `found?: string`: What was found, when known. Source: `packages/zerolith/src/render.ts:36` ### Root ```ts interface Root ``` The handle returned by `render()`. - `readonly container: Element | DocumentFragment`: The element or fragment the view was rendered into. - `dispose(): void`: Removes everything rendered and disposes every effect it created. Source: `packages/zerolith/src/render.ts:27` ### View ```ts interface View ``` A description of UI produced by `html`, `each`, or `when`, or by a component function. - `readonly VIEW: true`: The brand, always `true`. The package does not export its symbol key, so a `View` comes only from `html`, `each`, `when`, or `unsafeHtml`, never from an object literal. Source: `packages/zerolith/src/render.ts:20` ### Styles ```ts interface Styles ``` A stylesheet produced by `css`. Bind it to a root element's class attribute. - `readonly scope: string`: The generated class that selects this component's roots. - `readonly text: string`: The full stylesheet text including the @scope wrapper, for server rendering. - `toString(): string`: The class names to put on a root element: the shared marker plus `scope`. Source: `packages/zerolith/src/css.ts:15` ### Problem ```ts interface Problem ``` An RFC 9457 problem details document with the `fields` extension. - `type?: string`: A URI identifying the problem type; `about:blank` when the status says it all. - `title?: string`: A short human-readable summary. - `status?: number`: The HTTP status code. - `detail?: string`: A human-readable explanation specific to this occurrence. - `instance?: string`: A URI identifying this occurrence. - `fields?: FieldErrors`: Validation messages per field name. Source: `packages/zerolith/src/problem.ts:12` ## Types ### Applicability ```ts type Applicability = "machine_applicable" | "maybe_incorrect" | "has_placeholders" | "unspecified" ``` How safely a suggestion can be applied without a human reading it, following the grades rustc uses for its own suggestions. Source: `packages/zerolith/src/diagnostics.ts:13` ### DiagnosticArgs ```ts type DiagnosticArgs = Readonly> ``` Values interpolated into a diagnostic's text, kept separately so tools can render their own. Source: `packages/zerolith/src/diagnostics.ts:47` ### DiagnosticCode ```ts type DiagnosticCode = "signal_written_inside_computed" | "computed_cycle" | "effect_cycle" | "effect_loop" | "on_dispose_outside_scope" | "binding_in_tag_position" | "binding_in_comment" | "binding_in_raw_text" | "binding_not_single" | "script_in_template" | "template_unclosed_tag" | "unsafe_property_binding" | "unsafe_attribute_binding" | "unsafe_url_blocked" | "unrenderable_value" | "each_items_function" | "event_handler_not_function" | "when_condition_function" | "mount_component_uncalled" | "each_key_undefined" | "each_key_duplicate" | "css_value_not_allowed" | "ref_not_assignable" | "hydration_mismatch" | "jsx_not_lowered" | "template_frozen_read" | "image_without_alt" | "button_without_name" | "frame_without_title" | "mount_target_missing" | "template_not_prepared" | "lazy_module_not_split" | "package_version_mismatch" ``` The codes the runtime can emit. Every code has exactly one catalog entry. Source: `packages/zerolith/src/diagnostics.ts:83` ### DiagnosticListener ```ts type DiagnosticListener = (diagnostic: Diagnostic) => void ``` Receives every non-throwing diagnostic the runtime reports. Source: `packages/zerolith/src/diagnostics.ts:169` ### DiagnosticSeverity ```ts type DiagnosticSeverity = "error" | "warning" | "deprecation" | "info" ``` The weight of a diagnostic. Deprecations are their own class so tooling can count them separately. Source: `packages/zerolith/src/diagnostics.ts:20` ### EffectFunction ```ts type EffectFunction = () => void | (() => void) ``` The function run by `effect()`; it may return a cleanup function. Source: `packages/zerolith/src/signals.ts:54` ### Equals ```ts type Equals = (previous: T, next: T) => boolean ``` Decides whether a new value counts as a change. Source: `packages/zerolith/src/signals.ts:28` ### ResourceStatus ```ts type ResourceStatus = "idle" | "pending" | "resolved" | "error" ``` The lifecycle of a resource's current request. Source: `packages/zerolith/src/resource.ts:8` ### KeyOf ```ts type KeyOf = (item: T, index: number) => string | number | bigint | boolean | symbol | object ``` The key function for `each()`. Source: `packages/zerolith/src/render.ts:1173` ### MountTarget ```ts type MountTarget = Element | DocumentFragment | string ``` Where a view mounts: an element or fragment, or a CSS selector for one element in the document. Source: `packages/zerolith/src/render.ts:1013` ### RowOf ```ts type RowOf = (item: ReadableSignal, index: ReadableSignal) => unknown ``` The row renderer for `each()`. The item is a signal that updates in place; the index is a signal too, created only when the function declares a second parameter. Source: `packages/zerolith/src/render.ts:1176` ### FieldErrors ```ts type FieldErrors = Readonly> ``` Messages per field name, the `fields` extension member of a problem. Source: `packages/zerolith/src/problem.ts:9` ## Constants ### DIAGNOSTIC_URL ```ts const DIAGNOSTIC_URL: string ``` Base of every diagnostic URL; the code is appended as the path. Source: `packages/zerolith/src/diagnostics.ts:80` ### diagnosticCatalog ```ts const diagnosticCatalog: Readonly>> ``` The message text for every diagnostic code. The documentation pages for the codes are generated from this table, so an entry here is the single source of truth for both the message and the docs. Production builds ship an empty catalog, so look entries up with `?.`. Source: `packages/zerolith/src/catalog.ts:10` ### PROBLEM_MEDIA_TYPE ```ts const PROBLEM_MEDIA_TYPE: string ``` The media type of a problem details document. Source: `packages/zerolith/src/problem.ts:29`