@gyral/core 0.2.0 → 0.3.1

package/dist/view/render/hook-run.js

@@ -0,0 +1,72 @@
+// Running element hooks' queued client calls (view/02-bindings.md "Commit order",
+// gyral-1zd.27). Inside a scheduler flush the calls wait until every dirty host has rendered,
+// then run children first: one root's calls in document order, roots in reverse render order
+// (the scheduler renders parents before children), so a parent's hook sees the child components
+// it renders. Outside a flush a `render` call runs its own calls when it returns. Installed by
+// `defineHook`/`defineHook` (hook-part.ts), so apps without hooks bundle none of it.
+import { disposalPass, hookFailure, queue, setCommitting, } from './hooks.js';
+/** Inside a flush: the roots rendered since the last flush of hooks (the queue starts empty). */
+let batch;
+/**
+ * Runs the calls queued since `mark` for `roots`: disposal first (dispose.ts), then each
+ * root's `client` calls in document order, the last-rendered root first. The scheduler renders
+ * parents before children, so children's hooks run first. Each hook on its own: one that
+ * throws doesn't keep the others from running.
+ */
+function runQueued(mark, roots) {
+    try {
+        const dispose = disposalPass();
+        for (const root of roots) {
+            setCommitting(root);
+            dispose?.(root); // disposable hooks whose element left `root` dispose first
+        }
+        const failed = hookFailure();
+        // One root's calls are queued together: walk those runs from the end.
+        for (let end = queue.length; end > mark;) {
+            let start = end - 1;
+            while (start > mark && queue[start - 1]?.owner === queue[end - 1]?.owner)
+                start--;
+            for (let i = start; i < end; i++) {
+                const part = queue[i];
+                try {
+                    part.spec.client(part.el, part.args, part.prev);
+                }
+                catch (error) {
+                    failed(error, part.owner);
+                }
+            }
+            end = start;
+        }
+    }
+    finally {
+        queue.length = mark;
+        setCommitting(undefined);
+    }
+}
+function flush() {
+    if (batch === undefined || batch.length === 0)
+        return;
+    const roots = batch;
+    batch = [];
+    runQueued(0, roots);
+}
+export const runner = {
+    run(mark, root) {
+        if (batch !== undefined)
+            batch.push(root);
+        else
+            runQueued(mark, [root]);
+    },
+    start() {
+        batch = [];
+    },
+    flush,
+    end(ok) {
+        if (ok)
+            flush();
+        else
+            queue.length = 0;
+        batch = undefined;
+    },
+};
+//# sourceMappingURL=hook-run.js.map

package/dist/view/render/hook-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-run.js","sourceRoot":"","sources":["../../../src/view/render/hook-run.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,8FAA8F;AAC9F,6FAA6F;AAC7F,gGAAgG;AAChG,+FAA+F;AAC/F,qFAAqF;AACrF,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,EACL,aAAa,GAId,MAAM,YAAY,CAAC;AAEpB,iGAAiG;AACjG,IAAI,KAAyB,CAAC;AAE9B;;;;;GAKG;AACH,SAAS,SAAS,CAAC,IAAY,EAAE,KAAsB;IACrD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,YAAY,EAAE,CAAC;QAC/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,aAAa,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,2DAA2D;QAC9E,CAAC;QACD,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;QAC7B,sEAAsE;QACtE,KAAK,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,GAAG,CAAC;YACzC,IAAI,KAAK,GAAG,GAAG,GAAG,CAAC,CAAC;YACpB,OAAO,KAAK,GAAG,IAAI,IAAI,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,KAAK;gBAAE,KAAK,EAAE,CAAC;YAClF,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;gBACjC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAa,CAAC;gBAClC,IAAI,CAAC;oBACF,IAAI,CAAC,IAAqC,CAAC,MAAM,CAChD,IAAI,CAAC,EAAE,EACP,IAAI,CAAC,IAA0B,EAC/B,IAAI,CAAC,IAAI,CACV,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,KAAa,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;YACD,GAAG,GAAG,KAAK,CAAC;QACd,CAAC;IACH,CAAC;YAAS,CAAC;QACT,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;QACpB,aAAa,CAAC,SAAS,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC;AAED,SAAS,KAAK;IACZ,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACtD,MAAM,KAAK,GAAG,KAAK,CAAC;IACpB,KAAK,GAAG,EAAE,CAAC;IACX,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACtB,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAe;IAChC,GAAG,CAAC,IAAI,EAAE,IAAI;QACZ,IAAI,KAAK,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;YACrC,SAAS,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,KAAK;QACH,KAAK,GAAG,EAAE,CAAC;IACb,CAAC;IACD,KAAK;IACL,GAAG,CAAC,EAAE;QACJ,IAAI,EAAE;YAAE,KAAK,EAAE,CAAC;;YACX,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACtB,KAAK,GAAG,SAAS,CAAC;IACpB,CAAC;CACF,CAAC","sourcesContent":["// Running element hooks' queued client calls (view/02-bindings.md \"Commit order\",\n// gyral-1zd.27). Inside a scheduler flush the calls wait until every dirty host has rendered,\n// then run children first: one root's calls in document order, roots in reverse render order\n// (the scheduler renders parents before children), so a parent's hook sees the child components\n// it renders. Outside a flush a `render` call runs its own calls when it returns. Installed by\n// `defineHook`/`defineHook` (hook-part.ts), so apps without hooks bundle none of it.\nimport {\n  disposalPass,\n  hookFailure,\n  queue,\n  setCommitting,\n  type HookPart,\n  type HookRunner,\n  type HookSpec,\n} from './hooks.js';\n\n/** Inside a flush: the roots rendered since the last flush of hooks (the queue starts empty). */\nlet batch: Node[] | undefined;\n\n/**\n * Runs the calls queued since `mark` for `roots`: disposal first (dispose.ts), then each\n * root's `client` calls in document order, the last-rendered root first. The scheduler renders\n * parents before children, so children's hooks run first. Each hook on its own: one that\n * throws doesn't keep the others from running.\n */\nfunction runQueued(mark: number, roots: readonly Node[]): void {\n  try {\n    const dispose = disposalPass();\n    for (const root of roots) {\n      setCommitting(root);\n      dispose?.(root); // disposable hooks whose element left `root` dispose first\n    }\n    const failed = hookFailure();\n    // One root's calls are queued together: walk those runs from the end.\n    for (let end = queue.length; end > mark;) {\n      let start = end - 1;\n      while (start > mark && queue[start - 1]?.owner === queue[end - 1]?.owner) start--;\n      for (let i = start; i < end; i++) {\n        const part = queue[i] as HookPart;\n        try {\n          (part.spec as HookSpec<readonly unknown[]>).client(\n            part.el,\n            part.args as readonly unknown[],\n            part.prev,\n          );\n        } catch (error) {\n          failed(error, part.owner as Node);\n        }\n      }\n      end = start;\n    }\n  } finally {\n    queue.length = mark;\n    setCommitting(undefined);\n  }\n}\n\nfunction flush(): void {\n  if (batch === undefined || batch.length === 0) return;\n  const roots = batch;\n  batch = [];\n  runQueued(0, roots);\n}\n\nexport const runner: HookRunner = {\n  run(mark, root) {\n    if (batch !== undefined) batch.push(root);\n    else runQueued(mark, [root]);\n  },\n  start() {\n    batch = [];\n  },\n  flush,\n  end(ok) {\n    if (ok) flush();\n    else queue.length = 0;\n    batch = undefined;\n  },\n};\n"]}

