@nisli/core 0.55.0 → 0.57.0

package/dist/index.js

@@ -1,44 +1,2607 @@
-/**
- * packages/framework/ — Public API barrel export
- *
- * This is the single import point for all framework primitives.
- *
- * ```ts
- * import {
- *   signal, computed, effect, flush,
- *   component, html, when,
- *   inject, provide,
- *   Emitter,
- *   query, QueryClient,
- * } from './framework';
- * ```
- */
-// ── Reactivity ──────────────────────────────────────────────────────
-export { signal, computed, effect, flush, tick, isSignal, flushEffects, untrack, SIGNAL_BRAND, } from './signal.js';
-// ── Setup context ───────────────────────────────────────────────────
-export { runWithContext, getCurrentComponent, hasContext, } from './context.js';
-// ── Typed event emitters ────────────────────────────────────────────
-export { Emitter } from './emitter.js';
-// ── Dependency injection (app-global) ───────────────────────────────
-export { inject, provide, createToken, resetInjector, } from './injector.js';
-// ── Subtree-scoped context (DOM provide/inject) ─────────────────────
-export { createContext, } from './element-context.js';
-// ── Component model ─────────────────────────────────────────────────
-export { component, } from './component.js';
-// ── Template engine ─────────────────────────────────────────────────
-export { html, el, when, each, raw, sanitized, setSanitizerFallback, } from './template.js';
-// ── Element refs ────────────────────────────────────────────────────
-export { ref, isRef, } from './ref.js';
-// ── Lifecycle hooks ─────────────────────────────────────────────────
-export { onMount, onCleanup, useHostEvent, } from './lifecycle.js';
-// ── Content projection (ADR 0025 item 1) ────────────────
-export { children, } from './projection.js';
-// ── Declarative data loading (keyed logical-request store) ──────────
-export { query, QueryClient, } from './query.js';
-// ── Local async derivations ─────────────────────────────────────────
-export { resource, } from './resource.js';
-// ── Async quiescence (test/verify + SSG pre-snapshot barrier) ───────
-export { settle } from './settle.js';
-// ── View Transitions (opt-in wrapper over the synchronous flush) ────
-export { viewTransition, } from './view-transition.js';
-//# sourceMappingURL=index.js.map
+// src/diagnostics.ts
+var override = null;
+function isDev() {
+  return override ?? true;
+}
+function setDevMode(on) {
+  if (true) override = on;
+}
+function formatDiag(code, message) {
+  return `[nisli ${code}] ${message}`;
+}
+function diag(code, message, detail) {
+  if (detail === void 0) {
+    console.error(formatDiag(code, message));
+  } else {
+    console.error(formatDiag(code, message), detail);
+  }
+}
+
+// src/disposable.ts
+var DISPOSE = Symbol.dispose;
+function disposable(value, dispose) {
+  if (DISPOSE) value[DISPOSE] = dispose;
+  return value;
+}
+
+// src/signal.ts
+var contextHook = null;
+function setContextHook(hook) {
+  contextHook = hook;
+}
+var SIGNAL_BRAND = /* @__PURE__ */ Symbol.for("backlog.signal");
+var activeObserver = null;
+var runningEffect = null;
+var globalEpoch = 0;
+var nextEffectOrder = 0;
+function diag2(code, message, detail) {
+  if (!isDev()) return;
+  diag(code, message, detail);
+}
+var pendingEffects = /* @__PURE__ */ new Set();
+var flushScheduled = false;
+function scheduleFlush() {
+  if (!flushScheduled) {
+    flushScheduled = true;
+    queueMicrotask(flushPendingEffects);
+  }
+}
+function flushPendingEffects() {
+  flushScheduled = false;
+  const effects = [...pendingEffects].sort((a, b) => a.order - b.order);
+  pendingEffects.clear();
+  for (const effect3 of effects) {
+    if (!effect3.disposed) {
+      runEffect(effect3);
+    }
+  }
+}
+var NO_COMPUTED_ERROR = /* @__PURE__ */ Symbol("no-computed-error");
+var SignalImpl = class {
+  [SIGNAL_BRAND] = true;
+  /** @internal */
+  _node;
+  constructor(initialValue) {
+    this._node = {
+      value: initialValue,
+      lastChanged: globalEpoch,
+      observers: /* @__PURE__ */ new Set()
+    };
+  }
+  get value() {
+    if (activeObserver) {
+      activeObserver.sources.add(this._node);
+      this._node.observers.add(activeObserver);
+    }
+    return this._node.value;
+  }
+  set value(newValue) {
+    if (Object.is(this._node.value, newValue)) return;
+    if (isDev() && runningEffect !== null && runningEffect.sources.has(this._node)) {
+      diag2(
+        "N302",
+        "Effect wrote to a signal it also reads \u2014 the write re-schedules the effect. If this does not converge to an equal value it is an infinite loop. Derive the value with computed() instead.",
+        runningEffect.createdAt ? { effect: runningEffect.createdAt } : void 0
+      );
+    }
+    this._node.value = newValue;
+    this._node.lastChanged = ++globalEpoch;
+    notifyObservers(this._node.observers, 2 /* Dirty */);
+  }
+  peek() {
+    return this._node.value;
+  }
+  subscribe(fn) {
+    return effect(() => {
+      const value = this.value;
+      untrack(() => fn(value));
+    });
+  }
+};
+function notifyObservers(observers, flavor) {
+  for (const observer of observers) {
+    observer.notify(flavor);
+  }
+}
+var ComputedImpl = class {
+  [SIGNAL_BRAND] = true;
+  /** @internal */
+  _node;
+  compute;
+  state = 2 /* Dirty */;
+  // Start dirty so first read computes
+  sources = /* @__PURE__ */ new Set();
+  computing = false;
+  error = NO_COMPUTED_ERROR;
+  /**
+   * globalEpoch snapshot at the end of the last update()/validation pass.
+   * A MaybeDirty computed recomputes only if some source's lastChanged
+   * advanced past this — otherwise it revalidates to Clean for free.
+   */
+  lastValidated = 0;
+  constructor(fn) {
+    this.compute = fn;
+    this._node = {
+      value: void 0,
+      lastChanged: 0,
+      observers: /* @__PURE__ */ new Set(),
+      pull: () => {
+        this.peek();
+      }
+    };
+  }
+  get value() {
+    if (this.computing) {
+      throw new Error("Circular dependency detected in computed()");
+    }
+    if (activeObserver) {
+      activeObserver.sources.add(this._node);
+      this._node.observers.add(activeObserver);
+    }
+    if (this.state !== 0 /* Clean */) {
+      this.update();
+    }
+    if (this.error !== NO_COMPUTED_ERROR) {
+      throw this.error;
+    }
+    return this._node.value;
+  }
+  peek() {
+    if (this.computing) {
+      throw new Error("Circular dependency detected in computed()");
+    }
+    if (this.state !== 0 /* Clean */) {
+      this.update();
+    }
+    if (this.error !== NO_COMPUTED_ERROR) {
+      throw this.error;
+    }
+    return this._node.value;
+  }
+  /**
+   * MaybeDirty validation: pull each source (computeds recompute lazily) and
+   * report whether any source's change-epoch advanced past our last
+   * validation. A pulled source may throw — its error-state transition
+   * already bumped its change-epoch, so the epoch comparison decides.
+   */
+  sourcesChanged() {
+    for (const source of this.sources) {
+      if ("pull" in source) {
+        try {
+          source.pull();
+        } catch (_) {
+        }
+      }
+      if (source.lastChanged > this.lastValidated) return true;
+    }
+    return false;
+  }
+  update() {
+    if (this.state === 1 /* MaybeDirty */ && !this.sourcesChanged()) {
+      this.state = 0 /* Clean */;
+      this.lastValidated = globalEpoch;
+      return;
+    }
+    for (const source of this.sources) {
+      source.observers.delete(this);
+    }
+    this.sources.clear();
+    const prevObserver = activeObserver;
+    activeObserver = this;
+    this.computing = true;
+    const wasError = this.error !== NO_COMPUTED_ERROR;
+    try {
+      const newValue = this.compute();
+      this.error = NO_COMPUTED_ERROR;
+      if (!Object.is(this._node.value, newValue)) {
+        this._node.value = newValue;
+        this._node.lastChanged = ++globalEpoch;
+      } else if (wasError) {
+        this._node.lastChanged = ++globalEpoch;
+      }
+    } catch (error) {
+      this.error = error;
+      if (!wasError) {
+        this._node.lastChanged = ++globalEpoch;
+      }
+      throw error;
+    } finally {
+      this.computing = false;
+      activeObserver = prevObserver;
+      this.state = 0 /* Clean */;
+      this.lastValidated = globalEpoch;
+    }
+  }
+  /** @internal — called by the ReactiveNode interface when a source changes */
+  notify(flavor) {
+    if (flavor > this.state) {
+      const wasClean = this.state === 0 /* Clean */;
+      this.state = flavor;
+      if (wasClean) {
+        notifyObservers(this._node.observers, 1 /* MaybeDirty */);
+      }
+    }
+  }
+  subscribe(fn) {
+    return effect(() => {
+      const value = this.value;
+      untrack(() => fn(value));
+    });
+  }
+  // ReactiveNode interface — used by dependency tracking
+  get sources_() {
+    return this.sources;
+  }
+};
+Object.defineProperty(ComputedImpl.prototype, "sources", {
+  enumerable: false
+});
+var MAX_EFFECT_RERUNS = 100;
+function createEffectNode(fn) {
+  return {
+    state: 2 /* Dirty */,
+    fn,
+    cleanup: null,
+    disposed: false,
+    sources: /* @__PURE__ */ new Set(),
+    disposers: [],
+    order: nextEffectOrder++,
+    lastRunEpoch: 0,
+    selfReschedules: 0,
+    notify(flavor) {
+      if (this.disposed) return;
+      if (flavor > this.state) this.state = flavor;
+      pendingEffects.add(this);
+      scheduleFlush();
+    }
+  };
+}
+function effectSourcesChanged(node) {
+  for (const source of node.sources) {
+    if ("pull" in source) {
+      try {
+        source.pull();
+      } catch (_) {
+      }
+    }
+    if (source.lastChanged > node.lastRunEpoch) return true;
+  }
+  return false;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function runEffect(node) {
+  if (node.disposed) return;
+  if (node.state === 1 /* MaybeDirty */ && !effectSourcesChanged(node)) {
+    node.state = 0 /* Clean */;
+    return;
+  }
+  if (node.cleanup) {
+    try {
+      node.cleanup();
+    } catch (_) {
+    }
+    node.cleanup = null;
+  }
+  for (const source of node.sources) {
+    source.observers.delete(node);
+  }
+  node.sources.clear();
+  node.state = 0 /* Clean */;
+  const prevObserver = activeObserver;
+  const prevRunning = true ? runningEffect : null;
+  activeObserver = node;
+  if (true) runningEffect = node;
+  try {
+    const result = node.fn();
+    if (typeof result === "function") {
+      node.cleanup = result;
+    } else if (isThenable(result)) {
+      if (isDev() && !node.asyncWarned) {
+        node.asyncWarned = true;
+        diag2(
+          "N310",
+          "effect() callback returned a Promise \u2014 effects must be synchronous. Async state belongs in resource(). The returned Promise is not a cleanup function; its rejection is contained by the effect error path.",
+          node.createdAt ? { effect: node.createdAt } : void 0
+        );
+      }
+      result.then(void 0, (err) => {
+        console.error("Effect error:", err);
+      });
+    }
+  } catch (err) {
+    console.error("Effect error:", err);
+  } finally {
+    activeObserver = prevObserver;
+    if (true) runningEffect = prevRunning;
+    node.lastRunEpoch = globalEpoch;
+  }
+  if (pendingEffects.has(node)) {
+    if (++node.selfReschedules > MAX_EFFECT_RERUNS) {
+      if (isDev()) diag2(
+        "N301",
+        `Effect exceeded maximum re-run limit (${MAX_EFFECT_RERUNS}). This usually means the effect writes to a signal it reads. The effect has been disposed to prevent a UI freeze.`,
+        node.createdAt ? { effect: node.createdAt } : void 0
+      );
+      node.disposed = true;
+      for (const source of node.sources) {
+        source.observers.delete(node);
+      }
+      node.sources.clear();
+      pendingEffects.delete(node);
+    }
+  } else {
+    node.selfReschedules = 0;
+  }
+}
+function signal(initialValue) {
+  return new SignalImpl(initialValue);
+}
+function computed(fn) {
+  return new ComputedImpl(fn);
+}
+function effect(fn, ..._rejectAsync) {
+  const node = createEffectNode(fn);
+  if (isDev()) {
+    node.createdAt = new Error("effect() created here").stack;
+  }
+  runEffect(node);
+  const dispose = () => {
+    node.disposed = true;
+    if (node.cleanup) {
+      try {
+        node.cleanup();
+      } catch (_) {
+      }
+      node.cleanup = null;
+    }
+    for (const source of node.sources) {
+      source.observers.delete(node);
+    }
+    node.sources.clear();
+    pendingEffects.delete(node);
+  };
+  if (contextHook) {
+    const addDisposer = contextHook();
+    if (addDisposer) {
+      addDisposer(dispose);
+    }
+  }
+  return disposable(dispose, dispose);
+}
+function isSignal(value) {
+  return value !== null && typeof value === "object" && SIGNAL_BRAND in value;
+}
+function untrack(fn) {
+  const prev = activeObserver;
+  activeObserver = null;
+  try {
+    return fn();
+  } finally {
+    activeObserver = prev;
+  }
+}
+function flush() {
+  let guard = 0;
+  while (pendingEffects.size > 0) {
+    flushPendingEffects();
+    if (++guard > 1e5) {
+      if (isDev()) diag2(
+        "N303",
+        "flush() cascade cap reached (100000 passes) \u2014 effects keep scheduling more effects (a cross-effect write cycle?). Breaking out to avoid a freeze; pending work remains unflushed."
+      );
+      break;
+    }
+  }
+}
+async function tick() {
+  flush();
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    if (pendingEffects.size === 0) return;
+    flush();
+  }
+  if (isDev()) diag2(
+    "N303",
+    "tick() iteration cap (50) reached with effects still pending \u2014 something keeps scheduling reactive work every task (a self-perpetuating scheduler?). Returning with work still queued."
+  );
+}
+
+// src/context.ts
+var currentComponent = null;
+function runWithContext(component2, fn) {
+  const prev = currentComponent;
+  currentComponent = component2;
+  try {
+    fn();
+  } finally {
+    currentComponent = prev;
+  }
+}
+function getCurrentComponent() {
+  if (!currentComponent) {
+    throw new Error(
+      "getCurrentComponent() called outside setup(). inject(), effect(), and other context-dependent functions can only be called during component initialization."
+    );
+  }
+  return currentComponent;
+}
+function hasContext() {
+  return currentComponent !== null;
+}
+
+// src/emitter.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Emit a typed event. All subscribers for this event name are called
+   * synchronously. If a subscriber throws, other subscribers still fire.
+   */
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const fn of [...set]) {
+      try {
+        fn(payload);
+      } catch (err) {
+        console.error(`Emitter: subscriber for '${String(event)}' threw:`, err);
+      }
+    }
+  }
+  /**
+   * Subscribe to a typed event. Returns an unsubscribe function.
+   *
+   * If called during component setup, the subscription is automatically
+   * disposed on disconnectedCallback.
+   */
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    const unsubscribe = () => {
+      set.delete(fn);
+      if (set.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+    if (hasContext()) {
+      getCurrentComponent().addDisposer(unsubscribe);
+    }
+    return disposable(unsubscribe, unsubscribe);
+  }
+  /**
+   * Bridge an event into the signal system.
+   * Returns a signal that updates whenever the event fires.
+   *
+   * @param event - Event name to subscribe to
+   * @param selector - Transform the payload into the signal value
+   * @param initial - Initial signal value before any event fires
+   */
+  toSignal(event, selector, initial) {
+    const s = signal(initial);
+    this.on(event, (payload) => {
+      s.value = selector(payload);
+    });
+    return s;
+  }
+  /**
+   * Remove all subscribers. Useful for testing cleanup.
+   */
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/injector.ts
+var singletonCache = /* @__PURE__ */ new Map();
+var factoryOverrides = /* @__PURE__ */ new Map();
+var instantiating = /* @__PURE__ */ new Set();
+function inject(token) {
+  if (singletonCache.has(token)) {
+    return singletonCache.get(token);
+  }
+  if (instantiating.has(token)) {
+    const name = typeof token === "function" ? token.name : token.name;
+    throw new Error(
+      `Circular dependency detected when instantiating '${name}'. Check your service constructors for circular inject() calls.`
+    );
+  }
+  instantiating.add(token);
+  try {
+    let instance;
+    const factory = factoryOverrides.get(token);
+    if (factory) {
+      instance = factory();
+    } else if (typeof token === "function") {
+      instance = new token();
+    } else {
+      const injToken = token;
+      if (injToken._factory) {
+        instance = injToken._factory();
+      } else {
+        throw new Error(
+          `No provider found for token '${injToken.name}'. Use provide() to register a factory before calling inject().`
+        );
+      }
+    }
+    singletonCache.set(token, instance);
+    return instance;
+  } finally {
+    instantiating.delete(token);
+  }
+}
+function provide(token, factory) {
+  if (isDev() && singletonCache.has(token)) {
+    const name = typeof token === "function" ? token.name : token.name;
+    throw new Error(formatDiag(
+      "N501",
+      `provide(${name}) after '${name}' was already instantiated \u2014 existing consumers keep the old instance while new inject() calls would get the new one (mixed-instance split). Call resetInjector() first (tests), or provide() before the first inject().`
+    ));
+  }
+  factoryOverrides.set(token, factory);
+  singletonCache.delete(token);
+}
+function createToken(name, defaultFactory) {
+  return {
+    __brand: "InjectionToken",
+    name,
+    _factory: defaultFactory
+  };
+}
+var resetHooks = /* @__PURE__ */ new Set();
+function registerResetHook(hook) {
+  resetHooks.add(hook);
+}
+function resetInjector() {
+  singletonCache.clear();
+  factoryOverrides.clear();
+  instantiating.clear();
+  for (const hook of resetHooks) hook();
+}
+
+// src/element-context.ts
+function createContext(name, options = {}) {
+  const { providerTag } = options;
+  const KEY = /* @__PURE__ */ Symbol(`nisli.context:${name}`);
+  const store = (el2) => el2;
+  const provide2 = (host, value) => {
+    store(host)[KEY] = value;
+  };
+  const peek2 = (host) => KEY in host ? store(host)[KEY] : void 0;
+  const find = (start) => {
+    let el2 = start;
+    while (el2) {
+      if (KEY in el2) return store(el2)[KEY];
+      el2 = el2.parentElement;
+    }
+    return void 0;
+  };
+  const startHost = (host, caller) => {
+    if (host) return host;
+    if (!hasContext()) {
+      throw new Error(
+        `${caller} for context "${name}" was called without a host and outside component setup. Call it during setup (so the provider is resolved before any portal move), or pass an explicit host.`
+      );
+    }
+    return getCurrentComponent().element;
+  };
+  const inject2 = ((host) => {
+    const start = startHost(host, "inject()");
+    const found = find(start);
+    if (found === void 0) {
+      const injectingTag = start.tagName.toLowerCase();
+      throw new Error(
+        providerTag ? `Context "${name}": <${injectingTag}> must be used inside <${providerTag}>.` : `Context "${name}" not found: <${injectingTag}> must be rendered inside a provider that calls ${name}Context.provide(host, \u2026).`
+      );
+    }
+    return found;
+  });
+  inject2.optional = (host) => {
+    if (!host && !hasContext()) return void 0;
+    return find(startHost(host, "inject.optional()"));
+  };
+  return { name, provide: provide2, inject: inject2, peek: peek2 };
+}
+
+// src/lifecycle.ts
+var 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);
+  }
+}
+
+// src/component.ts
+var propsReadKeys = true ? /* @__PURE__ */ new WeakMap() : void 0;
+var completedSetups = true ? /* @__PURE__ */ new WeakSet() : void 0;
+var echoedProps = true ? /* @__PURE__ */ new WeakMap() : void 0;
+setContextHook(() => {
+  if (hasContext()) {
+    const comp = getCurrentComponent();
+    return (disposer) => comp.addDisposer(disposer);
+  }
+  return null;
+});
+var camelToKebab = (s) => s.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+var declType = (decl) => typeof decl === "string" ? decl : decl.type;
+var declAttrName = (key, decl) => typeof decl === "object" && decl.attr ? decl.attr : camelToKebab(key);
+function resolveAttrValue(decl, raw2) {
+  const t = declType(decl);
+  if (t === "boolean") {
+    const def = typeof decl === "object" && "default" in decl && decl.default !== void 0 ? decl.default : false;
+    if (raw2 === null) return def;
+    return raw2 !== "false";
+  }
+  if (t === "number") {
+    const def = typeof decl === "object" && "default" in decl ? decl.default : void 0;
+    if (raw2 === null) return def;
+    const n = Number(raw2);
+    return Number.isNaN(n) ? def : n;
+  }
+  if (raw2 === null) {
+    return typeof decl === "object" && "default" in decl ? decl.default : void 0;
+  }
+  return raw2;
+}
+var ComponentHostImpl = class {
+  element;
+  disposers = [];
+  setupComplete = false;
+  constructor(element) {
+    this.element = element;
+  }
+  addDisposer(fn) {
+    this.disposers.push(fn);
+  }
+  dispose() {
+    for (const fn of this.disposers) {
+      try {
+        fn();
+      } catch (_) {
+      }
+    }
+    this.disposers.length = 0;
+  }
+};
+function createPropsProxy() {
+  const signals = /* @__PURE__ */ new Map();
+  const getOrCreate = (key, initialValue) => {
+    let s = signals.get(key);
+    if (!s) {
+      s = signal(initialValue);
+      signals.set(key, s);
+    }
+    return s;
+  };
+  const props = new Proxy({}, {
+    get(_target, key) {
+      if (typeof key !== "string") return void 0;
+      if (true) propsReadKeys.get(props).add(key);
+      return getOrCreate(key);
+    }
+  });
+  if (true) propsReadKeys.set(props, /* @__PURE__ */ new Set());
+  const setProperty = (key, value) => {
+    const s = getOrCreate(key, value);
+    s.value = value;
+  };
+  return { props, setProperty };
+}
+var firstDefineSites = true ? /* @__PURE__ */ new Map() : void 0;
+function captureDefineSite() {
+  const stack = new Error().stack;
+  if (!stack) return "(site unavailable)";
+  const lines = stack.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    if (line.includes("captureDefineSite") || /[/\\]component\.(?:ts|js)\b/.test(line)) continue;
+    return line;
+  }
+  return "(site unavailable)";
+}
+function component(tagName, setup, ...[options]) {
+  const attrEntries = /* @__PURE__ */ new Map();
+  const attrEntriesByKey = /* @__PURE__ */ new Map();
+  if (options?.attrs) {
+    for (const key of Object.keys(options.attrs)) {
+      const decl = options.attrs[key];
+      const attrName = declAttrName(key, decl);
+      const entry = { key, attrName, decl };
+      attrEntries.set(attrName, entry);
+      attrEntriesByKey.set(key, entry);
+    }
+  }
+  const observedList = Array.from(attrEntries.keys());
+  class FrameworkComponent extends HTMLElement {
+    _host = null;
+    _propsProxy = null;
+    _mounted = false;
+    _templateResult = null;
+    _errorTemplateResult = null;
+    _teardownScheduled = false;
+    // Props explicitly set via _setProp (factory / direct assignment) are
+    // "pinned": an explicit prop wins, so attribute writes no longer overwrite
+    // it. (Precedence ruling: prop-pins.)
+    _pinned = /* @__PURE__ */ new Set();
+    // Guards our own removeAttribute() during 'forward' relocation from
+    // re-entering attributeChangedCallback.
+    _relocating = false;
+    /** The browser reads this once at define time. Empty → no callbacks. */
+    static get observedAttributes() {
+      return observedList;
+    }
+    constructor() {
+      super();
+      this._propsProxy = createPropsProxy();
+    }
+    /** Write one declared attribute onto its prop signal, honoring pinning. */
+    _applyAttr(entry, raw2) {
+      if (declType(entry.decl) === "forward") {
+        if (raw2 !== null) {
+          if (!this._pinned.has(entry.key)) {
+            this._propsProxy.setProperty(entry.key, raw2);
+          }
+          this._relocating = true;
+          this.removeAttribute(entry.attrName);
+          this._relocating = false;
+        }
+        return;
+      }
+      if (this._pinned.has(entry.key)) return;
+      this._propsProxy.setProperty(entry.key, resolveAttrValue(entry.decl, raw2));
+    }
+    /** Seed initial prop values from current attributes (incl. defaults). */
+    _seedAttrs() {
+      for (const entry of attrEntries.values()) {
+        this._applyAttr(entry, this.getAttribute(entry.attrName));
+      }
+    }
+    attributeChangedCallback(name, _old, next) {
+      if (this._relocating) return;
+      const entry = attrEntries.get(name);
+      if (entry) this._applyAttr(entry, next);
+    }
+    connectedCallback() {
+      if (this._mounted) return;
+      this._mounted = true;
+      untrack(() => {
+        const host = new ComponentHostImpl(this);
+        this._host = host;
+        if (attrEntries.size) this._seedAttrs();
+        if (this.childNodes.length) {
+          this.__capturedChildren = Array.from(this.childNodes);
+        }
+        let phase = "setup";
+        try {
+          runWithContext(host, () => {
+            this._templateResult = setup(
+              this._propsProxy.props,
+              this
+            );
+          });
+          if (this._templateResult) {
+            mountTemplate(this, this._templateResult, host);
+          }
+          const sweepHost = this;
+          if (sweepHost.__nisliProjectionSweep) {
+            const sweep = sweepHost.__nisliProjectionSweep;
+            sweepHost.__nisliProjectionSweep = void 0;
+            sweep();
+          }
+          phase = "mount";
+          runMountCallbacks(host);
+          if (true) completedSetups.add(this);
+          this.removeAttribute("data-nisli-error");
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          const code = phase === "setup" ? "N401" : "N402";
+          diag(code, `<${tagName}> ${phase} failed: ${error.message}`, {
+            tag: tagName,
+            phase,
+            error
+          });
+          this.__nisliProjectionSweep = void 0;
+          if (this._templateResult?.dispose) {
+            this._templateResult.dispose();
+          }
+          this._templateResult = null;
+          host.dispose();
+          this._host = null;
+          this.replaceChildren();
+          this.setAttribute("data-nisli-error", code);
+          if (options?.onError) {
+            try {
+              const fallback = options.onError(error, this);
+              if (typeof fallback === "string") {
+                this.innerHTML = fallback;
+              } else {
+                this._errorTemplateResult = fallback;
+                mountTemplate(this, fallback);
+              }
+            } catch (_) {
+              if (this._errorTemplateResult?.dispose) {
+                this._errorTemplateResult.dispose();
+              }
+              this._errorTemplateResult = null;
+              this.innerHTML = `<div style="color:red;padding:4px">Error in &lt;${tagName}&gt;</div>`;
+            }
+          } else {
+            this.innerHTML = `<div style="color:red;padding:4px">Error in &lt;${tagName}&gt;</div>`;
+          }
+          this.dispatchEvent(
+            new CustomEvent("nisli-error", {
+              bubbles: true,
+              composed: true,
+              detail: { code, tag: tagName, phase, message: error.message }
+            })
+          );
+        }
+      });
+    }
+    disconnectedCallback() {
+      if (this._teardownScheduled) return;
+      this._teardownScheduled = true;
+      queueMicrotask(() => {
+        this._teardownScheduled = false;
+        if (this.isConnected) return;
+        this._teardownNow();
+      });
+    }
+    /**
+     * Atomic DOM moves preserve this component's position-independent state,
+     * so the platform-level lifecycle is a no-op. ADR 0023's deferred
+     * disconnect teardown remains the fallback for append-based moves.
+     */
+    connectedMoveCallback() {
+    }
+    /**
+     * Synchronously dispose the current component scope and restore any
+     * projected light-DOM children as direct host children. Normal disconnect
+     * calls this after the move-detection microtask; HMR calls it directly so
+     * reconnect cannot be defeated by the `_mounted` guard (issues 0001/0002).
+     */
+    _teardownNow() {
+      this._mounted = false;
+      if (true) completedSetups.delete(this);
+      if (this._templateResult?.dispose) {
+        this._templateResult.dispose();
+      }
+      this._templateResult = null;
+      if (this._errorTemplateResult?.dispose) {
+        this._errorTemplateResult.dispose();
+      }
+      this._errorTemplateResult = null;
+      if (this._host) {
+        this._host.dispose();
+        this._host = null;
+      }
+      const captured = this.__capturedChildren ?? [];
+      this.replaceChildren(...captured);
+    }
+    /** @internal — transport-agnostic HMR in-place remount hook. */
+    _remount() {
+      this._teardownScheduled = false;
+      this._teardownNow();
+      this.connectedCallback();
+    }
+    /**
+     * Set a prop value. Called by the factory and by direct property assignment.
+     * The Proxy intercepts and creates/updates backing signals.
+     *
+     * Precedence = DEFINED-write-pins (ADR 0025 item 3): a defined
+     * value pins the key so a declared attribute no longer overwrites it. An
+     * explicit `undefined` (e.g. a factory spreading an unset optional prop —
+     * `{...opts}` fires _setProp(key, undefined) per the Object.entries walk)
+     * must NOT pin; it falls back to the declared attribute/default, matching
+     * attr()'s coalesce. For a declared attribute, that fallback re-resolves
+     * from the current attribute, keeping declared-default booleans
+     * non-undefined.
+     */
+    _setProp(key, value) {
+      if (completedSetups.has(this) && value !== void 0 && isDev() && !attrEntriesByKey.has(key) && !propsReadKeys.get(this._propsProxy.props).has(key) && !echoedProps.get(this)?.has(key)) {
+        const echoed = echoedProps.get(this) ?? /* @__PURE__ */ new Set();
+        echoed.add(key);
+        echoedProps.set(this, echoed);
+        diag(
+          "N202",
+          `<${tagName}> prop '${key}' was set but setup() never read it \u2014 misspelled or unsupported prop?`,
+          { tag: tagName, key }
+        );
+      }
+      if (value === void 0) {
+        this._pinned.delete(key);
+        const entry = attrEntriesByKey.get(key);
+        if (entry) {
+          const raw2 = this.getAttribute(entry.attrName);
+          if (raw2 === null && declType(entry.decl) === "forward") {
+            this._propsProxy?.setProperty(key, resolveAttrValue(entry.decl, null));
+          } else {
+            this._applyAttr(entry, raw2);
+          }
+          return;
+        }
+      } else {
+        this._pinned.add(key);
+      }
+      this._propsProxy?.setProperty(key, value);
+    }
+    /**
+     * Read a prop's backing signal (framework-internal). Used by children()
+     * to fold the factory `children` prop into the projection slot (ADR 0025
+     * item 1) without a new public read API.
+     */
+    _propSignal(key) {
+      return this._propsProxy.props[key];
+    }
+    /**
+     * Whether a prop is currently pinned by a defined factory/property write
+     * (framework-internal, like _propSignal). The attribute-as-truth open-state
+     * pattern needs this as its controlled-mode discriminator: a declared
+     * 'boolean' prop is never undefined (absent → false), so pin state is the
+     * ONLY way a component can tell "parent drives this" from "the attribute
+     * drives this" — e.g. setOpen() must not write the open attribute while a
+     * controlled parent has it pinned, or the DOM attribute diverges from the
+     * pinned state until the next prop write.
+     */
+    _isPinned(key) {
+      return this._pinned.has(key);
+    }
+  }
+  if (!customElements.get(tagName)) {
+    customElements.define(tagName, FrameworkComponent);
+    if (isDev()) firstDefineSites.set(tagName, captureDefineSite());
+  } else if (isDev() && !setup.__nisliHmr) {
+    const first = firstDefineSites.get(tagName) ?? "(unknown site \u2014 defined outside component(), or before dev mode was enabled)";
+    throw new Error(formatDiag(
+      "N201",
+      `duplicate define for <${tagName}>. First defined ${first}; the second definition site is this error's own stack. The first definition stays live (first-wins) \u2014 rename one of the components.`
+    ));
+  }
+  const factory = (props, hostAttrs) => {
+    return {
+      __type: "factory",
+      tagName,
+      props,
+      hostAttrs
+    };
+  };
+  return factory;
+}
+function ensureSignal(value) {
+  if (isSignal(value)) return value;
+  return signal(value);
+}
+function mountTemplate(host, result, hostImpl) {
+  if (result && typeof result === "object" && "mount" in result && typeof result.mount === "function") {
+    result.mount(host);
+  } else if (result && typeof result === "object" && "__type" in result) {
+    const factoryResult = result;
+    const el2 = document.createElement(factoryResult.tagName);
+    for (const [key, raw2] of Object.entries(factoryResult.props)) {
+      const sig = ensureSignal(raw2);
+      el2._setProp(key, sig.value);
+      const unsub = sig.subscribe((newVal) => {
+        el2._setProp(key, newVal);
+      });
+      if (hostImpl) {
+        hostImpl.addDisposer(unsub);
+      }
+    }
+    if (factoryResult.hostAttrs?.class != null) {
+      const classSig = ensureSignal(factoryResult.hostAttrs.class);
+      applyHostClass(el2, "", classSig.value);
+      let prevClass = classSig.value;
+      const unsub = classSig.subscribe((newClass) => {
+        applyHostClass(el2, prevClass, newClass);
+        prevClass = newClass;
+      });
+      if (hostImpl) {
+        hostImpl.addDisposer(unsub);
+      }
+    }
+    host.appendChild(el2);
+  }
+}
+function applyHostClass(el2, prev, next) {
+  const prevClasses = prev ? prev.split(/\s+/).filter(Boolean) : [];
+  const nextClasses = next ? next.split(/\s+/).filter(Boolean) : [];
+  for (const cls of prevClasses) {
+    if (!nextClasses.includes(cls)) el2.classList.remove(cls);
+  }
+  for (const cls of nextClasses) {
+    if (!prevClasses.includes(cls)) el2.classList.add(cls);
+  }
+}
+
+// src/ref.ts
+var 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;
+}
+
+// src/template-audit.ts
+var enabledOverride = null;
+function isTemplateAuditEnabled() {
+  return enabledOverride ?? isDev();
+}
+function diag3(code, message, detail) {
+  if (!isTemplateAuditEnabled()) return;
+  diag(code, message, detail === void 0 ? void 0 : { detail });
+}
+var callsites = true ? /* @__PURE__ */ new WeakMap() : void 0;
+function captureCallsite(strings) {
+  if (!isTemplateAuditEnabled() || callsites.has(strings)) return;
+  const stack = new Error().stack ?? "";
+  const frame = stack.split("\n").slice(1).find((line) => line.includes("at ") && !/template(-audit)?\.(ts|js|mjs|cjs)/.test(line));
+  callsites.set(strings, frame ? frame.trim() : "(unknown callsite)");
+}
+var audited = true ? /* @__PURE__ */ new WeakSet() : void 0;
+var KNOWN_MODIFIERS = true ? /* @__PURE__ */ new Set(["stop", "prevent", "once", "enter", "escape", "space", "tab"]) : void 0;
+var COMPONENT_EVENT_PREFIXES = ["ui-", "nisli-"];
+var NATIVE_EVENTS_WITHOUT_IDL = true ? /* @__PURE__ */ new Set(["focusin", "focusout"]) : void 0;
+var GLOBAL_ATTRS = true ? /* @__PURE__ */ new Set([
+  "id",
+  "class",
+  "style",
+  "slot",
+  "title",
+  "role",
+  "tabindex",
+  "name",
+  "part",
+  "hidden",
+  "dir",
+  "lang",
+  "is"
+]) : void 0;
+function parseDirectives(content) {
+  const directives = { off: false, allowUndefined: /* @__PURE__ */ new Set() };
+  for (const node of content.childNodes) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      if ((node.textContent ?? "").trim() === "") continue;
+      break;
+    }
+    if (node.nodeType === Node.COMMENT_NODE) {
+      const body = (node.textContent ?? "").trim();
+      if (!body.startsWith("nisli-audit")) break;
+      const rest = body.slice("nisli-audit".length).trim();
+      if (rest === "off") {
+        directives.off = true;
+      } else if (rest.startsWith("allow-undefined")) {
+        const tags = rest.slice("allow-undefined".length).replace(/^[:\s]+/, "").split(/[\s,]+/).filter(Boolean);
+        for (const tag of tags) directives.allowUndefined.add(tag.toLowerCase());
+      }
+    }
+    break;
+  }
+  return directives;
+}
+function checkDashTag(tag, site) {
+  let registry;
+  try {
+    registry = customElements;
+  } catch {
+    return;
+  }
+  if (!registry || registry.get(tag)) return;
+  let defined = false;
+  try {
+    registry.whenDefined(tag).then(
+      () => {
+        defined = true;
+      },
+      () => {
+      }
+    );
+  } catch {
+    diag3("N101", `<${tag}> is not a valid custom element name \u2014 at ${site}`);
+    return;
+  }
+  queueMicrotask(() => {
+    if (defined) return;
+    setTimeout(() => {
+      try {
+        if (!isTemplateAuditEnabled() || defined || registry.get(tag)) return;
+        diag3(
+          "N101",
+          `<${tag}> is used in a template but never defined (customElements.get returned undefined after grace) \u2014 at ${site}. If this tag is a lazily-loaded island, suppress with a leading <!-- nisli-audit allow-undefined: ${tag} --> comment.`
+        );
+      } catch {
+      }
+    }, 0);
+  });
+}
+function checkEvent(el2, attrName, site) {
+  const parts = attrName.slice(1).split(".");
+  const eventName = parts[0] ?? "";
+  const modifiers = parts.slice(1);
+  const isNative = `on${eventName}` in el2 || NATIVE_EVENTS_WITHOUT_IDL.has(eventName);
+  const isComponentEvent = COMPONENT_EVENT_PREFIXES.some((p) => eventName.startsWith(p));
+  if (eventName && !isNative && !isComponentEvent) {
+    diag3(
+      "N102",
+      `@${eventName} on <${el2.tagName.toLowerCase()}> is not a known native event (and not an allowlisted ${COMPONENT_EVENT_PREFIXES.join("/")} component event) \u2014 at ${site}`
+    );
+  }
+  for (const mod of modifiers) {
+    if (!KNOWN_MODIFIERS.has(mod)) {
+      diag3(
+        "N103",
+        `unknown event modifier ".${mod}" in "${attrName}" \u2014 known: ${[...KNOWN_MODIFIERS].join(", ")} \u2014 at ${site}`
+      );
+    }
+  }
+}
+function checkComponentAttr(tag, name, observed, site) {
+  if (name.startsWith("data-") || name.startsWith("aria-")) return;
+  if (GLOBAL_ATTRS.has(name) || observed.includes(name)) return;
+  diag3(
+    "N104",
+    `<${tag}> declares attributes [${observed.join(", ")}] but the template sets unknown "${name}" \u2014 at ${site}. Undeclared names route through _setProp and are silently dead as attributes.`
+  );
+}
+function auditTemplate(strings, template) {
+  if (!isTemplateAuditEnabled() || audited.has(strings)) return;
+  audited.add(strings);
+  const site = callsites.get(strings) ?? "(unknown callsite)";
+  const content = template.content;
+  const directives = parseDirectives(content);
+  if (directives.off) return;
+  for (const el2 of content.querySelectorAll("*")) {
+    const tag = el2.tagName.toLowerCase();
+    const isDashTag = tag.includes("-");
+    if (isDashTag && !directives.allowUndefined.has(tag)) {
+      checkDashTag(tag, site);
+    }
+    let observed;
+    if (isDashTag) {
+      const ctor = customElements.get(tag);
+      const list = ctor?.observedAttributes;
+      if (Array.isArray(list) && list.length > 0) observed = list;
+    }
+    for (const attr of [...el2.attributes]) {
+      const name = attr.name;
+      if (name.startsWith("@")) {
+        checkEvent(el2, name, site);
+        continue;
+      }
+      if (name.startsWith("class:") || name === "ref" || name === "html:inner") continue;
+      if (observed) checkComponentAttr(tag, name, observed, site);
+    }
+  }
+}
+
+// src/template.ts
+var canMoveWithin = (parent) => typeof parent.moveBefore === "function";
+function untracked(fn) {
+  let result;
+  untrack(() => {
+    result = fn();
+  });
+  return result;
+}
+function raw(value) {
+  return { __raw: true, value };
+}
+function isRawHtml(value) {
+  return typeof value === "object" && value !== null && "__raw" in value && value.__raw === true && typeof value.value === "string";
+}
+function sanitized(value) {
+  return { __sanitize: true, value };
+}
+function isSanitizedHtml(value) {
+  return typeof value === "object" && value !== null && "__sanitize" in value && value.__sanitize === true && typeof value.value === "string";
+}
+var sanitizerFallback = null;
+function setSanitizerFallback(fn) {
+  sanitizerFallback = fn;
+}
+var nativeSetHtml = (el2, html2) => {
+  el2.setHTML(html2);
+};
+function sanitizerFor(el2) {
+  const platform = typeof Element === "function" ? Element.prototype.setHTML : void 0;
+  return typeof platform === "function" && el2.setHTML === platform ? nativeSetHtml : sanitizerFallback;
+}
+function isTrustedHtml(value) {
+  const tt = globalThis.trustedTypes;
+  return tt !== void 0 && tt.isHTML(value);
+}
+function nisliError(code, message) {
+  return new Error(`[nisli] ${code}: ${message}`);
+}
+var templateCache = /* @__PURE__ */ new WeakMap();
+var parseCount = 0;
+function parseTemplate(strings, valueCount) {
+  let template = templateCache.get(strings);
+  if (template) return template;
+  let htmlStr = "";
+  let inTag = false;
+  let quoteChar = null;
+  for (let i = 0; i < strings.length; i++) {
+    const s = strings[i] ?? "";
+    for (let c = 0; c < s.length; c++) {
+      const ch = s.charAt(c);
+      if (quoteChar) {
+        if (ch === quoteChar) quoteChar = null;
+      } else if (inTag) {
+        if (ch === ">") inTag = false;
+        else if (ch === '"' || ch === "'") quoteChar = ch;
+      } else {
+        if (ch === "<") inTag = true;
+      }
+    }
+    htmlStr += s;
+    if (i < valueCount) {
+      const needsQuotes = inTag && !quoteChar && /=\s*$/.test(s);
+      htmlStr += needsQuotes ? `"${createMarker(i)}"` : createMarker(i);
+    }
+  }
+  parseCount++;
+  template = document.createElement("template");
+  template.innerHTML = htmlStr;
+  templateCache.set(strings, template);
+  if (true) auditTemplate(strings, template);
+  return template;
+}
+var MARKER_PREFIX = "<!--bk-";
+var MARKER_SUFFIX = "-->";
+function createMarker(index) {
+  return `${MARKER_PREFIX}${index}${MARKER_SUFFIX}`;
+}
+function html(strings, ...values) {
+  const bindings = [];
+  const disposers = [];
+  if (true) captureCallsite(strings);
+  let mounted = false;
+  return {
+    __templateResult: true,
+    mount(host) {
+      if (mounted && values.length > 0) {
+        throw nisliError(
+          "N105",
+          `mount() on an already-mounted TemplateResult with ${values.length} value binding(s) \u2014 dispose() it first or create a fresh template per mount. Template starts: ${JSON.stringify((strings[0] ?? "").slice(0, 60))}`
+        );
+      }
+      mounted = true;
+      const template = parseTemplate(strings, values.length);
+      const fragment = template.content.cloneNode(true);
+      processNode(fragment, values, bindings, disposers);
+      host.appendChild(fragment);
+    },
+    dispose() {
+      for (const d of disposers) {
+        try {
+          d();
+        } catch (_) {
+        }
+      }
+      disposers.length = 0;
+      for (const b of bindings) {
+        if ("dispose" in b && b.dispose) {
+          try {
+            b.dispose();
+          } catch (_) {
+          }
+        }
+      }
+      bindings.length = 0;
+      mounted = false;
+    }
+  };
+}
+function processNode(node, values, bindings, disposers) {
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const el2 = node;
+    processAttributes(el2, values, bindings, disposers);
+  }
+  if (node.nodeType === Node.COMMENT_NODE) {
+    const comment = node;
+    const text = comment.textContent || "";
+    if (text.startsWith("bk-") && !isNaN(Number(text.slice(3)))) {
+      const index = Number(text.slice(3));
+      const value = values[index];
+      replaceMarkerWithBinding(comment, value, bindings, disposers);
+      return;
+    }
+  }
+  const children2 = [...node.childNodes];
+  for (const child of children2) {
+    processNode(child, values, bindings, disposers);
+  }
+}
+function processAttributes(el2, values, bindings, disposers) {
+  const attrsToRemove = [];
+  for (const attr of [...el2.attributes]) {
+    const name = attr.name;
+    const attrValue = attr.value;
+    if (name.startsWith("@")) {
+      const eventParts = name.slice(1).split(".");
+      const eventName = eventParts[0] ?? "";
+      const modifiers = eventParts.slice(1);
+      const markerMatch = attrValue.match(/<!--bk-(\d+)-->/);
+      if (markerMatch) {
+        const index = Number(markerMatch[1]);
+        const handler = values[index];
+        if (typeof handler === "function") {
+          bindEvent(el2, eventName, handler, modifiers, bindings);
+        }
+      }
+      attrsToRemove.push(name);
+      continue;
+    }
+    if (name.startsWith("class:")) {
+      const className = name.slice(6);
+      const markerMatch = attrValue.match(/<!--bk-(\d+)-->/);
+      if (markerMatch) {
+        const index = Number(markerMatch[1]);
+        const value = values[index];
+        bindClass(el2, className, value, bindings, disposers);
+      }
+      attrsToRemove.push(name);
+      continue;
+    }
+    if (name === "html:inner") {
+      const markerMatch = attrValue.match(/<!--bk-(\d+)-->/);
+      if (markerMatch) {
+        const index = Number(markerMatch[1]);
+        const value = values[index];
+        bindInnerHtml(el2, value, bindings, disposers);
+      }
+      attrsToRemove.push(name);
+      continue;
+    }
+    if (name === "ref" && attrValue.includes(MARKER_PREFIX)) {
+      const markerMatch = attrValue.match(/<!--bk-(\d+)-->/);
+      if (markerMatch) {
+        const index = Number(markerMatch[1]);
+        const value = values[index];
+        if (isRef(value)) {
+          value.current = el2;
+          disposers.push(() => {
+            value.current = null;
+          });
+        }
+      }
+      attrsToRemove.push(name);
+      continue;
+    }
+    if (attrValue.includes(MARKER_PREFIX)) {
+      const markers = [...attrValue.matchAll(/<!--bk-(\d+)-->/g)];
+      if (markers.length) {
+        const first = markers[0];
+        if (markers.length === 1 && first && attrValue === first[0]) {
+          bindAttribute(el2, name, values[Number(first[1])], bindings, disposers);
+        } else {
+          const resolve = () => attrValue.replace(/<!--bk-(\d+)-->/g, (_, i) => {
+            const v = values[Number(i)];
+            const raw2 = isSignal(v) ? v.value : v;
+            return raw2 == null || raw2 === false ? "" : String(raw2);
+          });
+          const hasSignals = markers.some((m) => isSignal(values[Number(m[1])]));
+          bindAttribute(el2, name, hasSignals ? computed(resolve) : resolve(), bindings, disposers);
+        }
+      }
+      continue;
+    }
+  }
+  for (const name of attrsToRemove) {
+    el2.removeAttribute(name);
+  }
+}
+function mountFactoryResult(factory) {
+  const el2 = document.createElement(factory.tagName);
+  const localDisposers = [];
+  for (const [key, raw2] of Object.entries(factory.props)) {
+    if (isSignal(raw2)) {
+      const sig = raw2;
+      const unsub = sig.subscribe((newVal) => {
+        el2._setProp?.(key, newVal);
+      });
+      localDisposers.push(unsub);
+    } else {
+      el2._setProp?.(key, raw2);
+    }
+  }
+  if (factory.hostAttrs?.class != null) {
+    const classVal = factory.hostAttrs.class;
+    if (isSignal(classVal)) {
+      const sig = classVal;
+      let prevClasses = [];
+      const applyClasses = (raw2) => {
+        const next = raw2 ? raw2.split(/\s+/).filter(Boolean) : [];
+        for (const cls of prevClasses) {
+          if (!next.includes(cls)) el2.classList.remove(cls);
+        }
+        for (const cls of next) {
+          if (!prevClasses.includes(cls)) el2.classList.add(cls);
+        }
+        prevClasses = next;
+      };
+      const unsub = sig.subscribe(applyClasses);
+      localDisposers.push(unsub);
+    } else if (typeof classVal === "string" && classVal) {
+      for (const cls of classVal.split(/\s+/).filter(Boolean)) {
+        el2.classList.add(cls);
+      }
+    }
+  }
+  return {
+    element: el2,
+    dispose() {
+      for (const dispose of localDisposers.splice(0)) {
+        try {
+          dispose();
+        } catch (_) {
+        }
+      }
+    }
+  };
+}
+function replaceMarkerWithBinding(comment, value, bindings, disposers) {
+  const parent = comment.parentNode;
+  if (!parent) return;
+  if (isSignal(value)) {
+    const startMarker = document.createComment("slot-start");
+    const endMarker = document.createComment("slot-end");
+    parent.replaceChild(endMarker, comment);
+    parent.insertBefore(startMarker, endMarker);
+    let currentResults = [];
+    let currentNodes = [];
+    let currentFactoryDisposers = [];
+    let currentText = null;
+    const NOT_RENDERED = /* @__PURE__ */ Symbol("not-rendered");
+    let lastValue = NOT_RENDERED;
+    const dispose = effect(() => {
+      const newValue = value.value;
+      const liveParent = endMarker.parentNode;
+      if (!liveParent) return;
+      if (newValue === lastValue) return;
+      lastValue = newValue;
+      const isTemplate = Boolean(
+        newValue && typeof newValue === "object" && "__templateResult" in newValue
+      );
+      const isFactory = Boolean(
+        newValue && typeof newValue === "object" && "__type" in newValue && newValue.__type === "factory"
+      );
+      const isPrimitive = newValue != null && newValue !== false && !Array.isArray(newValue) && !isTemplate && !isFactory;
+      if (isPrimitive && currentText) {
+        currentText.data = String(newValue);
+        return;
+      }
+      for (const r of currentResults) {
+        try {
+          r.dispose();
+        } catch (_) {
+        }
+      }
+      for (const dispose2 of currentFactoryDisposers) {
+        try {
+          dispose2();
+        } catch (_) {
+        }
+      }
+      for (const node of currentNodes) {
+        node.parentNode?.removeChild(node);
+      }
+      currentNodes = [];
+      currentResults = [];
+      currentFactoryDisposers = [];
+      currentText = null;
+      if (newValue == null) {
+      } else if (Array.isArray(newValue)) {
+        for (const item of newValue) {
+          if (item && typeof item === "object" && "__templateResult" in item) {
+            const tpl = item;
+            const wrapper = document.createDocumentFragment();
+            tpl.mount(wrapper);
+            const nodes = [...wrapper.childNodes];
+            currentNodes.push(...nodes);
+            currentResults.push(tpl);
+            liveParent.insertBefore(wrapper, endMarker);
+          } else if (item && typeof item === "object" && "__type" in item && item.__type === "factory") {
+            const mounted = mountFactoryResult(item);
+            currentNodes.push(mounted.element);
+            currentFactoryDisposers.push(mounted.dispose);
+            liveParent.insertBefore(mounted.element, endMarker);
+          } else if (item != null && item !== false) {
+            const textNode = document.createTextNode(String(item));
+            currentNodes.push(textNode);
+            liveParent.insertBefore(textNode, endMarker);
+          }
+        }
+      } else if (isTemplate) {
+        const tpl = newValue;
+        const wrapper = document.createDocumentFragment();
+        tpl.mount(wrapper);
+        currentNodes = [...wrapper.childNodes];
+        currentResults.push(tpl);
+        liveParent.insertBefore(wrapper, endMarker);
+      } else if (isFactory) {
+        const mounted = mountFactoryResult(newValue);
+        currentNodes.push(mounted.element);
+        currentFactoryDisposers.push(mounted.dispose);
+        liveParent.insertBefore(mounted.element, endMarker);
+      } else if (newValue !== false) {
+        currentText = document.createTextNode(String(newValue));
+        currentNodes.push(currentText);
+        liveParent.insertBefore(currentText, endMarker);
+      }
+    });
+    disposers.push(dispose);
+    disposers.push(() => {
+      for (const r of currentResults.splice(0)) {
+        try {
+          r.dispose();
+        } catch (_) {
+        }
+      }
+      for (const factoryDispose of currentFactoryDisposers.splice(0)) {
+        try {
+          factoryDispose();
+        } catch (_) {
+        }
+      }
+      currentNodes = [];
+      currentText = null;
+    });
+  } else if (value && typeof value === "object" && "__templateResult" in value) {
+    const result = value;
+    const startMarker = document.createComment("tpl-start");
+    const endMarker = document.createComment("tpl-end");
+    parent.replaceChild(endMarker, comment);
+    parent.insertBefore(startMarker, endMarker);
+    const wrapper = document.createDocumentFragment();
+    result.mount(wrapper);
+    parent.insertBefore(wrapper, endMarker);
+    disposers.push(() => result.dispose());
+  } else if (value && typeof value === "object" && "__type" in value && value.__type === "factory") {
+    const mounted = mountFactoryResult(value);
+    parent.replaceChild(mounted.element, comment);
+    disposers.push(mounted.dispose);
+  } else if (Array.isArray(value)) {
+    const startMarker = document.createComment("list-start");
+    const endMarker = document.createComment("list-end");
+    parent.replaceChild(endMarker, comment);
+    parent.insertBefore(startMarker, endMarker);
+    for (const item of value) {
+      if (item && typeof item === "object" && "__templateResult" in item) {
+        const wrapper = document.createDocumentFragment();
+        item.mount(wrapper);
+        parent.insertBefore(wrapper, endMarker);
+        disposers.push(() => item.dispose());
+      } else if (item && typeof item === "object" && "__type" in item && item.__type === "factory") {
+        const mounted = mountFactoryResult(item);
+        parent.insertBefore(mounted.element, endMarker);
+        disposers.push(mounted.dispose);
+      } else {
+        const textNode = document.createTextNode(String(item));
+        parent.insertBefore(textNode, endMarker);
+      }
+    }
+  } else if (value == null || value === false) {
+    parent.removeChild(comment);
+  } else {
+    const textNode = document.createTextNode(String(value));
+    parent.replaceChild(textNode, comment);
+  }
+}
+function bindAttribute(el2, name, value, bindings, disposers) {
+  if (name === "class") {
+    bindClassAttribute(el2, value, bindings, disposers);
+    return;
+  }
+  const isHtmlAttr = name === "id" || name === "style" || name === "slot" || name === "title" || name === "role" || name === "tabindex" || name === "name" || name.startsWith("data-") || name.startsWith("aria-");
+  const hasPropSetter = !isHtmlAttr && typeof el2._setProp === "function";
+  if (hasPropSetter) {
+    if (isSignal(value)) {
+      const binding = { type: "attribute", element: el2, name };
+      bindings.push(binding);
+      const dispose = effect(() => {
+        el2._setProp(name, value.value);
+      });
+      binding.dispose = dispose;
+      disposers.push(dispose);
+    } else {
+      el2._setProp(name, value);
+    }
+    return;
+  }
+  bindPlainAttribute(el2, name, value, bindings, disposers);
+}
+function bindPlainAttribute(el2, name, value, bindings, disposers) {
+  if (isSignal(value)) {
+    const binding = { type: "attribute", element: el2, name };
+    bindings.push(binding);
+    const dispose = effect(() => {
+      const v = value.value;
+      if (v == null || v === false) {
+        el2.removeAttribute(name);
+      } else if (v === true) {
+        el2.setAttribute(name, "");
+      } else {
+        el2.setAttribute(name, String(v));
+      }
+    });
+    binding.dispose = dispose;
+    disposers.push(dispose);
+  } else {
+    if (value == null || value === false) {
+      el2.removeAttribute(name);
+    } else if (value === true) {
+      el2.setAttribute(name, "");
+    } else {
+      el2.setAttribute(name, String(value));
+    }
+  }
+}
+function bindClassAttribute(el2, value, bindings, disposers) {
+  let initialized = false;
+  let prevClasses = [];
+  const applyClasses = (raw2) => {
+    if (!initialized) {
+      el2.setAttribute("class", "");
+      initialized = true;
+    }
+    const str = raw2 == null || raw2 === false ? "" : String(raw2);
+    const next = str.split(/\s+/).filter(Boolean);
+    for (const cls of prevClasses) {
+      if (!next.includes(cls)) {
+        el2.classList.remove(cls);
+      }
+    }
+    for (const cls of next) {
+      if (!prevClasses.includes(cls)) {
+        el2.classList.add(cls);
+      }
+    }
+    prevClasses = next;
+  };
+  if (isSignal(value)) {
+    const binding = { type: "attribute", element: el2, name: "class" };
+    bindings.push(binding);
+    const dispose = effect(() => {
+      applyClasses(value.value);
+    });
+    binding.dispose = dispose;
+    disposers.push(dispose);
+  } else {
+    applyClasses(value);
+  }
+}
+function bindClass(el2, className, value, bindings, disposers) {
+  if (isSignal(value)) {
+    const binding = { type: "class", element: el2, className };
+    bindings.push(binding);
+    const dispose = effect(() => {
+      const v = value.value;
+      el2.classList.toggle(className, !!v);
+    });
+    binding.dispose = dispose;
+    disposers.push(dispose);
+  } else {
+    el2.classList.toggle(className, !!value);
+  }
+}
+function bindInnerHtml(el2, value, bindings, disposers) {
+  const resolveHtml = (v) => {
+    if (v == null) return "";
+    if (isRawHtml(v)) {
+      if (isSanitizedHtml(v)) {
+        throw nisliError(
+          "N106",
+          `html:inner rejects a value branded both raw() and sanitized() \u2014 the trust decision is ambiguous. Pick one brand.`
+        );
+      }
+      return v.value;
+    }
+    if (isSanitizedHtml(v)) {
+      if (sanitizerFor(el2) === null) {
+        throw nisliError(
+          "N107",
+          `html:inner cannot render sanitized() markup: this engine has no native Element.setHTML() and no fallback is registered. Wire one at startup \u2014 setSanitizerFallback((el, html) => { el.innerHTML = DOMPurify.sanitize(html) }) \u2014 nisli ships no sanitizer and will not fall back to innerHTML.`
+        );
+      }
+      return v;
+    }
+    if (isTrustedHtml(v)) return v;
+    throw nisliError(
+      "N106",
+      `html:inner rejects unbranded values (got ${typeof v}). Wrap trusted markup in raw(html), untrusted markup in sanitized(html) \u2014 and never wrap user-generated input in raw().`
+    );
+  };
+  const writeHtml = (v) => {
+    const resolved = resolveHtml(v);
+    if (isSanitizedHtml(resolved)) {
+      sanitizerFor(el2)?.(el2, resolved.value);
+      return;
+    }
+    el2.innerHTML = resolved;
+  };
+  if (isSignal(value)) {
+    untracked(() => resolveHtml(value.value));
+    const binding = { type: "innerHtml", element: el2 };
+    bindings.push(binding);
+    const dispose = effect(() => {
+      writeHtml(value.value);
+    });
+    binding.dispose = dispose;
+    disposers.push(dispose);
+  } else {
+    writeHtml(value);
+  }
+}
+function bindEvent(el2, eventName, handler, modifiers, bindings) {
+  let safeHandler;
+  let composed = handler;
+  if (modifiers.includes("stop")) {
+    const inner = composed;
+    composed = (e) => {
+      e.stopPropagation();
+      inner(e);
+    };
+  }
+  if (modifiers.includes("prevent")) {
+    const inner = composed;
+    composed = (e) => {
+      e.preventDefault();
+      inner(e);
+    };
+  }
+  if (modifiers.includes("once")) {
+    const inner = composed;
+    composed = (e) => {
+      el2.removeEventListener(eventName, safeHandler);
+      inner(e);
+    };
+  }
+  for (const mod of modifiers) {
+    if (["enter", "escape", "space", "tab"].includes(mod)) {
+      const keyMap = {
+        enter: "Enter",
+        escape: "Escape",
+        space: " ",
+        tab: "Tab"
+      };
+      const inner = composed;
+      composed = (e) => {
+        if (e.key === keyMap[mod]) {
+          inner(e);
+        }
+      };
+    }
+  }
+  safeHandler = (e) => {
+    try {
+      untrack(() => composed(e));
+    } catch (err) {
+      console.error(`Event handler error for '${eventName}':`, err);
+    }
+  };
+  el2.addEventListener(eventName, safeHandler);
+  bindings.push({
+    type: "event",
+    element: el2,
+    eventName,
+    handler: safeHandler,
+    modifiers,
+    dispose: () => el2.removeEventListener(eventName, safeHandler)
+  });
+}
+function asTemplateResult(result) {
+  if (result && typeof result === "object" && "__templateResult" in result) {
+    return result;
+  }
+  if (result && typeof result === "object" && result.__type === "factory") {
+    let mounted = null;
+    return {
+      __templateResult: true,
+      mount(host) {
+        mounted = mountFactoryResult(result);
+        host.appendChild(mounted.element);
+      },
+      dispose() {
+        mounted?.dispose();
+        mounted?.element.remove();
+        mounted = null;
+      }
+    };
+  }
+  throw new TypeError(
+    `each(): template callback must return a TemplateResult or a component factory result, got ${result === null ? "null" : typeof result}`
+  );
+}
+function each(items, keyFn, templateFn) {
+  let startMarker;
+  let endMarker;
+  let entries = [];
+  let effectDispose = null;
+  return {
+    __templateResult: true,
+    mount(host) {
+      startMarker = document.createComment("each-start");
+      endMarker = document.createComment("each-end");
+      host.appendChild(startMarker);
+      host.appendChild(endMarker);
+      effectDispose = effect(() => {
+        const newItems = items.value;
+        reconcile(newItems);
+      });
+    },
+    dispose() {
+      if (effectDispose) {
+        effectDispose();
+        effectDispose = null;
+      }
+      for (const entry of entries) {
+        entry.templateResult.dispose();
+      }
+      entries = [];
+    }
+  };
+  function reconcile(newItems) {
+    const parent = endMarker.parentNode;
+    if (!parent) return;
+    const keyedItems = [];
+    const keyIndices = /* @__PURE__ */ new Map();
+    for (let i = 0; i < newItems.length; i++) {
+      const item = newItems[i];
+      if (item === void 0) continue;
+      const key = keyFn(item, i);
+      const previousIndex = keyIndices.get(key);
+      if (previousIndex !== void 0) {
+        const formattedKey = typeof key === "string" ? JSON.stringify(key) : String(key);
+        console.error(
+          `each() requires unique keys. Duplicate key ${formattedKey} found at indices ${previousIndex} and ${i}; reconciliation skipped.`
+        );
+        return;
+      }
+      keyIndices.set(key, i);
+      keyedItems.push({ item, index: i, key });
+    }
+    const oldMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      oldMap.set(entry.key, entry);
+    }
+    const newEntries = [];
+    const newKeys = /* @__PURE__ */ new Set();
+    for (const { item, index, key } of keyedItems) {
+      newKeys.add(key);
+      const existing = oldMap.get(key);
+      if (existing) {
+        existing.itemSignal.value = item;
+        existing.indexSignal.value = index;
+        newEntries.push(existing);
+      } else {
+        const itemSignal = signal(item);
+        const indexSignal = signal(index);
+        const wrapper = document.createElement("each-item");
+        wrapper.style.display = "contents";
+        const templateResult = asTemplateResult(templateFn(itemSignal, indexSignal));
+        templateResult.mount(wrapper);
+        newEntries.push({ key, itemSignal, indexSignal, templateResult, wrapper });
+      }
+    }
+    for (const entry of entries) {
+      if (!newKeys.has(entry.key)) {
+        entry.templateResult.dispose();
+        entry.wrapper.parentNode?.removeChild(entry.wrapper);
+      }
+    }
+    let cursor = startMarker;
+    for (const entry of newEntries) {
+      const nextSibling = cursor.nextSibling;
+      if (nextSibling !== entry.wrapper) {
+        if (entry.wrapper.parentNode === parent && canMoveWithin(parent)) {
+          parent.moveBefore(entry.wrapper, nextSibling);
+        } else {
+          parent.insertBefore(entry.wrapper, nextSibling);
+        }
+      }
+      cursor = entry.wrapper;
+    }
+    entries = newEntries;
+  }
+}
+function when(condition, template, elseTemplate) {
+  const resolveBranch = (branch) => {
+    if (branch === void 0) return null;
+    if (typeof branch === "function") return untracked(branch);
+    return branch;
+  };
+  if (isSignal(condition)) {
+    let lastGate;
+    let lastResult = null;
+    return computed(() => {
+      const gate = !!condition.value;
+      if (gate === lastGate) return lastResult;
+      const next = gate ? resolveBranch(template) : resolveBranch(elseTemplate);
+      lastGate = gate;
+      lastResult = next;
+      return next;
+    });
+  }
+  return condition ? resolveBranch(template) : resolveBranch(elseTemplate);
+}
+function el(tag, props = {}, children2) {
+  let node = null;
+  const bindings = [];
+  const disposers = [];
+  return {
+    __templateResult: true,
+    mount(host) {
+      const element = document.createElement(tag);
+      node = element;
+      for (const [key, val] of Object.entries(props)) {
+        if (val === void 0) continue;
+        if (key === "ref") {
+          if (isRef(val)) {
+            val.current = element;
+            disposers.push(() => {
+              val.current = null;
+            });
+          }
+          continue;
+        }
+        if (key === "on") {
+          for (const [event, handler] of Object.entries(val)) {
+            bindEvent(element, event, handler, [], bindings);
+          }
+          continue;
+        }
+        if (key === "class") {
+          bindClassAttribute(element, val, bindings, disposers);
+          continue;
+        }
+        bindPlainAttribute(element, key, val, bindings, disposers);
+      }
+      const flat = [];
+      flattenChildren(children2, flat);
+      for (const child of flat) {
+        const anchor = document.createComment("");
+        element.appendChild(anchor);
+        replaceMarkerWithBinding(anchor, child, bindings, disposers);
+      }
+      host.appendChild(element);
+    },
+    dispose() {
+      for (const d of disposers) {
+        try {
+          d();
+        } catch (_) {
+        }
+      }
+      disposers.length = 0;
+      for (const b of bindings) {
+        if ("dispose" in b && b.dispose) {
+          try {
+            b.dispose();
+          } catch (_) {
+          }
+        }
+      }
+      bindings.length = 0;
+      node?.parentNode?.removeChild(node);
+      node = null;
+    }
+  };
+}
+function flattenChildren(children2, out) {
+  if (children2 === void 0) return;
+  if (Array.isArray(children2)) {
+    for (const c of children2) flattenChildren(c, out);
+  } else {
+    out.push(children2);
+  }
+}
+
+// src/projection.ts
+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;
+  });
+}
+
+// src/settle.ts
+var pending = /* @__PURE__ */ new Set();
+function __enrollPending() {
+  let resolve;
+  const entry = new Promise((res) => {
+    resolve = res;
+  });
+  pending.add(entry);
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    pending.delete(entry);
+    resolve();
+  };
+}
+function __resetPending() {
+  pending.clear();
+}
+registerResetHook(__resetPending);
+async function settle() {
+  for (let i = 0; i < 50; i++) {
+    await tick();
+    if (pending.size === 0) return;
+    await Promise.allSettled([...pending]);
+  }
+  if (isDev()) diag(
+    "N603",
+    "settle() did not reach quiescence within 50 iterations \u2014 something keeps scheduling new async work (a self-invalidating query or a polling loop?). settle() is a test/verify primitive; under live background refetch it is unbounded by design. Returning anyway."
+  );
+}
+
+// src/query.ts
+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(raw2) {
+  if (!Array.isArray(raw2)) {
+    throw keyError(`expected an array, got ${typeof raw2}`);
+  }
+  for (let i = 0; i < raw2.length; i++) {
+    const el2 = raw2[i];
+    if (el2 === null) continue;
+    const t = typeof el2;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (Number.isFinite(el2)) continue;
+      throw keyError(`non-finite number at index ${i} (would collide with null)`);
+    }
+    if (el2 === void 0) {
+      throw keyError(`undefined at index ${i}`);
+    }
+    throw keyError(`${t} at index ${i}`);
+  }
+  return raw2.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;
+}
+var 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");
+  }
+}
+var QueryClient = class {
+  /** @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);
+}
+
+// src/resource.ts
+function resource(source, loader) {
+  const data = signal(void 0);
+  const loading = signal(false);
+  const error = signal(null);
+  const refreshVersion = signal(0);
+  let generation = 0;
+  let disposed = false;
+  let stopEffect = () => {
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    generation++;
+    stopEffect();
+    loading.value = false;
+  };
+  if (hasContext()) {
+    getCurrentComponent().addDisposer(dispose);
+  }
+  stopEffect = effect(() => {
+    refreshVersion.value;
+    const currentGeneration = ++generation;
+    let sourceValue;
+    try {
+      sourceValue = source();
+    } catch (cause) {
+      loading.value = false;
+      error.value = toError2(cause);
+      return;
+    }
+    if (sourceValue === void 0) {
+      data.value = void 0;
+      loading.value = false;
+      error.value = null;
+      return;
+    }
+    const controller = new AbortController();
+    loading.value = true;
+    error.value = null;
+    const enabledSource = sourceValue;
+    const isStale = () => disposed || controller.signal.aborted || currentGeneration !== generation;
+    const settled = __enrollPending();
+    void Promise.resolve().then(async () => {
+      if (isStale()) {
+        settled();
+        return;
+      }
+      try {
+        const value = await loader(enabledSource, controller.signal);
+        if (isStale()) {
+          settled();
+          return;
+        }
+        data.value = value;
+        loading.value = false;
+        settled();
+      } catch (cause) {
+        if (isStale()) {
+          settled();
+          return;
+        }
+        error.value = toError2(cause);
+        loading.value = false;
+        settled();
+      }
+    });
+    return () => {
+      if (currentGeneration === generation) generation++;
+      controller.abort();
+      settled();
+    };
+  });
+  const result = {
+    data,
+    loading,
+    error,
+    refresh() {
+      if (!disposed) refreshVersion.value++;
+    },
+    dispose
+  };
+  return disposable(result, dispose);
+}
+function toError2(cause) {
+  if (cause instanceof Error) return cause;
+  try {
+    return new Error(String(cause));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+
+// src/view-transition.ts
+function supportsTransitionTypes() {
+  return typeof ViewTransition !== "undefined" && "types" in ViewTransition.prototype;
+}
+function viewTransition(update, options = {}) {
+  const commit = () => {
+    update();
+    flush();
+  };
+  if (typeof document === "undefined" || typeof document.startViewTransition !== "function") {
+    commit();
+    return null;
+  }
+  const types = options.types;
+  return types !== void 0 && types.length > 0 && supportsTransitionTypes() ? document.startViewTransition({ update: commit, types }) : document.startViewTransition(commit);
+}
+export {
+  Emitter,
+  QueryClient,
+  SIGNAL_BRAND,
+  children,
+  component,
+  computed,
+  createContext,
+  createToken,
+  each,
+  effect,
+  el,
+  flush,
+  flush as flushEffects,
+  getCurrentComponent,
+  hasContext,
+  html,
+  inject,
+  isRef,
+  isSignal,
+  onCleanup,
+  onMount,
+  provide,
+  query,
+  raw,
+  ref,
+  resetInjector,
+  resource,
+  runWithContext,
+  sanitized,
+  setDevMode,
+  setSanitizerFallback,
+  settle,
+  signal,
+  tick,
+  untrack,
+  useHostEvent,
+  viewTransition,
+  when
+};
+//# sourceMappingURL=index.js.map