@nisli/core 0.56.0 → 0.57.0

package/dist/bundler/lifecycle.js

@@ -0,0 +1,56 @@
+import { hasContext, getCurrentComponent } from "./context.js";
+const mountCallbacks = /* @__PURE__ */ new WeakMap();
+function onMount(callback) {
+  if (!hasContext()) {
+    throw new Error(
+      "onMount() called outside setup(). It can only be called during component initialization."
+    );
+  }
+  const comp = getCurrentComponent();
+  let callbacks = mountCallbacks.get(comp);
+  if (!callbacks) {
+    callbacks = [];
+    mountCallbacks.set(comp, callbacks);
+  }
+  callbacks.push(callback);
+}
+function onCleanup(callback) {
+  if (!hasContext()) {
+    throw new Error(
+      "onCleanup() called outside setup(). It can only be called during component initialization."
+    );
+  }
+  getCurrentComponent().addDisposer(callback);
+}
+function useHostEvent(target, eventName, handler) {
+  if (!hasContext()) {
+    throw new Error(
+      "useHostEvent() called outside setup(). It can only be called during component initialization."
+    );
+  }
+  target.addEventListener(eventName, handler);
+  getCurrentComponent().addDisposer(() => {
+    target.removeEventListener(eventName, handler);
+  });
+}
+function runMountCallbacks(comp) {
+  const callbacks = mountCallbacks.get(comp);
+  if (!callbacks) return;
+  try {
+    for (const cb of callbacks) {
+      const cleanup = cb();
+      if (typeof cleanup === "function") {
+        comp.addDisposer(cleanup);
+      }
+    }
+  } finally {
+    mountCallbacks.delete(comp);
+  }
+}
+export {
+  onCleanup,
+  onMount,
+  runMountCallbacks,
+  useHostEvent
+};
+//# sourceMappingURL=lifecycle.js.map

package/dist/bundler/lifecycle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lifecycle.ts"],
+  "sourcesContent": ["/**\n * lifecycle.ts \u2014 Post-mount and cleanup lifecycle hooks\n *\n * `onMount()` registers a callback that runs after the component's\n * template is mounted to the DOM. If the callback returns a function,\n * that function runs on disconnect (cleanup).\n *\n * `onCleanup()` registers a standalone cleanup callback that runs\n * on disconnect \u2014 for cases where you need cleanup without mount logic.\n *\n * Both must be called synchronously during component setup.\n *\n * ```ts\n * component('my-el', (props, host) => {\n *   onMount(() => {\n *     host.querySelector('input')?.focus();\n *     return () => console.log('unmounted');\n *   });\n *\n *   onCleanup(() => clearInterval(timerId));\n *\n *   return html`<input />`;\n * });\n * ```\n */\n\nimport { hasContext, getCurrentComponent } from './context.js';\n\n// \u2500\u2500 Mount callback storage \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Mount callbacks are stored on the component host and called after template mount. */\nconst mountCallbacks = new WeakMap<object, (() => void | (() => void))[]>();\n\n/**\n * Register a callback to run after the component's template is mounted.\n * If the callback returns a function, it will be called on disconnect.\n *\n * Must be called synchronously during component setup.\n */\nexport function onMount(callback: () => void | (() => void)): void {\n  if (!hasContext()) {\n    throw new Error(\n      'onMount() called outside setup(). ' +\n      'It can only be called during component initialization.'\n    );\n  }\n  const comp = getCurrentComponent();\n  let callbacks = mountCallbacks.get(comp);\n  if (!callbacks) {\n    callbacks = [];\n    mountCallbacks.set(comp, callbacks);\n  }\n  callbacks.push(callback);\n}\n\n/**\n * Register a cleanup callback to run on disconnect.\n * This is a convenience for cases where you need cleanup without mount logic.\n *\n * Must be called synchronously during component setup.\n */\nexport function onCleanup(callback: () => void): void {\n  if (!hasContext()) {\n    throw new Error(\n      'onCleanup() called outside setup(). ' +\n      'It can only be called during component initialization.'\n    );\n  }\n  getCurrentComponent().addDisposer(callback);\n}\n\n/**\n * Listen for a DOM event on a target and auto-dispose the listener when the\n * component disconnects. Works with any EventTarget (host element, document,\n * window, etc.). Must be called during component setup.\n *\n * ```ts\n * useHostEvent(host, 'click', (e) => {\n *   // Runs on each click\n * });\n * ```\n */\nexport function useHostEvent<E extends Event = Event>(\n  target: EventTarget,\n  eventName: string,\n  handler: (event: E) => void,\n): void {\n  if (!hasContext()) {\n    throw new Error(\n      'useHostEvent() called outside setup(). ' +\n      'It can only be called during component initialization.'\n    );\n  }\n  target.addEventListener(eventName, handler as EventListener);\n  getCurrentComponent().addDisposer(() => {\n    target.removeEventListener(eventName, handler as EventListener);\n  });\n}\n\n/**\n * Run all registered mount callbacks for a component host.\n * Called by component.ts after the template is mounted to the DOM.\n *\n * A throw here PROPAGATES to component.ts's containment boundary \u2014 the SAME\n * boundary as a setup throw (ADR 0030.2 T6, code N402): remaining callbacks\n * are skipped, the partial scope (including cleanups already registered by\n * earlier callbacks) is disposed, the error fallback renders, and the host is\n * stamped `data-nisli-error`. The pre-T6 behavior (console-and-limp per\n * callback) left a half-mounted component alive with no machine-readable\n * trace and no teardown \u2014 the one containment semantics setup already had\n * (issue 0010) now covers mount too.\n * @internal\n */\nexport function runMountCallbacks(comp: object): void {\n  const callbacks = mountCallbacks.get(comp);\n  if (!callbacks) return;\n\n  try {\n    for (const cb of callbacks) {\n      const cleanup = cb();\n      if (typeof cleanup === 'function') {\n        // Register cleanup as a disposer on the component\n        (comp as any).addDisposer(cleanup);\n      }\n    }\n  } finally {\n    // Clear \u2014 mount callbacks run once (also when a throw contains the scope:\n    // the boundary re-runs setup from scratch on the next mount, which\n    // re-registers a fresh callback list).\n    mountCallbacks.delete(comp);\n  }\n}\n"],
+  "mappings": "AA0BA,SAAS,YAAY,2BAA2B;AAKhD,MAAM,iBAAiB,oBAAI,QAA+C;AAQnE,SAAS,QAAQ,UAA2C;AACjE,MAAI,CAAC,WAAW,GAAG;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,QAAM,OAAO,oBAAoB;AACjC,MAAI,YAAY,eAAe,IAAI,IAAI;AACvC,MAAI,CAAC,WAAW;AACd,gBAAY,CAAC;AACb,mBAAe,IAAI,MAAM,SAAS;AAAA,EACpC;AACA,YAAU,KAAK,QAAQ;AACzB;AAQO,SAAS,UAAU,UAA4B;AACpD,MAAI,CAAC,WAAW,GAAG;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,sBAAoB,EAAE,YAAY,QAAQ;AAC5C;AAaO,SAAS,aACd,QACA,WACA,SACM;AACN,MAAI,CAAC,WAAW,GAAG;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IAEF;AAAA,EACF;AACA,SAAO,iBAAiB,WAAW,OAAwB;AAC3D,sBAAoB,EAAE,YAAY,MAAM;AACtC,WAAO,oBAAoB,WAAW,OAAwB;AAAA,EAChE,CAAC;AACH;AAgBO,SAAS,kBAAkB,MAAoB;AACpD,QAAM,YAAY,eAAe,IAAI,IAAI;AACzC,MAAI,CAAC,UAAW;AAEhB,MAAI;AACF,eAAW,MAAM,WAAW;AAC1B,YAAM,UAAU,GAAG;AACnB,UAAI,OAAO,YAAY,YAAY;AAEjC,QAAC,KAAa,YAAY,OAAO;AAAA,MACnC;AAAA,IACF;AAAA,EACF,UAAE;AAIA,mBAAe,OAAO,IAAI;AAAA,EAC5B;AACF;",
+  "names": []
+}

