@solidjs/web 2.0.0-experimental.8 → 2.0.0-rc.0

package/frames/dist/client.cjs

@@ -0,0 +1,1916 @@
+'use strict';
+
+var solidJs = require('solid-js');
+var web = require('@solidjs/web');
+var client = require('@solidjs/web/server-functions/client');
+
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const CLAIM_SEAM = Symbol.for("dom-expressions.element-claims");
+const CLAIMED_ELEMENTS = "a[href], form[action]";
+function claimHandlers() {
+  const handlers = globalThis[CLAIM_SEAM];
+  return handlers !== undefined && handlers.length !== 0 ? handlers : undefined;
+}
+function claimNode(handlers, el) {
+  for (let i = 0; i < handlers.length; i++) handlers[i](el);
+}
+const claimedAttr = name => name === "href" || name === "action";
+function claimTree(handlers, root) {
+  const isElement = root.nodeType === ELEMENT_NODE;
+  if (!isElement && root.nodeType !== 11 ) return;
+  if (isElement && root.matches(CLAIMED_ELEMENTS)) claimNode(handlers, root);
+  const found = root.querySelectorAll(CLAIMED_ELEMENTS);
+  for (let i = 0; i < found.length; i++) claimNode(handlers, found[i]);
+}
+const placeholderId = name => `pl-${name}`;
+const SLOT_START = /^slot:(.+):start$/;
+const SLOT_END = /^slot:(.+):end$/;
+const slotEnd = id => `slot:${id}:end`;
+function chunkToRecords(chunk) {
+  switch (chunk.type) {
+    case "start":
+    case "data":
+      return {};
+    case "html":
+      return {
+        "": {
+          kind: "html",
+          value: chunk.html
+        }
+      };
+    case "fragment":
+      return {
+        [`seg:${chunk.key}`]: {
+          kind: "html",
+          value: chunk.html
+        }
+      };
+    case "reveal":
+      {
+        const records = {};
+        const gate = chunk.fallback ? "fallback" : "reveal";
+        for (const key of chunk.keys) records[`seg:${key}:${gate}`] = true;
+        return records;
+      }
+    case "assets":
+      return {
+        [`seg:${chunk.key}:assets`]: chunk
+      };
+    case "slot":
+      return {
+        [`slot:${chunk.key}`]: {
+          kind: "slot",
+          args: chunk.args
+        }
+      };
+    case "hole":
+      return {
+        [`hole:${chunk.key}`]: {
+          kind: "html",
+          value: chunk.html
+        }
+      };
+    case "attr":
+      return {
+        [`attr:${chunk.key}`]: {
+          kind: "attrs",
+          value: chunk.attrs,
+          removed: chunk.removed
+        }
+      };
+    case "complete":
+      return {
+        ":complete": true
+      };
+    case "error":
+      if (!chunk.key) return {
+        ":error": chunk.error
+      };
+      return {
+        [`${/^lha?:/.test(chunk.key) ? "hole" : "seg"}:${chunk.key}:error`]: chunk.error
+      };
+    default:
+      return {};
+  }
+}
+function createFrameHost(options = {}) {
+  const frames = new Map();
+  const stores = new Map();
+  const storeFor = id => {
+    let store = stores.get(id);
+    if (!store) stores.set(id, store = {
+      version: undefined,
+      records: {}
+    });
+    return store;
+  };
+  const write = (store, version, records) => {
+    if (store.version !== undefined && version < store.version) return false;
+    if (store.version === undefined || version > store.version) {
+      store.version = version;
+      clearStreamRecords(store.records);
+    }
+    Object.assign(store.records, records);
+    return true;
+  };
+  return {
+    register(id, frame) {
+      let set = frames.get(id);
+      if (!set) frames.set(id, set = new Set());
+      set.add(frame);
+      const store = stores.get(id);
+      if (store && store.version !== undefined) {
+        frame.apply({
+          version: store.version,
+          r: store.records
+        });
+        frame.rebase && frame.rebase();
+      }
+    },
+    unregister(id, frame) {
+      const set = frames.get(id);
+      if (set && frame) set.delete(frame);
+      if (!set || !frame || !set.size) {
+        frames.delete(id);
+        if (frame && frame.contentHTML) {
+          const store = storeFor(id);
+          if (!store.records[""]) {
+            const html = frame.contentHTML();
+            if (html != null) {
+              store.records[""] = {
+                kind: "html",
+                value: html
+              };
+              if (store.version === undefined) store.version = 0;
+            }
+          }
+        }
+      }
+      if (!frame) stores.delete(id);
+    },
+    apply(chunk) {
+      if (chunk.type === "data") {
+        options.applyData && options.applyData(chunk);
+        return;
+      }
+      const records = chunkToRecords(chunk);
+      if (!write(storeFor(chunk.id), chunk.version, records)) return;
+      const set = frames.get(chunk.id);
+      if (set) {
+        for (const frame of set) frame.apply({
+          version: chunk.version,
+          r: records
+        });
+      }
+    },
+    get(id) {
+      const set = frames.get(id);
+      return set && set.values().next().value;
+    },
+    serialize(value) {
+      if (!options.serialize) throw new Error("host has no serializer");
+      return options.serialize(value);
+    },
+    resolve(ref, frameId) {
+      return options.resolve ? options.resolve(ref, frameId) : undefined;
+    },
+    revive: options.revive,
+    isContainer: options.isContainer,
+    prepareData: options.prepareData
+  };
+}
+const FRAME_APPLIED_EVENT = "frame:applied";
+class FrameImpl {
+  #element;
+  #start;
+  #end;
+  #options;
+  #version;
+  #store = Object.create(null);
+  #appliedRootValue;
+  #hasContent = false;
+  #errorNotified = false;
+  #revealed = new Set();
+  #fallbackShown = new Set();
+  #appliedHoles = new Map();
+  #slots;
+  #mountedSlots = new Set();
+  #slotCleanups = new Map();
+  #slotArgs = new Map();
+  #slotUpdaters = new Map();
+  #slotRegions = new Map();
+  #slotResolvedRefs = new Map();
+  #slotNodes = new Map();
+  #processedAssets = new Set();
+  #recordRefresh = null;
+  #disposed = false;
+  #styleFlush = () => {
+    if (!this.#disposed) this.#flush();
+  };
+  #claimTree = (node, direct) => {
+    const handlers = claimHandlers();
+    if (!handlers) return;
+    this.#scoped(() => direct ? claimNode(handlers, node) : claimTree(handlers, node));
+  };
+  #scoped(fn) {
+    const scope = this.#options.ownerScope;
+    return scope ? scope(fn) : fn();
+  }
+  constructor(element, start, end, options = {}) {
+    this.#element = element;
+    this.#start = start;
+    this.#end = end;
+    this.#options = options;
+    this.#slots = options.slots;
+    if (options.adopt) {
+      this.#hasContent = true;
+      this.#claimContent();
+    }
+    if (options.host && options.id !== undefined) {
+      options.host.register(options.id, this);
+    }
+    if (options.adopt && this.#version === undefined) this.#syncSlots();
+  }
+  #parent() {
+    return this.#element ?? this.#start.parentNode;
+  }
+  #applied(version, reason) {
+    this.#options.onApply?.({
+      version,
+      reason
+    });
+    const parent = this.#parent();
+    const Ev = parent && (parent.ownerDocument || parent).defaultView?.CustomEvent;
+    if (Ev) {
+      parent.dispatchEvent(new Ev(FRAME_APPLIED_EVENT, {
+        bubbles: true,
+        detail: {
+          id: this.#options.id,
+          version,
+          reason
+        }
+      }));
+    }
+  }
+  #firstContent() {
+    return this.#start ? this.#start.nextSibling : this.#parent().firstChild;
+  }
+  get version() {
+    return this.#version;
+  }
+  get store() {
+    return this.#store;
+  }
+  isRevealed(segment) {
+    return this.#revealed.has(segment);
+  }
+  get error() {
+    return this.#store[":error"];
+  }
+  apply(write) {
+    if (this.#disposed) return;
+    const v = write.version;
+    if (this.#version === undefined) {
+      this.#version = v;
+    } else if (v < this.#version) {
+      return;
+    } else if (v > this.#version) {
+      this.#version = v;
+      this.#resetStreamState();
+    }
+    for (const key in write.r) {
+      const incoming = write.r[key];
+      if (incoming && incoming.kind === "slot" && key.charCodeAt(0) === 115  && key.startsWith("slot:")) {
+        const existing = this.#store[key];
+        if (existing && existing.kind === "slot" && argsEquivalent(existing.args, incoming.args)) {
+          continue;
+        }
+      }
+      this.#store[key] = incoming;
+    }
+    this.#flush();
+  }
+  #resetStreamState(root) {
+    this.#revealed.clear();
+    this.#fallbackShown.clear();
+    this.#appliedHoles.clear();
+    this.#errorNotified = false;
+    clearStreamRecords(this.#store, root);
+  }
+  #flush() {
+    if (this.#disposed) return;
+    const version = this.#version;
+    const root = this.#store[""];
+    if (root && root.kind === "html" && root.value !== this.#appliedRootValue) {
+      const reason = this.#hasContent ? "morph" : "materialize";
+      this.#applyRoot(root.value);
+      this.#appliedRootValue = root.value;
+      this.#applied(version, reason);
+    }
+    if (this.#store[":error"] && !this.#errorNotified) {
+      this.#errorNotified = true;
+      this.#applied(version, "error");
+    }
+    let progressed = true;
+    while (progressed) {
+      progressed = false;
+      for (const key in this.#store) {
+        const name = segmentName(key);
+        if (name === null || this.#revealed.has(name)) continue;
+        if (this.#segmentReady(name)) {
+          this.#revealSegment(name);
+          this.#applied(version, "reveal");
+          progressed = true;
+        }
+      }
+      for (const key in this.#store) {
+        const m = /^seg:([^:]+):fallback$/.exec(key);
+        if (!m) continue;
+        const name = m[1];
+        if (this.#revealed.has(name) || this.#fallbackShown.has(name)) continue;
+        if (this.#showFallback(name)) {
+          this.#fallbackShown.add(name);
+          this.#applied(version, "reveal");
+          progressed = true;
+        }
+      }
+    }
+    for (const key in this.#store) {
+      const record = this.#store[key];
+      if (!record || this.#appliedHoles.get(key) === record) continue;
+      if (key.startsWith("hole:")) {
+        if (key.endsWith(":error")) {
+          this.#appliedHoles.set(key, record);
+        } else if (this.#applyHole(key.slice(5), record.value)) {
+          this.#appliedHoles.set(key, record);
+          this.#applied(version, "morph");
+        }
+      } else if (key.startsWith("attr:")) {
+        if (this.#applyAttrs(key.slice(5), record.value, record.removed)) {
+          this.#appliedHoles.set(key, record);
+          this.#applied(version, "morph");
+        }
+      }
+    }
+    for (const key in this.#store) {
+      if (this.#processedAssets.has(key) || !key.endsWith(":assets")) continue;
+      this.#processedAssets.add(key);
+      const record = this.#store[key];
+      if (record && record.modules) {
+        for (const href of record.modules) ensureModulePreload(href);
+      }
+    }
+    this.#syncSlots();
+  }
+  #resolveSlot(prop) {
+    return this.#slots?.[prop] ?? this.#options.resolveSlot?.(prop);
+  }
+  #resolveSlotRecord(occurrence) {
+    const record = this.#store[`slot:${occurrence}`];
+    if (record !== undefined) return record;
+    return this.#options.resolveSlotRecord?.(occurrence);
+  }
+  #removeSlotRecord(occurrence) {
+    const key = `slot:${occurrence}`;
+    if (key in this.#store) {
+      if (!this.#mountedSlots.has(occurrence)) delete this.#store[key];
+    } else this.#options.removeSlotRecord?.(occurrence);
+  }
+  #syncSlots(root) {
+    if (!this.#slots && !this.#options.resolveSlot) return;
+    const found = new Map();
+    if (root) collectSlots(root.firstChild, null, found);else this.#collectSlots(found);
+    for (const [occurrence, start] of found) {
+      const callback = this.#resolveSlot(propOf(occurrence));
+      if (!callback) continue;
+      const record = this.#resolveSlotRecord(occurrence);
+      if (record && record.kind === "slot" && this.#refsUnresolved(record.args)) continue;
+      const prev = this.#slotNodes.get(occurrence);
+      const prevFirst = Array.isArray(prev) ? prev[0] : prev;
+      const zombie = this.#mountedSlots.has(occurrence) && prevFirst && !prevFirst.parentNode;
+      if (zombie) {
+        this.#mountedSlots.delete(occurrence);
+        this.#runSlotCleanups(occurrence);
+      }
+      if (!this.#mountedSlots.has(occurrence)) {
+        if (record === undefined && !root && this.#options.adopt && this.#options.recordsPending?.()) {
+          this.#recordRefresh ??= setTimeout(() => {
+            this.#recordRefresh = null;
+            if (this.#disposed) return;
+            this.#options.drainRecords?.();
+            this.#syncSlots();
+          });
+          continue;
+        }
+        if (this.#options.adopt) this.#discoverRegions(occurrence, start);
+        const nodes = this.#invokeSlot(occurrence, callback, record, start, this.#options.adopt);
+        if (nodes) this.#replaceRange(occurrence, start, nodes);
+        this.#slotNodes.set(occurrence, nodes);
+        this.#mountedSlots.add(occurrence);
+        if (!this.#options.adopt || nodes) this.#discoverRegions(occurrence, start);
+        this.#bindRegions(occurrence);
+      } else if (record !== this.#slotArgs.get(occurrence)) {
+        if (this.#refArgsUnchanged(occurrence, record)) {
+          this.#slotArgs.set(occurrence, record);
+          this.#reconcileRegions(occurrence, record);
+          continue;
+        }
+        const update = this.#slotUpdaters.get(occurrence);
+        if (update) {
+          const props = this.#resolveArgs(occurrence, record.args);
+          this.#slotArgs.set(occurrence, record);
+          update(props);
+          this.#bindRegions(occurrence);
+          continue;
+        }
+        const nodes = this.#invokeSlot(occurrence, callback, record, start);
+        if (nodes) this.#replaceRange(occurrence, start, nodes);
+        this.#slotNodes.set(occurrence, nodes);
+        this.#bindRegions(occurrence);
+      }
+    }
+    if (!root) {
+      for (const occurrence of [...this.#mountedSlots]) {
+        if (!found.has(occurrence)) this.#unmountSlot(occurrence);
+      }
+    }
+  }
+  #invokeSlot(occurrence, callback, record, start, adopted) {
+    this.#slotUpdaters.delete(occurrence);
+    const cleanups = this.#slotCleanups.get(occurrence) ?? [];
+    let existing = [];
+    let end = null;
+    if (start) end = eachInRange(start, occurrence, n => existing.push(n));
+    const ctx = {
+      frame: this.#options.claimScope ?? this.#options.id,
+      key: occurrence,
+      adopted: !!adopted,
+      invoked: !!(record && record.kind === "slot"),
+      onCleanup: fn => cleanups.push(fn),
+      onUpdate: fn => this.#slotUpdaters.set(occurrence, fn),
+      existing,
+      range: end ? {
+        start,
+        end
+      } : undefined
+    };
+    const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record.args) : {};
+    const content = this.#scoped(() => callback(props, ctx));
+    this.#slotArgs.set(occurrence, record);
+    if (cleanups.length) this.#slotCleanups.set(occurrence, cleanups);
+    if (content == null) return null;
+    return Array.isArray(content) ? content : [content];
+  }
+  #replaceRange(key, start, nodes) {
+    const parent = start.parentNode;
+    const end = eachInRange(start, key, n => parent.removeChild(n));
+    for (const node of nodes) parent.insertBefore(node, end);
+  }
+  #unmountSlot(key) {
+    this.#mountedSlots.delete(key);
+    this.#slotNodes.delete(key);
+    this.#slotArgs.delete(key);
+    this.#slotUpdaters.delete(key);
+    this.#slotResolvedRefs.delete(key);
+    this.#removeSlotRecord(key);
+    this.#runSlotCleanups(key);
+    const regions = this.#slotRegions.get(key);
+    if (regions) {
+      disposeRegions(regions);
+      this.#slotRegions.delete(key);
+    }
+  }
+  #runSlotCleanups(key) {
+    const cleanups = this.#slotCleanups.get(key);
+    if (!cleanups) return;
+    this.#slotCleanups.delete(key);
+    for (const fn of cleanups) fn();
+  }
+  #refsUnresolved(args) {
+    const {
+      host,
+      id
+    } = this.#options;
+    if (host) for (const key in args) {
+      if (isDataRef(args[key]) && host.resolve(args[key], id) === undefined) return true;
+    }
+    return false;
+  }
+  #regionsFor(slotKey) {
+    let regions = this.#slotRegions.get(slotKey);
+    if (!regions) this.#slotRegions.set(slotKey, regions = new Map());
+    return regions;
+  }
+  #resolveArgs(slotKey, args) {
+    const host = this.#options.host;
+    const regions = this.#regionsFor(slotKey);
+    const props = {};
+    for (const key in args) {
+      const value = args[key];
+      if (isDataRef(value)) {
+        const resolved = host ? host.resolve(value, this.#options.id) : undefined;
+        let cache = this.#slotResolvedRefs.get(slotKey);
+        if (!cache) this.#slotResolvedRefs.set(slotKey, cache = {});
+        cache[key] = resolved;
+        props[key] = resolved;
+      } else if (isFrameRef(value)) {
+        let entry = regions.get(key);
+        if (!entry) {
+          const element = makeFrameElement(value.$frame);
+          entry = {
+            childId: value.$frame,
+            element,
+            frame: undefined
+          };
+          regions.set(key, entry);
+        } else if (entry.childId !== value.$frame) {
+          renameRegion(entry, value.$frame);
+        }
+        props[key] = entry.element;
+      } else {
+        props[key] = host && host.revive ? host.revive(value) : value;
+      }
+    }
+    return props;
+  }
+  #discoverRegions(slotKey, start) {
+    if (!start) return;
+    const regions = this.#regionsFor(slotKey);
+    eachInRange(start, slotKey, n => collectRegionElements(n, regions));
+  }
+  #refArgsUnchanged(occurrence, record) {
+    const old = this.#slotArgs.get(occurrence);
+    if (!record || record.kind !== "slot") return false;
+    if (old && old.kind !== "slot") return false;
+    const a = old && old.args || {};
+    const b = record.args || {};
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (kb.length !== ka.length) return false;
+    const cache = this.#slotResolvedRefs.get(occurrence);
+    for (const key of ka) {
+      const va = a[key];
+      const vb = b[key];
+      if (va === vb) continue;
+      if (isFrameRef(va) && isFrameRef(vb)) continue;
+      if (isDataRef(va) && isDataRef(vb) && cache && key in cache) {
+        const host = this.#options.host;
+        const next = host ? host.resolve(vb, this.#options.id) : undefined;
+        if (host && host.isContainer && (host.isContainer(next) || host.isContainer(cache[key]))) {
+          if (next === cache[key]) continue;
+          return false;
+        }
+        if (isAsyncLike(next) || isAsyncLike(cache[key])) return false;
+        try {
+          if (JSON.stringify(next) === JSON.stringify(cache[key])) continue;
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  #reconcileRegions(occurrence, record) {
+    const args = record && record.args;
+    if (!args) return;
+    const regions = this.#slotRegions.get(occurrence);
+    if (!regions) return;
+    for (const key in args) {
+      const value = args[key];
+      if (!isFrameRef(value)) continue;
+      const entry = regions.get(key);
+      if (entry && entry.childId !== value.$frame) renameRegion(entry, value.$frame);
+    }
+  }
+  #bindRegions(slotKey) {
+    const regions = this.#slotRegions.get(slotKey);
+    if (!regions) return;
+    for (const entry of regions.values()) {
+      if (!entry.frame) {
+        entry.frame = new FrameImpl(entry.element, null, null, {
+          id: entry.childId,
+          host: this.#options.host,
+          adopt: entry.adopt,
+          claimScope: this.#options.claimScope ?? this.#options.id,
+          ownerScope: this.#options.ownerScope,
+          resolveSlot: prop => this.#resolveSlot(prop),
+          resolveSlotRecord: occurrence => this.#resolveSlotRecord(occurrence),
+          removeSlotRecord: occurrence => this.#removeSlotRecord(occurrence)
+        });
+      }
+    }
+  }
+  #collectSlots(found) {
+    collectSlots(this.#firstContent(), this.#end, found);
+  }
+  #findPlaceholder(name) {
+    return findPlaceholder(this.#firstContent(), this.#end, placeholderId(name));
+  }
+  contentHTML() {
+    if (this.#disposed || !this.#element || !this.#hasContent) return null;
+    return this.#element.innerHTML;
+  }
+  rebind(id) {
+    if (this.#disposed || id === this.#options.id) return;
+    const {
+      host,
+      id: oldId
+    } = this.#options;
+    if (host && oldId !== undefined) host.unregister(oldId, this);
+    this.#options = {
+      ...this.#options,
+      id
+    };
+    if (this.#element && this.#element.nodeType === ELEMENT_NODE) {
+      this.#element.setAttribute(FRAME_ID_ATTR, id);
+    }
+    this.#version = undefined;
+    this.#appliedRootValue = undefined;
+    this.#resetStreamState(true);
+    if (host) host.register(id, this);
+  }
+  rebase() {
+    this.#version = undefined;
+  }
+  dispose() {
+    if (this.#disposed) return;
+    const {
+      host,
+      id
+    } = this.#options;
+    if (host && id !== undefined) host.unregister(id, this);
+    this.#disposed = true;
+    if (this.#recordRefresh) {
+      clearTimeout(this.#recordRefresh);
+      this.#recordRefresh = null;
+    }
+    for (const key of [...this.#slotCleanups.keys()]) this.#runSlotCleanups(key);
+    for (const key of this.#mountedSlots) this.#removeSlotRecord(key);
+    for (const regions of this.#slotRegions.values()) disposeRegions(regions);
+    this.#slotRegions.clear();
+    this.#mountedSlots.clear();
+  }
+  #applyRoot(html) {
+    const fragment = parseFragment(html);
+    const parent = this.#parent();
+    if (!this.#hasContent) {
+      this.#clearContent();
+      this.#claimTree(fragment);
+      parent.insertBefore(fragment, this.#end);
+      this.#hasContent = true;
+    } else {
+      const claim = claimHandlers() ? this.#claimTree : null;
+      const ranges = new Map();
+      this.#collectSlots(ranges);
+      const grafts = [];
+      reconcileChildren(parent, fragment, this.#start, this.#end, claim, ranges, grafts);
+      if (ranges.size) for (const root of grafts) flushGrafts(root, ranges);
+    }
+  }
+  #applyHole(marker, html) {
+    if (!this.#hasContent) return false;
+    const open = findLiveTarget(this.#firstContent(), this.#end, n => n.nodeType === COMMENT_NODE && n.data === marker);
+    if (!open) return false;
+    const close = rangeClose(open, "lh:/" + marker.slice(3));
+    if (!close) {
+      return false;
+    }
+    const claim = claimHandlers() ? this.#claimTree : null;
+    reconcileChildren(open.parentNode, parseFragment(html), open, close, claim);
+    return true;
+  }
+  #applyAttrs(addr, text, removed) {
+    if (!this.#hasContent) return false;
+    const el = findLiveTarget(this.#firstContent(), this.#end, n => n.nodeType === ELEMENT_NODE && n.getAttribute("data-lha") === addr);
+    if (!el) return false;
+    const parsed = parseFragment(`<i${text}></i>`).firstChild;
+    if (parsed) {
+      for (let i = 0; i < parsed.attributes.length; i++) {
+        const {
+          name,
+          value
+        } = parsed.attributes[i];
+        if (el.getAttribute(name) !== value) el.setAttribute(name, value);
+      }
+    }
+    if (removed) for (const name of removed) el.removeAttribute(name);
+    return true;
+  }
+  #clearContent() {
+    removeUntil(this.#parent(), this.#firstContent(), this.#end);
+  }
+  #claimContent() {
+    if (!claimHandlers()) return;
+    let n = this.#firstContent();
+    while (n && n !== this.#end) {
+      this.#claimTree(n);
+      n = n.nextSibling;
+    }
+  }
+  #segmentReady(name) {
+    const content = this.#store[`seg:${name}`];
+    if (!content || content.kind !== "html") return false;
+    if (!this.#store[`seg:${name}:reveal`]) return false;
+    const assets = this.#store[`seg:${name}:assets`];
+    if (assets && assets.styles) {
+      let ready = true;
+      for (const entry of assets.styles) ready = ensureStylesheet(entry, this.#styleFlush) && ready;
+      if (!ready) return false;
+    }
+    if (!this.#findPlaceholder(name)) return false;
+    return true;
+  }
+  #revealSegment(name) {
+    const tpl = this.#findPlaceholder(name);
+    if (!tpl) return;
+    const assets = this.#store[`seg:${name}:assets`];
+    if (assets && assets.inlineStyles) applyInlineStyles(assets.inlineStyles);
+    const content = this.#store[`seg:${name}`];
+    const closing = rangeClose(tpl, placeholderId(name));
+    const parent = tpl.parentNode;
+    removeUntil(parent, tpl.nextSibling, closing);
+    if (this.#options.reveal) {
+      const fallbackFrag = tpl.content.cloneNode(true);
+      this.#claimTree(fallbackFrag);
+      this.#options.reveal({
+        before: closing,
+        fallback: [...fallbackFrag.childNodes],
+        content: () => {
+          const materialized = this.#materialize(content);
+          this.#syncSlots(materialized);
+          this.#claimTree(materialized);
+          return materialized;
+        }
+      });
+      tpl.remove();
+      this.#revealed.add(name);
+      return;
+    }
+    const materialized = this.#materialize(content);
+    this.#claimTree(materialized);
+    parent.insertBefore(materialized, closing);
+    tpl.remove();
+    closing && closing.remove();
+    this.#revealed.add(name);
+  }
+  #showFallback(name) {
+    const tpl = this.#findPlaceholder(name);
+    if (!tpl) return false;
+    const closing = rangeClose(tpl, placeholderId(name));
+    if (!closing) return false;
+    const fallback = tpl.content.cloneNode(true);
+    this.#claimTree(fallback);
+    closing.parentNode.insertBefore(fallback, closing);
+    return true;
+  }
+  #materialize(record) {
+    return record.kind === "html" ? parseFragment(record.value) : parseFragment("");
+  }
+}
+function createFrame(boundary, options) {
+  return new FrameImpl(boundary, null, null, options);
+}
+const FRAME_TAG = "dx-frame";
+const FRAME_ID_ATTR = "data-fid";
+function createFrameElement(options) {
+  const el = makeFrameElement(options.id);
+  const frame = new FrameImpl(el, null, null, options);
+  return {
+    element: el,
+    frame,
+    dispose() {
+      frame.dispose();
+      el.remove();
+    }
+  };
+}
+function makeFrameElement(id) {
+  const el = document.createElement(FRAME_TAG);
+  el.style.display = "contents";
+  if (id !== undefined) el.setAttribute(FRAME_ID_ATTR, id);
+  return el;
+}
+function isFrameElement(node) {
+  return node.nodeType === ELEMENT_NODE && node.hasAttribute(FRAME_ID_ATTR);
+}
+function segmentName(key) {
+  const m = /^seg:([^:]+)$/.exec(key);
+  return m ? m[1] : null;
+}
+function isAsyncLike(v) {
+  return !!v && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
+}
+function propOf(occurrence) {
+  const hash = occurrence.indexOf("#");
+  return hash === -1 ? occurrence : occurrence.slice(0, hash);
+}
+function isDataRef(value) {
+  return !!value && typeof value.$ref === "string";
+}
+function isFrameRef(value) {
+  return !!value && typeof value.$frame === "string";
+}
+function disposeRegions(regions) {
+  for (const {
+    frame
+  } of regions.values()) frame?.dispose();
+}
+function removeUntil(parent, n, stop) {
+  while (n && n !== stop) {
+    const next = n.nextSibling;
+    parent.removeChild(n);
+    n = next;
+  }
+}
+function parseFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+function findHeadElement(selector, attr, value) {
+  for (const node of document.head.querySelectorAll(selector)) {
+    if (node.getAttribute(attr) === value) return node;
+  }
+  return null;
+}
+function ensureStylesheet(entry, onSettle) {
+  const href = typeof entry === "string" ? entry : entry.href;
+  let link = findHeadElement('link[rel="stylesheet"]', "href", href);
+  if (!link) {
+    link = document.createElement("link");
+    link.rel = "stylesheet";
+    if (typeof entry !== "string" && entry.attrs) {
+      for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
+    }
+    link.href = href;
+    const waiters = new Set();
+    link._$frWaiters = waiters;
+    const settle = () => {
+      link._$frWaiters = null;
+      for (const fn of waiters) fn();
+    };
+    link.addEventListener("load", settle);
+    link.addEventListener("error", settle);
+    document.head.appendChild(link);
+  }
+  const waiters = link._$frWaiters;
+  if (waiters == null) return true;
+  waiters.add(onSettle);
+  return false;
+}
+function ensureModulePreload(href) {
+  if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
+  const link = document.createElement("link");
+  link.rel = "modulepreload";
+  link.href = href;
+  document.head.appendChild(link);
+}
+function applyInlineStyles(inlineStyles) {
+  for (const entry of inlineStyles) {
+    if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
+    const el = document.createElement("style");
+    el.setAttribute("data-asset", entry.id);
+    if (entry.attrs) {
+      for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
+    }
+    el.textContent = entry.content || "";
+    document.head.appendChild(el);
+  }
+}
+function isPlaceholderStart(node, id) {
+  return node.tagName === "TEMPLATE" && node.id === id;
+}
+function rangeClose(start, id) {
+  let n = start.nextSibling;
+  while (n) {
+    if (n.nodeType === COMMENT_NODE && n.data === id) return n;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function findLiveTarget(n, end, test) {
+  while (n && n !== end) {
+    if (n.nodeType === ELEMENT_NODE) {
+      const fid = isFrameElement(n) ? n.getAttribute(FRAME_ID_ATTR) : null;
+      if (fid === null || fid.includes(".")) {
+        if (test(n)) return n;
+        const found = findLiveTarget(n.firstChild, null, test);
+        if (found) return found;
+      }
+    } else if (test(n)) return n;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function findPlaceholder(n, end, id) {
+  while (n && n !== end) {
+    if (isPlaceholderStart(n, id)) return n;
+    if (n.nodeType === ELEMENT_NODE) {
+      const found = findPlaceholder(n.firstChild, null, id);
+      if (found) return found;
+    }
+    n = n.nextSibling;
+  }
+  return null;
+}
+function collectSlots(n, end, out) {
+  while (n && n !== end) {
+    const id = slotStartId(n);
+    if (id !== null) {
+      if (!out.has(id)) out.set(id, n);
+      n = afterRange(n, id);
+      continue;
+    }
+    if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) collectSlots(n.firstChild, null, out);
+    n = n.nextSibling;
+  }
+}
+function collectRegionElements(node, regions) {
+  if (node.nodeType !== ELEMENT_NODE) return;
+  if (isFrameElement(node)) {
+    const childId = node.getAttribute(FRAME_ID_ATTR);
+    if (childId && childId.includes(".")) {
+      const argKey = childId.slice(childId.lastIndexOf(".") + 1);
+      if (!regions.has(argKey)) {
+        regions.set(argKey, {
+          childId,
+          element: node,
+          frame: undefined,
+          adopt: true
+        });
+      }
+    }
+    return;
+  }
+  for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions);
+}
+function renameRegion(entry, childId) {
+  entry.childId = childId;
+  if (entry.frame) entry.frame.rebind(childId);else entry.element.setAttribute(FRAME_ID_ATTR, childId);
+}
+function eachInRange(start, key, cb) {
+  const end = slotEnd(key);
+  let n = start.nextSibling;
+  while (n && !(n.nodeType === COMMENT_NODE && n.data === end)) {
+    const next = n.nextSibling;
+    cb(n);
+    n = next;
+  }
+  return n;
+}
+function clearStreamRecords(records, root) {
+  for (const key in records) {
+    if (/^(seg|hole|attr):/.test(key) || key === ":error" || root && key === "") {
+      delete records[key];
+    }
+  }
+}
+function argsEquivalent(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (const key of ka) {
+    const va = a[key];
+    const vb = b[key];
+    if (va === vb) continue;
+    if (isFrameRef(va) && va.$frame === vb?.$frame) continue;
+    return false;
+  }
+  return true;
+}
+function slotStartId(node) {
+  if (node.nodeType !== COMMENT_NODE) return null;
+  const m = SLOT_START.exec(node.data);
+  return m ? m[1] : null;
+}
+function isSlotMarker(node) {
+  if (node.nodeType !== COMMENT_NODE) return false;
+  const data = node.data;
+  return SLOT_START.test(data) || SLOT_END.test(data);
+}
+function compatible(a, b) {
+  if (a.nodeType !== b.nodeType) return false;
+  if (a.nodeType === ELEMENT_NODE) return a.nodeName === b.nodeName;
+  return a.nodeType === TEXT_NODE || a.nodeType === COMMENT_NODE;
+}
+function preservesOpen(el) {
+  const t = el.tagName;
+  return t === "DETAILS" || t === "DIALOG";
+}
+function morphAttributes(oldEl, newEl, claim) {
+  let reclaim = false;
+  let changed = false;
+  const keepOpen = preservesOpen(oldEl);
+  const oldAttrs = oldEl.attributes;
+  for (let i = oldAttrs.length - 1; i >= 0; i--) {
+    const name = oldAttrs[i].name;
+    if (keepOpen && name === "open") continue;
+    if (!newEl.hasAttribute(name)) {
+      oldEl.removeAttribute(name);
+      changed = true;
+      reclaim ||= claimedAttr(name);
+    }
+  }
+  const newAttrs = newEl.attributes;
+  for (let i = 0; i < newAttrs.length; i++) {
+    const attr = newAttrs[i];
+    if (keepOpen && attr.name === "open") continue;
+    if (oldEl.getAttribute(attr.name) !== attr.value) {
+      oldEl.setAttribute(attr.name, attr.value);
+      changed = true;
+      reclaim ||= claimedAttr(attr.name);
+    }
+  }
+  if (claim && (reclaim || changed && oldEl.matches(CLAIMED_ELEMENTS))) claim(oldEl, true);
+}
+function morphNode(oldNode, newNode, claim, ranges, grafts) {
+  if (oldNode.nodeType === ELEMENT_NODE) {
+    if (oldNode.hasAttribute("data-preserve")) return;
+    morphAttributes(oldNode, newNode, claim);
+    reconcileChildren(oldNode, newNode, null, null, claim, ranges, grafts);
+  } else if (oldNode.data !== newNode.data) {
+    oldNode.data = newNode.data;
+  }
+}
+function afterRange(start, id) {
+  const end = slotEnd(id);
+  let n = start.nextSibling;
+  while (n) {
+    if (n.nodeType === COMMENT_NODE && n.data === end) return n.nextSibling;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function findRangeStart(from, id, bound) {
+  const target = `slot:${id}:start`;
+  let n = from;
+  while (n && n !== bound) {
+    if (n.nodeType === COMMENT_NODE && n.data === target) return n;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function moveRangeBefore(parent, start, id, ref) {
+  const end = slotEnd(id);
+  let n = start;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    parent.insertBefore(n, ref);
+    if (isEnd) break;
+    n = next;
+  }
+}
+function placeRange(parent, range, id, ref) {
+  if (range.nodeType === 11 ) {
+    parent.insertBefore(range, ref);
+  } else {
+    moveRangeBefore(parent, range, id, ref);
+  }
+}
+function adoptRange(parent, start, id, ref, claim) {
+  const end = slotEnd(id);
+  let n = start;
+  let after = null;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    parent.insertBefore(n, ref);
+    if (claim) claim(n);
+    if (isEnd) {
+      after = next;
+      break;
+    }
+    n = next;
+  }
+  return after;
+}
+function reconcileChildren(parent, source, boundStart = null, boundEnd = null, claim = null, ranges = null, grafts = null) {
+  let oldChild = boundStart ? boundStart.nextSibling : parent.firstChild;
+  let newChild = source.firstChild;
+  while (newChild) {
+    const nextNew = newChild.nextSibling;
+    const pid = slotStartId(newChild);
+    const old = oldChild === boundEnd ? null : oldChild;
+    if (pid !== null) {
+      if (old && slotStartId(old) === pid) {
+        oldChild = afterRange(old, pid);
+        newChild = afterRange(newChild, pid);
+      } else {
+        const displaced = ranges && ranges.get(pid);
+        const existing = displaced || findRangeStart(old, pid, boundEnd);
+        if (existing) {
+          if (ranges) ranges.delete(pid);
+          placeRange(parent, existing, pid, old ?? boundEnd);
+          newChild = afterRange(newChild, pid);
+        } else {
+          newChild = adoptRange(parent, newChild, pid, old ?? boundEnd, claim);
+        }
+      }
+      continue;
+    }
+    if (!old) {
+      parent.insertBefore(newChild, boundEnd);
+      if (claim) claim(newChild);
+      if (grafts) grafts.push(newChild);
+      newChild = nextNew;
+      continue;
+    }
+    if (isSlotMarker(old)) {
+      parent.insertBefore(newChild, old);
+      if (claim) claim(newChild);
+      if (grafts) grafts.push(newChild);
+      newChild = nextNew;
+      continue;
+    }
+    if (compatible(old, newChild)) {
+      morphNode(old, newChild, claim, ranges, grafts);
+      oldChild = old.nextSibling;
+      newChild = nextNew;
+      continue;
+    }
+    if (newChild.nodeType === 1) {
+      let ahead = old.nextSibling;
+      while (ahead && ahead !== boundEnd && !compatible(ahead, newChild)) {
+        const aheadPid = slotStartId(ahead);
+        ahead = aheadPid !== null ? afterRange(ahead, aheadPid) : ahead.nextSibling;
+      }
+      if (ahead && ahead !== boundEnd) {
+        parent.insertBefore(ahead, old);
+        morphNode(ahead, newChild, claim, ranges, grafts);
+        newChild = nextNew;
+        continue;
+      }
+    }
+    parent.insertBefore(newChild, old);
+    if (claim) claim(newChild);
+    if (grafts) grafts.push(newChild);
+    newChild = nextNew;
+  }
+  while (oldChild && oldChild !== boundEnd) {
+    const next = oldChild.nextSibling;
+    const pid = ranges ? slotStartId(oldChild) : null;
+    if (pid !== null && ranges.get(pid) === oldChild) {
+      const frag = document.createDocumentFragment();
+      const after = stashRange(frag, oldChild, pid);
+      ranges.set(pid, frag);
+      oldChild = after;
+      continue;
+    }
+    parent.removeChild(oldChild);
+    oldChild = next;
+  }
+}
+function flushGrafts(node, ranges) {
+  if (node.nodeType !== ELEMENT_NODE || isFrameElement(node)) return;
+  let n = node.firstChild;
+  while (n) {
+    const id = slotStartId(n);
+    if (id !== null) {
+      const next = afterRange(n, id);
+      const displaced = ranges.get(id);
+      if (displaced) {
+        ranges.delete(id);
+        placeRange(node, displaced, id, n);
+        stashRange(document.createDocumentFragment(), n, id);
+      }
+      n = next;
+      continue;
+    }
+    flushGrafts(n, ranges);
+    n = n.nextSibling;
+  }
+}
+function stashRange(frag, start, id) {
+  const end = slotEnd(id);
+  let n = start;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    frag.appendChild(n);
+    if (isEnd) return next;
+    n = next;
+  }
+  return null;
+}
+
+const FRAME_STREAM_HEADER = "X-Frame-Stream";
+function isFrameStreamResponse(response) {
+  return response.headers.has(FRAME_STREAM_HEADER);
+}
+async function applyFrameResponse(response, host, options = {}) {
+  const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
+  const as = options.as;
+  const version = options.version;
+  const perFrame = typeof version === "function" ? new Map() : null;
+  const reader = new client.ChunkReader(response.body);
+  let result = await reader.next();
+  while (!result.done) {
+    const chunk = JSON.parse(result.value);
+    if (chunk.type === "outcome") {
+      if (options.onOutcome) options.onOutcome(chunk.payload);
+    } else {
+      if (as !== undefined && chunk.id === rootId) chunk.id = as;
+      if (perFrame) {
+        let v = perFrame.get(chunk.id);
+        if (v === undefined) perFrame.set(chunk.id, v = version(chunk.id));
+        chunk.version = v;
+      } else if (version !== undefined) chunk.version = version;
+      if (chunk.type === "data" && host.prepareData) await host.prepareData();
+      host.apply(chunk);
+    }
+    result = await reader.next();
+  }
+  return as !== undefined ? as : rootId;
+}
+const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("dom-expressions.server-component");
+const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("dom-expressions.server-component-address");
+const COMPONENT_BINDING = /*#__PURE__*/Symbol.for("dom-expressions.component-binding");
+let resolveServerComponent;
+function parseServerComponent(value, ctx) {
+  return {
+    id: ctx.parse(value[SERVER_COMPONENT]),
+    address: ctx.parse(value[SERVER_COMPONENT_ADDRESS])
+  };
+}
+const ServerComponentPlugin = {
+  tag: "dom-expressions/server-component",
+  test(value) {
+    return typeof value === "function" && SERVER_COMPONENT in value;
+  },
+  parse: {
+    sync: parseServerComponent,
+    async async(value, ctx) {
+      return {
+        id: await ctx.parse(value[SERVER_COMPONENT]),
+        address: await ctx.parse(value[SERVER_COMPONENT_ADDRESS])
+      };
+    },
+    stream: parseServerComponent
+  },
+  serialize(node, ctx) {
+    const registry = "self._$SC";
+    return registry + ".r(" + ctx.serialize(node.id) + "," + ctx.serialize(node.address) + ")";
+  },
+  deserialize(node, ctx) {
+    const id = ctx.deserialize(node.id);
+    const address = ctx.deserialize(node.address);
+    if (address !== undefined && resolveServerComponent) {
+      return resolveServerComponent(id, address);
+    }
+    return globalThis._$SC.r(id);
+  }
+};
+function flightCodec(codec) {
+  const plugins = codec && codec.plugins || [];
+  if (plugins.some(plugin => plugin && plugin.tag === ServerComponentPlugin.tag)) return codec;
+  return {
+    ...codec,
+    plugins: [...plugins, ServerComponentPlugin]
+  };
+}
+function createServerComponentHandler({
+  host,
+  component,
+  onStream,
+  intercept,
+  consumer = client.getFlightDataConsumer,
+  codec = client.getServerFunctionsCodec
+}) {
+  const byFn = new Map();
+  const componentFor = fnId => {
+    let comp = byFn.get(fnId);
+    if (comp === undefined) byFn.set(fnId, comp = component(fnId));
+    return comp;
+  };
+  const byAddress = new Map();
+  const bindingFor = (address, fnId) => {
+    let binding = byAddress.get(address);
+    if (!binding) {
+      const comp = componentFor(fnId);
+      binding = props => comp(props, () => address);
+      binding[COMPONENT_BINDING] = {
+        component: comp,
+        address
+      };
+      byAddress.set(address, binding);
+    }
+    return binding;
+  };
+  resolveServerComponent = (id, address) => bindingFor(address, id);
+  const versions = new Map();
+  const bump = address => {
+    const version = (versions.get(address) || 0) + 1;
+    versions.set(address, version);
+    return version;
+  };
+  return {
+    intercept: intercept && (info => {
+      const hit = intercept(info);
+      if (hit === undefined) return undefined;
+      return bindingFor(client.frameAddress(info.id, info.args), info.id);
+    }),
+    handle(response, ctx) {
+      if (!isFrameStreamResponse(response)) return undefined;
+      const address = client.frameAddress(ctx.id, ctx.args);
+      const binding = bindingFor(address, ctx.id);
+      if (response.headers.has(client.SINGLE_FLIGHT_HEADER)) {
+        return applyFlightResponse(response, address, binding);
+      }
+      const version = bump(address);
+      if (onStream) onStream(address, version, response);
+      applyFrameResponse(response, host, {
+        as: address,
+        version
+      }).catch(err => host.apply({
+        type: "error",
+        id: address,
+        version,
+        error: {
+          message: String(err && err.message)
+        }
+      }));
+      return binding;
+    },
+    showing(address, functionId) {
+      bindingFor(address, functionId);
+      const comp = componentFor(functionId);
+      if (comp && (typeof comp === "function" || typeof comp === "object") && !comp[COMPONENT_BINDING]) {
+        comp[COMPONENT_BINDING] = {
+          component: comp,
+          address
+        };
+      }
+    }
+  };
+  async function applyFlightResponse(response, address, binding) {
+    const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
+    const as = rootId ? address : undefined;
+    let feed;
+    const source = new ReadableStream({
+      start(controller) {
+        feed = controller;
+      }
+    });
+    const payload = client.deserializeStream(new Response(source), flightCodec(codec()));
+    let carried = false;
+    await applyFrameResponse(response, host, {
+      as,
+      version: frameId => {
+        const version = bump(frameId);
+        if (onStream) onStream(frameId, version, response);
+        return version;
+      },
+      onOutcome: text => {
+        carried = true;
+        feed.enqueue(client.createChunk(text));
+      }
+    });
+    feed.close();
+    if (!carried) throw new Error("Single-flight frame response carried no outcome");
+    const envelope = await payload;
+    const deliver = consumer();
+    if (deliver) await deliver(envelope.data, {
+      response
+    });
+    if (response.headers.has(client.ERROR_HEADER) && !response.headers.has("Location") && !response.headers.has(client.REVALIDATE_HEADER)) {
+      throw envelope.value;
+    }
+    return rootId ? binding : envelope.value;
+  }
+}
+
+const STATE = Symbol.for("dom-expressions.container-trace-state");
+const state = globalThis[STATE] || (globalThis[STATE] = {
+  materialized: new WeakMap(),
+  materializedValues: new WeakSet()
+});
+function setContainerTraceMaterializer(fn) {
+  state.materializeTrace = fn;
+}
+function materialize(marker) {
+  let value = state.materialized.get(marker.$tr);
+  if (value === undefined) {
+    value = state.materializeTrace(marker);
+    state.materialized.set(marker.$tr, value);
+    if (value !== null && typeof value === "object") state.materializedValues.add(value);
+  }
+  return value;
+}
+function isMaterializedContainer(value) {
+  return value !== null && typeof value === "object" && state.materializedValues.has(value);
+}
+function isContainerTraceMarker(value) {
+  return value != null && typeof value === "object" && value.$tr != null && typeof value.$tr[Symbol.asyncIterator] === "function";
+}
+function reviveContainerTraces(value) {
+  if (!state.materializeTrace || value == null || typeof value !== "object") return value;
+  if (isContainerTraceMarker(value)) return materialize(value);
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) value[i] = reviveContainerTraces(value[i]);
+  } else if (Object.getPrototypeOf(value) === Object.prototype) {
+    for (const key of Object.keys(value)) value[key] = reviveContainerTraces(value[key]);
+  }
+  return value;
+}
+
+setContainerTraceMaterializer(solidJs.materializeContainerTrace);
+function asyncArg(value) {
+  return value;
+}
+let sharedHost;
+let codec;
+let codecLoading;
+function loadCodec() {
+  return codecLoading ??= import('@solidjs/web/serialization/decode').then(m => {
+    codec = m;
+  });
+}
+const tables = new Map();
+function ensureTable(root) {
+  let table = tables.get(root);
+  if (!table && codec) tables.set(root, table = codec.createJSONDataTable());
+  return table;
+}
+function tableFor(id) {
+  if (tables.has(id)) return ensureTable(id);
+  for (const root of tables.keys()) if (id.startsWith(root + ".")) return ensureTable(root);
+  return undefined;
+}
+function beginStream(frameId) {
+  tables.set(frameId, undefined);
+}
+function getFrameHost() {
+  if (!sharedHost) {
+    sharedHost = createFrameHost({
+      prepareData: loadCodec,
+      applyData: c => tableFor(c.id)?.apply(c),
+      resolve: (ref, id) => tableFor(id)?.resolve(ref),
+      revive: reviveContainerTraces,
+      isContainer: isMaterializedContainer
+    });
+  }
+  return sharedHost;
+}
+function normalizeSlotContent(value) {
+  while (typeof value === "function") value = value();
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const v of value) {
+      const n = normalizeSlotContent(v);
+      Array.isArray(n) ? out.push(...n) : out.push(n);
+    }
+    return out;
+  }
+  if (value == null || typeof value === "boolean") return document.createTextNode("");
+  return value instanceof Node ? value : document.createTextNode(String(value));
+}
+function gatherClaims(el, registry) {
+  if (el.hasAttribute("_hk")) registry.set(el.getAttribute("_hk"), el);
+  if (el.hasAttribute(FRAME_ID_ATTR)) return;
+  for (let c = el.firstElementChild; c; c = c.nextElementSibling) gatherClaims(c, registry);
+}
+function hasPendingFragment(existing) {
+  for (const n of existing) {
+    if (n.nodeType !== 1) continue;
+    const el = n;
+    if (el.tagName === "TEMPLATE" && el.id.startsWith("pl-")) return true;
+    if (el.querySelector?.('template[id^="pl-"]')) return true;
+  }
+  return false;
+}
+function claimRender(prefix, existing, render) {
+  const sc = solidJs.sharedConfig;
+  if (!sc.getNextContextId) return render();
+  const registry = new Map();
+  for (const n of existing) {
+    if (n.nodeType !== 1) continue;
+    gatherClaims(n, registry);
+  }
+  if (!registry.size && !hasPendingFragment(existing)) return render();
+  const prevRegistry = sc.registry;
+  const prevHydrating = sc.hydrating;
+  const prevClaimRoots = sc.claimRoots;
+  if (prevRegistry) for (const key of registry.keys()) prevRegistry.delete(key);
+  sc.registry = registry;
+  sc.hydrating = true;
+  sc.claimRoots = existing;
+  try {
+    return solidJs.runWithOwner(solidJs.createOwner({
+      id: prefix
+    }), render);
+  } finally {
+    sc.registry = prevRegistry;
+    sc.hydrating = prevHydrating;
+    sc.claimRoots = prevClaimRoots;
+  }
+}
+function liveSlotProps(initial, ctx) {
+  const [args, setArgs] = solidJs.createSignal(initial);
+  ctx.onUpdate(next => setArgs(() => next));
+  return slotArgsProxy(args);
+}
+function isAsyncValue(v) {
+  return v !== null && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
+}
+function slotArgsProxy(args) {
+  const owner = solidJs.getOwner();
+  const asyncReads = new Map();
+  return new Proxy({}, {
+    get: (_, key) => {
+      const v = args()[key];
+      if (isMaterializedContainer(v)) return v;
+      if (!isAsyncValue(v)) return v;
+      let read = asyncReads.get(key);
+      if (!read) {
+        const make = () => solidJs.createMemo(() => args()[key]);
+        read = owner ? solidJs.runWithOwner(owner, make) : make();
+        asyncReads.set(key, read);
+      }
+      return read();
+    },
+    has: (_, key) => key in args(),
+    ownKeys: () => Reflect.ownKeys(args()),
+    getOwnPropertyDescriptor: (_, key) => key in args() ? {
+      enumerable: true,
+      configurable: true
+    } : undefined
+  });
+}
+function isReactiveContent(value) {
+  if (typeof value === "function") return true;
+  if (Array.isArray(value)) {
+    for (const v of value) if (isReactiveContent(v)) return true;
+  }
+  return false;
+}
+function slotsFor(props) {
+  const bindings = new Map();
+  const fillScopes = new Map();
+  return new Proxy({}, {
+    get(_, prop) {
+      if (typeof prop !== "string" || !(prop in props)) return undefined;
+      return (slotProps, ctx) => {
+        const key = ctx && ctx.key;
+        const prev = key !== undefined && bindings.get(key);
+        if (prev) {
+          bindings.delete(key);
+          prev.dispose();
+        }
+        const prevFill = key !== undefined && fillScopes.get(key);
+        if (prevFill) {
+          fillScopes.delete(key);
+          prevFill.dispose();
+        }
+        const fillOwner = streamInvoke ? solidJs.createOwner() : null;
+        if (fillOwner && key !== undefined && ctx) {
+          fillScopes.set(key, fillOwner);
+          ctx.onCleanup(() => {
+            if (fillScopes.get(key) === fillOwner) fillScopes.delete(key);
+            fillOwner.dispose();
+          });
+        }
+        const settle = out => {
+          const existing = ctx && ctx.existing || [];
+          if (existing.length) {
+            const list = Array.isArray(out) ? out : [out];
+            const inPlace = list.every(n => existing.some(e => e === n || e.nodeType === 1 && e.contains(n)));
+            if (inPlace) return undefined;
+          }
+          return out;
+        };
+        const evaluate = () => {
+          const v = props[prop];
+          if (typeof v === "function" && ctx && ctx.invoked) {
+            return v(ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps));
+          }
+          return v;
+        };
+        const adopted = !!(ctx && ctx.frame && ctx.adopted && ctx.existing && ctx.existing.length);
+        const prefix = ctx && ctx.frame ? `sc-${ctx.frame}-${ctx.key}-` : "";
+        const value = fillOwner ? solidJs.runWithOwner(fillOwner, () => adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate()) : adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate();
+        if (!isReactiveContent(value)) {
+          return settle(normalizeSlotContent(value));
+        }
+        if (ctx && ctx.range) {
+          const source = value;
+          const owner = solidJs.createOwner();
+          bindings.set(key, owner);
+          ctx.onCleanup(() => {
+            if (bindings.get(key) === owner) bindings.delete(key);
+            owner.dispose();
+          });
+          const end = ctx.range.end;
+          const bind = () => web.insert(end.parentNode, () => typeof source === "function" ? source() : source, end, [...ctx.existing]);
+          solidJs.runWithOwner(owner, () => adopted ? claimRender(prefix, ctx.existing, bind) : bind());
+          return undefined;
+        }
+        return settle(normalizeSlotContent(value));
+      };
+    }
+  });
+}
+function revealSeam(owner) {
+  return seam => solidJs.runWithOwner(owner, () => web.insert(seam.before.parentNode, solidJs.createLoadingBoundary(() => seam.content(), () => seam.fallback), seam.before));
+}
+let streamInvoke = false;
+function boundaryScope(owner) {
+  return fn => {
+    if (solidJs.getOwner()) return fn();
+    streamInvoke = true;
+    try {
+      return solidJs.runWithOwner(owner, fn);
+    } finally {
+      streamInvoke = false;
+    }
+  };
+}
+function boundaryComponent(host, fnId) {
+  return (props, binding) => {
+    const owner = solidJs.getOwner();
+    const id = binding ? binding() : fnId;
+    let applied = !tables.has(id);
+    let release;
+    const arm = () => new Promise(r => release = r);
+    const mountGate = applied ? undefined : arm();
+    let setGate;
+    const {
+      element,
+      frame,
+      dispose
+    } = createFrameElement({
+      host,
+      id,
+      slots: slotsFor(props),
+      ownerScope: boundaryScope(owner),
+      reveal: revealSeam(owner),
+      onApply: () => {
+        applied = true;
+        if (release) {
+          release();
+          release = undefined;
+        }
+        setGate && setGate(undefined);
+      }
+    });
+    const [gatePromise, setGatePromise] = solidJs.createSignal(applied ? undefined : mountGate);
+    setGate = setGatePromise;
+    if (binding) {
+      solidJs.createRenderEffect(binding, (address, prev) => {
+        if (prev !== undefined && address !== prev && tables.has(address)) {
+          applied = false;
+          setGatePromise(arm());
+        }
+        frame.rebind(address);
+      });
+    }
+    solidJs.onCleanup(dispose);
+    if (applied && !binding) return element;
+    const gate = solidJs.createMemo(() => gatePromise());
+    return solidJs.createMemo(() => (gate(), element));
+  };
+}
+const claimedBoundaries = new Set();
+const liveOps = new Map();
+const liveAppliers = new Set();
+let livePumped = null;
+function pumpLiveChannel() {
+  const stream = globalThis._$HY?.r?.["sc:live"];
+  if (!stream || stream === livePumped || typeof stream.getReader !== "function") return;
+  livePumped = stream;
+  const reader = stream.getReader();
+  const pump = () => reader.read().then(r => {
+    if (r.done) return;
+    const op = r.value;
+    liveOps.set(`${op.type}:${op.fid || ""}:${op.key || ""}`, op);
+    for (const apply of liveAppliers) apply(op);
+    return pump();
+  });
+  pump().catch(() => {
+  });
+}
+let boundaryIndex = null;
+const isBoundaryId = id => !id.includes(".");
+function indexBoundaries(root) {
+  root.querySelectorAll(`[${FRAME_ID_ATTR}]`).forEach(el => {
+    const key = el.getAttribute(FRAME_ID_ATTR);
+    if (key && isBoundaryId(key) && !boundaryIndex.has(key)) boundaryIndex.set(key, el);
+  });
+}
+function findBoundaryElement(id) {
+  if (!boundaryIndex) {
+    boundaryIndex = new Map();
+    if (typeof document !== "undefined" && document.body) indexBoundaries(document.body);
+  }
+  return boundaryIndex.get(id);
+}
+const boundaryWaiters = new Map();
+function boundaryMayArrive() {
+  const hy = globalThis._$HY;
+  if (!hy) return false;
+  return !hy.done || !!(hy.fr && hy.fr.pending());
+}
+function installRevealHook() {
+  const hy = globalThis._$HY;
+  if (!hy || hy.$sc || !hy.fr) return;
+  hy.$sc = true;
+  hy.fr.subscribe((_id, parent) => {
+    if (!boundaryIndex) return;
+    const root = parent || (typeof document !== "undefined" ? document.body : null);
+    if (root) indexBoundaries(root);
+    if (!boundaryWaiters.size) return;
+    const exhausted = hy.done && !hy.fr.pending();
+    for (const [id, notify] of boundaryWaiters) {
+      const el = boundaryIndex && boundaryIndex.get(id);
+      if (!el && !exhausted) continue;
+      boundaryWaiters.delete(id);
+      notify(el);
+    }
+  });
+}
+function documentBoundary(host, id, props, binding) {
+  installRevealHook();
+  const claimed = claimedBoundaries.has(id);
+  const el = !claimed ? findBoundaryElement(id) : undefined;
+  if (el) return adoptBoundary(host, id, el, props, binding);
+  if (!claimed && !boundaryWaiters.has(id) && boundaryMayArrive()) {
+    const owner = solidJs.getOwner();
+    const arrival = new Promise(resolve => boundaryWaiters.set(id, resolve));
+    solidJs.onCleanup(() => boundaryWaiters.delete(id));
+    return solidJs.createMemo(() => arrival.then(node => solidJs.runWithOwner(owner, () =>
+    node ? adoptBoundary(host, id, node, props, binding) : boundaryComponent(host, id)(props, binding))));
+  }
+  return boundaryComponent(host, id)(props, binding);
+}
+function documentAddress(id) {
+  const records = globalThis._$SC?.a;
+  if (records) {
+    for (const address in records) if (records[address] === id) return address;
+  }
+  return id;
+}
+function adoptBoundary(host, id, el, props, binding) {
+  claimedBoundaries.add(id);
+  const address = binding ? binding() : documentAddress(id);
+  const appliedRecords = new Set();
+  const claimedFragments = new Set();
+  const claimRegionFragments = root => {
+    const fr = globalThis._$HY?.fr;
+    if (!fr || !fr.claim) return;
+    root.querySelectorAll('template[id^="pl-"]').forEach(tpl => {
+      const fragId = tpl.id.slice(3);
+      if (claimedFragments.has(fragId)) return;
+      claimedFragments.add(fragId);
+      fr.claim(fragId);
+    });
+  };
+  const drainRecords = () => {
+    const hy = globalThis._$HY;
+    if (!hy || !hy.r) return;
+    pumpLiveChannel();
+    const slotPrefix = `sc:slot:${id}:`;
+    for (const key of Object.keys(hy.r)) {
+      if (appliedRecords.has(key)) continue;
+      if (key.startsWith(slotPrefix)) {
+        appliedRecords.add(key);
+        host.apply({
+          type: "slot",
+          id: address,
+          version: 0,
+          key: key.slice(slotPrefix.length),
+          args: hy.r[key]
+        });
+      } else if (key.startsWith("sc:region:")) {
+        const childId = key.slice("sc:region:".length);
+        if (childId.startsWith(id + ".")) {
+          appliedRecords.add(key);
+          const val = hy.r[key];
+          const apply = html => host.apply({
+            type: "html",
+            id: childId,
+            version: 0,
+            html
+          });
+          val && typeof val.then === "function" ? val.then(apply) : apply(val);
+        }
+      }
+    }
+  };
+  claimRegionFragments(el);
+  const fr = globalThis._$HY?.fr;
+  const unsubscribe = fr ? fr.subscribe((_fragId, parent) => {
+    if (fr.claim && parent && el.contains(parent)) claimRegionFragments(parent);
+    drainRecords();
+  }) : undefined;
+  const applyLiveOp = op => {
+    if (op.type === "slot" && op.fid !== id) return;
+    host.apply({
+      ...op,
+      id: address,
+      version: 0
+    });
+  };
+  liveAppliers.add(applyLiveOp);
+  solidJs.onCleanup(() => {
+    liveAppliers.delete(applyLiveOp);
+    unsubscribe && unsubscribe();
+    if (fr && fr.release) for (const fragId of claimedFragments) fr.release(fragId);
+  });
+  drainRecords();
+  for (const op of liveOps.values()) applyLiveOp(op);
+  const owner = solidJs.getOwner();
+  let release;
+  let setGate;
+  const frame = createFrame(el, {
+    adopt: true,
+    host,
+    id: address,
+    slots: slotsFor(props),
+    ownerScope: boundaryScope(owner),
+    reveal: revealSeam(owner),
+    onApply: () => {
+      if (release) {
+        release();
+        release = undefined;
+      }
+      setGate && setGate(undefined);
+    },
+    ...{
+      recordsPending: () => {
+        if (document.readyState === "loading") return true;
+        const hy = globalThis._$HY;
+        return !!(hy && hy.fr && hy.fr.pending());
+      },
+      drainRecords,
+      claimScope: id
+    }
+  });
+  if (binding) {
+    const arm = () => new Promise(r => release = r);
+    const [gatePromise, setGatePromise] = solidJs.createSignal(undefined);
+    setGate = setGatePromise;
+    const gate = solidJs.createMemo(() => gatePromise());
+    solidJs.createRenderEffect(binding, (address, prev) => {
+      if (prev !== undefined && address !== prev && tables.has(address)) {
+        setGatePromise(arm());
+      }
+      frame.rebind(address);
+    });
+    solidJs.createRenderEffect(() => (gate(), undefined), () => {});
+  }
+  solidJs.onCleanup(() => frame.dispose());
+  return el;
+}
+function installServerComponents(host = getFrameHost()) {
+  const g = globalThis;
+  if (!g._$SC) {
+    g._$SC = {
+      c: {},
+      a: {},
+      r(i, a) {
+        if (a) {
+          g._$SC.a[a] = i;
+          g._$SC.reg && g._$SC.reg(a, i);
+        }
+        return g._$SC.c[i] || (g._$SC.c[i] = (p, b) => g._$SC.impl(i, p, b));
+      }
+    };
+  }
+  g._$SC.impl = (id, props, binding) => documentBoundary(host, id, props, binding);
+  installRevealHook();
+  const handler = createServerComponentHandler({
+    host,
+    component: fnId => g._$SC.r(fnId),
+    onStream: address => beginStream(address),
+    intercept: ({
+      id
+    }) => {
+      if (claimedBoundaries.has(id) || !findBoundaryElement(id)) return undefined;
+      return g._$SC.r(id);
+    }
+  });
+  const showing = (address, id) => handler.showing(address, id);
+  const records = g._$SC.a || (g._$SC.a = {});
+  for (const address in records) showing(address, records[address]);
+  g._$SC.reg = showing;
+  client.configureServerFunctionsClient({
+    responseHandler: handler
+  });
+}
+
+exports.FRAME_APPLIED_EVENT = FRAME_APPLIED_EVENT;
+exports.FRAME_STREAM_HEADER = FRAME_STREAM_HEADER;
+exports.applyFrameResponse = applyFrameResponse;
+exports.asyncArg = asyncArg;
+exports.createFrame = createFrame;
+exports.createFrameElement = createFrameElement;
+exports.createFrameHost = createFrameHost;
+exports.createServerComponentHandler = createServerComponentHandler;
+exports.getFrameHost = getFrameHost;
+exports.installServerComponents = installServerComponents;
+exports.isFrameStreamResponse = isFrameStreamResponse;