package/dist/view/render/hooks.d.ts

@@ -0,0 +1,108 @@
+declare const HOOK: unique symbol;
+/** Internal: a hook result's commit function (hook-part.ts), so apps without hooks skip it. */
+export declare const COMMIT_HOOK: unique symbol;
+/** Attributes a hook's server half adds to the start tag (`true`: present, no value). */
+export type HookAttributes = Readonly<Record<string, string | true>>;
+export interface HookSpec<A extends readonly unknown[]> {
+    /** Attributes for the server-rendered start tag (view/06-server.md). */
+    server?(args: A): HookAttributes;
+    /** Runs after the commit when `args` changed; `prev` is undefined the first time. */
+    client(el: Element, args: A, prev: A | undefined): void;
+    /**
+     * When `client` runs again: `'args'` (the default) when an argument changed (`Object.is`),
+     * `'always'` on every render that commits the hook's position (a skipped `each` row doesn't).
+     */
+    readonly update?: 'args' | 'always';
+    /**
+     * Teardown, with the last arguments `client` got (view/02 "Widgets with a lifecycle"): runs
+     * when Gyral removes the element, when the position stops holding this hook, or when the host
+     * disconnects (not on moves). After a host reconnects, `client` runs again with `prev`
+     * undefined.
+     */
+    dispose?(el: Element, args: A): void;
+}
+/** What a hook returns in a template: `<input ${invalid(errors)}>`. */
+export interface HookResult<A extends readonly unknown[] = readonly unknown[]> {
+    readonly [HOOK]: HookSpec<A>;
+    readonly [COMMIT_HOOK]: (part: HookPart, result: HookResult) => void;
+    readonly args: A;
+}
+/** A hook position as committing sees it (an element part of kind HOOK). */
+export interface HookPart {
+    readonly el: Element;
+    spec: HookSpec<readonly unknown[]> | null;
+    args: readonly unknown[] | undefined;
+    prev: readonly unknown[] | undefined;
+    /** dispose.ts: the tracked disposable hook, its last arguments, and whether a disconnect
+     * disposed it (`client` runs again after the next render). */
+    kept?: HookSpec<readonly unknown[]> | undefined;
+    keptArgs?: readonly unknown[] | undefined;
+    off?: boolean | undefined;
+    /** The render root it was queued for (hook-run.ts: failures, order). */
+    owner?: Node | undefined;
+}
+export declare const isHook: (value: unknown) => value is HookResult;
+/** The spec of a hook result, or undefined for anything else. */
+export declare const hookSpec: (value: unknown) => HookSpec<readonly unknown[]> | undefined;
+/** Internal (hook-part.ts): a hook result. */
+export declare const hookResult: <A extends readonly unknown[]>(spec: HookSpec<A>, args: A, commit: HookResult[typeof COMMIT_HOOK]) => HookResult<A>;
+/** Shallow comparison of two argument lists, `Object.is` per argument. */
+export declare function sameArgs(a: readonly unknown[], b: readonly unknown[] | undefined): boolean;
+/**
+ * Hook disposal (dispose.ts), set when the first disposable hook commits: `disposal(root)`
+ * after a render of `root` commits (before its client calls), `disposal(root, true)` when the
+ * host owning `root` disconnects (true when hooks wait to run `client` again after the next
+ * render). A plain variable, not an object, to keep apps without it small.
+ */
+declare let disposal: ((root: Node, disconnect?: boolean) => boolean) | undefined;
+/** Internal (dispose.ts): turns hook disposal on. */
+export declare function useDisposal(run: (root: Node, disconnect?: boolean) => boolean): void;
+/** How a hook with `dispose` commits (dispose.ts `commitTracked`), once registered. */
+export declare let disposableCommit: ((part: HookPart, result: HookResult) => void) | undefined;
+/** Internal (`#spec-features`, use-disposal.ts): registers hook disposal. */
+export declare function useDisposableHooks(commit: (part: HookPart, result: HookResult) => void): void;
+/** The host owning `root` disconnected (element.ts): disposes its disposable hooks. */
+export declare const suspendHooks: (root: Node | undefined) => boolean | undefined;
+/** Internal (hook-run.ts): queued client calls. */
+export declare const queue: HookPart[];
+/** Queues `part`'s client call for the end of the render, or of the flush. */
+export declare function queueHook(part: HookPart): void;
+/** The root being committed (dispose.ts tracks disposable hooks per root). */
+export declare const committing: () => Node | undefined;
+/** Internal (hook-run.ts): sets the root being committed (disposal re-queues hooks for it). */
+export declare function setCommitting(root: Node | undefined): void;
+/** The queue position before a render of `root`, for `runHooks`/`dropHooks`. */
+export declare function hookMark(root: Node): number;
+/** Internal (core's element.ts): reports hook failures. */
+export declare function onHookFailure(report: (error: unknown, root: Node) => void): void;
+/** Internal (hook-run.ts): where failures go, and the disposal pass. */
+export declare const hookFailure: () => ((error: unknown, root: Node) => void);
+export declare const disposalPass: () => typeof disposal;
+/**
+ * What runs queued client calls (hook-run.ts): ordering, batching across a flush, failures.
+ * Set by `defineHook`, so apps without hooks bundle none of it; without
+ * hooks nothing is ever queued.
+ */
+export interface HookRunner {
+    /** `root` committed: run its calls now, or note it for the end of the flush. */
+    run(mark: number, root: Node): void;
+    /** A flush starts. */
+    start(): void;
+    /** Runs the calls of every root rendered in the flush so far. */
+    flush(): void;
+    /** A flush ends: runs what's left (or drops it when the flush threw). */
+    end(ok: boolean): void;
+}
+/** Internal (hook-part.ts): installs the runner. */
+export declare function useHookRunner(run: HookRunner): void;
+/** `root` committed: its queued `client` calls run now, or with the flush's (hook-run.ts). */
+export declare function runHooks(mark: number, root: Node): void;
+/** A flush starts (render.ts `renderBatch`). */
+export declare function startHooks(): void;
+/** Runs the hooks of every root rendered in this flush so far (the scheduler, after each pass). */
+export declare function flushHooks(): void;
+/** A flush ends. */
+export declare function endHooks(ok: boolean): void;
+/** Forgets the calls queued since `mark` (the render threw). */
+export declare function dropHooks(mark: number): void;
+export {};