package/dist/bundler/projection.js

@@ -0,0 +1,92 @@
+import { getCurrentComponent } from "./context.js";
+import { onCleanup } from "./lifecycle.js";
+import { signal, computed, flush } from "./signal.js";
+function isMeaningful(nodes) {
+  return nodes.some(
+    (n) => n.nodeType === 1 || n.nodeType === 3 && (n.textContent ?? "").trim() !== ""
+  );
+}
+function nodesTemplate(nodes) {
+  return {
+    __templateResult: true,
+    mount(w) {
+      for (const node of nodes) w.appendChild(node);
+    },
+    dispose() {
+    }
+  };
+}
+function textTemplate(text) {
+  return {
+    __templateResult: true,
+    mount(w) {
+      w.appendChild(document.createTextNode(text));
+    },
+    dispose() {
+    }
+  };
+}
+function asSlot(value) {
+  if (value == null || value === "") return null;
+  if (typeof value === "object" && ("__templateResult" in value || "__type" in value)) {
+    return value;
+  }
+  if (Array.isArray(value)) return value;
+  return textTemplate(String(value));
+}
+function children(fallback) {
+  const host = getCurrentComponent().element;
+  const captured = host.__capturedChildren ?? [];
+  host.__capturedChildren = void 0;
+  for (const node of captured) {
+    if (node.parentNode === host) host.removeChild(node);
+  }
+  const childrenProp = host._propSignal ? host._propSignal("children") : void 0;
+  const projectedNodes = signal(captured);
+  let disposed = false;
+  onCleanup(() => {
+    disposed = true;
+    const nodes = projectedNodes.value;
+    host.__capturedChildren = nodes.length ? nodes : void 0;
+  });
+  host.__nisliProjectionSweep = () => {
+    const renderedRoots = new Set(Array.from(host.childNodes));
+    queueMicrotask(() => {
+      if (disposed) return;
+      const late = Array.from(host.childNodes).filter((n) => !renderedRoots.has(n));
+      if (late.length && isMeaningful(late)) {
+        for (const node of late) host.removeChild(node);
+        projectedNodes.value = [...projectedNodes.value, ...late];
+        flush();
+      }
+    });
+  };
+  let fallbackSlot = null;
+  if (fallback != null) {
+    if (typeof fallback === "string") {
+      fallbackSlot = textTemplate(fallback);
+    } else {
+      const holder = document.createDocumentFragment();
+      fallback.mount(holder);
+      const fallbackNodes = Array.from(holder.childNodes);
+      onCleanup(() => {
+        try {
+          fallback.dispose();
+        } catch (_) {
+        }
+      });
+      fallbackSlot = nodesTemplate(fallbackNodes);
+    }
+  }
+  return computed(() => {
+    const kids = childrenProp?.value;
+    if (kids != null && kids !== "") return asSlot(kids);
+    const nodes = projectedNodes.value;
+    if (isMeaningful(nodes)) return nodesTemplate(nodes);
+    return fallbackSlot;
+  });
+}
+export {
+  children
+};
+//# sourceMappingURL=projection.js.map

