@lightspeed-js/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3060 @@
+// src/runtime/diagnostics.ts
+var PREFIX = "[lightspeed]";
+function isDev() {
+  try {
+    return Boolean(import.meta.env?.DEV);
+  } catch {
+    return false;
+  }
+}
+function warn(message, ...detail) {
+  console.warn(`${PREFIX} ${message}`, ...detail);
+}
+function fail(message, ...detail) {
+  console.error(`${PREFIX} ${message}`, ...detail);
+}
+function debug(message, ...args) {
+  if (isDev())
+    console.log(`${PREFIX} ${message}`, ...args);
+}
+
+// src/runtime/signals/SignalManager.ts
+class SignalManager {
+  listeners = new Map;
+  history = new Map;
+  emit(event, data) {
+    if (!this.history.has(event)) {
+      this.history.set(event, []);
+    }
+    this.history.get(event).push(data);
+    const eventListeners = this.listeners.get(event) || [];
+    eventListeners.forEach((listener) => {
+      try {
+        listener(data);
+      } catch (error) {
+        fail(`Error in signal listener for ${event}:`, error);
+      }
+    });
+  }
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(listener);
+  }
+  off(event, listener) {
+    const eventListeners = this.listeners.get(event);
+    if (eventListeners) {
+      const index = eventListeners.indexOf(listener);
+      if (index > -1) {
+        eventListeners.splice(index, 1);
+      }
+    }
+  }
+  getHistory(event) {
+    return this.history.get(event) || [];
+  }
+  getLatest(event) {
+    const history = this.history.get(event);
+    if (!history || history.length === 0) {
+      return;
+    }
+    return history[history.length - 1];
+  }
+  clear() {
+    this.listeners.clear();
+    this.history.clear();
+  }
+}
+// src/runtime/signals/signals.ts
+function createSignalAPI(signalManager) {
+  return {
+    emit: (event, data) => signalManager.emit(event, data),
+    on: (event, listener) => signalManager.on(event, listener),
+    off: (event, listener) => signalManager.off(event, listener),
+    getHistory: (event) => signalManager.getHistory(event),
+    getLatest: (event) => signalManager.getLatest(event)
+  };
+}
+function createScopedSignalAPI(signalManager, registerCleanup) {
+  return {
+    emit: (event, data) => signalManager.emit(event, data),
+    on: (event, listener) => {
+      signalManager.on(event, listener);
+      registerCleanup(() => signalManager.off(event, listener));
+    },
+    off: (event, listener) => signalManager.off(event, listener),
+    getHistory: (event) => signalManager.getHistory(event),
+    getLatest: (event) => signalManager.getLatest(event)
+  };
+}
+// src/runtime/reactive/ReactiveProxy.ts
+function isWrappable(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return true;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+class ReactiveProxy {
+  onChange;
+  caches = new WeakMap;
+  ownerless = {};
+  rawTargets = new WeakMap;
+  observers = new WeakMap;
+  constructor(onChange) {
+    this.onChange = onChange;
+  }
+  cacheFor(owner) {
+    const key = owner ?? this.ownerless;
+    let cache = this.caches.get(key);
+    if (!cache) {
+      cache = new WeakMap;
+      this.caches.set(key, cache);
+    }
+    return cache;
+  }
+  create(target, owner = null) {
+    if (this.rawTargets.has(target))
+      return target;
+    if (owner)
+      this.observe(target, owner);
+    const cache = this.cacheFor(owner);
+    const existing = cache.get(target);
+    if (existing)
+      return existing;
+    const proxy = new Proxy(target, {
+      get: (obj, prop, receiver) => {
+        const value = Reflect.get(obj, prop, receiver);
+        return isWrappable(value) ? this.create(value, owner) : value;
+      },
+      set: (obj, prop, value) => {
+        const next = this.rawTargets.get(value) ?? value;
+        const previous = obj[prop];
+        obj[prop] = next;
+        if (!Object.is(previous, next)) {
+          this.notify(obj, owner);
+        }
+        return true;
+      },
+      deleteProperty: (obj, prop) => {
+        const existed = prop in obj;
+        delete obj[prop];
+        if (existed) {
+          this.notify(obj, owner);
+        }
+        return true;
+      }
+    });
+    cache.set(target, proxy);
+    this.rawTargets.set(proxy, target);
+    return proxy;
+  }
+  share(value, observer) {
+    const target = this.rawTargets.get(value) ?? value;
+    if (!isWrappable(target))
+      return;
+    this.observe(target, observer);
+  }
+  observe(target, owner) {
+    let set = this.observers.get(target);
+    if (!set) {
+      set = new Set;
+      this.observers.set(target, set);
+    }
+    for (const ref of set) {
+      const held = ref.deref();
+      if (!held)
+        set.delete(ref);
+      else if (held === owner)
+        return;
+    }
+    set.add(new WeakRef(owner));
+  }
+  notify(target, owner) {
+    this.onChange(owner);
+    const set = this.observers.get(target);
+    if (!set)
+      return;
+    for (const ref of set) {
+      const observer = ref.deref();
+      if (!observer) {
+        set.delete(ref);
+        continue;
+      }
+      if (observer !== owner)
+        this.onChange(observer);
+    }
+  }
+  raw(value) {
+    return this.rawTargets.get(value) ?? value;
+  }
+}
+// src/runtime/reactive/UpdateScheduler.ts
+class UpdateScheduler {
+  queue = new Set;
+  scheduled = false;
+  flushCallback;
+  constructor(flushCallback) {
+    this.flushCallback = flushCallback;
+  }
+  queueUpdate(owner) {
+    this.queue.add(owner);
+    if (!this.scheduled) {
+      this.scheduled = true;
+      requestAnimationFrame(() => this.flushUpdates());
+    }
+  }
+  flushUpdates() {
+    this.scheduled = false;
+    const batch = [...this.queue];
+    this.queue.clear();
+    this.flushCallback(batch);
+  }
+  clear() {
+    this.queue.clear();
+  }
+}
+// src/runtime/components/ComponentRegistry.ts
+class ComponentRegistry {
+  components = new Map;
+  register(component) {
+    this.components.set(component.id, component);
+    if (import.meta.env?.DEV) {
+      debug(`registered ${component.id}`);
+    }
+  }
+  update(id, component) {
+    this.components.set(id, component);
+    if (import.meta.env?.DEV) {
+      debug(`hot updated ${id}`);
+    }
+  }
+  get(id) {
+    return this.components.get(id);
+  }
+  has(id) {
+    return this.components.has(id);
+  }
+  getAllIds() {
+    return Array.from(this.components.keys());
+  }
+  getAll() {
+    return Array.from(this.components.values());
+  }
+  clear() {
+    this.components.clear();
+  }
+}
+// src/runtime/components/ComponentInstance.ts
+class ComponentInstance {
+  id;
+  componentId;
+  parent;
+  children = [];
+  rootNodes = [];
+  refs = {};
+  mountedCallbacks = [];
+  logicCleanup = [];
+  bindings = [];
+  blocks = [];
+  scopeId;
+  props = {};
+  state = {};
+  handlers = new Map;
+  updateCallbacks = [];
+  handlerNames = [];
+  signals;
+  cleanup = [];
+  listeners = 0;
+  models = 0;
+  wantsMount = false;
+  runtimeCells = new Set;
+  constructor(id, componentId, signals, parent = null) {
+    this.id = id;
+    this.componentId = componentId;
+    this.signals = signals;
+    this.parent = parent;
+  }
+  addHandler(name, fn) {
+    this.handlers.set(name, fn);
+  }
+  getHandler(name) {
+    return this.handlers.get(name);
+  }
+  hasHandler(name) {
+    return this.handlers.has(name);
+  }
+  addCleanup(cleanup) {
+    this.cleanup.push(cleanup);
+  }
+  addLogicCleanup(cleanup) {
+    this.logicCleanup.push(cleanup);
+  }
+  releaseDom() {
+    this.blocks.forEach((block) => block.destroy());
+    this.blocks.length = 0;
+    this.cleanup.forEach((cleanup) => cleanup());
+    this.cleanup.length = 0;
+    this.bindings.length = 0;
+    this.rootNodes.length = 0;
+    for (const name of Object.keys(this.refs))
+      delete this.refs[name];
+  }
+  addBinding(binding) {
+    this.bindings.push(binding);
+  }
+  addBlock(block) {
+    this.blocks.push(block);
+  }
+  destroy() {
+    this.children.forEach((child) => child.destroy());
+    this.children.length = 0;
+    this.blocks.forEach((block) => block.destroy());
+    this.blocks.length = 0;
+    this.cleanup.forEach((cleanup) => cleanup());
+    this.cleanup.length = 0;
+    this.logicCleanup.forEach((cleanup) => cleanup());
+    this.logicCleanup.length = 0;
+    this.handlers.clear();
+    this.bindings.length = 0;
+    this.rootNodes.length = 0;
+    for (const name of Object.keys(this.refs))
+      delete this.refs[name];
+    this.mountedCallbacks.length = 0;
+  }
+}
+// src/runtime/bindings/BindingEvaluator.ts
+class BindingScope {
+  instance;
+  locals;
+  cleanup;
+  constructor(instance, locals, cleanup) {
+    this.instance = instance;
+    this.locals = locals;
+    this.cleanup = cleanup;
+  }
+  get id() {
+    return this.instance.id;
+  }
+  get state() {
+    return this.instance.state;
+  }
+  get props() {
+    return this.instance.props;
+  }
+}
+var BOOLEAN_ATTRIBUTES = new Set([
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+var NO_LOCALS = [];
+var SKIP = Symbol("skip");
+var IDENTITY = (raw) => raw;
+var TO_NUMBER = (raw) => raw === "" || raw == null ? undefined : Number(raw);
+function resolveModelTarget(el) {
+  const tag = el.tagName;
+  if (tag === "SELECT")
+    return { prop: "value", event: "change", coerce: IDENTITY };
+  if (tag === "TEXTAREA")
+    return { prop: "value", event: "input", coerce: IDENTITY };
+  if (tag === "INPUT") {
+    const type = el.type;
+    if (type === "checkbox")
+      return { prop: "checked", event: "change", coerce: Boolean };
+    if (type === "radio")
+      return { prop: "value", event: "change", coerce: IDENTITY, radio: true };
+    if (type === "number" || type === "range")
+      return { prop: "value", event: "input", coerce: TO_NUMBER };
+  }
+  return { prop: "value", event: "input", coerce: IDENTITY };
+}
+
+class BindingEvaluator {
+  cells;
+  onPropChanged;
+  compiledCache = new Map;
+  writerCache = new Map;
+  constructor(cells, onPropChanged = () => {
+  }) {
+    this.cells = cells;
+    this.onPropChanged = onPropChanged;
+  }
+  expressions = new Map;
+  writers = new Map;
+  registerExpressions(expressions = {}, writers = {}) {
+    for (const [key, fn] of Object.entries(expressions)) {
+      this.expressions.set(key, fn);
+    }
+    for (const [key, fn] of Object.entries(writers)) {
+      this.writers.set(key, fn);
+    }
+  }
+  compile(expr, params) {
+    const compiled = this.expressions.get(`${params.join(",")}|${expr}`);
+    if (compiled)
+      return compiled;
+    fail(`No compiled expression for ${JSON.stringify(expr)}` + (params.length ? ` in scope [${params.join(", ")}]` : ""));
+    return () => {
+      return;
+    };
+  }
+  compileWriter(expr, params) {
+    const writer = this.writers.get(`${params.join(",")}|${expr}`);
+    if (writer)
+      return writer;
+    warn(`$model needs an assignable expression, got "${expr}" - it will render but not write back.`);
+    return () => {
+      return;
+    };
+  }
+  createBinding(el, kind, expr, attr, params = []) {
+    return { el, kind, attr, expr, compiled: this.compile(expr, params) };
+  }
+  createPropBinding(target, name, expr, params = []) {
+    return {
+      kind: "prop",
+      target,
+      name,
+      expr,
+      compiled: this.compile(expr, params)
+    };
+  }
+  bindCellProp(target, name, key) {
+    const cell = this.cells.get(key);
+    if (!cell.pending)
+      target.props[name] = cell.value;
+    target.runtimeCells.add(key);
+    const unsubscribe = cell.subscribe((value) => {
+      if (Object.is(target.props[name], value))
+        return;
+      target.props[name] = value;
+      this.onPropChanged(target);
+    });
+    target.addLogicCleanup(unsubscribe);
+  }
+  createModelBinding(el, expr, params = []) {
+    return {
+      kind: "model",
+      el,
+      expr,
+      target: resolveModelTarget(el),
+      compiled: this.compile(expr, params),
+      write: this.compileWriter(expr, params)
+    };
+  }
+  createForBinding(block, expr, params = []) {
+    return { kind: "for", block, expr, compiled: this.compile(expr, params) };
+  }
+  readProxy() {
+    return this.cells.createReadProxy();
+  }
+  pendingProbe(onRead) {
+    return (key) => {
+      onRead?.(key);
+      return this.cells.get(key).pending;
+    };
+  }
+  get cellManager() {
+    return this.cells;
+  }
+  compileExpression(expr, params = []) {
+    return this.compile(expr, params);
+  }
+  evaluate(expr, instance, locals = []) {
+    try {
+      return this.compile(expr, [])(instance.state, instance.props, this.cells.createReadProxy(), this.pendingProbe(), ...locals);
+    } catch (error) {
+      warn(`Error evaluating "${expr}" in ${instance.id}:`, error);
+      return;
+    }
+  }
+  applyBinding(binding, scope) {
+    this.apply(binding, scope);
+  }
+  updateInstance(instance) {
+    const scope = new BindingScope(instance, NO_LOCALS, instance);
+    for (const binding of instance.bindings) {
+      this.apply(binding, scope);
+    }
+    for (const block of instance.blocks) {
+      this.updateBlock(block);
+    }
+  }
+  updateRow(instance, row) {
+    const scope = new BindingScope(instance, row.locals, row);
+    for (const binding of row.bindings) {
+      this.apply(binding, scope);
+    }
+    for (const block of row.blocks) {
+      this.updateBlock(block);
+    }
+  }
+  updateBlock(block) {
+    block.rows.forEach((row) => {
+      for (let i = 0;i < block.parentLocals.length; i++) {
+        row.locals[i] = block.parentLocals[i];
+      }
+      this.updateRow(block.owner, row);
+    });
+  }
+  updateTree(instance) {
+    this.updateInstance(instance);
+    for (const child of instance.children) {
+      this.updateTree(child);
+    }
+  }
+  attachModel(binding, scope) {
+    const listener = () => {
+      const next = this.readFromDom(binding);
+      if (next === SKIP)
+        return;
+      try {
+        binding.write(scope.state, scope.props, this.cells.createReadProxy(), this.pendingProbe(), next, ...scope.locals);
+      } catch (error) {
+        warn(`Failed writing $model="${binding.expr}":`, error);
+      }
+    };
+    binding.el.addEventListener(binding.target.event, listener);
+    scope.cleanup.addCleanup(() => binding.el.removeEventListener(binding.target.event, listener));
+  }
+  readFromDom(binding) {
+    const el = binding.el;
+    if (binding.target.radio) {
+      return el.checked ? el.value : SKIP;
+    }
+    return binding.target.coerce(el[binding.target.prop]);
+  }
+  apply(binding, scope) {
+    const reads = new Set;
+    const shared = this.cells.createReadProxy((key) => reads.add(key));
+    const pending = this.pendingProbe((key) => reads.add(key));
+    let value;
+    try {
+      value = binding.compiled(scope.state, scope.props, shared, pending, ...scope.locals);
+      this.syncCellSubscriptions(binding, scope, reads);
+    } catch (error) {
+      warn(`Error evaluating "${binding.expr}" in ${scope.id}:`, error);
+      return;
+    }
+    if (binding.kind === "for") {
+      binding.block.schedule(binding.block.toItems(value));
+      return;
+    }
+    if (binding.kind === "model") {
+      this.applyModel(binding, value);
+      return;
+    }
+    if (binding.kind === "prop") {
+      const target = binding.target;
+      if (Object.is(target.props[binding.name], value))
+        return;
+      target.props[binding.name] = value;
+      this.onPropChanged(target);
+      return;
+    }
+    switch (binding.kind) {
+      case "text":
+        binding.el.textContent = value == null ? "" : String(value);
+        break;
+      case "class":
+        this.updateClasses(binding.el, value);
+        break;
+      case "show":
+        setHidden(binding.el, !value);
+        break;
+      case "html":
+        binding.el.innerHTML = value == null ? "" : String(value);
+        break;
+      case "attr": {
+        const attr = binding.attr;
+        const aria = attr.startsWith("aria-");
+        if (BOOLEAN_ATTRIBUTES.has(attr) && !aria) {
+          if (value)
+            binding.el.setAttribute(attr, "");
+          else
+            binding.el.removeAttribute(attr);
+          break;
+        }
+        if (value == null || value === false && !aria) {
+          binding.el.removeAttribute(attr);
+        } else if (aria) {
+          binding.el.setAttribute(attr, String(value));
+        } else {
+          binding.el.setAttribute(attr, value === true ? "" : String(value));
+        }
+        break;
+      }
+    }
+  }
+  applyModel(binding, value) {
+    const el = binding.el;
+    const { prop, radio, coerce } = binding.target;
+    if (radio) {
+      const shouldCheck = String(value) === el.value;
+      if (el.checked !== shouldCheck)
+        el.checked = shouldCheck;
+      return;
+    }
+    if (Object.is(coerce(el[prop]), value))
+      return;
+    if (prop === "checked") {
+      el.checked = Boolean(value);
+    } else {
+      el.value = value == null ? "" : String(value);
+    }
+  }
+  syncCellSubscriptions(binding, scope, reads) {
+    const previous = binding.cellKeys;
+    if (previous && sameKeys(previous, reads))
+      return;
+    binding.cellUnsubscribes?.forEach((unsubscribe) => unsubscribe());
+    binding.cellKeys = reads;
+    binding.cellUnsubscribes = [...reads].map((key) => this.cells.get(key).subscribe(() => this.apply(binding, scope)));
+    if (!binding.cleanupRegistered) {
+      binding.cleanupRegistered = true;
+      scope.cleanup.addCleanup(() => {
+        binding.cellUnsubscribes?.forEach((unsubscribe) => unsubscribe());
+        binding.cellUnsubscribes = [];
+        binding.cellKeys = undefined;
+      });
+    }
+  }
+  appliedClasses = new WeakMap;
+  updateClasses(element, classObj) {
+    if (typeof classObj === "string") {
+      const previous = this.appliedClasses.get(element) ?? [];
+      const next = classObj.split(/\s+/).filter(Boolean);
+      for (const name of previous) {
+        if (!next.includes(name))
+          element.classList.remove(name);
+      }
+      for (const name of next)
+        element.classList.add(name);
+      this.appliedClasses.set(element, next);
+      return;
+    }
+    if (typeof classObj === "object" && classObj !== null) {
+      Object.entries(classObj).forEach(([className, shouldAdd]) => {
+        if (shouldAdd) {
+          element.classList.add(className);
+        } else {
+          element.classList.remove(className);
+        }
+      });
+    }
+  }
+}
+function sameKeys(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const key of a)
+    if (!b.has(key))
+      return false;
+  return true;
+}
+var HIDDEN_ATTR = "data-lsp-hidden";
+function setHidden(el, hidden) {
+  if (hidden)
+    el.setAttribute(HIDDEN_ATTR, "");
+  else
+    el.removeAttribute(HIDDEN_ATTR);
+}
+// src/runtime/events/EventBinder.ts
+class EventBinder {
+  bind(el, eventType, handlerName, owner, cleanupTarget = owner) {
+    this.listen(el, eventType, (event) => {
+      const handler = owner.getHandler(handlerName);
+      if (!handler) {
+        warn(`Handler not found: ${handlerName} (on ${owner.componentId})`);
+        return;
+      }
+      handler(event);
+    }, cleanupTarget, `${eventType} handler ${handlerName}`);
+  }
+  bindExpression(el, eventType, invoke, cleanupTarget, label) {
+    this.listen(el, eventType, invoke, cleanupTarget, label);
+  }
+  listen(el, eventType, run, cleanupTarget, label) {
+    const listener = (event) => {
+      try {
+        run(event);
+      } catch (error) {
+        fail(`Error in ${label}:`, error);
+      }
+    };
+    el.addEventListener(eventType, listener);
+    cleanupTarget.addCleanup(() => el.removeEventListener(eventType, listener));
+  }
+}
+// src/runtime/globals/GlobalFunctions.ts
+class GlobalFunctions {
+  reactiveProxy;
+  globalSignals;
+  constructor(reactiveProxy, globalSignals) {
+    this.reactiveProxy = reactiveProxy;
+    this.globalSignals = globalSignals;
+  }
+  setup() {
+    window.defineProps = this.defineProps.bind(this);
+    window.reactive = this.reactive.bind(this);
+    window.defineSignal = this.defineSignal.bind(this);
+    window.onMounted = this.onMounted.bind(this);
+  }
+  defineProps(propsDefinition) {
+    const props = {};
+    if (propsDefinition && typeof propsDefinition === "object") {
+      Object.entries(propsDefinition).forEach(([key, definition]) => {
+        if (definition && typeof definition === "object" && "default" in definition) {
+          props[key] = definition.default;
+        }
+      });
+    }
+    return props;
+  }
+  reactive(target) {
+    return this.reactiveProxy.create(target);
+  }
+  defineSignal() {
+    return createSignalAPI(this.globalSignals);
+  }
+  onMounted(callback) {
+    setTimeout(callback, 0);
+  }
+  cleanup() {
+    delete window.defineProps;
+    delete window.reactive;
+    delete window.defineSignal;
+    delete window.onMounted;
+  }
+}
+// src/runtime/state/Cell.ts
+class Cell {
+  key;
+  currentValue;
+  isPending = true;
+  listeners = new Set;
+  persist;
+  constructor(key, options = {}) {
+    this.key = key;
+    this.persist = options.persist ?? false;
+    if (this.persist) {
+      const stored = readStored(key);
+      if (stored !== undefined) {
+        this.currentValue = stored;
+        this.isPending = false;
+      }
+    }
+  }
+  get value() {
+    return this.currentValue;
+  }
+  set value(next) {
+    this.set(next);
+  }
+  get pending() {
+    return this.isPending;
+  }
+  set(next) {
+    if (!this.isPending && Object.is(next, this.currentValue))
+      return;
+    this.currentValue = next;
+    this.isPending = false;
+    if (this.persist)
+      writeStored(this.key, next);
+    this.listeners.forEach((listener) => {
+      try {
+        listener(next);
+      } catch (error) {
+        fail(`Error in cell listener for ${this.key}:`, error);
+      }
+    });
+  }
+  enablePersistence() {
+    if (this.persist)
+      return;
+    this.persist = true;
+    const stored = readStored(this.key);
+    if (this.isPending) {
+      if (stored !== undefined)
+        this.set(stored);
+      return;
+    }
+    writeStored(this.key, this.currentValue);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+}
+var STORAGE_PREFIX = "lsp:";
+function readStored(key) {
+  try {
+    const raw = globalThis.localStorage?.getItem(STORAGE_PREFIX + key);
+    return raw == null ? undefined : JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+function writeStored(key, value) {
+  try {
+    if (value === undefined) {
+      globalThis.localStorage?.removeItem(STORAGE_PREFIX + key);
+    } else {
+      globalThis.localStorage?.setItem(STORAGE_PREFIX + key, JSON.stringify(value));
+    }
+  } catch {
+  }
+}
+// src/runtime/state/CellManager.ts
+class CellManager {
+  ssg;
+  cells = new Map;
+  initialised = new Set;
+  declaredDefaults = new Map;
+  refreshKeys = new Set;
+  refreshed = new Set;
+  buildKeys = new Set;
+  buildWork = [];
+  constructor(ssg = false) {
+    this.ssg = ssg;
+  }
+  get(key, init, options = {}) {
+    let cell = this.cells.get(key);
+    if (!cell) {
+      cell = new Cell(key, options);
+      this.cells.set(key, cell);
+    } else if (options.persist) {
+      cell.enablePersistence();
+    }
+    if (init !== undefined) {
+      if (typeof init === "function") {
+        this.runInitialiser(key, cell, init, options);
+      } else {
+        this.applyDefault(key, cell, init);
+      }
+    }
+    return cell;
+  }
+  applyDefault(key, cell, value) {
+    if (import.meta.env?.DEV) {
+      if (this.declaredDefaults.has(key) && !Object.is(this.declaredDefaults.get(key), value)) {
+        warn(`Conflicting defaults for cell "${key}": ${JSON.stringify(this.declaredDefaults.get(key))} vs ${JSON.stringify(value)}. First one wins, and which is first can vary.`);
+      }
+      this.declaredDefaults.set(key, value);
+    }
+    if (cell.pending)
+      cell.set(value);
+  }
+  runInitialiser(key, cell, initialiser, options = {}) {
+    const atBuild = options.fetchAt === "build";
+    if (this.ssg && !atBuild)
+      return;
+    if (atBuild)
+      this.buildKeys.add(key);
+    if (atBuild && options.refresh)
+      this.refreshKeys.add(key);
+    if (this.initialised.has(key)) {
+      if (!this.ssg && options.refresh && !this.refreshed.has(key)) {
+        this.refreshed.add(key);
+        this.fetch(key, cell, initialiser, false);
+      }
+      return;
+    }
+    this.initialised.add(key);
+    this.fetch(key, cell, initialiser, this.ssg);
+  }
+  fetch(key, cell, initialiser, tracked) {
+    try {
+      const result = initialiser();
+      if (result instanceof Promise) {
+        const settled = result.then((value) => cell.set(value));
+        if (tracked) {
+          settled.catch(() => {
+          });
+          this.buildWork.push(settled);
+        } else {
+          settled.catch((error) => fail(`Cell initialiser failed for "${key}":`, error));
+        }
+      } else {
+        cell.set(result);
+      }
+    } catch (error) {
+      fail(`Cell initialiser failed for "${key}":`, error);
+    }
+  }
+  whenReady(keys, onReady) {
+    const outstanding = keys.filter((key) => this.get(key).pending);
+    if (!outstanding.length) {
+      onReady();
+      return () => {
+      };
+    }
+    const unsubscribes = [];
+    const cancel = () => {
+      unsubscribes.forEach((unsubscribe) => unsubscribe());
+      unsubscribes.length = 0;
+    };
+    const check = () => {
+      if (outstanding.some((key) => this.get(key).pending))
+        return;
+      cancel();
+      onReady();
+    };
+    outstanding.forEach((key) => unsubscribes.push(this.get(key).subscribe(check)));
+    return cancel;
+  }
+  pendingKeys(keys) {
+    return keys.filter((key) => this.get(key).pending);
+  }
+  async settleBuildData() {
+    while (this.buildWork.length) {
+      const pending = this.buildWork;
+      this.buildWork = [];
+      await Promise.all(pending);
+    }
+  }
+  isBuildKey(key) {
+    return this.buildKeys.has(key);
+  }
+  isBakedOnly(key) {
+    return this.buildKeys.has(key) && !this.refreshKeys.has(key);
+  }
+  hasBuildData() {
+    return this.buildKeys.size > 0;
+  }
+  buildPayload() {
+    const payload = {};
+    for (const key of this.buildKeys) {
+      const cell = this.cells.get(key);
+      if (cell && !cell.pending)
+        payload[key] = cell.value;
+    }
+    return payload;
+  }
+  seed(values) {
+    for (const [key, value] of Object.entries(values)) {
+      this.initialised.add(key);
+      this.get(key).set(value);
+    }
+  }
+  has(key) {
+    return this.cells.has(key);
+  }
+  keys() {
+    return [...this.cells.keys()];
+  }
+  createReadProxy(onRead) {
+    return new Proxy({}, {
+      get: (_target, prop) => {
+        if (typeof prop !== "string")
+          return;
+        const key = prop;
+        onRead?.(key);
+        return this.get(key).value;
+      },
+      set: (_target, prop, value) => {
+        if (typeof prop !== "string")
+          return false;
+        this.get(prop).set(value);
+        return true;
+      },
+      has: () => true
+    });
+  }
+  clear() {
+    this.cells.clear();
+    this.initialised.clear();
+    this.declaredDefaults.clear();
+  }
+}
+// src/runtime/dom/ForBlock.ts
+class Row {
+  locals;
+  key = "";
+  nodes = [];
+  bindings = [];
+  blocks = [];
+  cleanup = [];
+  instances = [];
+  constructor(locals) {
+    this.locals = locals;
+  }
+  addBinding(binding) {
+    this.bindings.push(binding);
+  }
+  addCleanup(cleanup) {
+    this.cleanup.push(cleanup);
+  }
+  addBlock(block) {
+    this.blocks.push(block);
+  }
+  get item() {
+    return this.locals[this.locals.length - 1];
+  }
+  set item(value) {
+    this.locals[this.locals.length - 1] = value;
+  }
+}
+function toIterable(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "number") {
+    return Array.from({ length: Math.max(0, Math.floor(value)) }, (_, i) => i);
+  }
+  if (typeof value[Symbol.iterator] === "function")
+    return [...value];
+  if (typeof value === "object")
+    return Object.values(value);
+  return [];
+}
+var nextObjectId = 1;
+var objectIds = new WeakMap;
+function identityOf(value) {
+  if (typeof value === "symbol")
+    return value.toString();
+  if (value !== null && typeof value === "object") {
+    let id = objectIds.get(value);
+    if (id === undefined) {
+      id = nextObjectId++;
+      objectIds.set(value, id);
+    }
+    return `o${id}`;
+  }
+  return `${typeof value}:${String(value)}`;
+}
+
+class ForBlock {
+  owner;
+  anchor;
+  templates;
+  alias;
+  params;
+  parentLocals;
+  keyFor;
+  renderer;
+  conditional;
+  itemsExpr;
+  rows = new Map;
+  order = [];
+  pendingItems = null;
+  running = false;
+  warnedDuplicates = false;
+  constructor(owner, anchor, templates, alias, params, parentLocals, keyFor, renderer, conditional = false, itemsExpr = "") {
+    this.owner = owner;
+    this.anchor = anchor;
+    this.templates = templates;
+    this.alias = alias;
+    this.params = params;
+    this.parentLocals = parentLocals;
+    this.keyFor = keyFor;
+    this.renderer = renderer;
+    this.conditional = conditional;
+    this.itemsExpr = itemsExpr;
+  }
+  toItems(value) {
+    if (this.conditional) {
+      return Number.isInteger(value) && value >= 0 ? [value] : [];
+    }
+    return toIterable(value);
+  }
+  templateFor(item) {
+    return this.conditional ? this.templates[item] : this.templates[0];
+  }
+  schedule(items) {
+    this.pendingItems = items;
+    if (this.running)
+      return;
+    this.running = true;
+    this.drain();
+  }
+  async drain() {
+    try {
+      while (this.pendingItems !== null) {
+        const items = this.pendingItems;
+        this.pendingItems = null;
+        await this.reconcile(items);
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+  keysFor(items) {
+    const occurrences = new Map;
+    return items.map((item) => {
+      const locals = [...this.parentLocals, item];
+      const base = identityOf(this.keyFor ? this.keyFor(locals) : item);
+      const seen = occurrences.get(base) ?? 0;
+      occurrences.set(base, seen + 1);
+      if (seen > 0 && !this.keyFor && !this.warnedDuplicates) {
+        this.warnedDuplicates = true;
+        {
+          warn(`$for over duplicate values in "${this.alias}" - rows are matched by position among equal items. Add $key for exact identity.`);
+        }
+      }
+      return `${base}#${seen}`;
+    });
+  }
+  async reconcile(items) {
+    const keys = this.keysFor(items);
+    const next = new Map;
+    for (let i = 0;i < items.length; i++) {
+      const key = keys[i];
+      const existing = this.rows.get(key);
+      if (existing) {
+        this.rows.delete(key);
+        if (this.alias)
+          existing.item = items[i];
+        this.renderer.refreshRow(this, existing);
+        next.set(key, existing);
+      } else {
+        const row = await this.renderer.createRow(this, items[i]);
+        row.key = key;
+        next.set(key, row);
+      }
+    }
+    this.rows.forEach((row) => this.renderer.destroyRow(this, row));
+    this.rows = next;
+    this.order = keys;
+    this.position();
+  }
+  position() {
+    const parent = this.anchor.parentNode;
+    if (!parent)
+      return;
+    let reference = this.anchor;
+    for (let i = this.order.length - 1;i >= 0; i--) {
+      const row = this.rows.get(this.order[i]);
+      if (!row)
+        continue;
+      for (let j = row.nodes.length - 1;j >= 0; j--) {
+        const node = row.nodes[j];
+        if (node.nextSibling !== reference || node.parentNode !== parent) {
+          parent.insertBefore(node, reference);
+        }
+        reference = node;
+      }
+    }
+    if (parent.isConnected)
+      this.renderer.connected?.();
+  }
+  destroy() {
+    this.pendingItems = null;
+    this.rows.forEach((row) => this.renderer.destroyRow(this, row));
+    this.rows.clear();
+    this.order = [];
+    this.anchor.parentNode?.removeChild(this.anchor);
+  }
+}
+
+// src/runtime/dom/hydration.ts
+var TRIGGERS = new Set([
+  "load",
+  "idle",
+  "visible",
+  "interaction",
+  "never",
+  "always"
+]);
+function parseTrigger(value) {
+  if (!value)
+    return "load";
+  const trigger = value.trim().toLowerCase();
+  if (TRIGGERS.has(trigger)) {
+    return trigger;
+  }
+  warn(`Unknown $hydrate="${value}" - expected load, idle, visible, interaction, never or always. Falling back to load.`);
+  return "load";
+}
+function scheduleHydration(trigger, element, run) {
+  if (trigger === "load") {
+    run();
+    return () => {
+    };
+  }
+  if (trigger === "idle") {
+    const idle = globalThis.requestIdleCallback;
+    if (typeof idle === "function") {
+      const handle2 = idle(run);
+      return () => globalThis.cancelIdleCallback?.(handle2);
+    }
+    const handle = setTimeout(run, 1);
+    return () => clearTimeout(handle);
+  }
+  if (trigger === "interaction") {
+    const events = ["pointerdown", "keydown", "focusin"];
+    const cancel = () => {
+      events.forEach((event) => element.removeEventListener(event, fire));
+    };
+    const fire = () => {
+      cancel();
+      run();
+    };
+    events.forEach((event) => element.addEventListener(event, fire));
+    return cancel;
+  }
+  const Observer = globalThis.IntersectionObserver;
+  if (typeof Observer !== "function") {
+    warn('$hydrate="visible" needs IntersectionObserver; hydrating immediately.');
+    run();
+    return () => {
+    };
+  }
+  const observer = new Observer((entries) => {
+    if (!entries.some((entry) => entry.isIntersecting))
+      return;
+    observer.disconnect();
+    run();
+  });
+  observer.observe(element);
+  return () => observer.disconnect();
+}
+
+// src/marker.ts
+var START = "lsp ";
+var END = "/lsp";
+var MARKER_END = `<!--${END}-->`;
+function isMarkerStart(node) {
+  return node.nodeType === 8 && node.data.startsWith(START);
+}
+function isMarkerEnd(node) {
+  return node.nodeType === 8 && node.data.trim() === END;
+}
+function parseMarker(node) {
+  const data = node.data.slice(START.length);
+  try {
+    const payload = JSON.parse(data);
+    return typeof payload?.c === "string" ? payload : null;
+  } catch {
+    warn("Malformed island marker:", data);
+    return null;
+  }
+}
+function findMarkerEnd(nodes, start) {
+  let depth = 0;
+  for (let i = start;i < nodes.length; i++) {
+    if (isMarkerStart(nodes[i]))
+      depth++;
+    else if (isMarkerEnd(nodes[i])) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function slotNodesFor(payload, between) {
+  if (!payload.ssr)
+    return between;
+  const stash = between.find((node) => node.nodeType === 1 && node.tagName === "TEMPLATE" && node.hasAttribute("data-lsp-slot"));
+  return stash ? Array.from(stash.content.childNodes) : [];
+}
+
+// src/runtime/dom/Mounter.ts
+class Mounter {
+  registry;
+  bindings;
+  events;
+  initInstance;
+  releaseInstance;
+  resolve;
+  metadata;
+  ssg;
+  styles;
+  constructor(registry, bindings, events, initInstance, releaseInstance = () => {
+  }, resolve = async (id) => null, metadata = () => null, ssg = false, styles = null) {
+    this.registry = registry;
+    this.bindings = bindings;
+    this.events = events;
+    this.initInstance = initInstance;
+    this.releaseInstance = releaseInstance;
+    this.resolve = resolve;
+    this.metadata = metadata;
+    this.ssg = ssg;
+    this.styles = styles;
+  }
+  async mountRoot(componentId, container, props = {}, slotNodes = []) {
+    const instance = await this.mount(componentId, null, props, slotNodes);
+    if (!instance)
+      return null;
+    container.innerHTML = "";
+    const frag = document.createDocumentFragment();
+    instance.rootNodes.forEach((node) => frag.appendChild(node));
+    container.appendChild(frag);
+    return instance;
+  }
+  async mount(componentId, parent, props, slotNodes, preserved, adopt, rescue) {
+    const definition = await this.resolve(componentId);
+    if (!definition)
+      return null;
+    const instance = await this.initInstance(componentId, parent, props);
+    if (!instance)
+      return null;
+    let fragment = this.parseTemplate(definition.template);
+    const markers = [];
+    const context = {
+      owner: instance,
+      holder: instance,
+      params: [],
+      locals: [],
+      preserved
+    };
+    if (adopt) {
+      const adopted = [];
+      if (this.adoptNodes(Array.from(fragment.childNodes), adopt, context, adopted)) {
+        for (const marker of adopted) {
+          await this.mountMarker(marker, instance, context);
+        }
+        instance.rootNodes = significant(adopt);
+        const adoptedRoot = instance.rootNodes.find((node) => node.nodeType === 1);
+        adoptedRoot?.setAttribute("data-lsp-instance", instance.id);
+        parent?.children.push(instance);
+        return instance;
+      }
+      warn(`Could not adopt server-rendered DOM for <${componentId}> - rebuilding. Something rendered at build differs from what the client expects.`);
+      instance.releaseDom();
+      fragment = this.parseTemplate(definition.template);
+    }
+    const parentOwned = this.fillSlots(fragment, slotNodes, parent !== null);
+    if (rescue)
+      context.preserved = rescue();
+    this.collect(fragment, context, parentOwned, markers);
+    for (const marker of markers) {
+      await this.mountMarker(marker, instance, context);
+    }
+    instance.rootNodes = Array.from(fragment.childNodes);
+    const rootElement = instance.rootNodes.find((node) => node.nodeType === 1);
+    rootElement?.setAttribute("data-lsp-instance", instance.id);
+    parent?.children.push(instance);
+    return instance;
+  }
+  unmount(instance) {
+    const nodes = [...instance.rootNodes];
+    instance.destroy();
+    nodes.forEach((node) => node.remove?.());
+    const siblings = instance.parent?.children;
+    if (siblings) {
+      const index = siblings.indexOf(instance);
+      if (index > -1)
+        siblings.splice(index, 1);
+    }
+  }
+  parseTemplate(html) {
+    const template = document.createElement("template");
+    template.innerHTML = html.trim();
+    return template.content;
+  }
+  fillSlots(fragment, slotNodes, ownedByParent = true) {
+    const outlets = Array.from(fragment.querySelectorAll("slot"));
+    const placed = expandSlotFills(slotNodes);
+    const parentOwned = ownedByParent ? new Set(placed) : new Set;
+    if (outlets.length === 0)
+      return parentOwned;
+    const byName = new Map;
+    for (const node of slotNodes) {
+      const name = node.nodeType === 1 ? node.getAttribute("slot") ?? "" : "";
+      const group = byName.get(name) ?? [];
+      group.push(node);
+      byName.set(name, group);
+    }
+    const filled = new Set;
+    for (const outlet of outlets) {
+      const name = outlet.getAttribute("name") ?? "";
+      if (filled.has(name)) {
+        warn(`Duplicate <slot${name ? ` name="${name}"` : ""}> - only the first is filled.`);
+        outlet.remove();
+        continue;
+      }
+      filled.add(name);
+      const supplied = byName.get(name);
+      byName.delete(name);
+      const holder = document.createDocumentFragment();
+      if (supplied?.length) {
+        supplied.forEach((node) => {
+          if (isSlotTemplate(node)) {
+            holder.appendChild(node.content);
+          } else {
+            if (node.nodeType === 1)
+              node.removeAttribute("slot");
+            holder.appendChild(node);
+          }
+        });
+        if (this.ssg) {
+          holder.insertBefore(document.createComment(`${SLOT_MARK}${name}`), holder.firstChild);
+          holder.appendChild(document.createComment(SLOT_END));
+        }
+      } else {
+        Array.from(outlet.childNodes).forEach((node) => holder.appendChild(node));
+      }
+      outlet.replaceWith(holder);
+    }
+    for (const [name, nodes] of byName) {
+      if (!nodes.length)
+        continue;
+      warn(name ? `No <slot name="${name}"> to receive this content - it was dropped.` : "Content passed to a component with no unnamed <slot> - it was dropped.");
+    }
+    return parentOwned;
+  }
+  collect(node, context, skip, markers) {
+    if (skip.has(node))
+      return;
+    if (node.nodeType === 1) {
+      const el = node;
+      if (el.hasAttribute("data-bind-for")) {
+        this.createBlock(el, context, "for");
+        return;
+      }
+      if (el.hasAttribute("data-bind-if")) {
+        this.createBlock(el, context, "if");
+        return;
+      }
+      if (el.hasAttribute("data-bind-else") || el.hasAttribute("data-bind-else-if")) {
+        warn("$else / $else-if must directly follow a $if or $else-if sibling", el);
+        el.remove();
+        return;
+      }
+      if (el.hasAttribute("data-lsp-needs")) {
+        this.collectNeeds(el, context, markers);
+        return;
+      }
+      this.collectElement(el, context);
+    }
+    this.collectChildren(node, context, skip, markers);
+  }
+  collectNeeds(el, context, markers) {
+    const keys = (el.getAttribute("data-lsp-needs") ?? "").split(",").map((key) => key.trim()).filter(Boolean);
+    const shimmer = el.getAttribute("data-lsp-shimmer");
+    el.removeAttribute("data-lsp-needs");
+    el.removeAttribute("data-lsp-shimmer");
+    this.collectElement(el, context);
+    if (!keys.length) {
+      warn(`$needs on <${el.tagName.toLowerCase()}> must name at least one cell - bare $needs is only meaningful on a component usage.`);
+      this.collectChildren(el, context, new Set, markers);
+      return;
+    }
+    if (!this.bindings.cellManager.pendingKeys(keys).length) {
+      this.collectChildren(el, context, new Set, markers);
+      return;
+    }
+    const held = document.createDocumentFragment();
+    Array.from(el.childNodes).forEach((child) => held.appendChild(child));
+    el.setAttribute("data-lsp-pending", "");
+    if (shimmer !== null) {
+      el.setAttribute("data-lsp-shimmer", "");
+      if (shimmer)
+        el.setAttribute("style", joinStyle(el, `--lsp-pending-width: ${shimmer}`));
+      this.styles?.ensurePendingStyles();
+    }
+    const cancel = this.bindings.cellManager.whenReady(keys, () => {
+      el.removeAttribute("data-lsp-pending");
+      el.removeAttribute("data-lsp-shimmer");
+      Array.from(held.childNodes).forEach((child) => el.appendChild(child));
+      const nested = [];
+      this.collectChildren(el, context, new Set, nested);
+      nested.forEach((range) => {
+        this.mountMarker(range, context.owner, context);
+      });
+      this.bindings.updateInstance(context.owner);
+    });
+    context.holder.addCleanup(cancel);
+  }
+  collectChildren(node, context, skip, markers) {
+    const children = Array.from(node.childNodes);
+    for (let i = 0;i < children.length; i++) {
+      const child = children[i];
+      if (!isMarkerStart(child)) {
+        this.collect(child, context, skip, markers);
+        continue;
+      }
+      const endIndex = findMarkerEnd(children, i);
+      if (endIndex === -1) {
+        warn("Unterminated island marker:", child.data);
+        continue;
+      }
+      const payload = parseMarker(child);
+      const between = children.slice(i + 1, endIndex);
+      const slotNodes = payload ? slotNodesFor(payload, between) : between;
+      expandSlotFills(slotNodes).forEach((slotNode) => this.collect(slotNode, context, skip, markers));
+      if (payload) {
+        markers.push({
+          start: child,
+          end: children[endIndex],
+          payload,
+          slotNodes: liveSlotNodes(payload, child, children[endIndex], slotNodes)
+        });
+      }
+      i = endIndex;
+    }
+  }
+  rescueRendered(range) {
+    const rescued = new Map;
+    const counts = new Map;
+    const children = [];
+    let current = range.start.nextSibling;
+    while (current && current !== range.end) {
+      children.push(current);
+      current = current.nextSibling;
+    }
+    const walk = (nodes) => {
+      for (let i = 0;i < nodes.length; i++) {
+        const node = nodes[i];
+        if (!isMarkerStart(node)) {
+          walk(Array.from(node.childNodes));
+          continue;
+        }
+        const endIndex = findMarkerEnd(nodes, i);
+        if (endIndex === -1)
+          continue;
+        const payload = parseMarker(node);
+        const between = nodes.slice(i + 1, endIndex);
+        if (payload) {
+          const ordinal = counts.get(payload.c) ?? 0;
+          counts.set(payload.c, ordinal + 1);
+          const held = document.createDocumentFragment();
+          between.forEach((child) => held.appendChild(child));
+          rescued.set(`${payload.c}#${ordinal}`, Array.from(held.childNodes));
+        }
+        i = endIndex;
+      }
+    };
+    walk(children);
+    return rescued;
+  }
+  takeRescued(range, context) {
+    if (!context.preserved)
+      return null;
+    const seen = context.seen ??= new Map;
+    const ordinal = seen.get(range.payload.c) ?? 0;
+    seen.set(range.payload.c, ordinal + 1);
+    return context.preserved.get(`${range.payload.c}#${ordinal}`) ?? null;
+  }
+  adoptNodes(templateNodes, domNodes, context, markers) {
+    const wanted = significant(templateNodes);
+    const found = significant(domNodes);
+    let d = 0;
+    for (let i = 0;i < wanted.length; i++) {
+      const node = wanted[i];
+      if (node.nodeType === 1) {
+        const el = node;
+        if (el.hasAttribute("data-bind-for")) {
+          const consumed = this.adoptBlock(el, found, d, context, "for");
+          if (!consumed)
+            return false;
+          d += consumed.dom;
+          continue;
+        }
+        if (el.hasAttribute("data-bind-if")) {
+          const consumed = this.adoptBlock(el, found, d, context, "if");
+          if (!consumed)
+            return false;
+          d += consumed.dom;
+          i += consumed.templates - 1;
+          continue;
+        }
+        if (el.tagName === "SLOT") {
+          if (!found[d] || !isSlotStart(found[d])) {
+            if (!this.adoptNodes(Array.from(el.childNodes), found.slice(d), context, markers)) {
+              return false;
+            }
+            d = found.length;
+            continue;
+          }
+          while (d < found.length && !isSlotEnd(found[d]))
+            d++;
+          d++;
+          continue;
+        }
+        const target = found[d++];
+        if (!target || target.nodeType !== 1)
+          return false;
+        if (target.tagName !== el.tagName)
+          return false;
+        if (el.tagName === "NOSCRIPT")
+          continue;
+        this.collectElement(target, context);
+        if (!this.adoptNodes(Array.from(el.childNodes), Array.from(target.childNodes), context, markers)) {
+          return false;
+        }
+        continue;
+      }
+      if (isMarkerStart(node)) {
+        const end = findMarkerEnd(wanted, i);
+        if (end === -1)
+          return false;
+        const domStart = found[d];
+        if (!domStart || !isMarkerStart(domStart))
+          return false;
+        const domEnd = findMarkerEnd(found, d);
+        if (domEnd === -1)
+          return false;
+        const payload = parseMarker(domStart);
+        if (!payload)
+          return false;
+        const templateFills = wanted.slice(i + 1, end);
+        const between = found.slice(d + 1, domEnd);
+        const regions = templateFills.length ? findSlotRegions(between) : new Map;
+        let slotNodes = templateFills;
+        let slotsAdopted = regions.size > 0;
+        if (slotsAdopted) {
+          const placed = [];
+          for (const [name, fills] of groupSlotFills(templateFills)) {
+            const region = regions.get(name);
+            if (!region || !this.adoptNodes(fills, region, context, markers)) {
+              slotsAdopted = false;
+              break;
+            }
+            placed.push(...region);
+          }
+          if (slotsAdopted)
+            slotNodes = placed;
+        }
+        if (!slotsAdopted) {
+          expandSlotFills(templateFills).forEach((slotNode) => this.collect(slotNode, context, new Set, markers));
+          slotNodes = templateFills;
+        }
+        markers.push({
+          start: domStart,
+          end: found[domEnd],
+          payload,
+          slotNodes,
+          adopted: templateFills.length === 0 || slotsAdopted
+        });
+        i = end;
+        d = domEnd + 1;
+        continue;
+      }
+      d++;
+    }
+    return true;
+  }
+  adoptBlock(el, found, from, context, kind) {
+    let anchorIndex = -1;
+    for (let i = from;i < found.length; i++) {
+      if (isBlockAnchor(found[i])) {
+        anchorIndex = i;
+        break;
+      }
+      if (!isRowMark(found[i]) && i === from)
+        continue;
+    }
+    if (anchorIndex === -1)
+      return null;
+    const block = this.createBlock(el, context, kind, found[anchorIndex]);
+    if (!block)
+      return null;
+    const slices = anchorIndex === from ? [] : sliceRows(found, from, anchorIndex);
+    if (!slices)
+      return null;
+    if (!this.adoptRows(block, slices, context))
+      return null;
+    return {
+      dom: anchorIndex - from + 1,
+      templates: block.templates.length
+    };
+  }
+  onConnected;
+  fillRange(range, nodes) {
+    const parent = range.start.parentNode;
+    if (!parent)
+      return;
+    let current = range.start.nextSibling;
+    while (current && current !== range.end) {
+      const next = current.nextSibling;
+      parent.removeChild(current);
+      current = next;
+    }
+    const fragment = document.createDocumentFragment();
+    nodes.forEach((node) => fragment.appendChild(node));
+    parent.insertBefore(fragment, range.end);
+    if (parent.isConnected)
+      this.onConnected?.();
+  }
+  collectElement(el, context) {
+    addScope(el, context.owner.scopeId);
+    for (const attr of Array.from(el.attributes)) {
+      this.applyDirective(el, attr.name, attr.value, context);
+    }
+  }
+  createBlock(el, context, kind, existingAnchor) {
+    const conditional = kind === "if";
+    const rawExpression = el.getAttribute(`data-bind-${kind}`) ?? "";
+    const branches = conditional ? this.gatherBranches(el) : [];
+    const expression = conditional ? composeBranchExpression(branches) : rawExpression;
+    const parsed = conditional ? { alias: null, items: expression } : parseForExpression(rawExpression);
+    if (!parsed) {
+      warn(`Could not parse $for="${expression}" - expected "item in items"`);
+      el.remove();
+      return null;
+    }
+    if (!conditional && el.hasAttribute("data-bind-if")) {
+      warn(`$for and $if on the same element are not supported (${rawExpression}). Wrap one in an element.`);
+    }
+    const keyExpr = conditional ? null : el.getAttribute("data-bind-key");
+    el.removeAttribute(`data-bind-${kind}`);
+    el.removeAttribute("data-bind-key");
+    let anchor;
+    if (existingAnchor) {
+      anchor = existingAnchor;
+      el.remove();
+    } else {
+      anchor = document.createComment(` ${kind}: ${expression} `);
+      el.replaceWith(anchor);
+    }
+    const templates = conditional ? branches.map((b) => b.el) : [el];
+    const params = parsed.alias ? [...context.params, parsed.alias] : context.params;
+    const keyFor = keyExpr ? (locals) => {
+      const compiled = this.bindings.compileExpression(keyExpr, params);
+      return compiled(context.owner.state, context.owner.props, this.cellsProxy(), this.bindings.pendingProbe(), ...locals);
+    } : null;
+    const block = new ForBlock(context.owner, anchor, templates, parsed.alias, context.params, context.locals, keyFor, this, conditional, parsed.items);
+    context.holder.addBlock(block);
+    context.holder.addBinding(this.bindings.createForBinding(block, parsed.items, context.params));
+    return block;
+  }
+  adoptRows(block, slices, context) {
+    const value = this.bindings.evaluate(block.itemsExpr, context.owner, context.locals);
+    const items = block.toItems(value);
+    if (items.length !== slices.length)
+      return false;
+    const keys = block.keysFor(items);
+    for (let i = 0;i < items.length; i++) {
+      const item = items[i];
+      const row = new Row(block.alias ? [...block.parentLocals, item] : [...block.parentLocals]);
+      row.key = keys[i];
+      row.nodes = slices[i];
+      const rowContext = {
+        owner: block.owner,
+        holder: row,
+        params: block.alias ? [...block.params, block.alias] : block.params,
+        locals: row.locals
+      };
+      const template = block.templateFor(item);
+      const templateNodes = template.tagName === "TEMPLATE" ? Array.from(template.content.cloneNode(true).childNodes) : [template.cloneNode(true)];
+      const markers = [];
+      const content = slices[i].filter((node) => !isRowMark(node));
+      if (!this.adoptNodes(templateNodes, content, rowContext, markers)) {
+        return false;
+      }
+      for (const marker of markers) {
+        this.mountMarker(marker, block.owner, rowContext).then((child) => {
+          if (child)
+            row.instances.push(child);
+        });
+      }
+      block.rows.set(keys[i], row);
+      block.order.push(keys[i]);
+    }
+    return true;
+  }
+  gatherBranches(el) {
+    const branches = [
+      { condition: el.getAttribute("data-bind-if"), el }
+    ];
+    let sibling = el.nextElementSibling;
+    while (sibling) {
+      const next = sibling.nextElementSibling;
+      if (sibling.hasAttribute("data-bind-else-if")) {
+        branches.push({
+          condition: sibling.getAttribute("data-bind-else-if"),
+          el: sibling
+        });
+        sibling.removeAttribute("data-bind-else-if");
+        sibling.remove();
+        sibling = next;
+        continue;
+      }
+      if (sibling.hasAttribute("data-bind-else")) {
+        branches.push({ condition: null, el: sibling });
+        sibling.removeAttribute("data-bind-else");
+        sibling.remove();
+        break;
+      }
+      break;
+    }
+    return branches;
+  }
+  async createRow(block, item) {
+    const row = new Row(block.alias ? [...block.parentLocals, item] : [...block.parentLocals]);
+    const fragment = document.createDocumentFragment();
+    const source = block.templateFor(item);
+    fragment.appendChild(source.tagName === "TEMPLATE" ? source.content.cloneNode(true) : source.cloneNode(true));
+    const context = {
+      owner: block.owner,
+      holder: row,
+      params: block.alias ? [...block.params, block.alias] : block.params,
+      locals: row.locals
+    };
+    const markers = [];
+    this.collect(fragment, context, new Set, markers);
+    for (const marker of markers) {
+      const child = await this.mountMarker(marker, block.owner, context);
+      if (child)
+        row.instances.push(child);
+    }
+    if (this.ssg) {
+      fragment.insertBefore(document.createComment(ROW_MARK), fragment.firstChild);
+    }
+    row.nodes = Array.from(fragment.childNodes);
+    this.bindings.updateRow(block.owner, row);
+    row.instances.forEach((child) => this.bindings.updateTree(child));
+    return row;
+  }
+  connected() {
+    this.onConnected?.();
+  }
+  refreshRow(block, row) {
+    this.bindings.updateRow(block.owner, row);
+  }
+  destroyRow(block, row) {
+    row.blocks.forEach((nested) => nested.destroy());
+    row.blocks.length = 0;
+    row.instances.forEach((instance) => {
+      const siblings = block.owner.children;
+      const index = siblings.indexOf(instance);
+      if (index > -1)
+        siblings.splice(index, 1);
+      this.releaseInstance(instance);
+      instance.destroy();
+    });
+    row.instances.length = 0;
+    row.cleanup.forEach((cleanup) => cleanup());
+    row.cleanup.length = 0;
+    row.bindings.length = 0;
+    row.nodes.forEach((node) => node.remove?.());
+    row.nodes.length = 0;
+  }
+  cellsProxy() {
+    return this.bindings.readProxy();
+  }
+  applyDirective(el, name, value, context) {
+    const { holder, params } = context;
+    if (name === "data-lsp-ref") {
+      if (context.owner.refs[value]) {
+        warn(`Duplicate $ref="${value}" in <${context.owner.componentId}> - a ref names one element, and inside a $for every row would claim it. The last one wins.`);
+      }
+      context.owner.refs[value] = el;
+      return true;
+    }
+    if (name === "data-text") {
+      holder.addBinding(this.bindings.createBinding(el, "text", value, undefined, params));
+      return true;
+    }
+    if (name === "data-bind-show") {
+      holder.addBinding(this.bindings.createBinding(el, "show", value, undefined, params));
+      return true;
+    }
+    if (name === "data-bind-htmlfor") {
+      holder.addBinding(this.bindings.createBinding(el, "attr", value, "for", params));
+      return true;
+    }
+    if (name === "data-bind-html") {
+      holder.addBinding(this.bindings.createBinding(el, "html", value, undefined, params));
+      return true;
+    }
+    if (name === "data-bind-class") {
+      holder.addBinding(this.bindings.createBinding(el, "class", value, undefined, params));
+      return true;
+    }
+    if (name === "data-bind-model") {
+      context.owner.models++;
+      const binding = this.bindings.createModelBinding(el, value, params);
+      holder.addBinding(binding);
+      this.bindings.attachModel(binding, new BindingScope(context.owner, context.locals, holder));
+      return true;
+    }
+    if (name === "data-bind-key" || name === "data-bind-if" || name === "data-bind-else" || name === "data-bind-else-if" || name === "data-bind-hydrate") {
+      return true;
+    }
+    if (name.startsWith("data-bind-")) {
+      holder.addBinding(this.bindings.createBinding(el, "attr", value, name.slice(10), params));
+      return true;
+    }
+    if (name.startsWith("data-on-")) {
+      this.bindEvent(el, name.slice(8), value, context);
+      return true;
+    }
+    return false;
+  }
+  bindEvent(el, eventType, source, context) {
+    const expression = source.trim();
+    const { owner, holder, params, locals } = context;
+    owner.listeners++;
+    if (/^[A-Za-z_$][\w$]*$/.test(expression)) {
+      this.events.bind(el, eventType, expression, owner, holder);
+      return;
+    }
+    const handlerNames = owner.handlerNames.filter((name) => !params.includes(name));
+    const compiled = this.bindings.compileExpression(expression, [
+      ...params,
+      ...handlerNames,
+      "$event"
+    ]);
+    this.events.bindExpression(el, eventType, (event) => {
+      compiled(owner.state, owner.props, this.bindings.readProxy(), this.bindings.pendingProbe(), ...locals, ...handlerNames.map((name) => owner.getHandler(name)), event);
+    }, holder, `${eventType} expression "${expression}"`);
+  }
+  async mountMarker(range, owner, context) {
+    if (range.payload.dyn && !range.payload.c) {
+      const id = this.resolveDynamicId(range.payload.dyn, context);
+      if (!id) {
+        warn(`<Dynamic $is="${range.payload.dyn}"> resolved to nothing, so no component was mounted.`);
+        return null;
+      }
+      range.payload.c = id;
+    }
+    const { needs } = range.payload;
+    const trigger = parseTrigger(range.payload.hydrate ?? null);
+    if (this.ssg) {
+      const waiting = needs && this.bindings.cellManager.pendingKeys(needs).length > 0;
+      if (needs && (waiting || needs.length === 0)) {
+        this.renderSkeleton(range);
+        return null;
+      }
+      return this.completeMount(range, owner, context);
+    }
+    if (trigger === "never")
+      return null;
+    if (needs || trigger !== "load" && trigger !== "always") {
+      this.deferMarker(range, owner, context, trigger, needs);
+      return null;
+    }
+    return this.completeMount(range, owner, context);
+  }
+  deferMarker(range, owner, context, trigger, needs) {
+    const held = document.createDocumentFragment();
+    range.slotNodes.forEach((node) => held.appendChild(node));
+    const rescued = this.takeRescued(range, context);
+    if (rescued)
+      this.fillRange(range, rescued);
+    else if (!range.payload.ssr && !range.adopted)
+      this.renderSkeleton(range);
+    let triggered = false;
+    let ready = !needs;
+    const attempt = () => {
+      if (!triggered || !ready)
+        return;
+      this.completeMount(range, owner, context);
+    };
+    const cancelTrigger = scheduleHydration(trigger, triggerTarget(range), () => {
+      triggered = true;
+      attempt();
+    });
+    context.holder.addCleanup(cancelTrigger);
+    if (needs) {
+      const cancelReady = this.bindings.cellManager.whenReady(needs, () => {
+        ready = true;
+        attempt();
+      });
+      context.holder.addCleanup(cancelReady);
+    }
+  }
+  resolveDynamicId(expr, context) {
+    const scope = new BindingScope(context.owner, context.locals, context.holder);
+    try {
+      const value = this.bindings.compileExpression(expr, context.params)(scope.state, scope.props, this.bindings.readProxy(), this.bindings.pendingProbe(), ...scope.locals);
+      return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : null;
+    } catch (error) {
+      warn(`Error evaluating <Dynamic $is="${expr}">:`, error);
+      return null;
+    }
+  }
+  renderSkeleton(range) {
+    const definition = this.registry.get(range.payload.c);
+    const fallback = definition ? null : this.metadata(range.payload.c);
+    const skeleton = definition?.skeleton ?? fallback?.skeleton ?? "";
+    const scopeId = definition?.scopeId ?? fallback?.scope;
+    const template = document.createElement("template");
+    template.innerHTML = skeleton;
+    if (scopeId) {
+      Array.from(template.content.querySelectorAll("*")).forEach((node) => addScope(node, scopeId));
+    }
+    this.fillRange(range, Array.from(template.content.childNodes));
+  }
+  async completeMount(range, owner, context) {
+    const { payload } = range;
+    const props = { ...payload.props ?? {} };
+    const scope = new BindingScope(owner, context.locals, context.holder);
+    const propBindings = Object.entries(payload.bind ?? {}).filter(([name]) => name !== "class" && name !== "style");
+    for (const [name, expr] of propBindings) {
+      props[name] = this.bindings.compileExpression(expr, context.params)(scope.state, scope.props, this.bindings.readProxy(), this.bindings.pendingProbe(), ...scope.locals);
+    }
+    const cellProps = Object.entries(payload.cells ?? {});
+    for (const [name, key] of cellProps) {
+      const cell = this.bindings.cellManager.get(key);
+      if (!cell.pending)
+        props[name] = cell.value;
+    }
+    const holdsSkeleton = Boolean(payload.needs) && !payload.ssr;
+    const child = await this.mount(payload.c, owner, props, range.slotNodes, undefined, (payload.ssr || range.adopted) && !holdsSkeleton ? nodesBetween(range.start, range.end) : undefined, payload.ssr ? () => this.rescueRendered(range) : undefined);
+    if (!child)
+      return null;
+    for (const [name, key] of cellProps) {
+      this.bindings.bindCellProp(child, name, key);
+    }
+    for (const [name, expr] of propBindings) {
+      const binding = this.bindings.createPropBinding(child, name, expr, context.params);
+      context.holder.addBinding(binding);
+      this.bindings.applyBinding(binding, scope);
+    }
+    const rootElement = child.rootNodes.find((node) => node.nodeType === 1);
+    if (rootElement)
+      this.applyForwarded(rootElement, payload, context);
+    this.fillRange(range, child.rootNodes);
+    this.bindings.updateTree(child);
+    return child;
+  }
+  findIslands(scope) {
+    const comments = [];
+    const walker = document.createTreeWalker(scope, 128);
+    while (walker.nextNode())
+      comments.push(walker.currentNode);
+    const islands = [];
+    let depth = 0;
+    let openIndex = -1;
+    for (let i = 0;i < comments.length; i++) {
+      if (isMarkerStart(comments[i])) {
+        if (depth === 0)
+          openIndex = i;
+        depth++;
+      } else if (isMarkerEnd(comments[i])) {
+        depth--;
+        if (depth === 0 && openIndex >= 0) {
+          const payload = parseMarker(comments[openIndex]);
+          if (payload) {
+            islands.push({
+              start: comments[openIndex],
+              end: comments[i],
+              payload,
+              slotNodes: slotNodesFor(payload, nodesBetween(comments[openIndex], comments[i]))
+            });
+          }
+          openIndex = -1;
+        }
+      }
+    }
+    return islands;
+  }
+  async mountRange(range, props, slotNodes) {
+    const child = await this.mount(range.payload.c, null, props, slotNodes, undefined, range.payload.ssr ? nodesBetween(range.start, range.end) : undefined, range.payload.ssr ? () => this.rescueRendered(range) : undefined);
+    if (!child)
+      return null;
+    const root = child.rootNodes.find((node) => node.nodeType === 1);
+    if (root) {
+      for (const [name, value] of Object.entries(range.payload.attrs ?? {})) {
+        if (name === "class") {
+          const existing = root.getAttribute("class") ?? "";
+          const merged = new Set(`${existing} ${value}`.split(/\s+/).filter(Boolean));
+          root.setAttribute("class", [...merged].join(" "));
+        } else {
+          root.setAttribute(name, value);
+        }
+      }
+    }
+    this.fillRange(range, child.rootNodes);
+    this.bindings.updateTree(child);
+    return child;
+  }
+  applyForwarded(root, payload, context) {
+    for (const [name, value] of Object.entries(payload.attrs ?? {})) {
+      if (name === "class") {
+        const existing = root.getAttribute("class") ?? "";
+        const merged = new Set(`${existing} ${value}`.split(/\s+/).filter(Boolean));
+        root.setAttribute("class", [...merged].join(" "));
+      } else if (name === "style") {
+        const existing = root.getAttribute("style");
+        root.setAttribute("style", existing ? `${existing};${value}` : value);
+      } else {
+        root.setAttribute(name, value);
+      }
+    }
+    for (const [event, handler] of Object.entries(payload.on ?? {})) {
+      this.bindEvent(root, event, handler, context);
+    }
+    for (const [name, expr] of Object.entries(payload.bind ?? {})) {
+      if (name !== "class" && name !== "style")
+        continue;
+      this.applyDirective(root, `data-bind-${name}`, expr, context);
+    }
+  }
+}
+function addScope(el, scopeId) {
+  if (!scopeId)
+    return;
+  const existing = el.getAttribute("data-lsp");
+  if (!existing) {
+    el.setAttribute("data-lsp", scopeId);
+    return;
+  }
+  if (!existing.split(/\s+/).includes(scopeId)) {
+    el.setAttribute("data-lsp", `${existing} ${scopeId}`);
+  }
+}
+function parseForExpression(expression) {
+  const match = expression.match(/^\s*(.+?)\s+(?:in|of)\s+(.+?)\s*$/);
+  if (!match)
+    return null;
+  const alias = match[1].trim();
+  if (!/^[A-Za-z_$][\w$]*$/.test(alias)) {
+    warn(`$for alias must be a plain identifier, got "${alias}"`);
+    return null;
+  }
+  return { alias, items: match[2].trim() };
+}
+function composeBranchExpression(branches) {
+  const elseIndex = branches.findIndex((branch) => branch.condition === null);
+  let expression = elseIndex >= 0 ? String(elseIndex) : "-1";
+  for (let i = branches.length - 1;i >= 0; i--) {
+    const { condition } = branches[i];
+    if (condition === null)
+      continue;
+    expression = `((${condition}) ? ${i} : ${expression})`;
+  }
+  return expression;
+}
+function liveSlotNodes(payload, start, end, collected) {
+  if (payload.ssr)
+    return collected;
+  return nodesBetween(start, end);
+}
+function groupSlotFills(fills) {
+  const byName = new Map;
+  for (const node of fills) {
+    const name = node.nodeType === 1 ? node.getAttribute("slot") ?? "" : "";
+    const group = byName.get(name) ?? [];
+    group.push(...isSlotTemplate(node) ? Array.from(node.content.childNodes) : [node]);
+    byName.set(name, group);
+  }
+  return byName;
+}
+function isSlotTemplate(node) {
+  return node.nodeType === 1 && node.tagName === "TEMPLATE" && node.hasAttribute("slot");
+}
+function expandSlotFills(slotNodes) {
+  const placed = [];
+  for (const node of slotNodes) {
+    if (isSlotTemplate(node)) {
+      placed.push(...Array.from(node.content.childNodes));
+    } else {
+      placed.push(node);
+    }
+  }
+  return placed;
+}
+function nodesBetween(start, end) {
+  const nodes = [];
+  let current = start.nextSibling;
+  while (current && current !== end) {
+    nodes.push(current);
+    current = current.nextSibling;
+  }
+  return nodes;
+}
+function sliceRows(found, from, anchorIndex) {
+  const slices = [];
+  let current = null;
+  for (let i = from;i < anchorIndex; i++) {
+    const node = found[i];
+    if (isRowMark(node)) {
+      current = [node];
+      slices.push(current);
+      continue;
+    }
+    if (!current)
+      return null;
+    current.push(node);
+  }
+  return slices;
+}
+var SLOT_MARK = "s:";
+var SLOT_END = "/s";
+function isSlotStart(node) {
+  return node.nodeType === 8 && node.data.startsWith(SLOT_MARK);
+}
+function isSlotEnd(node) {
+  return node.nodeType === 8 && node.data === SLOT_END;
+}
+function findSlotRegions(nodes, into = new Map) {
+  for (const node of nodes) {
+    if (isMarkerStart(node))
+      continue;
+    if (isSlotStart(node)) {
+      const name = node.data.slice(SLOT_MARK.length);
+      const region = [];
+      let current = node.nextSibling;
+      while (current && !isSlotEnd(current)) {
+        region.push(current);
+        current = current.nextSibling;
+      }
+      into.set(name, region);
+      continue;
+    }
+    if (node.childNodes?.length) {
+      findSlotRegions(Array.from(node.childNodes), into);
+    }
+  }
+  return into;
+}
+var ROW_MARK = "|";
+function isRowMark(node) {
+  return node.nodeType === 8 && node.data === ROW_MARK;
+}
+function isBlockAnchor(node) {
+  if (node.nodeType !== 8)
+    return false;
+  const data = node.data.trim();
+  return data.startsWith("for:") || data.startsWith("if:");
+}
+function isInsignificant(node) {
+  return node.nodeType === 3 && !(node.textContent ?? "").trim();
+}
+function significant(nodes) {
+  return nodes.filter((node) => !isInsignificant(node));
+}
+function joinStyle(el, declaration) {
+  const existing = el.getAttribute("style")?.trim() ?? "";
+  if (!existing)
+    return declaration;
+  return existing.endsWith(";") ? `${existing} ${declaration}` : `${existing}; ${declaration}`;
+}
+function triggerTarget(range) {
+  const first = range.start.nextSibling;
+  return first && first.nodeType === 1 ? first : range.start.parentNode;
+}
+// src/manifest.ts
+var HIDDEN_RULE = "[data-lsp-hidden]{display:none!important}";
+
+// src/runtime/dom/StyleManager.ts
+var PENDING_STYLES = `
+:where([data-lsp-pending][data-lsp-shimmer]) {
+  display: inline-block;
+  min-width: var(--lsp-pending-width, 4ch);
+  border-radius: 0.25em;
+  background-image: linear-gradient(90deg, #f0f0f0 25%, rgba(0,0,0,0) 37%, #f0f0f0 63%);
+  background-size: 400% 100%;
+  animation: lsp-pending 1.4s ease infinite;
+}
+
+@keyframes lsp-pending {
+  0% { background-position: 100% 50%; }
+  100% { background-position: 0% 50%; }
+}
+`;
+
+class StyleManager {
+  ssg;
+  componentRegistry;
+  styleElement = null;
+  sheet = null;
+  adopted = [];
+  pendingStylesUsed = false;
+  covered = new Set;
+  deferredCovered = new Set;
+  constructor(componentRegistry, ssg = false) {
+    this.ssg = ssg;
+    this.componentRegistry = componentRegistry;
+  }
+  ensureElement() {
+    if (this.styleElement)
+      return this.styleElement;
+    this.styleElement = document.getElementById("lightspeed-styles");
+    if (!this.styleElement) {
+      this.styleElement = document.createElement("style");
+      this.styleElement.id = "lightspeed-styles";
+      this.styleElement.textContent = HIDDEN_RULE;
+      document.head.appendChild(this.styleElement);
+    }
+    seed(this.covered, this.styleElement.getAttribute("data-lsp-covers"));
+    seed(this.deferredCovered, document.getElementById("lightspeed-styles-deferred")?.getAttribute("data-lsp-covers") ?? null);
+    return this.styleElement;
+  }
+  updateStyles() {
+    const element = this.ensureElement();
+    const additions = [];
+    if (this.pendingStylesUsed && !this.covered.has("@pending")) {
+      this.covered.add("@pending");
+      additions.push(PENDING_STYLES);
+    }
+    for (const component of this.componentRegistry.getAll()) {
+      if (component.style && !this.covered.has(component.id)) {
+        this.covered.add(component.id);
+        additions.push(component.style);
+      }
+      if (!this.ssg && component.styleDeferred && !this.deferredCovered.has(component.id)) {
+        this.deferredCovered.add(component.id);
+        additions.push(component.styleDeferred);
+      }
+    }
+    if (!additions.length)
+      return;
+    this.emit(element, additions);
+    element.setAttribute("data-lsp-covers", [...this.covered].join(","));
+    debug("styles updated");
+  }
+  ensurePendingStyles() {
+    if (this.pendingStylesUsed)
+      return;
+    this.pendingStylesUsed = true;
+    this.updateStyles();
+  }
+  coveredComponents() {
+    return [...this.covered].filter((id) => id !== "@pending");
+  }
+  removeStyles() {
+    if (this.styleElement) {
+      this.styleElement.remove();
+      this.styleElement = null;
+    }
+  }
+  addComponentStyle(componentId, style) {
+    this.updateStyles();
+  }
+  removeComponentStyle(componentId) {
+    this.updateStyles();
+  }
+  emit(element, additions) {
+    if (this.ssg || !this.adopts()) {
+      element.textContent = [element.textContent ?? "", ...additions].filter(Boolean).join(`
+
+`);
+      return;
+    }
+    if (!this.sheet) {
+      this.sheet = new (this.sheetConstructor());
+      document.adoptedStyleSheets = [...document.adoptedStyleSheets, this.sheet];
+    }
+    this.adopted.push(...additions);
+    this.sheet.replaceSync(this.adopted.join(`
+
+`));
+  }
+  sheetConstructor() {
+    const view = document?.defaultView;
+    return view?.CSSStyleSheet ?? globalThis.CSSStyleSheet;
+  }
+  adopts() {
+    return typeof document !== "undefined" && "adoptedStyleSheets" in document && typeof this.sheetConstructor() === "function";
+  }
+}
+function seed(target, list) {
+  if (!list)
+    return;
+  list.split(",").map((id) => id.trim()).filter(Boolean).forEach((id) => target.add(id));
+}
+// src/parser/route.ts
+function parseRoute(pattern) {
+  if (!pattern.startsWith("/")) {
+    throw new Error(`[lightspeed] Route pattern "${pattern}" must start with "/".`);
+  }
+  const segments = [];
+  const params = [];
+  let fixedDepth = true;
+  for (const raw of pattern.split("/").filter(Boolean)) {
+    if (raw === "*") {
+      fixedDepth = false;
+      segments.push({ value: "*", param: true });
+      params.push("*");
+      continue;
+    }
+    if (raw.startsWith(":")) {
+      const name = raw.slice(1);
+      if (!name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`[lightspeed] Route pattern "${pattern}" has an invalid parameter "${raw}".`);
+      }
+      if (params.includes(name)) {
+        throw new Error(`[lightspeed] Route pattern "${pattern}" declares ":${name}" twice.`);
+      }
+      segments.push({ value: name, param: true });
+      params.push(name);
+      continue;
+    }
+    segments.push({ value: raw, param: false });
+  }
+  if (!params.length) {
+    throw new Error(`[lightspeed] Route pattern "${pattern}" has no parameters. A page with ` + `a fixed URL does not need one - its filename already decides its path.`);
+  }
+  return { pattern, segments, params, fixedDepth };
+}
+function matchPath(route, pathname) {
+  const parts = pathname.split("/").filter(Boolean);
+  const params = {};
+  for (let i = 0;i < route.segments.length; i++) {
+    const segment = route.segments[i];
+    if (segment.value === "*" && segment.param) {
+      const rest = parts.slice(i);
+      if (!rest.length)
+        return null;
+      params["*"] = rest.map(decodeURIComponent).join("/");
+      return params;
+    }
+    const part = parts[i];
+    if (part === undefined)
+      return null;
+    if (segment.param) {
+      params[segment.value] = decodeURIComponent(part);
+    } else if (part !== segment.value) {
+      return null;
+    }
+  }
+  if (parts.length !== route.segments.length)
+    return null;
+  return params;
+}
+
+// src/runtime/core.ts
+var PAGE_SCOPE = {
+  id: "page",
+  state: {},
+  props: {},
+  addCleanup: () => {
+  },
+  addBinding: () => {
+  },
+  addBlock: () => {
+  }
+};
+var pendingPageExpressions = [];
+function registerPageExpressions(expressions = {}, writers = {}) {
+  pendingPageExpressions.push({ expressions, writers });
+}
+
+class LightspeedRuntime {
+  componentRegistry = new ComponentRegistry;
+  instances = new Map;
+  globalSignals = new SignalManager;
+  cells;
+  initialised = false;
+  instanceCounter = 0;
+  loaders = new Map;
+  loading = new Map;
+  pageMetadata = {};
+  roots = new Map;
+  rootCounter = 0;
+  ssg = false;
+  pendingIslands = [];
+  reactiveProxy;
+  updateScheduler;
+  bindingEvaluator;
+  eventBinder;
+  globalFunctions;
+  pendingMounts = [];
+  flushing = false;
+  mounter;
+  styleManager;
+  constructor(options = {}) {
+    this.cells = new CellManager(options.ssg ?? false);
+    this.updateScheduler = new UpdateScheduler((owners) => this.handleUpdate(owners));
+    this.reactiveProxy = new ReactiveProxy((owner) => {
+      if (owner && this.updating.has(owner))
+        return;
+      this.updateScheduler.queueUpdate(owner);
+    });
+    this.bindingEvaluator = new BindingEvaluator(this.cells, (instance) => {
+      this.shareObjectProps(instance);
+      this.updateScheduler.queueUpdate(instance);
+    });
+    this.eventBinder = new EventBinder;
+    this.globalFunctions = new GlobalFunctions(this.reactiveProxy, this.globalSignals);
+    this.styleManager = new StyleManager(this.componentRegistry, options.ssg ?? false);
+    this.mounter = new Mounter(this.componentRegistry, this.bindingEvaluator, this.eventBinder, (componentId, parent, props) => this.createInstance(componentId, parent, props), (instance) => this.unregisterSubtree(instance), (componentId) => this.resolveComponent(componentId), (componentId) => this.pageMetadata[componentId] ?? null, options.ssg ?? false, this.styleManager);
+    this.mounter.onConnected = () => this.flushMounted();
+    this.ssg = options.ssg ?? false;
+    this.readPageMetadata();
+    for (const table of pendingPageExpressions) {
+      this.bindingEvaluator.registerExpressions(table.expressions, table.writers);
+    }
+    this.readPageState();
+    this.readPageRoute();
+    this.globalFunctions.setup();
+  }
+  updating = new Set;
+  runUpdateCallbacks(instance) {
+    if (!instance.updateCallbacks.length)
+      return;
+    if (this.updating.has(instance))
+      return;
+    this.updating.add(instance);
+    try {
+      for (const callback of instance.updateCallbacks) {
+        try {
+          callback();
+        } catch (error) {
+          warn(`onUpdate failed in ${instance.id}: ${String(error)}`);
+        }
+      }
+    } finally {
+      this.updating.delete(instance);
+    }
+  }
+  handleUpdate(owners) {
+    for (const owner of owners) {
+      if (owner) {
+        this.runUpdateCallbacks(owner);
+        this.bindingEvaluator.updateInstance(owner);
+      } else {
+        this.roots.forEach((root) => this.bindingEvaluator.updateTree(root.instance));
+      }
+    }
+  }
+  registerComponent(component) {
+    this.bindingEvaluator.registerExpressions(component.expressions, component.writers);
+    this.componentRegistry.register(component);
+  }
+  readPageMetadata() {
+    const element = typeof document !== "undefined" ? document.getElementById("lightspeed-manifest") : null;
+    if (!element?.textContent)
+      return;
+    try {
+      this.pageMetadata = JSON.parse(element.textContent);
+    } catch {
+      warn("Malformed inlined component metadata");
+    }
+  }
+  readPageRoute() {
+    if (this.ssg || typeof document === "undefined")
+      return;
+    const element = document.getElementById("lightspeed-route");
+    if (!element?.textContent)
+      return;
+    try {
+      const { pattern } = JSON.parse(element.textContent);
+      const path = document.location.pathname;
+      const params = matchPath(parseRoute(pattern), path);
+      if (!params) {
+        warn(`Route "${pattern}" does not match ${path} - the ` + `server rewrote a URL onto this page that the page does not claim.`);
+        return;
+      }
+      this.cells.seed({
+        route: { path, pattern, params }
+      });
+    } catch (error) {
+      warn(`Malformed route declaration: ${error.message}`);
+    }
+  }
+  readPageState() {
+    const element = typeof document !== "undefined" ? document.getElementById("lightspeed-state") : null;
+    if (!element?.textContent)
+      return;
+    try {
+      this.cells.seed(JSON.parse(element.textContent));
+    } catch {
+      warn("Malformed build-time state payload");
+    }
+  }
+  useComponents(loaders, page) {
+    if (page) {
+      this.bindingEvaluator.registerExpressions(page.expressions, page.writers);
+    }
+    for (const [id, loader] of Object.entries(loaders)) {
+      this.loaders.set(id, loader);
+    }
+  }
+  async resolveComponent(componentId) {
+    const registered = this.componentRegistry.get(componentId);
+    if (registered)
+      return registered;
+    const inFlight = this.loading.get(componentId);
+    if (inFlight)
+      return inFlight;
+    const loader = this.loaders.get(componentId);
+    if (!loader) {
+      warn(`Component not found: ${componentId}`);
+      return null;
+    }
+    const request = loader().then((module) => {
+      const definition = module?.default ?? module;
+      if (!definition?.id) {
+        warn(`Component module for "${componentId}" has no definition`);
+        return null;
+      }
+      this.registerComponent(definition);
+      this.styleManager.updateStyles();
+      return definition;
+    }).catch((error) => {
+      fail(`Failed to load component "${componentId}":`, error);
+      return null;
+    }).finally(() => this.loading.delete(componentId));
+    this.loading.set(componentId, request);
+    return request;
+  }
+  updateComponent(id, component) {
+    this.componentRegistry.update(id, component);
+    if (this.initialised) {
+      this.remountAll();
+    }
+  }
+  shareObjectProps(instance) {
+    const props = instance.props;
+    if (!props)
+      return;
+    for (const key of Object.keys(props)) {
+      this.reactiveProxy.share(props[key], instance);
+    }
+  }
+  async createInstance(componentId, parent, props) {
+    const component = await this.resolveComponent(componentId);
+    if (!component)
+      return null;
+    const instanceId = `${componentId}#${++this.instanceCounter}`;
+    const instance = new ComponentInstance(instanceId, componentId, this.globalSignals, parent);
+    instance.props = props ?? {};
+    this.shareObjectProps(instance);
+    instance.scopeId = component.scopeId;
+    instance.handlerNames = component.handlers ?? [];
+    if (component.setup) {
+      try {
+        component.setup(this.createExecutionContext(instance));
+        debug(`mounted ${instance.id}`);
+      } catch (error) {
+        fail(`Error executing logic for ${instance.id}:`, error);
+      }
+    }
+    this.instances.set(instanceId, instance);
+    return instance;
+  }
+  createExecutionContext(instance) {
+    const runtimeHelpers = {
+      reactive: (target) => this.reactiveProxy.create(target, instance),
+      defineSignal: () => createScopedSignalAPI(this.globalSignals, (cleanup) => instance.addLogicCleanup(cleanup)),
+      shared: (key, init, options) => {
+        if (options?.fetchAt !== "build" || options?.refresh) {
+          instance.runtimeCells.add(key);
+        }
+        return this.scopedCell(key, init, options, instance);
+      },
+      defineRefs: () => instance.refs,
+      onMounted: (callback) => {
+        if (this.ssg) {
+          instance.wantsMount = true;
+          return;
+        }
+        instance.mountedCallbacks.push(callback);
+        if (!this.pendingMounts.includes(instance)) {
+          this.pendingMounts.push(instance);
+        }
+      },
+      onUnmounted: (callback) => {
+        if (this.ssg)
+          return;
+        instance.addLogicCleanup(callback);
+      },
+      onUpdate: (callback) => {
+        if (this.ssg)
+          return;
+        instance.updateCallbacks.push(callback);
+      },
+      defineProps: (propsDefinition) => {
+        const props = {
+          ...this.defaultProps(propsDefinition),
+          ...instance.props
+        };
+        instance.props = props;
+        return props;
+      }
+    };
+    return {
+      _componentInstance: instance,
+      __lightspeedRuntime: runtimeHelpers,
+      _components: this.componentRegistry,
+      _getComponent: (id) => this.componentRegistry.get(id),
+      console,
+      _addHandler: (name, fn) => {
+        instance.addHandler(name, fn);
+      }
+    };
+  }
+  hasBuildData() {
+    return this.cells.hasBuildData();
+  }
+  settleBuildData() {
+    return this.cells.settleBuildData();
+  }
+  buildPayload() {
+    return this.cells.buildPayload();
+  }
+  hydrationReport(options = {}) {
+    const rows = [];
+    const visit = (instance) => {
+      instance.children.forEach(visit);
+      for (const block of instance.blocks) {
+        for (const row of block.rows.values()) {
+          row.instances.forEach(visit);
+          for (const nested of row.blocks) {
+            for (const nestedRow of nested.rows.values()) {
+              nestedRow.instances.forEach(visit);
+            }
+          }
+        }
+      }
+      const reasons = [];
+      const bound = new Set;
+      const collect = (bindings) => {
+        for (const binding of bindings) {
+          for (const key of binding.cellKeys ?? [])
+            bound.add(key);
+        }
+      };
+      collect(instance.bindings);
+      for (const block of instance.blocks) {
+        for (const row of block.rows.values()) {
+          collect(row.bindings);
+          for (const nested of row.blocks) {
+            for (const nestedRow of nested.rows.values())
+              collect(nestedRow.bindings);
+          }
+        }
+      }
+      const live = [...bound].filter((key) => !this.cells.isBakedOnly(key) && (key !== "route" || options.routeIsLive));
+      if (live.length)
+        reasons.push(`binds ${live.join(", ")}`);
+      if (instance.listeners)
+        reasons.push(`${instance.listeners} event handler(s)`);
+      if (instance.models)
+        reasons.push(`${instance.models} two-way binding(s)`);
+      if (instance.wantsMount)
+        reasons.push("onMounted");
+      if (instance.updateCallbacks.length)
+        reasons.push("onUpdate");
+      const cells = [...instance.runtimeCells].filter((key) => !this.cells.isBakedOnly(key) && (key !== "route" || options.routeIsLive));
+      if (cells.length)
+        reasons.push(`reads ${cells.join(", ")}`);
+      const isLive = reasons.length > 0;
+      rows.push({
+        id: instance.id,
+        componentId: instance.componentId,
+        live: isLive,
+        reasons
+      });
+      return isLive;
+    };
+    this.roots.forEach((root) => visit(root.instance));
+    return rows;
+  }
+  seedState(values) {
+    this.cells.seed(values);
+  }
+  shared(key, init, options) {
+    const cell = this.cells.get(key, init, options);
+    return {
+      key: cell.key,
+      get value() {
+        return cell.value;
+      },
+      set value(next) {
+        cell.set(next);
+      },
+      get pending() {
+        return cell.pending;
+      },
+      set: (next) => cell.set(next),
+      subscribe: (listener) => cell.subscribe(listener)
+    };
+  }
+  scopedCell(key, init, options, instance) {
+    const cell = this.cells.get(key, init, options);
+    return {
+      key: cell.key,
+      get value() {
+        return cell.value;
+      },
+      set value(next) {
+        cell.set(next);
+      },
+      get pending() {
+        return cell.pending;
+      },
+      set: (next) => cell.set(next),
+      subscribe: (listener) => {
+        const unsubscribe = cell.subscribe(listener);
+        instance.addLogicCleanup(unsubscribe);
+        return unsubscribe;
+      }
+    };
+  }
+  defaultProps(propsDefinition) {
+    const props = {};
+    if (propsDefinition && typeof propsDefinition === "object") {
+      Object.entries(propsDefinition).forEach(([key, definition]) => {
+        if (definition && typeof definition === "object" && "default" in definition) {
+          props[key] = definition.default;
+        }
+      });
+    }
+    return props;
+  }
+  async mount(componentId, target, props = {}, slotHtml) {
+    const container = this.resolveTarget(target);
+    if (!container)
+      return null;
+    const instance = await this.mounter.mountRoot(componentId, container, props, this.parseSlotHtml(slotHtml));
+    if (!instance)
+      return null;
+    const handle = {
+      id: `root#${++this.rootCounter}`,
+      componentId,
+      container,
+      instance,
+      props,
+      slotHtml
+    };
+    this.roots.set(handle.id, handle);
+    this.styleManager.updateStyles();
+    this.bindingEvaluator.updateTree(instance);
+    if (import.meta.env?.DEV) {
+      debug(`mounted ${componentId} → ${handle.id}`);
+    }
+    return handle;
+  }
+  unmount(handle) {
+    const root = this.roots.get(handle.id);
+    if (!root)
+      return;
+    this.unregisterSubtree(root.instance);
+    this.mounter.unmount(root.instance);
+    this.roots.delete(root.id);
+  }
+  async remountAll() {
+    for (const root of [...this.roots.values()]) {
+      this.unregisterSubtree(root.instance);
+      this.mounter.unmount(root.instance);
+      const instance = root.container ? await this.mounter.mountRoot(root.componentId, root.container, root.props, this.parseSlotHtml(root.slotHtml)) : await this.mounter.mountRange(root.range, root.props, this.parseSlotHtml(root.slotHtml));
+      if (instance) {
+        root.instance = instance;
+        this.bindingEvaluator.updateTree(instance);
+      } else {
+        this.roots.delete(root.id);
+      }
+    }
+    this.styleManager.updateStyles();
+  }
+  async hydrate(scope = document) {
+    const mounted = new Set;
+    this.roots.forEach((root) => {
+      if (root.range)
+        mounted.add(root.range.start);
+      if (root.container)
+        mounted.add(root.container);
+    });
+    const handles = [];
+    for (const range of this.mounter.findIslands(scope)) {
+      if (mounted.has(range.start))
+        continue;
+      const { payload } = range;
+      if (payload.on && Object.keys(payload.on).length) {
+        warn(`Ignoring @${Object.keys(payload.on).join(", @")} on top-level <${payload.c}>: no parent scope to resolve a handler from`);
+      }
+      const trigger = parseTrigger(payload.hydrate ?? null);
+      const slotHtml = serializeNodes(range.slotNodes);
+      const { needs } = payload;
+      if (this.ssg) {
+        if (needs) {
+          this.mounter.renderSkeleton(range);
+          continue;
+        }
+        const handle2 = await this.mountIsland(range, slotHtml);
+        if (handle2)
+          handles.push(handle2);
+        continue;
+      }
+      if (needs || trigger !== "load") {
+        if (!payload.ssr)
+          this.mounter.renderSkeleton(range);
+        const first = range.start.nextSibling;
+        const target = first && first.nodeType === 1 ? first : range.start.parentNode;
+        let triggered = false;
+        let ready = !needs;
+        const attempt = () => {
+          if (!triggered || !ready)
+            return;
+          this.mountIsland(range, slotHtml);
+        };
+        this.pendingIslands.push(scheduleHydration(trigger, target, () => {
+          triggered = true;
+          attempt();
+        }));
+        if (needs) {
+          this.pendingIslands.push(this.cells.whenReady(needs, () => {
+            ready = true;
+            attempt();
+          }));
+        }
+        continue;
+      }
+      const handle = await this.mountIsland(range, slotHtml);
+      if (handle)
+        handles.push(handle);
+    }
+    this.initialised = true;
+    this.flushMounted();
+    return handles;
+  }
+  flushMounted() {
+    if (this.flushing)
+      return;
+    this.flushing = true;
+    try {
+      let progressed = true;
+      while (progressed) {
+        progressed = false;
+        for (const instance of [...this.pendingMounts]) {
+          if (!instance.rootNodes.some((node) => node.isConnected))
+            continue;
+          const at = this.pendingMounts.indexOf(instance);
+          if (at >= 0)
+            this.pendingMounts.splice(at, 1);
+          progressed = true;
+          const callbacks = instance.mountedCallbacks.splice(0);
+          for (const callback of callbacks) {
+            try {
+              callback();
+            } catch (error) {
+              fail(`Error in onMounted for ${instance.id}:`, error);
+            }
+          }
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async mountIsland(range, slotHtml) {
+    const props = { ...range.payload.props ?? {} };
+    const dynamic = Object.entries(range.payload.bind ?? {}).filter(([name]) => name !== "class" && name !== "style");
+    for (const [name, expr] of dynamic) {
+      props[name] = this.bindingEvaluator.evaluate(expr, PAGE_SCOPE);
+    }
+    const cellProps = Object.entries(range.payload.cells ?? {});
+    for (const [name, key] of cellProps) {
+      const cell = this.cells.get(key);
+      if (!cell.pending)
+        props[name] = cell.value;
+    }
+    const instance = await this.mounter.mountRange(range, props, this.parseSlotHtml(slotHtml));
+    if (!instance)
+      return null;
+    for (const [name, key] of cellProps) {
+      this.bindingEvaluator.bindCellProp(instance, name, key);
+    }
+    for (const [name, expr] of dynamic) {
+      const binding = this.bindingEvaluator.createPropBinding(instance, name, expr);
+      instance.addBinding(binding);
+      this.bindingEvaluator.applyBinding(binding, new BindingScope(PAGE_SCOPE, [], instance));
+    }
+    const handle = {
+      id: `root#${++this.rootCounter}`,
+      componentId: range.payload.c,
+      instance,
+      props,
+      range,
+      slotHtml
+    };
+    this.roots.set(handle.id, handle);
+    this.styleManager.updateStyles();
+    this.bindingEvaluator.updateTree(instance);
+    this.flushMounted();
+    return handle;
+  }
+  parseSlotHtml(html) {
+    if (!html)
+      return [];
+    const template = document.createElement("template");
+    template.innerHTML = html;
+    return Array.from(template.content.childNodes);
+  }
+  resolveTarget(target) {
+    if (typeof target !== "string")
+      return target;
+    const element = document.querySelector(target);
+    if (!element) {
+      warn(`Mount target not found: ${target}`);
+    }
+    return element;
+  }
+  unregisterSubtree(instance) {
+    this.instances.delete(instance.id);
+    instance.children.forEach((child) => this.unregisterSubtree(child));
+  }
+  async init(rootComponentId = "home", target = "#app") {
+    if (import.meta.env?.DEV) {
+      debug("runtime ready");
+    }
+    await this.mount(rootComponentId, target);
+    this.flushMounted();
+    this.initialised = true;
+  }
+  destroy() {
+    this.initialised = false;
+    this.pendingIslands.forEach((cancel) => cancel());
+    this.pendingIslands.length = 0;
+    for (const root of [...this.roots.values()]) {
+      this.unregisterSubtree(root.instance);
+      this.mounter.unmount(root.instance);
+    }
+    this.roots.clear();
+    this.instances.clear();
+    this.globalSignals.clear();
+    this.cells.clear();
+    this.updateScheduler.clear();
+    this.styleManager.removeStyles();
+    this.globalFunctions.cleanup();
+  }
+}
+function createLightspeedApp(options) {
+  return new LightspeedRuntime(options);
+}
+function serializeNodes(nodes) {
+  return nodes.map((node) => node.nodeType === 1 ? node.outerHTML : node.textContent ?? "").join("");
+}
+// src/runtime/helpers.ts
+function reactive(target) {
+  return target;
+}
+function defineSignal() {
+  return {};
+}
+function onMounted(callback) {
+}
+function defineProps(propsDefinition) {
+  return {};
+}
+function onUnmounted(callback) {
+}
+function shared(key, init, options) {
+  return {};
+}
+export {
+  shared,
+  registerPageExpressions,
+  reactive,
+  onUnmounted,
+  onMounted,
+  defineSignal,
+  defineProps,
+  createLightspeedApp,
+  LightspeedRuntime
+};