package/dist/view/render/hooks.js

@@ -0,0 +1,108 @@
+// Element hooks (view/02-bindings.md "Element hooks", "Commit order"): their types and the
+// queue of client calls. A hook position (attr-parts.ts, kind HOOK) queues itself when its
+// arguments change (shallow `Object.is` per argument, hook-part.ts, which also holds
+// `defineHook`), or on every commit with `update: 'always'`. Inside a scheduler flush
+// (`renderBatch`) the queued `client` calls wait until every dirty host has rendered, then run
+// children first, each root's calls in document order (hook-run.ts), so a parent's hook sees its
+// child components rendered (view/02 "Commit order"). A `render` call outside a flush runs its
+// own calls when it returns, in document order.
+// A hook whose spec has `dispose` runs it when the element leaves its render root (Gyral removed
+// it: its part cleared, its instance replaced, its row removed), when the position stops holding
+// the hook, or when the host disconnects; not on moves. That machinery (dispose.ts) is reached
+// through `disposableCommit`, filled by core's `#spec-features` (every build without the preset)
+// or, with the preset, only when some module names `dispose` (compiler/features.ts): apps whose
+// hooks have no teardown don't bundle it (gyral-c5d.2, gyral-1zd.24) and pay one empty check per
+// render and per disconnect.
+const HOOK = Symbol('gyral.hook');
+/** Internal: a hook result's commit function (hook-part.ts), so apps without hooks skip it. */
+export const COMMIT_HOOK = Symbol('gyral.hook.commit');
+export const isHook = (value) => typeof value === 'object' && value !== null && HOOK in value;
+/** The spec of a hook result, or undefined for anything else. */
+export const hookSpec = (value) => isHook(value) ? value[HOOK] : undefined;
+/** Internal (hook-part.ts): a hook result. */
+export const hookResult = (spec, args, commit) => ({ [HOOK]: spec, [COMMIT_HOOK]: commit, args });
+/** Shallow comparison of two argument lists, `Object.is` per argument. */
+export function sameArgs(a, b) {
+    if (b === undefined || a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (!Object.is(a[i], b[i]))
+            return false;
+    return true;
+}
+/**
+ * Hook disposal (dispose.ts), set when the first disposable hook commits: `disposal(root)`
+ * after a render of `root` commits (before its client calls), `disposal(root, true)` when the
+ * host owning `root` disconnects (true when hooks wait to run `client` again after the next
+ * render). A plain variable, not an object, to keep apps without it small.
+ */
+let disposal;
+/** Internal (dispose.ts): turns hook disposal on. */
+export function useDisposal(run) {
+    disposal = run;
+}
+/** How a hook with `dispose` commits (dispose.ts `commitTracked`), once registered. */
+export let disposableCommit;
+/** Internal (`#spec-features`, use-disposal.ts): registers hook disposal. */
+export function useDisposableHooks(commit) {
+    disposableCommit = commit;
+}
+/** The host owning `root` disconnected (element.ts): disposes its disposable hooks. */
+export const suspendHooks = (root) => disposal?.(root, true);
+/** Internal (hook-run.ts): queued client calls. */
+export const queue = [];
+/** The root being committed, so `queueHook` knows the owner. */
+let current;
+/** Queues `part`'s client call for the end of the render, or of the flush. */
+export function queueHook(part) {
+    part.owner = current;
+    queue.push(part);
+}
+/** The root being committed (dispose.ts tracks disposable hooks per root). */
+export const committing = () => current;
+/** Internal (hook-run.ts): sets the root being committed (disposal re-queues hooks for it). */
+export function setCommitting(root) {
+    current = root;
+}
+/** The queue position before a render of `root`, for `runHooks`/`dropHooks`. */
+export function hookMark(root) {
+    current = root;
+    return queue.length;
+}
+/** Where a hook's failure goes (core reports it, ADR 0024); unset, `reportError`. */
+let hookFailed;
+/** Internal (core's element.ts): reports hook failures. */
+export function onHookFailure(report) {
+    hookFailed = report;
+}
+/** Internal (hook-run.ts): where failures go, and the disposal pass. */
+export const hookFailure = () => hookFailed ?? reportError;
+export const disposalPass = () => disposal;
+let runner;
+/** Internal (hook-part.ts): installs the runner. */
+export function useHookRunner(run) {
+    runner = run;
+}
+/** `root` committed: its queued `client` calls run now, or with the flush's (hook-run.ts). */
+export function runHooks(mark, root) {
+    current = undefined;
+    runner?.run(mark, root);
+}
+/** A flush starts (render.ts `renderBatch`). */
+export function startHooks() {
+    runner?.start();
+}
+/** Runs the hooks of every root rendered in this flush so far (the scheduler, after each pass). */
+export function flushHooks() {
+    runner?.flush();
+}
+/** A flush ends. */
+export function endHooks(ok) {
+    runner?.end(ok);
+}
+/** Forgets the calls queued since `mark` (the render threw). */
+export function dropHooks(mark) {
+    queue.length = mark;
+    current = undefined;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/view/render/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/view/render/hooks.ts"],"names":[],"mappings":"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","sourcesContent":["// Element hooks (view/02-bindings.md \"Element hooks\", \"Commit order\"): their types and the\n// queue of client calls. A hook position (attr-parts.ts, kind HOOK) queues itself when its\n// arguments change (shallow `Object.is` per argument, hook-part.ts, which also holds\n// `defineHook`), or on every commit with `update: 'always'`. Inside a scheduler flush\n// (`renderBatch`) the queued `client` calls wait until every dirty host has rendered, then run\n// children first, each root's calls in document order (hook-run.ts), so a parent's hook sees its\n// child components rendered (view/02 \"Commit order\"). A `render` call outside a flush runs its\n// own calls when it returns, in document order.\n// A hook whose spec has `dispose` runs it when the element leaves its render root (Gyral removed\n// it: its part cleared, its instance replaced, its row removed), when the position stops holding\n// the hook, or when the host disconnects; not on moves. That machinery (dispose.ts) is reached\n// through `disposableCommit`, filled by core's `#spec-features` (every build without the preset)\n// or, with the preset, only when some module names `dispose` (compiler/features.ts): apps whose\n// hooks have no teardown don't bundle it (gyral-c5d.2, gyral-1zd.24) and pay one empty check per\n// render and per disconnect.\n\nconst HOOK: unique symbol = Symbol('gyral.hook');\n/** Internal: a hook result's commit function (hook-part.ts), so apps without hooks skip it. */\nexport const COMMIT_HOOK: unique symbol = Symbol('gyral.hook.commit');\n\n/** Attributes a hook's server half adds to the start tag (`true`: present, no value). */\nexport type HookAttributes = Readonly<Record<string, string | true>>;\n\nexport interface HookSpec<A extends readonly unknown[]> {\n  /** Attributes for the server-rendered start tag (view/06-server.md). */\n  server?(args: A): HookAttributes;\n  /** Runs after the commit when `args` changed; `prev` is undefined the first time. */\n  client(el: Element, args: A, prev: A | undefined): void;\n  /**\n   * When `client` runs again: `'args'` (the default) when an argument changed (`Object.is`),\n   * `'always'` on every render that commits the hook's position (a skipped `each` row doesn't).\n   */\n  readonly update?: 'args' | 'always';\n  /**\n   * Teardown, with the last arguments `client` got (view/02 \"Widgets with a lifecycle\"): runs\n   * when Gyral removes the element, when the position stops holding this hook, or when the host\n   * disconnects (not on moves). After a host reconnects, `client` runs again with `prev`\n   * undefined.\n   */\n  dispose?(el: Element, args: A): void;\n}\n\n/** What a hook returns in a template: `<input ${invalid(errors)}>`. */\nexport interface HookResult<A extends readonly unknown[] = readonly unknown[]> {\n  readonly [HOOK]: HookSpec<A>;\n  readonly [COMMIT_HOOK]: (part: HookPart, result: HookResult) => void;\n  readonly args: A;\n}\n\n/** A hook position as committing sees it (an element part of kind HOOK). */\nexport interface HookPart {\n  readonly el: Element;\n  spec: HookSpec<readonly unknown[]> | null;\n  args: readonly unknown[] | undefined;\n  prev: readonly unknown[] | undefined;\n  /** dispose.ts: the tracked disposable hook, its last arguments, and whether a disconnect\n   * disposed it (`client` runs again after the next render). */\n  kept?: HookSpec<readonly unknown[]> | undefined;\n  keptArgs?: readonly unknown[] | undefined;\n  off?: boolean | undefined;\n  /** The render root it was queued for (hook-run.ts: failures, order). */\n  owner?: Node | undefined;\n}\n\nexport const isHook = (value: unknown): value is HookResult =>\n  typeof value === 'object' && value !== null && HOOK in value;\n\n/** The spec of a hook result, or undefined for anything else. */\nexport const hookSpec = (value: unknown): HookSpec<readonly unknown[]> | undefined =>\n  isHook(value) ? value[HOOK] : undefined;\n\n/** Internal (hook-part.ts): a hook result. */\nexport const hookResult = <A extends readonly unknown[]>(\n  spec: HookSpec<A>,\n  args: A,\n  commit: HookResult[typeof COMMIT_HOOK],\n): HookResult<A> => ({ [HOOK]: spec, [COMMIT_HOOK]: commit, args });\n\n/** Shallow comparison of two argument lists, `Object.is` per argument. */\nexport function sameArgs(a: readonly unknown[], b: readonly unknown[] | undefined): boolean {\n  if (b === undefined || a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;\n  return true;\n}\n\n/**\n * Hook disposal (dispose.ts), set when the first disposable hook commits: `disposal(root)`\n * after a render of `root` commits (before its client calls), `disposal(root, true)` when the\n * host owning `root` disconnects (true when hooks wait to run `client` again after the next\n * render). A plain variable, not an object, to keep apps without it small.\n */\nlet disposal: ((root: Node, disconnect?: boolean) => boolean) | undefined;\n\n/** Internal (dispose.ts): turns hook disposal on. */\nexport function useDisposal(run: (root: Node, disconnect?: boolean) => boolean): void {\n  disposal = run;\n}\n\n/** How a hook with `dispose` commits (dispose.ts `commitTracked`), once registered. */\nexport let disposableCommit: ((part: HookPart, result: HookResult) => void) | undefined;\n\n/** Internal (`#spec-features`, use-disposal.ts): registers hook disposal. */\nexport function useDisposableHooks(commit: (part: HookPart, result: HookResult) => void): void {\n  disposableCommit = commit;\n}\n\n/** The host owning `root` disconnected (element.ts): disposes its disposable hooks. */\nexport const suspendHooks = (root: Node | undefined): boolean | undefined =>\n  disposal?.(root as Node, true);\n\n/** Internal (hook-run.ts): queued client calls. */\nexport const queue: HookPart[] = [];\n/** The root being committed, so `queueHook` knows the owner. */\nlet current: Node | undefined;\n\n/** Queues `part`'s client call for the end of the render, or of the flush. */\nexport function queueHook(part: HookPart): void {\n  part.owner = current;\n  queue.push(part);\n}\n\n/** The root being committed (dispose.ts tracks disposable hooks per root). */\nexport const committing = (): Node | undefined => current;\n\n/** Internal (hook-run.ts): sets the root being committed (disposal re-queues hooks for it). */\nexport function setCommitting(root: Node | undefined): void {\n  current = root;\n}\n\n/** The queue position before a render of `root`, for `runHooks`/`dropHooks`. */\nexport function hookMark(root: Node): number {\n  current = root;\n  return queue.length;\n}\n\n/** Where a hook's failure goes (core reports it, ADR 0024); unset, `reportError`. */\nlet hookFailed: ((error: unknown, root: Node) => void) | undefined;\n\n/** Internal (core's element.ts): reports hook failures. */\nexport function onHookFailure(report: (error: unknown, root: Node) => void): void {\n  hookFailed = report;\n}\n\n/** Internal (hook-run.ts): where failures go, and the disposal pass. */\nexport const hookFailure = (): ((error: unknown, root: Node) => void) => hookFailed ?? reportError;\nexport const disposalPass = (): typeof disposal => disposal;\n\n/**\n * What runs queued client calls (hook-run.ts): ordering, batching across a flush, failures.\n * Set by `defineHook`, so apps without hooks bundle none of it; without\n * hooks nothing is ever queued.\n */\nexport interface HookRunner {\n  /** `root` committed: run its calls now, or note it for the end of the flush. */\n  run(mark: number, root: Node): void;\n  /** A flush starts. */\n  start(): void;\n  /** Runs the calls of every root rendered in the flush so far. */\n  flush(): void;\n  /** A flush ends: runs what's left (or drops it when the flush threw). */\n  end(ok: boolean): void;\n}\n\nlet runner: HookRunner | undefined;\n\n/** Internal (hook-part.ts): installs the runner. */\nexport function useHookRunner(run: HookRunner): void {\n  runner = run;\n}\n\n/** `root` committed: its queued `client` calls run now, or with the flush's (hook-run.ts). */\nexport function runHooks(mark: number, root: Node): void {\n  current = undefined;\n  runner?.run(mark, root);\n}\n\n/** A flush starts (render.ts `renderBatch`). */\nexport function startHooks(): void {\n  runner?.start();\n}\n\n/** Runs the hooks of every root rendered in this flush so far (the scheduler, after each pass). */\nexport function flushHooks(): void {\n  runner?.flush();\n}\n\n/** A flush ends. */\nexport function endHooks(ok: boolean): void {\n  runner?.end(ok);\n}\n\n/** Forgets the calls queued since `mark` (the render threw). */\nexport function dropHooks(mark: number): void {\n  queue.length = mark;\n  current = undefined;\n}\n"]}

package/dist/view/render/hydrate.d.ts

@@ -0,0 +1,10 @@
+import { type SeenMarkup } from './seen.js';
+import type { ChildValue } from './values.js';
+/**
+ * Hydrates the server-rendered DOM in `root` with `value`, the first client render
+ * (view/07-hydration.md): builds the parts over the existing nodes, runs element hooks' client
+ * halves once, and leaves later `render` calls to update in place. Throws `HydrationMismatch`
+ * when the DOM doesn't match; `host` names the component in its message; `seen` is as for
+ * `render`.
+ */
+export declare function hydrate(value: ChildValue, root: Element | ShadowRoot, host?: string, seen?: SeenMarkup): void;

package/dist/view/render/hydrate.js

@@ -0,0 +1,33 @@
+// `hydrate(value, root)` (view/07-hydration.md): the first client render of server-rendered DOM.
+// Kept apart from render.ts so the walk (adopt.ts) is bundled only where hydration is used: core
+// loads it lazily, with the first server-rendered host (07 "Loading").
+import { adopt } from './adopt.js';
+import { ChildPart } from './child-part.js';
+import { dropHooks, hookMark, runHooks } from './hooks.js';
+import { setRootPart } from './render.js';
+import { listenFor } from './seen.js';
+/**
+ * Hydrates the server-rendered DOM in `root` with `value`, the first client render
+ * (view/07-hydration.md): builds the parts over the existing nodes, runs element hooks' client
+ * halves once, and leaves later `render` calls to update in place. Throws `HydrationMismatch`
+ * when the DOM doesn't match; `host` names the component in its message; `seen` is as for
+ * `render`.
+ */
+export function hydrate(value, root, host = 'the root', seen) {
+    const part = new ChildPart(root, null, null, 0, false, 0);
+    const mark = hookMark(root);
+    const outer = listenFor(seen);
+    try {
+        adopt(part, value, root, host);
+    }
+    catch (error) {
+        dropHooks(mark);
+        throw error;
+    }
+    finally {
+        listenFor(outer);
+    }
+    setRootPart(root, part);
+    runHooks(mark, root);
+}
+//# sourceMappingURL=hydrate.js.map

package/dist/view/render/hydrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.js","sourceRoot":"","sources":["../../../src/view/render/hydrate.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,iGAAiG;AACjG,uEAAuE;AACvE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAmB,MAAM,WAAW,CAAC;AAGvD;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CACrB,KAAiB,EACjB,IAA0B,EAC1B,IAAI,GAAG,UAAU,EACjB,IAAiB;IAEjB,MAAM,IAAI,GAAG,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC5B,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAC;QACH,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,SAAS,CAAC,IAAI,CAAC,CAAC;QAChB,MAAM,KAAK,CAAC;IACd,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IACD,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACvB,CAAC","sourcesContent":["// `hydrate(value, root)` (view/07-hydration.md): the first client render of server-rendered DOM.\n// Kept apart from render.ts so the walk (adopt.ts) is bundled only where hydration is used: core\n// loads it lazily, with the first server-rendered host (07 \"Loading\").\nimport { adopt } from './adopt.js';\nimport { ChildPart } from './child-part.js';\nimport { dropHooks, hookMark, runHooks } from './hooks.js';\nimport { setRootPart } from './render.js';\nimport { listenFor, type SeenMarkup } from './seen.js';\nimport type { ChildValue } from './values.js';\n\n/**\n * Hydrates the server-rendered DOM in `root` with `value`, the first client render\n * (view/07-hydration.md): builds the parts over the existing nodes, runs element hooks' client\n * halves once, and leaves later `render` calls to update in place. Throws `HydrationMismatch`\n * when the DOM doesn't match; `host` names the component in its message; `seen` is as for\n * `render`.\n */\nexport function hydrate(\n  value: ChildValue,\n  root: Element | ShadowRoot,\n  host = 'the root',\n  seen?: SeenMarkup,\n): void {\n  const part = new ChildPart(root, null, null, 0, false, 0);\n  const mark = hookMark(root);\n  const outer = listenFor(seen);\n  try {\n    adopt(part, value, root, host);\n  } catch (error) {\n    dropHooks(mark);\n    throw error;\n  } finally {\n    listenFor(outer);\n  }\n  setRootPart(root, part);\n  runHooks(mark, root);\n}\n"]}

package/dist/view/render/instance.d.ts

@@ -0,0 +1,33 @@
+import type { TemplateObject } from '../normalize/types.js';
+import { type Part } from './attr-parts.js';
+import { ChildPart, type Owner } from './child-part.js';
+/** The DOM cloned from one template, plus its parts. */
+export declare class Instance implements Owner {
+    readonly template: TemplateObject;
+    /** The result source last rendered (strings array or compiled object), for a fast compare. */
+    source: unknown;
+    /** The child part whose content this instance is. */
+    readonly holder: ChildPart;
+    readonly parts: Part[];
+    /** First and last static root nodes; null when the template is a single hole. */
+    start: Node | null;
+    end: Node | null;
+    /** Root-level child parts before the first / after the last static root node. */
+    head: ChildPart | null;
+    tail: ChildPart | null;
+    /** The clone, until it is inserted. */
+    frag: DocumentFragment | null;
+    /** `adopt`: hydration (adopt.ts) fills the parts and root nodes from server DOM instead. */
+    constructor(template: TemplateObject, source: unknown, holder: ChildPart, adopt?: boolean);
+    private build;
+    /** Commits this render's values, part by part in document order. */
+    update(values: readonly unknown[]): void;
+    /** Inserts the (committed) clone; afterwards root-level parts resolve through the holder. */
+    insert(parent: Node, before: Node | null): void;
+    first(): Node | null;
+    last(): Node | null;
+    remove(): void;
+    /** Owner of root-level open parts: the clone while building, then the holder's parent. */
+    parentFor(): Node;
+    endFor(): Node | null;
+}

package/dist/view/render/instance.js

@@ -0,0 +1,107 @@
+import { attrPart } from './attr-parts.js';
+import { ChildPart } from './child-part.js';
+import { removeRange } from './nodes.js';
+import { report } from './seen.js';
+import { CHILD, nodes, planOf, ROOT, stack, walk } from './plan.js';
+/** The DOM cloned from one template, plus its parts. */
+export class Instance {
+    /** `adopt`: hydration (adopt.ts) fills the parts and root nodes from server DOM instead. */
+    constructor(template, source, holder, adopt) {
+        this.template = template;
+        this.source = source;
+        this.holder = holder;
+        this.parts = [];
+        this.head = null;
+        this.tail = null;
+        this.frag = this.start = this.end = null;
+        report(template);
+        if (adopt === true)
+            return;
+        const plan = planOf(template);
+        if (plan.single) {
+            const root = document.importNode(plan.content.firstChild, true);
+            stack[1] = root;
+            this.start = this.end = root;
+        }
+        else {
+            const frag = document.importNode(plan.content, true);
+            stack[0] = frag;
+            this.frag = frag;
+            this.start = frag.firstChild;
+            this.end = frag.lastChild;
+        }
+        walk(plan);
+        this.build(plan);
+    }
+    build(plan) {
+        const { a, b, at, kinds } = plan;
+        const specs = this.template.parts;
+        for (let i = 0; i < kinds.length; i++) {
+            const kind = kinds[i];
+            const node = nodes[a[i]];
+            if (kind >= 0) {
+                this.parts.push(attrPart(node, kind, specs[i], at[i]));
+                continue;
+            }
+            const r = b[i];
+            const ref = r >= 0 ? nodes[r] : null;
+            if (kind !== ROOT) {
+                this.parts.push(new ChildPart(node, ref, null, 0, kind !== CHILD, at[i]));
+                continue;
+            }
+            const part = new ChildPart(null, ref, ref === null ? this : null, 0, false, at[i]);
+            if (ref === null)
+                this.tail = part;
+            else if (ref === this.start)
+                this.head = part;
+            this.parts.push(part);
+        }
+    }
+    /** Commits this render's values, part by part in document order. */
+    update(values) {
+        const parts = this.parts;
+        for (let i = 0; i < parts.length; i++)
+            parts[i].set(values);
+    }
+    /** Inserts the (committed) clone; afterwards root-level parts resolve through the holder. */
+    insert(parent, before) {
+        parent.insertBefore(this.frag ?? this.start, before);
+        this.frag = null;
+    }
+    first() {
+        const head = this.head !== null ? this.head.first() : null;
+        if (head !== null)
+            return head;
+        if (this.start !== null)
+            return this.start;
+        return this.tail !== null ? this.tail.first() : null;
+    }
+    last() {
+        const tail = this.tail !== null ? this.tail.last() : null;
+        if (tail !== null)
+            return tail;
+        if (this.end !== null)
+            return this.end;
+        return this.head !== null ? this.head.last() : null;
+    }
+    remove() {
+        const first = this.first();
+        if (first === null)
+            return;
+        const last = this.last();
+        if (first === last)
+            first.remove();
+        else
+            removeRange(first, last);
+    }
+    /** Owner of root-level open parts: the clone while building, then the holder's parent. */
+    parentFor() {
+        if (this.frag !== null)
+            return this.frag;
+        return this.start !== null ? this.start.parentNode : this.holder.parent();
+    }
+    endFor() {
+        return this.frag !== null ? null : this.holder.end();
+    }
+}
+//# sourceMappingURL=instance.js.map

package/dist/view/render/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../src/view/render/instance.ts"],"names":[],"mappings":"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","sourcesContent":["// Template instances (view/01-templates.md \"Instantiation\", view/02-bindings.md \"Commit order\").\n// An instance is cloned with `document.importNode` (nested custom elements upgrade at once),\n// every part's nodes are resolved from the clone first by child-index paths (firstChild/\n// nextSibling, sharing prefixes; no TreeWalker, no marker search), then the values commit while\n// the clone is still detached, and only then is it inserted, so child components connect with\n// their props set. A template with one root node and no root-level holes clones just that node.\n// How to reach the nodes, and what each part is, comes from the template's plan (plan.ts).\n// Hydration (adopt.ts) creates instances with `adopt` set and fills them from server DOM.\nimport type { PartSpec, TemplateObject } from '../normalize/types.js';\nimport { attrPart, type Part } from './attr-parts.js';\nimport { ChildPart, type Owner } from './child-part.js';\nimport { removeRange } from './nodes.js';\nimport { report } from './seen.js';\nimport { CHILD, nodes, planOf, ROOT, stack, walk, type Plan } from './plan.js';\n\n/** The DOM cloned from one template, plus its parts. */\nexport class Instance implements Owner {\n  readonly template: TemplateObject;\n  /** The result source last rendered (strings array or compiled object), for a fast compare. */\n  source: unknown;\n  /** The child part whose content this instance is. */\n  readonly holder: ChildPart;\n  readonly parts: Part[];\n  /** First and last static root nodes; null when the template is a single hole. */\n  start: Node | null;\n  end: Node | null;\n  /** Root-level child parts before the first / after the last static root node. */\n  head: ChildPart | null;\n  tail: ChildPart | null;\n  /** The clone, until it is inserted. */\n  frag: DocumentFragment | null;\n\n  /** `adopt`: hydration (adopt.ts) fills the parts and root nodes from server DOM instead. */\n  constructor(template: TemplateObject, source: unknown, holder: ChildPart, adopt?: boolean) {\n    this.template = template;\n    this.source = source;\n    this.holder = holder;\n    this.parts = [];\n    this.head = null;\n    this.tail = null;\n    this.frag = this.start = this.end = null;\n    report(template);\n    if (adopt === true) return;\n    const plan = planOf(template);\n    if (plan.single) {\n      const root = document.importNode(plan.content.firstChild as Node, true);\n      stack[1] = root;\n      this.start = this.end = root;\n    } else {\n      const frag = document.importNode(plan.content, true);\n      stack[0] = frag;\n      this.frag = frag;\n      this.start = frag.firstChild;\n      this.end = frag.lastChild;\n    }\n    walk(plan);\n    this.build(plan);\n  }\n\n  private build(plan: Plan): void {\n    const { a, b, at, kinds } = plan;\n    const specs = this.template.parts;\n    for (let i = 0; i < kinds.length; i++) {\n      const kind = kinds[i] as number;\n      const node = nodes[a[i] as number] as Element;\n      if (kind >= 0) {\n        this.parts.push(attrPart(node, kind, specs[i] as PartSpec, at[i] as number));\n        continue;\n      }\n      const r = b[i] as number;\n      const ref = r >= 0 ? (nodes[r] as Node) : null;\n      if (kind !== ROOT) {\n        this.parts.push(new ChildPart(node, ref, null, 0, kind !== CHILD, at[i] as number));\n        continue;\n      }\n      const part = new ChildPart(null, ref, ref === null ? this : null, 0, false, at[i] as number);\n      if (ref === null) this.tail = part;\n      else if (ref === this.start) this.head = part;\n      this.parts.push(part);\n    }\n  }\n\n  /** Commits this render's values, part by part in document order. */\n  update(values: readonly unknown[]): void {\n    const parts = this.parts;\n    for (let i = 0; i < parts.length; i++) (parts[i] as Part).set(values);\n  }\n\n  /** Inserts the (committed) clone; afterwards root-level parts resolve through the holder. */\n  insert(parent: Node, before: Node | null): void {\n    parent.insertBefore(this.frag ?? (this.start as Node), before);\n    this.frag = null;\n  }\n\n  first(): Node | null {\n    const head = this.head !== null ? this.head.first() : null;\n    if (head !== null) return head;\n    if (this.start !== null) return this.start;\n    return this.tail !== null ? this.tail.first() : null;\n  }\n\n  last(): Node | null {\n    const tail = this.tail !== null ? this.tail.last() : null;\n    if (tail !== null) return tail;\n    if (this.end !== null) return this.end;\n    return this.head !== null ? this.head.last() : null;\n  }\n\n  remove(): void {\n    const first = this.first();\n    if (first === null) return;\n    const last = this.last() as Node;\n    if (first === last) (first as ChildNode).remove();\n    else removeRange(first, last);\n  }\n\n  /** Owner of root-level open parts: the clone while building, then the holder's parent. */\n  parentFor(): Node {\n    if (this.frag !== null) return this.frag;\n    return this.start !== null ? (this.start.parentNode as Node) : this.holder.parent();\n  }\n\n  endFor(): Node | null {\n    return this.frag !== null ? null : this.holder.end();\n  }\n}\n"]}

package/dist/view/render/keyed.d.ts

@@ -0,0 +1,6 @@
+import type { ChildValue, ListResult } from './values.js';
+/**
+ * Renders `value`, and replaces it with a fresh copy whenever `key` changes: a form cleared
+ * after sending, a CSS animation restarted, a child component reset.
+ */
+export declare function keyed(key: string | number, value: ChildValue): ListResult;

package/dist/view/render/keyed.js

@@ -0,0 +1,15 @@
+// keyed(key, value): a child value that is recreated, DOM and nested component state included,
+// whenever its key changes (view/03-lists.md "keyed"). It is a one-row each(), so it reuses the
+// keyed list's reconciliation, server writer and hydration walk, and costs nothing in apps that
+// don't call it.
+import { each } from './list.js';
+// One shared row function: each()'s development purity check is keyed by it.
+const itself = (value) => value;
+/**
+ * Renders `value`, and replaces it with a fresh copy whenever `key` changes: a form cleared
+ * after sending, a CSS animation restarted, a child component reset.
+ */
+export function keyed(key, value) {
+    return each([value], () => key, itself);
+}
+//# sourceMappingURL=keyed.js.map

package/dist/view/render/keyed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed.js","sourceRoot":"","sources":["../../../src/view/render/keyed.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,gGAAgG;AAChG,gGAAgG;AAChG,iBAAiB;AACjB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,6EAA6E;AAC7E,MAAM,MAAM,GAAG,CAAC,KAAiB,EAAc,EAAE,CAAC,KAAK,CAAC;AAExD;;;GAGG;AACH,MAAM,UAAU,KAAK,CAAC,GAAoB,EAAE,KAAiB;IAC3D,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["// keyed(key, value): a child value that is recreated, DOM and nested component state included,\n// whenever its key changes (view/03-lists.md \"keyed\"). It is a one-row each(), so it reuses the\n// keyed list's reconciliation, server writer and hydration walk, and costs nothing in apps that\n// don't call it.\nimport { each } from './list.js';\nimport type { ChildValue, ListResult } from './values.js';\n\n// One shared row function: each()'s development purity check is keyed by it.\nconst itself = (value: ChildValue): ChildValue => value;\n\n/**\n * Renders `value`, and replaces it with a fresh copy whenever `key` changes: a form cleared\n * after sending, a CSS animation restarted, a child component reset.\n */\nexport function keyed(key: string | number, value: ChildValue): ListResult {\n  return each([value], () => key, itself);\n}\n"]}

package/dist/view/render/list.d.ts

@@ -0,0 +1,20 @@
+import { ChildPart } from './child-part.js';
+import { List } from './rows.js';
+import { type ChildValue, type ListResult } from './values.js';
+export { List } from './rows.js';
+/** Removes every row; the list's part keeps its (now empty) list. */
+export declare function clearList(part: ChildPart, list: List): void;
+/**
+ * Creates rows for `l.items[from…to]` (keys from `keys[i - from]` when given) into one
+ * fragment, pushes them onto `rows` and inserts the fragment before `end`.
+ */
+export declare function createRows(part: ChildPart, list: List, l: ListResult, rows: ChildPart[], from: number, to: number, end: Node | null, keys?: readonly unknown[]): void;
+/**
+ * A keyed list (view/03-lists.md). `key` must give each item a unique string or number; `row`
+ * must depend only on its arguments: a row re-renders only when its item object or its `pick`
+ * result changes.
+ */
+export declare function each<T>(items: readonly T[], key: (item: T) => string | number, row: (item: T) => ChildValue): ListResult;
+export declare function each<T, P>(items: readonly T[], key: (item: T) => string | number, row: (item: T, picked: P) => ChildValue, pick: (item: T) => P): ListResult;
+/** A positional array: items reused by index (view/02-bindings.md "Child values"). */
+export declare function commitItems(part: ChildPart, values: readonly unknown[]): void;