package/dist/bundler/projection.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/projection.ts"],
+  "sourcesContent": ["/**\n * projection.ts \u2014 First-class content projection (ADR 0025 item 1)\n *\n * `children(fallback?)` is a setup-context primitive that owns the light-DOM\n * projection machinery the registry currently hand-rolls\n * (captureChildren/projectChildren + per-component conditional-default swaps).\n *\n * ```ts\n * component('ui-button', (props, host) => {\n *   transparentHost(host);\n *   return html`<button class=\"${classes}\">${children()}</button>`;\n * });\n * ```\n *\n * Semantics:\n * - Returns a reactive slot value (a signal) that a template interpolates. The\n *   slot resolves, in priority order: the factory `children` prop \u2192 the host's\n *   captured light-DOM children \u2192 the fallback.\n * - Factory `children` route through the SAME slot: `children()` READS the\n *   host's `children` prop signal (sugar over one path). Crucially it renders\n *   them AT the slot position (not by relocating them to light DOM), so a\n *   factory-composed child element is a DOM descendant of its parent when its\n *   connectedCallback runs \u2014 `closest()`-based parent lookup keeps working.\n * - Plain-HTML light-DOM children are captured pre-setup by component.ts\n *   (SEED \u2192 CAPTURE \u2192 CONTEXT) and projected here; late parser children are\n *   swept in a microtask (the ADR 0023 streaming machinery, now in core).\n * - `children(fallback)` renders `fallback` when no MEANINGFUL children exist\n *   (whitespace-only light DOM does not count) and REPLACES it reactively when\n *   children arrive \u2014 including late parser children. This natively solves the\n *   conditional-default class (message-scroller-button's default glyph).\n * - Single default slot only; named/multiple slots are a later design (v1 OUT).\n *\n * Zero-cost when unused: component.ts only snapshots childNodes when the host\n * has any, and only children() consumes them.\n */\n\nimport { getCurrentComponent } from './context.js';\nimport { onCleanup } from './lifecycle.js';\nimport { signal, computed, flush, type ReadonlySignal, type Signal } from './signal.js';\nimport type { TemplateResult } from './template.js';\n\n/** True if the nodes carry meaningful content (element or non-blank text). */\nfunction isMeaningful(nodes: Node[]): boolean {\n  return nodes.some(\n    (n) => n.nodeType === 1 || (n.nodeType === 3 && (n.textContent ?? '').trim() !== ''),\n  );\n}\n\n/** A minimal TemplateResult that mounts pre-existing DOM nodes into the slot. */\nfunction nodesTemplate(nodes: Node[]): TemplateResult {\n  return {\n    __templateResult: true,\n    mount(w: HTMLElement) {\n      for (const node of nodes) w.appendChild(node);\n    },\n    dispose() { /* nodes are owned by the host tree; nothing to tear down */ },\n  } as unknown as TemplateResult;\n}\n\n/** A re-mountable TemplateResult that renders a primitive as a fresh text node. */\nfunction textTemplate(text: string): TemplateResult {\n  return {\n    __templateResult: true,\n    mount(w: HTMLElement) {\n      w.appendChild(document.createTextNode(text));\n    },\n    dispose() { /* text node removed by the slot */ },\n  } as unknown as TemplateResult;\n}\n\n/**\n * Normalize a slot value so the template ALWAYS sees a TemplateResult / factory\n * / array / null \u2014 never a bare primitive. Projection values may be detached\n * and reinserted as fallback/light-DOM ownership changes, so wrapping primitive\n * text keeps that projection value explicitly re-mountable.\n */\nfunction asSlot(value: unknown): unknown {\n  if (value == null || value === '') return null;\n  if (\n    typeof value === 'object'\n    && ('__templateResult' in (value as object) || '__type' in (value as object))\n  ) {\n    return value;\n  }\n  if (Array.isArray(value)) return value;\n  return textTemplate(String(value));\n}\n\n/**\n * Project the host's children (factory `children` prop or light DOM) into this\n * slot, with an optional `fallback` rendered when empty. Must be called in\n * setup context. Interpolate the result in a template:\n * `html`<button>${children()}</button>``.\n */\nexport function children(fallback?: TemplateResult | string): ReadonlySignal<unknown> {\n  const host = getCurrentComponent().element as HTMLElement & {\n    __capturedChildren?: Node[];\n    __nisliProjectionSweep?: () => void;\n    _propSignal?(key: string): Signal<unknown>;\n  };\n\n  // Consume the pre-setup light-DOM capture; remove those nodes from the host\n  // so the rendered template doesn't duplicate them.\n  const captured = host.__capturedChildren ?? [];\n  host.__capturedChildren = undefined;\n  for (const node of captured) {\n    if (node.parentNode === host) host.removeChild(node);\n  }\n\n  // The factory `children` prop, folded into the same slot (sugar over one path).\n  const childrenProp = host._propSignal ? host._propSignal('children') : undefined;\n\n  // Projected light-DOM nodes; grows when the late-parser sweep finds more.\n  const projectedNodes = signal<Node[]>(captured);\n\n  // True once this setup scope has been disposed (true disconnect, HMR\n  // teardown, OR the containment boundary tearing down a failed mount). The\n  // queued sweep below must then no-op: it would otherwise misread the\n  // post-teardown host children (restored light DOM, or the error fallback)\n  // as \"late\" and relocate them into a dead slot.\n  let disposed = false;\n\n  // A true disconnect/HMR teardown clears the component-owned rendered tree\n  // before setup runs again. Hand the plain light-DOM nodes back to component.ts\n  // so it can restore them as direct host children for the next capture.\n  onCleanup(() => {\n    disposed = true;\n    const nodes = projectedNodes.value;\n    host.__capturedChildren = nodes.length ? nodes : undefined;\n  });\n\n  // LATE-CHILDREN SWEEP \u2014 scheduled by component.ts's dedicated projection\n  // phase (ADR 0030.2 \u00A73), which runs after the template is committed and\n  // BEFORE any onMount callback. Pre-0030.2 this was registered via\n  // children()'s own onMount, so the rendered-roots snapshot depended on\n  // where children() sat relative to other onMount() registrations (the 0025\n  // batch-3B ordering trap). Hoisting the SCHEDULING makes the rule\n  // universal: the snapshot is exactly the rendered template roots, and\n  // anything appearing after it \u2014 late parser/innerHTML children AND onMount\n  // host-appends \u2014 classifies as projected content. Only scheduling moved;\n  // the prop READ path (the computed below) is unchanged.\n  host.__nisliProjectionSweep = () => {\n    // The host's direct children at phase time are the rendered template\n    // roots. Anything that appears later is late projected content.\n    const renderedRoots = new Set<Node>(Array.from(host.childNodes));\n    queueMicrotask(() => {\n      if (disposed) return; // scope torn down before the sweep ran\n      const late = Array.from(host.childNodes).filter((n) => !renderedRoots.has(n));\n      if (late.length && isMeaningful(late)) {\n        for (const node of late) host.removeChild(node);\n        projectedNodes.value = [...projectedNodes.value, ...late];\n        // Flush the slot effect NOW so the late children land in this same\n        // microtask \u2014 the projectChildren() this replaces mutated the DOM\n        // imperatively, so callers only await one microtask for the sweep.\n        flush();\n      }\n    });\n  };\n\n  // Stable, RE-MOUNTABLE fallback slot: the same slot object is returned on\n  // every empty render, and it can be mounted \u2192 unmounted \u2192 mounted again\n  // (empty \u2192 filled \u2192 empty) without crashing. A string wraps to a fresh text\n  // node each mount. A TemplateResult is mounted ONCE here into a detached\n  // holder (its reactive bindings run in this component's context and dispose\n  // with it); its rendered nodes are then exposed as a re-mountable node slot,\n  // so the engine can detach and re-append them freely.\n  let fallbackSlot: unknown = null;\n  if (fallback != null) {\n    if (typeof fallback === 'string') {\n      fallbackSlot = textTemplate(fallback);\n    } else {\n      const holder = document.createDocumentFragment();\n      fallback.mount(holder as unknown as HTMLElement);\n      const fallbackNodes = Array.from(holder.childNodes);\n      onCleanup(() => { try { fallback.dispose(); } catch (_) { /* ignore */ } });\n      fallbackSlot = nodesTemplate(fallbackNodes);\n    }\n  }\n\n  // Priority: factory children \u2192 captured/late light DOM \u2192 fallback. Reactive,\n  // so late children (or a changing `children` prop) replace the fallback.\n  return computed(() => {\n    const kids = childrenProp?.value;\n    if (kids != null && kids !== '') return asSlot(kids);\n    const nodes = projectedNodes.value;\n    if (isMeaningful(nodes)) return nodesTemplate(nodes);\n    return fallbackSlot;\n  });\n}\n"],
+  "mappings": "AAoCA,SAAS,2BAA2B;AACpC,SAAS,iBAAiB;AAC1B,SAAS,QAAQ,UAAU,aAA+C;AAI1E,SAAS,aAAa,OAAwB;AAC5C,SAAO,MAAM;AAAA,IACX,CAAC,MAAM,EAAE,aAAa,KAAM,EAAE,aAAa,MAAM,EAAE,eAAe,IAAI,KAAK,MAAM;AAAA,EACnF;AACF;AAGA,SAAS,cAAc,OAA+B;AACpD,SAAO;AAAA,IACL,kBAAkB;AAAA,IAClB,MAAM,GAAgB;AACpB,iBAAW,QAAQ,MAAO,GAAE,YAAY,IAAI;AAAA,IAC9C;AAAA,IACA,UAAU;AAAA,IAA+D;AAAA,EAC3E;AACF;AAGA,SAAS,aAAa,MAA8B;AAClD,SAAO;AAAA,IACL,kBAAkB;AAAA,IAClB,MAAM,GAAgB;AACpB,QAAE,YAAY,SAAS,eAAe,IAAI,CAAC;AAAA,IAC7C;AAAA,IACA,UAAU;AAAA,IAAsC;AAAA,EAClD;AACF;AAQA,SAAS,OAAO,OAAyB;AACvC,MAAI,SAAS,QAAQ,UAAU,GAAI,QAAO;AAC1C,MACE,OAAO,UAAU,aACb,sBAAuB,SAAoB,YAAa,QAC5D;AACA,WAAO;AAAA,EACT;AACA,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO;AACjC,SAAO,aAAa,OAAO,KAAK,CAAC;AACnC;AAQO,SAAS,SAAS,UAA6D;AACpF,QAAM,OAAO,oBAAoB,EAAE;AAQnC,QAAM,WAAW,KAAK,sBAAsB,CAAC;AAC7C,OAAK,qBAAqB;AAC1B,aAAW,QAAQ,UAAU;AAC3B,QAAI,KAAK,eAAe,KAAM,MAAK,YAAY,IAAI;AAAA,EACrD;AAGA,QAAM,eAAe,KAAK,cAAc,KAAK,YAAY,UAAU,IAAI;AAGvE,QAAM,iBAAiB,OAAe,QAAQ;AAO9C,MAAI,WAAW;AAKf,YAAU,MAAM;AACd,eAAW;AACX,UAAM,QAAQ,eAAe;AAC7B,SAAK,qBAAqB,MAAM,SAAS,QAAQ;AAAA,EACnD,CAAC;AAYD,OAAK,yBAAyB,MAAM;AAGlC,UAAM,gBAAgB,IAAI,IAAU,MAAM,KAAK,KAAK,UAAU,CAAC;AAC/D,mBAAe,MAAM;AACnB,UAAI,SAAU;AACd,YAAM,OAAO,MAAM,KAAK,KAAK,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC;AAC5E,UAAI,KAAK,UAAU,aAAa,IAAI,GAAG;AACrC,mBAAW,QAAQ,KAAM,MAAK,YAAY,IAAI;AAC9C,uBAAe,QAAQ,CAAC,GAAG,eAAe,OAAO,GAAG,IAAI;AAIxD,cAAM;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AASA,MAAI,eAAwB;AAC5B,MAAI,YAAY,MAAM;AACpB,QAAI,OAAO,aAAa,UAAU;AAChC,qBAAe,aAAa,QAAQ;AAAA,IACtC,OAAO;AACL,YAAM,SAAS,SAAS,uBAAuB;AAC/C,eAAS,MAAM,MAAgC;AAC/C,YAAM,gBAAgB,MAAM,KAAK,OAAO,UAAU;AAClD,gBAAU,MAAM;AAAE,YAAI;AAAE,mBAAS,QAAQ;AAAA,QAAG,SAAS,GAAG;AAAA,QAAe;AAAA,MAAE,CAAC;AAC1E,qBAAe,cAAc,aAAa;AAAA,IAC5C;AAAA,EACF;AAIA,SAAO,SAAS,MAAM;AACpB,UAAM,OAAO,cAAc;AAC3B,QAAI,QAAQ,QAAQ,SAAS,GAAI,QAAO,OAAO,IAAI;AACnD,UAAM,QAAQ,eAAe;AAC7B,QAAI,aAAa,KAAK,EAAG,QAAO,cAAc,KAAK;AACnD,WAAO;AAAA,EACT,CAAC;AACH;",
+  "names": []
+}

package/dist/bundler/query.js

@@ -0,0 +1,302 @@
+import {
+  signal,
+  effect,
+  computed,
+  untrack
+} from "./signal.js";
+import { hasContext, getCurrentComponent } from "./context.js";
+import { disposable } from "./disposable.js";
+import { inject } from "./injector.js";
+import { __enrollPending } from "./settle.js";
+import { formatDiag } from "./diagnostics.js";
+function keyError(detail) {
+  return new Error(formatDiag(
+    "N602",
+    `invalid query key: ${detail}. Keys must be flat readonly (string | number | boolean | null)[] arrays \u2014 spread object params into tuple elements; null is the optional sentinel.`
+  ));
+}
+function validateKey(raw) {
+  if (!Array.isArray(raw)) {
+    throw keyError(`expected an array, got ${typeof raw}`);
+  }
+  for (let i = 0; i < raw.length; i++) {
+    const el = raw[i];
+    if (el === null) continue;
+    const t = typeof el;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (Number.isFinite(el)) continue;
+      throw keyError(`non-finite number at index ${i} (would collide with null)`);
+    }
+    if (el === void 0) {
+      throw keyError(`undefined at index ${i}`);
+    }
+    throw keyError(`${t} at index ${i}`);
+  }
+  return raw.slice();
+}
+function serializeKey(key) {
+  return JSON.stringify(key);
+}
+function matchesPrefix(key, prefix) {
+  if (prefix.length > key.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (key[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+let nextMountIndex = 0;
+function peek(s) {
+  let v;
+  untrack(() => {
+    v = s.value;
+  });
+  return v;
+}
+function toError(cause) {
+  if (cause instanceof Error) return cause;
+  try {
+    return new Error(String(cause));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+class QueryClient {
+  /** @internal */
+  _records = /* @__PURE__ */ new Map();
+  /** @internal clear() bumps this; observer effects track it and re-resolve. */
+  _version = signal(0);
+  /** @internal live observer count (N601 mixed-client diagnostic). */
+  _observers = 0;
+  /**
+   * Mark records matching the key prefix stale and rerun those with ≥1
+   * enabled observer (using the owning observer's fetcher/options).
+   * Disabled observers revalidate on re-enable; a record with only
+   * disabled/no observers stays stale until one arrives. Returns the
+   * number of records invalidated.
+   *
+   * invalidate(['tasks']) matches ['tasks'], ['tasks', '1'], ['tasks', '2', 'x'].
+   */
+  invalidate(keyPrefix) {
+    const prefix = validateKey(keyPrefix);
+    let count = 0;
+    for (const rec of this._records.values()) {
+      if (!matchesPrefix(rec.key, prefix)) continue;
+      count++;
+      rec.stale = true;
+      const owner = ownerOf(
+        rec,
+        /* requireEnabled */
+        true
+      );
+      if (owner) startRun(rec, owner.fetcher, owner.retry);
+    }
+    return count;
+  }
+  /**
+   * Drop every record. In-flight runs are aborted (a settle() termination).
+   * Live observers re-resolve fresh records on the version bump — enabled
+   * ones revalidate immediately.
+   */
+  clear() {
+    for (const rec of this._records.values()) {
+      rec.generation++;
+      rec.controller?.abort();
+      rec.terminate?.();
+      rec.controller = null;
+      rec.terminate = null;
+      rec.runPromise = null;
+      rec.running = false;
+      rec.observers.clear();
+    }
+    this._records.clear();
+    this._version.value++;
+  }
+  /**
+   * Imperatively warm a record. Joins an in-flight run; a fresh record
+   * (per the given staleTime) is a no-op. Otherwise starts a run with THE
+   * GIVEN fetcher — an explicit imperative is its own owner. The run
+   * commits even with zero observers. Resolves at run termination.
+   */
+  prefetch(key, fetcher, staleTime = 0) {
+    const rec = resolveRecord(this, key);
+    if (rec.running) return rec.runPromise ?? Promise.resolve();
+    if (!rec.stale && peek(rec.status) === "success" && staleTime > 0 && Date.now() - peek(rec.fetchedAt) < staleTime) {
+      return Promise.resolve();
+    }
+    return startRun(rec, fetcher, 0);
+  }
+}
+function resolveRecord(client, rawKey) {
+  const key = validateKey(rawKey);
+  const serialized = serializeKey(key);
+  let rec = client._records.get(serialized);
+  if (!rec) {
+    rec = {
+      key,
+      serialized,
+      data: signal(void 0),
+      error: signal(null),
+      status: signal("idle"),
+      fetchedAt: signal(0),
+      stale: false,
+      running: false,
+      generation: 0,
+      controller: null,
+      runPromise: null,
+      terminate: null,
+      observers: /* @__PURE__ */ new Set()
+    };
+    client._records.set(serialized, rec);
+  }
+  return rec;
+}
+function ownerOf(rec, requireEnabled = false) {
+  let best;
+  let bestDisabled;
+  for (const obs of rec.observers) {
+    if (obs.enabled) {
+      if (!best || obs.mountIndex > best.mountIndex) best = obs;
+    } else if (!requireEnabled) {
+      if (!bestDisabled || obs.mountIndex > bestDisabled.mountIndex) bestDisabled = obs;
+    }
+  }
+  return best ?? bestDisabled;
+}
+function needsRun(rec, observer) {
+  if (rec.running) return false;
+  if (rec.stale) return true;
+  const status = peek(rec.status);
+  if (status === "idle" || status === "error") return true;
+  if (observer.staleTime <= 0) return true;
+  return Date.now() - peek(rec.fetchedAt) >= observer.staleTime;
+}
+function startRun(rec, fetcher, retry) {
+  rec.controller?.abort();
+  rec.terminate?.();
+  const generation = ++rec.generation;
+  const controller = new AbortController();
+  const terminate = __enrollPending();
+  rec.controller = controller;
+  rec.terminate = terminate;
+  rec.running = true;
+  rec.stale = false;
+  rec.status.value = "loading";
+  rec.error.value = null;
+  const run = (async () => {
+    try {
+      let lastError = null;
+      for (let attempt = 0; attempt <= retry; attempt++) {
+        if (generation !== rec.generation) return;
+        try {
+          const result = await Promise.resolve().then(() => fetcher(controller.signal));
+          if (generation !== rec.generation) return;
+          rec.data.value = result;
+          rec.error.value = null;
+          rec.fetchedAt.value = Date.now();
+          rec.status.value = "success";
+          return;
+        } catch (cause) {
+          lastError = toError(cause);
+        }
+      }
+      if (generation !== rec.generation) return;
+      rec.error.value = lastError;
+      rec.status.value = "error";
+    } finally {
+      if (generation === rec.generation) {
+        rec.running = false;
+        rec.controller = null;
+        rec.runPromise = null;
+        rec.terminate = null;
+      }
+      terminate();
+    }
+  })();
+  rec.runPromise = run;
+  return run;
+}
+function query(keyFn, fetcher, options = {}) {
+  const { staleTime = 0, retry = 0, enabled, initialData } = options;
+  const client = inject(QueryClient);
+  untrack(() => {
+    validateKey(keyFn());
+  });
+  const observer = {
+    mountIndex: nextMountIndex++,
+    fetcher,
+    staleTime,
+    retry,
+    enabled: true,
+    record: null
+  };
+  client._observers++;
+  const recSig = signal(null);
+  const enabledSig = signal(true);
+  let disposed = false;
+  let prevEnabled = null;
+  let prevVersion = -1;
+  const stopEffect = effect(() => {
+    if (disposed) return;
+    const version = client._version.value;
+    const key = keyFn();
+    const on = enabled ? !!enabled() : true;
+    const rec = resolveRecord(client, key);
+    observer.enabled = on;
+    enabledSig.value = on;
+    const moved = rec !== observer.record;
+    if (moved) {
+      observer.record?.observers.delete(observer);
+      rec.observers.add(observer);
+      observer.record = rec;
+      if (initialData !== void 0 && peek(rec.status) === "idle" && peek(rec.data) === void 0) {
+        rec.data.value = initialData;
+      }
+      recSig.value = rec;
+    }
+    const reEnabled = prevEnabled === false && on;
+    const versionChanged = version !== prevVersion;
+    prevEnabled = on;
+    prevVersion = version;
+    if (on && (moved || reEnabled || versionChanged) && needsRun(rec, observer)) {
+      const owner = ownerOf(rec) ?? observer;
+      startRun(rec, owner.fetcher, owner.retry);
+    }
+  });
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    observer.record?.observers.delete(observer);
+    observer.record = null;
+    client._observers--;
+    stopEffect();
+  };
+  if (hasContext()) {
+    getCurrentComponent().addDisposer(dispose);
+  }
+  const refetch = () => {
+    if (disposed) return;
+    const rec = observer.record;
+    if (!rec || !observer.enabled) return;
+    if (rec.running) return;
+    const owner = ownerOf(rec) ?? observer;
+    startRun(rec, owner.fetcher, owner.retry);
+  };
+  const result = {
+    data: computed(() => {
+      const rec = recSig.value;
+      return rec ? rec.data.value : initialData;
+    }),
+    loading: computed(() => enabledSig.value && recSig.value?.status.value === "loading"),
+    error: computed(() => recSig.value?.error.value ?? null),
+    status: computed(() => recSig.value?.status.value ?? "idle"),
+    refetch,
+    dispose
+  };
+  return disposable(result, dispose);
+}
+export {
+  QueryClient,
+  query
+};
+//# sourceMappingURL=query.js.map

package/dist/bundler/query.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/query.ts"],
+  "sourcesContent": ["/**\n * query.ts \u2014 Keyed logical-request store (ADR 0030.2 T1).\n *\n * The cache unit is a per-key RECORD living in `QueryClient`:\n * `{data, error, status, fetchedAt}` as signals, plus exactly one `run()`\n * owning the retry loop, a per-run `AbortController` handed to the fetcher,\n * and the cache commit. `query()` is a thin OBSERVER: an effect keeps it\n * registered on the record its current key points at, and its outputs are\n * `computed()` views over that record. Dedup unit = logical request, by\n * construction (issues 0005\u20130009 close as a class).\n *\n * ```ts\n * const tasks = query(\n *   () => ['tasks', scopeId.value],\n *   (signal) => api.getTasks(scopeId.value, { signal }),\n * );\n * tasks.data      // ReadonlySignal<Task[] | undefined>\n * tasks.loading   // ReadonlySignal<boolean>\n * tasks.error     // ReadonlySignal<Error | null>\n * tasks.status    // ReadonlySignal<'idle' | 'loading' | 'success' | 'error'>\n * tasks.refetch() // force a refetch (joins an in-flight run)\n * tasks.dispose() // standalone callers; component setup auto-disposes\n * ```\n *\n * Ownership rules (ADR 0030.2 \u00A78, binding):\n * - The most-recently-mounted enabled observer's fetcher/options own the\n *   next run for a shared key; `staleTime` freshness is per-observer POLICY\n *   (it decides whether *that* observer triggers a run), while the record\n *   state is shared truth.\n * - `invalidate()` marks records stale and reruns only records with \u22651\n *   enabled observer; disabled observers revalidate on re-enable.\n * - A zero-observer record's in-flight run completes and commits.\n * - Records are NEVER garbage-collected: the cache is unbounded for the\n *   life of the client (restates today's unbounded-cache bound). Bound it\n *   operationally with `clear()` or a fresh client per app lifetime.\n *\n * Key contract: keys are FLAT \u2014 `readonly (string|number|boolean|null)[]`.\n * Objects and `undefined` are rejected with coded error N602 (`null` is\n * the optional sentinel). Flat keys are order-sensitive: prefer\n * per-endpoint key-builder helpers \u2014 a reordered key is a silent cache\n * *miss*, benign relative to a collision, but a miss.\n *\n * SSG stance (documented, not built): under core-render, records fetch\n * into the build-lifetime client and must TERMINATE before snapshot \u2014\n * `await settle()` is the barrier. Otherwise queries must be statically\n * disabled for the build.\n */\n\nimport {\n  signal,\n  effect,\n  computed,\n  untrack,\n  type Signal,\n  type ReadonlySignal,\n} from './signal.js';\nimport { hasContext, getCurrentComponent } from './context.js';\nimport { disposable, type DisposableResource } from './disposable.js';\nimport { inject } from './injector.js';\nimport { __enrollPending } from './settle.js';\nimport { formatDiag } from './diagnostics.js';\n\n// Diagnostics go through the core leaf (diagnostics.ts). Codes N602\u2013N603\n// belong to the query/async cluster (N601 retired before release \u2014 see\n// the eliminated-class note below).\n\n/** Build the coded error for key-contract violations. Always thrown \u2014\n *  key validity is a contract, not an advisory diagnostic. */\nfunction keyError(detail: string): Error {\n  return new Error(formatDiag(\n    'N602',\n    `invalid query key: ${detail}. Keys must be flat `\n    + 'readonly (string | number | boolean | null)[] arrays \u2014 spread '\n    + 'object params into tuple elements; null is the optional sentinel.',\n  ));\n}\n\n// \u2500\u2500 Key contract \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** A single query-key element. `null` is the optional sentinel. */\nexport type QueryKeyElement = string | number | boolean | null;\n\n/** The supported key contract: a flat, order-sensitive tuple. */\nexport type QueryKey = readonly QueryKeyElement[];\n\n/**\n * Validate a key against the flat contract and return a detached copy\n * (callers may mutate their array; records must not observe that).\n * Rejects objects, arrays, functions, undefined, and non-finite numbers\n * (NaN/Infinity JSON-serialize as null and would collide) with N602.\n */\nfunction validateKey(raw: unknown): QueryKey {\n  if (!Array.isArray(raw)) {\n    throw keyError(`expected an array, got ${typeof raw}`);\n  }\n  for (let i = 0; i < raw.length; i++) {\n    const el: unknown = raw[i];\n    if (el === null) continue;\n    const t = typeof el;\n    if (t === 'string' || t === 'boolean') continue;\n    if (t === 'number') {\n      if (Number.isFinite(el)) continue;\n      throw keyError(`non-finite number at index ${i} (would collide with null)`);\n    }\n    if (el === undefined) {\n      throw keyError(`undefined at index ${i}`);\n    }\n    throw keyError(`${t} at index ${i}`);\n  }\n  return raw.slice() as QueryKey;\n}\n\n/** THE one serializer: JSON.stringify of the validated flat array. */\nfunction serializeKey(key: QueryKey): string {\n  return JSON.stringify(key);\n}\n\n/** Element-wise prefix match over validated keys (=== is sound: elements\n *  are primitives and NaN is rejected by the contract). */\nfunction matchesPrefix(key: QueryKey, prefix: QueryKey): boolean {\n  if (prefix.length > key.length) return false;\n  for (let i = 0; i < prefix.length; i++) {\n    if (key[i] !== prefix[i]) return false;\n  }\n  return true;\n}\n\n// \u2500\u2500 Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type QueryStatus = 'idle' | 'loading' | 'success' | 'error';\n\n/** Fetcher contract: receives the run's AbortSignal. Zero-arg fetchers\n *  remain assignable. */\nexport type QueryFetcher<T> = (signal: AbortSignal) => Promise<T>;\n\nexport interface QueryResult<T> extends DisposableResource {\n  /** The record's data, or `initialData`/undefined before first commit. */\n  data: ReadonlySignal<T | undefined>;\n  /** True while this observer is enabled and its record is fetching. */\n  loading: ReadonlySignal<boolean>;\n  /** The record's terminal error, or null. Cleared when a run starts. */\n  error: ReadonlySignal<Error | null>;\n  /** The record's lifecycle status. */\n  status: ReadonlySignal<QueryStatus>;\n  /** Force a refetch: bypasses staleTime freshness, but JOINS an in-flight\n   *  logical request rather than starting a second one (issue 0005). No-op\n   *  while disabled. */\n  refetch(): void;\n  /** Unregister this observer. Component setup calls this automatically at\n   *  teardown; standalone callers (tests, scripts) call it explicitly. The\n   *  record \u2014 and any in-flight run \u2014 survives: zero-observer runs complete\n   *  and commit (ADR 0030.2 \u00A78). */\n  dispose(): void;\n}\n\nexport interface QueryOptions<T> {\n  /** Cache freshness duration in ms for THIS observer. Default: 0 (a\n   *  registration/re-enable always revalidates). */\n  staleTime?: number;\n  /** Number of retries the run performs when this observer owns it. Default: 0 */\n  retry?: number;\n  /** Skip fetching while this returns false. Signal reads are tracked. */\n  enabled?: () => boolean;\n  /** Synchronous seed committed into an untouched (idle) record. */\n  initialData?: T;\n}\n\n// \u2500\u2500 Record store \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\ninterface QueryRecord {\n  readonly key: QueryKey;\n  readonly serialized: string;\n  readonly data: Signal<unknown>;\n  readonly error: Signal<Error | null>;\n  readonly status: Signal<QueryStatus>;\n  /** Epoch ms of the last successful commit; 0 = never. */\n  readonly fetchedAt: Signal<number>;\n  /** Marked by invalidate(); cleared when a run starts. */\n  stale: boolean;\n  /** True while a run is in flight (status mirrors it reactively). */\n  running: boolean;\n  /** Increments per run start; a superseded run may never commit. */\n  generation: number;\n  controller: AbortController | null;\n  /** The in-flight run (joinable by prefetch). */\n  runPromise: Promise<void> | null;\n  /** settle() terminator for the in-flight run. */\n  terminate: (() => void) | null;\n  readonly observers: Set<QueryObserver>;\n}\n\ninterface QueryObserver {\n  readonly mountIndex: number;\n  readonly fetcher: QueryFetcher<unknown>;\n  readonly staleTime: number;\n  readonly retry: number;\n  enabled: boolean;\n  record: QueryRecord | null;\n}\n\n/** Monotonic mount counter \u2014 \"most recently mounted\" is decided by\n *  query() construction order, not re-registration order. */\nlet nextMountIndex = 0;\n\n/** Read a record signal without tracking it into the ambient observer \u2014\n *  the observer effect must depend on keys/enabled/version ONLY, never on\n *  record state (that is what keeps refetch loops unrepresentable). */\nfunction peek<T>(s: ReadonlySignal<T>): T {\n  let v!: T;\n  untrack(() => { v = s.value; });\n  return v;\n}\n\nfunction toError(cause: unknown): Error {\n  if (cause instanceof Error) return cause;\n  try {\n    return new Error(String(cause));\n  } catch {\n    return new Error('Unknown error');\n  }\n}\n\n/**\n * Global keyed logical-request store. One per app: resolved via\n * `inject(QueryClient)` (auto-singleton; override with\n * `provide(QueryClient, ...)` BEFORE the first query() call).\n *\n * Records are never GC'd \u2014 see the module doc for the bound.\n */\nexport class QueryClient {\n  /** @internal */ _records = new Map<string, QueryRecord>();\n  /** @internal clear() bumps this; observer effects track it and re-resolve. */\n  _version = signal(0);\n  /** @internal live observer count (N601 mixed-client diagnostic). */\n  _observers = 0;\n\n  /**\n   * Mark records matching the key prefix stale and rerun those with \u22651\n   * enabled observer (using the owning observer's fetcher/options).\n   * Disabled observers revalidate on re-enable; a record with only\n   * disabled/no observers stays stale until one arrives. Returns the\n   * number of records invalidated.\n   *\n   * invalidate(['tasks']) matches ['tasks'], ['tasks', '1'], ['tasks', '2', 'x'].\n   */\n  invalidate(keyPrefix: QueryKey): number {\n    const prefix = validateKey(keyPrefix);\n    let count = 0;\n    for (const rec of this._records.values()) {\n      if (!matchesPrefix(rec.key, prefix)) continue;\n      count++;\n      rec.stale = true;\n      const owner = ownerOf(rec, /* requireEnabled */ true);\n      if (owner) startRun(rec, owner.fetcher, owner.retry);\n    }\n    return count;\n  }\n\n  /**\n   * Drop every record. In-flight runs are aborted (a settle() termination).\n   * Live observers re-resolve fresh records on the version bump \u2014 enabled\n   * ones revalidate immediately.\n   */\n  clear(): void {\n    for (const rec of this._records.values()) {\n      rec.generation++;\n      rec.controller?.abort();\n      rec.terminate?.();\n      rec.controller = null;\n      rec.terminate = null;\n      rec.runPromise = null;\n      rec.running = false;\n      rec.observers.clear();\n    }\n    this._records.clear();\n    this._version.value++;\n  }\n\n  /**\n   * Imperatively warm a record. Joins an in-flight run; a fresh record\n   * (per the given staleTime) is a no-op. Otherwise starts a run with THE\n   * GIVEN fetcher \u2014 an explicit imperative is its own owner. The run\n   * commits even with zero observers. Resolves at run termination.\n   */\n  prefetch<T>(key: QueryKey, fetcher: QueryFetcher<T>, staleTime = 0): Promise<void> {\n    const rec = resolveRecord(this, key);\n    if (rec.running) return rec.runPromise ?? Promise.resolve();\n    if (!rec.stale && peek(rec.status) === 'success' && staleTime > 0\n      && Date.now() - peek(rec.fetchedAt) < staleTime) {\n      return Promise.resolve();\n    }\n    return startRun(rec, fetcher as QueryFetcher<unknown>, 0);\n  }\n}\n\n/** Get-or-create the record for a key. Validation throws N602. */\nfunction resolveRecord(client: QueryClient, rawKey: unknown): QueryRecord {\n  const key = validateKey(rawKey);\n  const serialized = serializeKey(key);\n  let rec = client._records.get(serialized);\n  if (!rec) {\n    rec = {\n      key,\n      serialized,\n      data: signal<unknown>(undefined),\n      error: signal<Error | null>(null),\n      status: signal<QueryStatus>('idle'),\n      fetchedAt: signal(0),\n      stale: false,\n      running: false,\n      generation: 0,\n      controller: null,\n      runPromise: null,\n      terminate: null,\n      observers: new Set(),\n    };\n    client._records.set(serialized, rec); // never deleted \u2014 documented bound\n  }\n  return rec;\n}\n\n/** The observer whose fetcher/options own the next run: most recently\n *  mounted, preferring enabled observers (a disabled observer asked not\n *  to fetch \u2014 its fetcher should not fire). */\nfunction ownerOf(rec: QueryRecord, requireEnabled = false): QueryObserver | undefined {\n  let best: QueryObserver | undefined;\n  let bestDisabled: QueryObserver | undefined;\n  for (const obs of rec.observers) {\n    if (obs.enabled) {\n      if (!best || obs.mountIndex > best.mountIndex) best = obs;\n    } else if (!requireEnabled) {\n      if (!bestDisabled || obs.mountIndex > bestDisabled.mountIndex) bestDisabled = obs;\n    }\n  }\n  return best ?? bestDisabled;\n}\n\n/** Does this record need a run, per THIS observer's freshness policy?\n *  Called only on real transitions (registration, re-enable, clear());\n *  record reads are untracked, so commits never re-trigger observers. */\nfunction needsRun(rec: QueryRecord, observer: QueryObserver): boolean {\n  if (rec.running) return false; // join the in-flight logical request\n  if (rec.stale) return true;\n  const status = peek(rec.status);\n  if (status === 'idle' || status === 'error') return true;\n  if (observer.staleTime <= 0) return true;\n  return Date.now() - peek(rec.fetchedAt) >= observer.staleTime;\n}\n\n/**\n * THE run: one logical request owning the retry loop and the commit.\n * Supersedes (aborts) any in-flight run for the record. Enrolls in the\n * settle() registry on start and terminates it at commit, terminal error,\n * or abort \u2014 never at raw promise settlement.\n */\nfunction startRun(\n  rec: QueryRecord,\n  fetcher: QueryFetcher<unknown>,\n  retry: number,\n): Promise<void> {\n  // Supersede: abort IS the superseded run's termination.\n  rec.controller?.abort();\n  rec.terminate?.();\n\n  const generation = ++rec.generation;\n  const controller = new AbortController();\n  const terminate = __enrollPending();\n  rec.controller = controller;\n  rec.terminate = terminate;\n  rec.running = true;\n  rec.stale = false;\n  rec.status.value = 'loading';\n  rec.error.value = null;\n\n  const run = (async () => {\n    try {\n      let lastError: Error | null = null;\n      for (let attempt = 0; attempt <= retry; attempt++) {\n        if (generation !== rec.generation) return; // superseded\n        try {\n          // The microtask hop makes a synchronous fetcher throw a normal\n          // rejection \u2014 it enters the same retry/terminal path (issue 0008).\n          const result = await Promise.resolve().then(() => fetcher(controller.signal));\n          if (generation !== rec.generation) return;\n          rec.data.value = result;\n          rec.error.value = null;\n          rec.fetchedAt.value = Date.now();\n          rec.status.value = 'success';\n          return; // commit\n        } catch (cause) {\n          lastError = toError(cause);\n        }\n      }\n      if (generation !== rec.generation) return;\n      rec.error.value = lastError;\n      rec.status.value = 'error'; // terminal error after retries\n    } finally {\n      if (generation === rec.generation) {\n        rec.running = false;\n        rec.controller = null;\n        rec.runPromise = null;\n        rec.terminate = null;\n      }\n      terminate(); // idempotent \u2014 superseded runs already terminated at abort\n    }\n  })();\n  rec.runPromise = run;\n  return run;\n}\n\n// \u2500\u2500 Mixed clients: an eliminated class (formerly N601) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// With inject() as the single resolution path, the only way two clients\n// could mix was provide(QueryClient, ...) landing after queries already\n// bound the auto-created singleton. The injector now throws N501 at that\n// exact provide() (DI freeze, ADR 0030.2 T6), so the split-brain state is\n// unrepresentable in dev and was always silent in prod \u2014 the symptom-side\n// warning this block used to hold (N601) died with its cause. Retired\n// before release; the code number is not reused.\n\n// \u2500\u2500 query() \u2014 the thin observer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Observe the record the reactive key points at.\n *\n * @param keyFn - Returns the flat cache key. Signal reads are tracked; a\n *   key change re-registers the observer on the new record.\n * @param fetcher - Fetches the data; receives the run's AbortSignal.\n * @param options - staleTime / retry / enabled / initialData.\n * @throws N602 synchronously when the initial key violates the contract.\n */\nexport function query<T>(\n  keyFn: () => QueryKey,\n  fetcher: QueryFetcher<T>,\n  options: QueryOptions<T> = {},\n): QueryResult<T> {\n  const { staleTime = 0, retry = 0, enabled, initialData } = options;\n\n  const client = inject(QueryClient);\n\n  // Surface key-contract violations at the call site: the observer effect\n  // is error-contained (a later reactive key going invalid is logged with\n  // the same coded message), so the construction-time key must be checked\n  // synchronously. untrack: query() may run under an ambient observer\n  // (component setup) and key signals must not widen its dependencies.\n  untrack(() => { validateKey(keyFn()); });\n\n  const observer: QueryObserver = {\n    mountIndex: nextMountIndex++,\n    fetcher: fetcher as QueryFetcher<unknown>,\n    staleTime,\n    retry,\n    enabled: true,\n    record: null,\n  };\n  client._observers++;\n\n  const recSig = signal<QueryRecord | null>(null);\n  const enabledSig = signal(true);\n  let disposed = false;\n  let prevEnabled: boolean | null = null;\n  let prevVersion = -1;\n\n  // The registration effect \u2014 depends on keyFn signals, enabled() signals,\n  // and the client version. NEVER on record state (all record reads are\n  // untracked), so commits cannot re-trigger it: run starts happen only on\n  // the real transitions listed in needsRun()'s doc.\n  const stopEffect = effect(() => {\n    if (disposed) return;\n    const version = client._version.value;\n    const key = keyFn();\n    const on = enabled ? !!enabled() : true;\n    const rec = resolveRecord(client, key);\n\n    observer.enabled = on;\n    enabledSig.value = on;\n\n    const moved = rec !== observer.record;\n    if (moved) {\n      observer.record?.observers.delete(observer);\n      rec.observers.add(observer);\n      observer.record = rec;\n      if (initialData !== undefined && peek(rec.status) === 'idle'\n        && peek(rec.data) === undefined) {\n        rec.data.value = initialData; // seed; not a fetch \u2014 status stays idle\n      }\n      recSig.value = rec;\n    }\n\n    const reEnabled = prevEnabled === false && on;\n    const versionChanged = version !== prevVersion;\n    prevEnabled = on;\n    prevVersion = version;\n\n    if (on && (moved || reEnabled || versionChanged) && needsRun(rec, observer)) {\n      const owner = ownerOf(rec) ?? observer;\n      startRun(rec, owner.fetcher, owner.retry);\n    }\n  });\n\n  const dispose = () => {\n    if (disposed) return;\n    disposed = true;\n    observer.record?.observers.delete(observer);\n    observer.record = null;\n    client._observers--;\n    stopEffect();\n    // NOTE: no abort \u2014 a zero-observer in-flight run completes and commits.\n  };\n\n  if (hasContext()) {\n    getCurrentComponent().addDisposer(dispose);\n  }\n\n  const refetch = () => {\n    if (disposed) return;\n    const rec = observer.record;\n    if (!rec || !observer.enabled) return;\n    if (rec.running) return; // join the in-flight logical request (dedup)\n    const owner = ownerOf(rec) ?? observer;\n    startRun(rec, owner.fetcher, owner.retry);\n  };\n\n  const result = {\n    data: computed(() => {\n      const rec = recSig.value;\n      return (rec ? rec.data.value : initialData) as T | undefined;\n    }),\n    loading: computed(() => enabledSig.value && recSig.value?.status.value === 'loading'),\n    error: computed(() => recSig.value?.error.value ?? null),\n    status: computed<QueryStatus>(() => recSig.value?.status.value ?? 'idle'),\n    refetch,\n    dispose,\n  };\n  return disposable(result, dispose);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/bundler/ref.js

@@ -0,0 +1,16 @@
+const REF_BRAND = /* @__PURE__ */ Symbol.for("backlog.ref");
+function ref() {
+  return {
+    [REF_BRAND]: true,
+    current: null
+  };
+}
+function isRef(value) {
+  return value !== null && typeof value === "object" && REF_BRAND in value;
+}
+export {
+  REF_BRAND,
+  isRef,
+  ref
+};
+//# sourceMappingURL=ref.js.map

package/dist/bundler/ref.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ref.ts"],
+  "sourcesContent": ["/**\n * ref.ts \u2014 Element reference primitive for imperative DOM access\n *\n * `ref()` creates a container that receives a DOM element reference\n * after the template is mounted. Use it for focus management, DOM\n * measurement, scroll management, and third-party library init.\n *\n * ```ts\n * const inputRef = ref<HTMLInputElement>();\n *\n * onMount(() => inputRef.current?.focus());\n *\n * return html`<input ref=\"${inputRef}\" @keydown.enter=${onSubmit} />`;\n * ```\n *\n * The template engine detects `Ref` objects in `ref=\"${...}\"`\n * attribute bindings and assigns the referenced element.\n */\n\n// \u2500\u2500 Brand for ref detection in templates \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport const REF_BRAND = Symbol.for('backlog.ref');\n\n// \u2500\u2500 Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface Ref<T extends Element = Element> {\n  readonly [REF_BRAND]: true;\n  /** The DOM element, or null before mount / after unmount */\n  current: T | null;\n}\n\n// \u2500\u2500 Public API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Create a ref container for imperative DOM access.\n *\n * After the template is mounted, `ref.current` holds the element.\n * After dispose, `ref.current` is set back to null.\n */\nexport function ref<T extends Element = Element>(): Ref<T> {\n  return {\n    [REF_BRAND]: true as const,\n    current: null,\n  };\n}\n\n/**\n * Check if a value is a Ref.\n * Used by the template engine to detect refs in expression slots.\n */\nexport function isRef(value: unknown): value is Ref {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    REF_BRAND in (value as Record<symbol, unknown>)\n  );\n}\n"],
+  "mappings": "AAqBO,MAAM,YAAY,uBAAO,IAAI,aAAa;AAkB1C,SAAS,MAA2C;AACzD,SAAO;AAAA,IACL,CAAC,SAAS,GAAG;AAAA,IACb,SAAS;AAAA,EACX;AACF;AAMO,SAAS,MAAM,OAA8B;AAClD,SACE,UAAU,QACV,OAAO,UAAU,YACjB,aAAc;AAElB;",
+  "names": []
+}