@atolljs/islands 0.1.12 → 0.1.13

package/dist/worker/index.js

@@ -0,0 +1,3159 @@
+import {
+  CALLBACK_EVENT,
+  assertCloneableProps,
+  connectIslandWorker,
+  contractOf,
+  cssStyleValue,
+  defineIslandContract,
+  isEventRef,
+  isIslandContract,
+  isKeepAliveClient,
+  islandApp,
+  islandAppNameOf,
+  marshalCallbackProps,
+  mountIsland,
+  propsPreview,
+  registerSubIslandMounter,
+  renderMemory,
+  unmarshalCallbackProps,
+  withContract
+} from "../chunk-TX4FAHRB.js";
+
+// src/worker/defineWorkers.ts
+import { defineWorker } from "@atolljs/core";
+
+// src/metrics.ts
+var proxyMetrics = {
+  enabled: false,
+  /** Frames currently inside instrumented proxy code (re-entrancy guard). */
+  depth: 0,
+  /** ms inside outermost instrumented frames since reset(). */
+  recordMs: 0,
+  /** Ops pushed since reset() — a count, free to keep. */
+  opsPushed: 0,
+  reset() {
+    this.depth = 0;
+    this.recordMs = 0;
+    this.opsPushed = 0;
+  }
+};
+var enterProxyFrame = () => {
+  proxyMetrics.depth++;
+  return proxyMetrics.depth === 1 ? performance.now() : -1;
+};
+var exitProxyFrame = (t0) => {
+  proxyMetrics.depth--;
+  if (t0 >= 0) proxyMetrics.recordMs += performance.now() - t0;
+};
+
+// src/worker/instance.ts
+var timed = (body) => {
+  if (!proxyMetrics.enabled) return body();
+  const t0 = enterProxyFrame();
+  try {
+    return body();
+  } finally {
+    exitProxyFrame(t0);
+  }
+};
+var ROOT_CONTAINER = Object.freeze({ id: 0 });
+var opsByInstance = /* @__PURE__ */ new Map();
+var activeInstance = "";
+var instances = /* @__PURE__ */ new Map();
+var handlers = /* @__PURE__ */ new Map();
+var DETACHED_CAP = 4096;
+var detachedInstances = /* @__PURE__ */ new Map();
+var detachedHandlers = /* @__PURE__ */ new Map();
+var evictOldest = (map) => {
+  if (map.size <= DETACHED_CAP) return;
+  const oldest = map.keys().next().value;
+  if (oldest !== void 0) map.delete(oldest);
+};
+var detachInstance = (id, handlerIds) => {
+  const record = instances.get(id);
+  if (record === void 0) return;
+  instances.delete(id);
+  detachedInstances.set(id, record);
+  evictOldest(detachedInstances);
+  for (const hid of handlerIds) {
+    const entry = handlers.get(hid);
+    if (entry !== void 0) {
+      handlers.delete(hid);
+      detachedHandlers.set(hid, entry);
+      evictOldest(detachedHandlers);
+    }
+  }
+};
+var attachInstance = (id, handlerIds) => {
+  const record = detachedInstances.get(id);
+  if (record !== void 0) {
+    detachedInstances.delete(id);
+    instances.set(id, record);
+  }
+  for (const hid of handlerIds) {
+    const entry = detachedHandlers.get(hid);
+    if (entry !== void 0) {
+      detachedHandlers.delete(hid);
+      handlers.set(hid, entry);
+    }
+  }
+};
+var lookupInstance = (id) => instances.get(id) ?? detachedInstances.get(id);
+var nextId = 1;
+var nextHandlerId = 1;
+var instanceContracts = /* @__PURE__ */ new Map();
+var setInstanceContract = (instance, contract) => {
+  if (contract === void 0) instanceContracts.delete(instance);
+  else instanceContracts.set(instance, contract);
+};
+var allocId = () => nextId++;
+var lastInstance = "";
+var setActiveInstance = (instance) => {
+  const prev = activeInstance;
+  activeInstance = instance;
+  if (instance !== "") lastInstance = instance;
+  return prev;
+};
+var getActiveInstance = () => activeInstance;
+var getLastActiveInstance = () => lastInstance;
+var touchedInstance = "";
+var getLastTouchedInstance = () => touchedInstance;
+var markInstanceActive = (instance) => {
+  if (instance) lastInstance = instance;
+};
+var runInInstance = (instance, fn) => {
+  const prev = setActiveInstance(instance);
+  try {
+    return fn();
+  } finally {
+    setActiveInstance(prev);
+  }
+};
+var pushOp = (instance, op) => timed(() => {
+  if (instance !== "") touchedInstance = instance;
+  let queue = opsByInstance.get(instance);
+  if (!queue) opsByInstance.set(instance, queue = []);
+  queue.push(op);
+  proxyMetrics.opsPushed++;
+});
+var doorbell = renderMemory;
+var setDoorbellContract = (contract) => {
+  doorbell = contract;
+};
+var bumpOpsVersion = () => {
+  if (!doorbell.bound) return;
+  const bell = doorbell.connector("opsVersion");
+  bell.write(Number(bell.read() ?? 0) + 1);
+};
+var takeOps = (instance) => timed(() => {
+  const queue = opsByInstance.get(instance);
+  if (!queue || queue.length === 0) return [];
+  opsByInstance.set(instance, []);
+  return queue;
+});
+var proxyInstanceStats = () => ({
+  liveNodes: instances.size,
+  handlers: handlers.size,
+  queuedOps: [...opsByInstance.values()].reduce((a, q) => a + q.length, 0),
+  queuedByInstance: Object.fromEntries(
+    [...opsByInstance.entries()].map(([k, q]) => [k, q.length])
+  )
+});
+var getHandler = (id) => handlers.get(id) ?? detachedHandlers.get(id);
+var instanceSizes = /* @__PURE__ */ new Map();
+var getInstanceSize = (instance) => instanceSizes.get(instance);
+var setInstanceSize = (instance, w, h) => {
+  instanceSizes.set(instance, { w, h });
+};
+var instanceRects = /* @__PURE__ */ new Map();
+var getInstanceRect = (instance, id) => instanceRects.get(instance)?.get(id);
+var setInstanceRect = (instance, rect) => {
+  let table = instanceRects.get(instance);
+  if (table === void 0) instanceRects.set(instance, table = /* @__PURE__ */ new Map());
+  table.set(rect.id, { x: rect.x, y: rect.y, w: rect.w, h: rect.h });
+};
+var clearInstanceRects = (instance) => {
+  instanceRects.delete(instance);
+};
+var registerHandler = (fn, instance, instanceId) => timed(() => {
+  const id = nextHandlerId++;
+  handlers.set(id, { fn, instance, instanceId });
+  return id;
+});
+var unregisterHandler = (id) => {
+  timed(() => {
+    handlers.delete(id);
+    detachedHandlers.delete(id);
+  });
+};
+var emit = (name, payload) => {
+  timed(() => {
+    const schema = instanceContracts.get(activeInstance)?.events?.[name];
+    if (schema !== void 0) {
+      try {
+        payload = schema.parse(payload);
+      } catch (err) {
+        throw new Error(
+          `emit("${name}") rejected by the island contract for "${activeInstance}": ` + (err instanceof Error ? err.message : String(err))
+        );
+      }
+    }
+    pushOp(activeInstance, { t: "emit", name, payload });
+  });
+};
+function serializeProps(instance, props) {
+  return timed(() => {
+    const out = {};
+    for (const [name, value] of Object.entries(props)) {
+      if (value === void 0 || value === null) continue;
+      if (name === "children" || name === "key" || name === "ref" || name === "dangerouslySetInnerHTML") {
+        continue;
+      }
+      if (typeof value === "function") {
+        if (name.length > 2 && name.startsWith("on")) {
+          let slot = instance.listenerSlots[name];
+          if (slot === void 0) {
+            slot = nextHandlerId++;
+            instance.listenerSlots[name] = slot;
+          }
+          handlers.set(slot, {
+            fn: value,
+            instance: instance.instance,
+            instanceId: instance.id
+          });
+          out[name] = { __evt: slot };
+        }
+        continue;
+      }
+      out[name] = value;
+    }
+    return out;
+  });
+}
+function newElement(type, props, ns, instance) {
+  return timed(() => {
+    const record = {
+      kind: "element",
+      id: allocId(),
+      type,
+      ns,
+      instance,
+      props: {},
+      listenerSlots: {}
+    };
+    record.props = serializeProps(record, props);
+    instances.set(record.id, record);
+    return record;
+  });
+}
+function newText(text, instance) {
+  return timed(() => {
+    const record = { kind: "text", id: allocId(), text, instance };
+    instances.set(record.id, record);
+    return record;
+  });
+}
+
+// src/worker/dom/node.ts
+var normalizeListenerOptions = (options) => {
+  const o = typeof options === "boolean" ? { capture: options } : options ?? {};
+  return { once: o.once === true, passive: o.passive === true, capture: o.capture === true };
+};
+var listenerOptsForWire = (options) => {
+  const o = normalizeListenerOptions(options);
+  return o.once || o.passive || o.capture ? { once: o.once, passive: o.passive, capture: o.capture } : void 0;
+};
+var hyphenate = (k) => k.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+var camelize = (k) => k.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+var nextPhantomId = -1;
+var allocPhantomId = () => nextPhantomId--;
+var rejectForeignChild = (child) => {
+  throw new Error(
+    "proxyDom.insertBefore: child is not a proxy node \u2014 the ambient `document`/`createElement` resolved a foreign DOM (a stale override or the real one), so this node was created outside the instance that owns the parent"
+  );
+};
+var detachFromParent = (child) => {
+  const p = child._parent;
+  if (p instanceof ProxyNode) p._detach(child);
+  else child._parent = null;
+};
+var asChild = (doc, n) => typeof n === "string" ? doc.createTextNode(n) : n;
+var ProxyNode = class _ProxyNode {
+  /** The shared host-instance record — same objects `instances` holds. */
+  instance;
+  /** The document that created/wrapped this node (internal fields below). */
+  doc;
+  _parent = null;
+  _children = [];
+  constructor(doc, instance) {
+    this.doc = doc;
+    this.instance = instance;
+  }
+  get nodeType() {
+    return 0;
+  }
+  /**
+   * '#text'/'#comment'/'#document-fragment' for character/fragment nodes;
+   * the tag name for elements — uppercase in the HTML namespace, verbatim
+   * for namespaced elements (svg 'foreignObject' keeps its case, matching
+   * the real DOM).
+   */
+  get nodeName() {
+    switch (this.nodeType) {
+      case 1: {
+        const inst = this.instance;
+        return inst.ns === void 0 ? inst.type.toUpperCase() : inst.type;
+      }
+      case 3:
+        return "#text";
+      case 8:
+        return "#comment";
+      case 11:
+        return "#document-fragment";
+      default:
+        return "#node";
+    }
+  }
+  /** The proxy document that owns this node — what real DOM code reads as
+   *  `el.ownerDocument`. */
+  get ownerDocument() {
+    return this.doc;
+  }
+  get parentNode() {
+    return this._parent;
+  }
+  get parentElement() {
+    return this._parent !== null && this._parent.nodeType === 1 ? this._parent : null;
+  }
+  /** A copy of the shadow child list — structural changes go through
+   *  appendChild/insertBefore/removeChild so ops stay in sync. */
+  get childNodes() {
+    return this._children.slice();
+  }
+  get firstChild() {
+    return this._children[0] ?? null;
+  }
+  get lastChild() {
+    return this._children[this._children.length - 1] ?? null;
+  }
+  get nextSibling() {
+    const p = this._parent;
+    if (p === null) return null;
+    return p._children[p._children.indexOf(this) + 1] ?? null;
+  }
+  get previousSibling() {
+    const p = this._parent;
+    if (p === null) return null;
+    const i = p._children.indexOf(this);
+    return i > 0 ? p._children[i - 1] : null;
+  }
+  /** Attached to the document's root (driver-side id 0 container)? */
+  get isConnected() {
+    let n = this;
+    while (n !== null) {
+      if (n === this.doc._root) return true;
+      n = n._parent;
+    }
+    return false;
+  }
+  /**
+   * The topmost shadow-tree ancestor — the root container element when the
+   * node is connected. (The facade has no separate Document node object;
+   * `doc.body`/`documentElement` ARE that root.)
+   */
+  getRootNode() {
+    let n = this;
+    while (n._parent !== null) n = n._parent;
+    return n;
+  }
+  /** Concatenated descendant text — walked from the shadow tree. Comments
+   *  are excluded: the DOM's descendant text content is Text-node data only. */
+  get textContent() {
+    let out = "";
+    for (const child of this._children) {
+      if (child.nodeType !== 8) out += child.textContent;
+    }
+    return out;
+  }
+  set textContent(value) {
+    this.doc._assertAlive();
+    const text = String(value);
+    for (const child of this._children) child._parent = null;
+    this._children = text === "" ? [] : [this.doc._phantomText(this, text)];
+    this._op({ t: "utext", id: this.instance.id, text });
+  }
+  contains(other) {
+    let n = other;
+    while (n !== null) {
+      if (n === this) return true;
+      n = n._parent;
+    }
+    return false;
+  }
+  appendChild(child) {
+    return this.insertBefore(child, null);
+  }
+  insertBefore(child, ref) {
+    this.doc._assertAlive();
+    if (this.nodeType === 3 || this.nodeType === 8) {
+      throw new Error(
+        `proxyDom.insertBefore: ${this.nodeName} nodes cannot have children`
+      );
+    }
+    if (!(child instanceof _ProxyNode)) rejectForeignChild(child);
+    if (child instanceof ProxyFragment) {
+      for (const c of child._children.slice()) this.insertBefore(c, ref);
+      return child;
+    }
+    let beforeId;
+    if (ref === null) {
+      detachFromParent(child);
+      child._parent = this;
+      this._children.push(child);
+    } else {
+      const index = this._children.indexOf(ref);
+      if (index === -1) {
+        throw new Error("proxyDom.insertBefore: reference node is not a child of this node");
+      }
+      detachFromParent(child);
+      child._parent = this;
+      this._children.splice(index, 0, child);
+      if (ref.instance.id > 0) beforeId = ref.instance.id;
+    }
+    child._attachRecords();
+    if (this.instance.id >= 0 && child.instance.id > 0) {
+      this._op({ t: "append", parent: this.instance.id, child: child.instance.id, before: beforeId });
+      if (child.nodeType === 1 && this.doc._measureRequested.has(child.instance.id)) {
+        child._op({ t: "measure", id: child.instance.id });
+      }
+    }
+    return child;
+  }
+  removeChild(child) {
+    this.doc._assertAlive();
+    const index = this._children.indexOf(child);
+    if (index === -1) {
+      throw new Error("proxyDom.removeChild: node is not a child of this node");
+    }
+    this._children.splice(index, 1);
+    child._parent = null;
+    child._detachRecords();
+    if (this.instance.id >= 0 && child.instance.id > 0) {
+      this._op({ t: "remove", child: child.instance.id });
+    }
+    return child;
+  }
+  /** Detach from the parent — no-op when already orphaned (like the DOM). */
+  remove() {
+    this._parent?.removeChild(this);
+  }
+  /* ── ChildNode / ParentNode conveniences ───────────────────────────────
+   * Strings become text nodes like the DOM. before/after/replaceWith on a
+   * parentless node are no-ops (per spec). append/prepend/replaceChildren
+   * live on the base so elements AND fragments share them — real DOM also
+   * exposes them on DocumentFragment. */
+  before(...nodes) {
+    const p = this._parent;
+    if (p === null) return;
+    for (const n of nodes) p.insertBefore(asChild(this.doc, n), this);
+  }
+  after(...nodes) {
+    const p = this._parent;
+    if (p === null) return;
+    const ref = this.nextSibling;
+    for (const n of nodes) p.insertBefore(asChild(this.doc, n), ref);
+  }
+  replaceWith(...nodes) {
+    const p = this._parent;
+    if (p === null) return;
+    for (const n of nodes) p.insertBefore(asChild(this.doc, n), this);
+    p.removeChild(this);
+  }
+  /** append(...nodes) — strings become text nodes, like the DOM. */
+  append(...nodes) {
+    this.doc._assertAlive();
+    for (const n of nodes) this.appendChild(asChild(this.doc, n));
+  }
+  /** prepend(...nodes) — inserts at the front, in argument order. */
+  prepend(...nodes) {
+    this.doc._assertAlive();
+    const ref = this.firstChild;
+    for (const n of nodes) this.insertBefore(asChild(this.doc, n), ref);
+  }
+  /** replaceChildren(...nodes) — remove every child, then append the set. */
+  replaceChildren(...nodes) {
+    this.doc._assertAlive();
+    for (const child of this._children.slice()) this.removeChild(child);
+    this.append(...nodes);
+  }
+  /**
+   * Structural clone — each concrete kind implements it. The copy is a
+   * FRESH instance (own id, own create op), not a shared record; listeners
+   * never cross, matching the DOM.
+   */
+  cloneNode(_deep) {
+    throw new Error("proxyDom.cloneNode: unsupported node kind");
+  }
+  /**
+   * Queue an op on this node's instance — the same routing hostConfig uses for
+   * instance-bound ops. Outside a instance task the op still lands on the right
+   * queue, and the doorbell is bumped so push-mode islands pick it up.
+   */
+  _op(op) {
+    pushOp(this.instance.instance, op);
+    if (getActiveInstance() !== this.instance.instance) bumpOpsVersion();
+  }
+  /** Detach a child from the shadow list WITHOUT emitting an op — used when
+   *  a following append op will move the real node on the main thread. */
+  _detach(child) {
+    const i = this._children.indexOf(child);
+    if (i !== -1) this._children.splice(i, 1);
+    child._parent = null;
+  }
+  /** Handler ids this node's records own: addEventListener hids (element
+   *  subclass only) plus the prop-listener slots on the instance record. */
+  _recordHandlerIds() {
+    const listeners = this._listeners;
+    const slots = this.instance.listenerSlots;
+    return [...listeners?.map((l) => l.hid) ?? [], ...Object.values(slots ?? {})];
+  }
+  /** Tombstone this subtree's instance/handler records (removeChild). */
+  _detachRecords() {
+    if (this.instance.id > 0) detachInstance(this.instance.id, this._recordHandlerIds());
+    for (const c of this._children) c._detachRecords();
+  }
+  /** Restore this subtree's records on re-append (idempotent — a live node
+   *  is simply not in the tombstone maps). */
+  _attachRecords() {
+    if (this.instance.id > 0) attachInstance(this.instance.id, this._recordHandlerIds());
+    for (const c of this._children) c._attachRecords();
+  }
+};
+var ProxyText = class extends ProxyNode {
+  constructor(doc, instance) {
+    super(doc, instance);
+  }
+  get nodeType() {
+    return 3;
+  }
+  /**
+   * The driver-side id a text write targets. Real text instances write
+   * their own id; phantoms (created by an element's `textContent` setter)
+   * have no driver-side node, so writes retarget the parent — whose real
+   * `textContent` IS this node's whole text.
+   */
+  get _utextTarget() {
+    return this.instance.id > 0 ? this.instance.id : this._parent?.instance.id ?? this.instance.id;
+  }
+  get data() {
+    return this.instance.text;
+  }
+  set data(v) {
+    this._write(v);
+  }
+  get nodeValue() {
+    return this.instance.text;
+  }
+  set nodeValue(v) {
+    this._write(v);
+  }
+  get textContent() {
+    return this.instance.text;
+  }
+  set textContent(v) {
+    this._write(v);
+  }
+  _write(v) {
+    this.doc._assertAlive();
+    const text = String(v);
+    this.instance.text = text;
+    this._op({ t: "utext", id: this._utextTarget, text });
+  }
+  /** Fresh text node — the clone is a new `text` op, not a shared record. */
+  cloneNode(_deep) {
+    return this.doc.createTextNode(this.instance.text);
+  }
+};
+var ProxyComment = class extends ProxyText {
+  get nodeType() {
+    return 8;
+  }
+  get data() {
+    return this.instance.text;
+  }
+  set data(v) {
+    this._shadowWrite(v);
+  }
+  get nodeValue() {
+    return this.instance.text;
+  }
+  set nodeValue(v) {
+    this._shadowWrite(v);
+  }
+  get textContent() {
+    return this.instance.text;
+  }
+  set textContent(v) {
+    this._shadowWrite(v);
+  }
+  _shadowWrite(v) {
+    this.doc._assertAlive();
+    this.instance.text = String(v);
+  }
+  cloneNode(_deep) {
+    return this.doc.createComment(this.data);
+  }
+};
+var ProxyFragment = class extends ProxyNode {
+  get nodeType() {
+    return 11;
+  }
+  /** Fresh fragment; `deep` clones children polymorphically so comment
+   *  anchors keep nodeType 8. */
+  cloneNode(deep) {
+    const copy = this.doc.createDocumentFragment();
+    if (deep === true) {
+      for (const child of this._children) copy.appendChild(child.cloneNode(true));
+    }
+    return copy;
+  }
+};
+
+// src/worker/dom/html.ts
+import { parseDocument, ElementType } from "htmlparser2";
+function parseChildren(doc, html) {
+  const parsed = parseDocument(String(html));
+  const build = (nodes) => {
+    const out = [];
+    for (const node of nodes) {
+      switch (node.type) {
+        case ElementType.Tag:
+        case ElementType.Script:
+        case ElementType.Style: {
+          const el = doc.createElement(node.name);
+          for (const [name, value] of Object.entries(node.attribs)) el.setAttribute(name, value);
+          for (const child of build(node.children)) el.appendChild(child);
+          out.push(el);
+          break;
+        }
+        case ElementType.Text: {
+          if (node.data !== "") out.push(doc.createTextNode(node.data));
+          break;
+        }
+        case ElementType.Comment: {
+          out.push(doc.createComment(node.data));
+          break;
+        }
+        case ElementType.CDATA: {
+          for (const child of build(node.children)) out.push(child);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return out;
+  };
+  return build(parsed.children);
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var escapeText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+function serializeNode(node) {
+  if (node instanceof ProxyComment) return `<!--${node.data}-->`;
+  if (node instanceof ProxyText) return escapeText(node.textContent);
+  if (!(node instanceof ProxyElement)) return "";
+  const tag = node.instance.type;
+  const attrs = new Map(node._attrs);
+  const styleText = Object.entries(node._styleProps).filter(([, v]) => v !== "").map(([k, v]) => `${hyphenate(k)}: ${v};`).join(" ");
+  if (styleText !== "") attrs.set("style", styleText);
+  let out = `<${tag}`;
+  for (const [name, value] of attrs) out += ` ${name}="${escapeAttr(value)}"`;
+  if (VOID_ELEMENTS.has(tag)) return `${out}>`;
+  out += ">";
+  for (const child of node._children) out += serializeNode(child);
+  return `${out}</${tag}>`;
+}
+
+// src/worker/dom/selectors.ts
+var unsupportedSelector = (sel) => {
+  throw new Error(
+    `proxyDom.querySelector: unsupported selector "${sel}" \u2014 only tag, .class, #id, [attr], [attr="v"] and descendant combinators are supported`
+  );
+};
+function parseCompound(part, sel) {
+  const out = { classes: [], attrs: [] };
+  let i = 0;
+  const tag = /^[a-zA-Z][\w-]*/.exec(part);
+  if (tag !== null) {
+    out.tag = tag[0].toLowerCase();
+    i = tag[0].length;
+  }
+  while (i < part.length) {
+    const ch = part[i];
+    if (ch === "#") {
+      const m = /^[\w-]+/.exec(part.slice(i + 1));
+      if (m === null) unsupportedSelector(sel);
+      out.id = m[0];
+      i += 1 + m[0].length;
+    } else if (ch === ".") {
+      const m = /^[\w-]+/.exec(part.slice(i + 1));
+      if (m === null) unsupportedSelector(sel);
+      out.classes.push(m[0]);
+      i += 1 + m[0].length;
+    } else if (ch === "[") {
+      const end = part.indexOf("]", i);
+      if (end === -1) unsupportedSelector(sel);
+      const body = part.slice(i + 1, end).trim();
+      const m = /^([\w-]+)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^'"\s]+)))?$/.exec(body);
+      if (m === null) unsupportedSelector(sel);
+      out.attrs.push({ name: m[1], value: m[2] ?? m[3] ?? m[4] });
+      i = end + 1;
+    } else {
+      unsupportedSelector(sel);
+    }
+  }
+  if (out.tag === void 0 && out.id === void 0 && out.classes.length === 0 && out.attrs.length === 0) {
+    unsupportedSelector(sel);
+  }
+  return out;
+}
+function parseSelector(selector) {
+  const sel = selector.trim();
+  if (sel === "" || sel.includes(",") || sel.includes(">") || sel.includes("+") || sel.includes("~") || sel.includes(":")) {
+    unsupportedSelector(selector);
+  }
+  return sel.split(/\s+/).map((part) => parseCompound(part, selector));
+}
+function matchCompound(el, c) {
+  if (c.tag !== void 0 && el.tagName.toLowerCase() !== c.tag) return false;
+  if (c.id !== void 0 && el._attrs.get("id") !== c.id) return false;
+  for (const cls of c.classes) if (!el._classes.has(cls)) return false;
+  for (const a of c.attrs) {
+    const v = el._attrs.get(a.name);
+    if (v === void 0) return false;
+    if (a.value !== void 0 && v !== a.value) return false;
+  }
+  return true;
+}
+function matchesChain(el, chain) {
+  if (!matchCompound(el, chain[chain.length - 1])) return false;
+  let cur = el._parent;
+  for (let i = chain.length - 2; i >= 0; i--) {
+    let found = false;
+    while (cur !== null) {
+      if (cur instanceof ProxyElement && matchCompound(cur, chain[i])) {
+        found = true;
+        cur = cur._parent;
+        break;
+      }
+      cur = cur._parent;
+    }
+    if (!found) return false;
+  }
+  return true;
+}
+
+// src/worker/dom/css.ts
+var classLists = /* @__PURE__ */ new WeakMap();
+var styles = /* @__PURE__ */ new WeakMap();
+var datasets = /* @__PURE__ */ new WeakMap();
+function syncClasses(el) {
+  const v = [...el._classes].join(" ");
+  el._attrs.set("class", v);
+  el._op({ t: "attr", id: el.instance.id, name: "class", value: v === "" ? null : v });
+}
+function classListFor(el) {
+  let cl = classLists.get(el);
+  if (cl === void 0) {
+    cl = {
+      add: (...tokens) => {
+        let changed = false;
+        for (const t of tokens) {
+          if (t !== "" && !el._classes.has(t)) {
+            el._classes.add(t);
+            changed = true;
+          }
+        }
+        if (changed) syncClasses(el);
+      },
+      remove: (...tokens) => {
+        let changed = false;
+        for (const t of tokens) changed = el._classes.delete(t) || changed;
+        if (changed) syncClasses(el);
+      },
+      toggle: (token, force) => {
+        const has = el._classes.has(token);
+        const want = force ?? !has;
+        if (want === has) return has;
+        if (want) el._classes.add(token);
+        else el._classes.delete(token);
+        syncClasses(el);
+        return want;
+      },
+      contains: (token) => el._classes.has(token),
+      get value() {
+        return el._attrs.get("class") ?? "";
+      }
+    };
+    classLists.set(el, cl);
+  }
+  return cl;
+}
+function styleProxyFor(el) {
+  let style = styles.get(el);
+  if (style === void 0) {
+    style = new Proxy(el._styleProps, {
+      get: (t, prop) => {
+        if (prop === "setProperty") {
+          return (k, v, priority) => {
+            const key = k.startsWith("--") ? k : camelize(k);
+            el._writeStyle(key, priority === "important" && v !== "" ? `${v} !important` : v);
+          };
+        }
+        if (prop === "removeProperty")
+          return (k) => el._writeStyle(k.startsWith("--") ? k : camelize(k), "");
+        if (prop === "getPropertyValue")
+          return (k) => {
+            const key = k.startsWith("--") ? k : camelize(k);
+            return String(t[key] ?? "").replace(/\s*!important$/, "");
+          };
+        if (prop === "cssText") {
+          return Object.entries(t).filter(([, v]) => v !== "").map(([k, v]) => `${hyphenate(k)}: ${v};`).join(" ");
+        }
+        if (typeof prop === "string") return t[prop] ?? "";
+        return void 0;
+      },
+      set: (_t, prop, v) => {
+        if (prop === "cssText") el._replaceStyleText(String(v));
+        else if (typeof prop === "string") el._writeStyle(prop, String(v));
+        return true;
+      },
+      deleteProperty: (_t, prop) => {
+        if (typeof prop === "string") el._writeStyle(prop, "");
+        return true;
+      },
+      has: (t, prop) => prop in t,
+      ownKeys: (t) => Reflect.ownKeys(t),
+      getOwnPropertyDescriptor: (t, prop) => typeof prop === "string" && prop in t ? { configurable: true, enumerable: true, value: t[prop] } : void 0
+    });
+    styles.set(el, style);
+  }
+  return style;
+}
+function datasetProxyFor(el) {
+  let ds = datasets.get(el);
+  if (ds === void 0) {
+    ds = new Proxy({}, {
+      get: (_t, prop) => {
+        if (typeof prop !== "string") return void 0;
+        return el.getAttribute(`data-${hyphenate(prop)}`) ?? void 0;
+      },
+      set: (_t, prop, v) => {
+        if (typeof prop === "string") el.setAttribute(`data-${hyphenate(prop)}`, v);
+        return true;
+      },
+      deleteProperty: (_t, prop) => {
+        if (typeof prop === "string") el.removeAttribute(`data-${hyphenate(prop)}`);
+        return true;
+      },
+      has: (_t, prop) => typeof prop === "string" && el._attrs.has(`data-${hyphenate(prop)}`),
+      ownKeys: () => [...el._attrs.keys()].filter((k) => k.startsWith("data-")).map((k) => camelize(k.slice(5))),
+      getOwnPropertyDescriptor: (_t, prop) => {
+        if (typeof prop !== "string") return void 0;
+        const v = el.getAttribute(`data-${hyphenate(prop)}`);
+        return v === null ? void 0 : { configurable: true, enumerable: true, value: v };
+      }
+    });
+    datasets.set(el, ds);
+  }
+  return ds;
+}
+
+// src/worker/dom/element.ts
+var templateContents = /* @__PURE__ */ new WeakMap();
+var ProxyElement = class _ProxyElement extends ProxyNode {
+  _attrs = /* @__PURE__ */ new Map();
+  _classes = /* @__PURE__ */ new Set();
+  _styleProps = {};
+  _listeners = [];
+  get nodeType() {
+    return 1;
+  }
+  get tagName() {
+    return this.instance.type.toUpperCase();
+  }
+  /** The element's namespace URI — HTML for ordinary elements, the `create`
+   *  op's `ns` for namespaced (svg/mathml) ones. */
+  get namespaceURI() {
+    return this.instance.ns ?? "http://www.w3.org/1999/xhtml";
+  }
+  /** Element children only — the shadow tree's HTMLCollection equivalent. */
+  get children() {
+    return this._children.filter((c) => c instanceof _ProxyElement);
+  }
+  get id() {
+    return this._attrs.get("id") ?? "";
+  }
+  set id(v) {
+    this._setAttr("id", v);
+  }
+  get className() {
+    return this._attrs.get("class") ?? "";
+  }
+  set className(v) {
+    this._setAttr("class", v);
+  }
+  getAttribute(name) {
+    return this._attrs.get(name) ?? null;
+  }
+  hasAttribute(name) {
+    return this._attrs.has(name);
+  }
+  setAttribute(name, value) {
+    this._setAttr(name, value);
+  }
+  removeAttribute(name) {
+    this.doc._assertAlive();
+    if (!this._attrs.has(name)) return;
+    this._attrs.delete(name);
+    this._afterAttrChange(name);
+    this._op({ t: "attr", id: this.instance.id, name, value: null });
+  }
+  /* Namespaced attribute surface — the wire `attr` op has no namespace
+   *  field, so the qualified name ('xlink:href') is the whole shadow key
+   *  and the driver's setAttribute covers prefixed names. Limitation: two
+   *  same-local-name attributes in different namespaces can't be told
+   *  apart. get/remove follow the DOM convention of receiving the LOCAL
+   *  name — resolve it to the stored qualified key (or accept a qualified
+   *  name directly, since some callers pass both ways). */
+  setAttributeNS(_ns, qualifiedName, value) {
+    this.setAttribute(qualifiedName, value);
+  }
+  getAttributeNS(_ns, name) {
+    const direct = this.getAttribute(name);
+    if (direct !== null) return direct;
+    for (const key of this._attrs.keys()) {
+      if (key.endsWith(`:${name}`)) return this.getAttribute(key);
+    }
+    return null;
+  }
+  removeAttributeNS(_ns, name) {
+    if (this.getAttribute(name) !== null) {
+      this.removeAttribute(name);
+      return;
+    }
+    for (const key of [...this._attrs.keys()]) {
+      if (key.endsWith(`:${name}`)) this.removeAttribute(key);
+    }
+  }
+  /* classList — a live view over _classes synced to the `class` attr. */
+  get classList() {
+    return classListFor(this);
+  }
+  /**
+   * Inline style — a Proxy over a plain prop record. Writes re-send only
+   * the changed key; `delete style.x`/`style.removeProperty('x')` send ''
+   * (the protocol's "clear this key"). `setProperty`/`getPropertyValue`
+   * accept kebab-case and camelize it, like the real CSSStyleDeclaration.
+   */
+  get style() {
+    return styleProxyFor(this);
+  }
+  /**
+   * dataset — a Proxy mapping camelCase keys to `data-*` attribute ops.
+   * `swatch.dataset.color = c` emits attr {name:'data-color', value:c};
+   * `delete el.dataset.x` emits the removal form.
+   */
+  get dataset() {
+    return datasetProxyFor(this);
+  }
+  /**
+   * Focus/blur — NO-OPS. Real focus can't be delivered over async postMessage
+   * (the driver's dispatch fires after the event; there is no focus op).
+   * They exist because gesture libraries call `el.focus()` unconditionally
+   * during mousedown paths (Leaflet's Keyboard handler does).
+   */
+  focus() {
+  }
+  blur() {
+  }
+  /* Events — registers a worker handler-table entry and emits listen.
+   * The driver's listenerFor dispatches EventPayloads back into the worker;
+   * the payload is enriched with a synthesized `target`/`composedPath` and
+   * the handler runs with `this` = this element, like the real DOM's
+   * currentTarget. `{once, passive, capture}` ride the op's `opts` field;
+   * `once` additionally auto-detaches worker-side after the first dispatch
+   * (matching the real listener's own auto-removal driver-side). */
+  addEventListener(type, fn, options) {
+    this.doc._assertAlive();
+    const opts = normalizeListenerOptions(options);
+    if (this._listeners.some((l) => l.type === type && l.fn === fn && l.capture === opts.capture)) {
+      return;
+    }
+    const hid = registerHandler(
+      (p) => {
+        try {
+          fn.call(this, this.doc._enrichEvent(p, this));
+        } finally {
+          if (opts.once) this.removeEventListener(type, fn, { capture: opts.capture });
+        }
+      },
+      this.instance.instance,
+      this.instance.id
+    );
+    this._listeners.push({ type, fn, hid, capture: opts.capture });
+    this.doc._handlerIds.add(hid);
+    this._op({
+      t: "listen",
+      id: this.instance.id,
+      type,
+      handler: hid,
+      opts: listenerOptsForWire(options)
+    });
+  }
+  removeEventListener(type, fn, options) {
+    this.doc._assertAlive();
+    const capture = normalizeListenerOptions(options).capture;
+    const index = this._listeners.findIndex(
+      (l) => l.type === type && l.fn === fn && l.capture === capture
+    );
+    if (index === -1) return;
+    const [entry] = this._listeners.splice(index, 1);
+    unregisterHandler(entry.hid);
+    this.doc._handlerIds.delete(entry.hid);
+    this._op({
+      t: "unlisten",
+      id: this.instance.id,
+      type,
+      handler: entry.hid,
+      opts: entry.capture ? { capture: true } : void 0
+    });
+  }
+  /** Live-descendant search over the shadow tree. Nodes mounted by the
+   *  reconciler aren't reachable (the op stream doesn't mirror React's
+   *  structure into _children) — adopted subtrees match only their own
+   *  proxy-built descendants. Class matching reads _classes AND the
+   *  instance's serialized className prop, so adopted React elements with
+   *  className set still match. */
+  getElementsByClassName(name) {
+    this.doc._assertAlive();
+    const out = [];
+    const visit = (el) => {
+      for (const child of el._children) {
+        if (!(child instanceof _ProxyElement)) continue;
+        const viaProps = (child.instance.props?.className ?? "").split(/\s+/).includes(name);
+        if (child._classes.has(name) || viaProps) out.push(child);
+        visit(child);
+      }
+    };
+    visit(this);
+    return out;
+  }
+  getElementsByTagName(tag) {
+    this.doc._assertAlive();
+    const want = tag.toLowerCase();
+    const out = [];
+    const visit = (el) => {
+      for (const child of el._children) {
+        if (!(child instanceof _ProxyElement)) continue;
+        if (want === "*" || child.instance.type.toLowerCase() === want) out.push(child);
+        visit(child);
+      }
+    };
+    visit(this);
+    return out;
+  }
+  /* SVG measurement APIs — no layout/text engine exists worker-side, so
+   *  these report honest zeros (warned once), exactly like the rest of the
+   *  geometry surface. Libraries doing animation sizing (recharts'
+   *  getTotalLength paths) degrade to instant/no animation. */
+  getBBox() {
+    this.doc._assertAlive();
+    this.doc._warn("getBBox");
+    return { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0 };
+  }
+  getTotalLength() {
+    this.doc._assertAlive();
+    this.doc._warn("getTotalLength");
+    return 0;
+  }
+  getComputedTextLength() {
+    this.doc._assertAlive();
+    this.doc._warn("getComputedTextLength");
+    return 0;
+  }
+  /* Selector matching — compound selectors only (see parseSelector). */
+  matches(selector) {
+    return matchesChain(this, parseSelector(selector));
+  }
+  /** Nearest element (self inclusive) matching the selector — walks the
+   *  shadow tree upward through ancestors. */
+  closest(selector) {
+    const chain = parseSelector(selector);
+    let n = this;
+    while (n !== null) {
+      if (n instanceof _ProxyElement && matchesChain(n, chain)) return n;
+      n = n._parent;
+    }
+    return null;
+  }
+  /** Scoped local-tree query — descendants only, same engine and the same
+   *  supported-selector subset as document.querySelectorAll. */
+  querySelector(selector) {
+    return this.querySelectorAll(selector)[0] ?? null;
+  }
+  querySelectorAll(selector) {
+    const chain = parseSelector(selector);
+    const out = [];
+    const walk = (node) => {
+      for (const child of node._children) {
+        if (child instanceof _ProxyElement && matchesChain(child, chain)) out.push(child);
+        walk(child);
+      }
+    };
+    walk(this);
+    return out;
+  }
+  /* ── innerHTML + friends: real HTML parsing worker-side ──────────────── */
+  /** Serialized shadow-tree children — the only innerHTML there CAN be over
+   *  an async op channel (it reflects writes made through this facade, not
+   *  the real DOM's current markup). */
+  get innerHTML() {
+    return this._children.map((child) => serializeNode(child)).join("");
+  }
+  get outerHTML() {
+    return serializeNode(this);
+  }
+  /**
+   * Parse `html` worker-side (htmlparser2 — pure JS, worker-safe) and
+   * rebuild this element's children as proxy nodes: each parsed element is
+   * createElement + setAttribute + recursive children, each text run a
+   * createTextNode — all emitting ordinary create/attr/append ops. Existing
+   * children are removed first (one remove op each). Comments and
+   * directives are skipped.
+   */
+  set innerHTML(html) {
+    this.doc._assertAlive();
+    for (const child of this._children.slice()) this.removeChild(child);
+    for (const node of parseChildren(this.doc, html)) this.appendChild(node);
+  }
+  /**
+   * Parse `html` and insert the resulting nodes relative to this element —
+   * 'beforebegin'/'afterend' require a parent and no-op without one (like
+   * the DOM on detached elements).
+   */
+  insertAdjacentHTML(position, html) {
+    this.doc._assertAlive();
+    this._insertAt(position, parseChildren(this.doc, html));
+  }
+  /** insertAdjacentElement — returns the inserted element like the DOM. */
+  insertAdjacentElement(position, el) {
+    this.doc._assertAlive();
+    if (!(el instanceof _ProxyElement)) return null;
+    this._insertAt(position, [el]);
+    return el;
+  }
+  _insertAt(position, nodes) {
+    switch (position) {
+      case "beforebegin": {
+        if (this._parent === null) return;
+        for (const n of nodes) this._parent.insertBefore(n, this);
+        return;
+      }
+      case "afterbegin": {
+        const ref = this.firstChild;
+        for (const n of nodes) this.insertBefore(n, ref);
+        return;
+      }
+      case "beforeend": {
+        for (const n of nodes) this.appendChild(n);
+        return;
+      }
+      case "afterend": {
+        if (this._parent === null) return;
+        const ref = this.nextSibling;
+        for (const n of nodes) this._parent.insertBefore(n, ref);
+        return;
+      }
+      default:
+        throw new Error(`proxyDom.insertAdjacent*: unknown position "${String(position)}"`);
+    }
+  }
+  /**
+   * `<template>.content` — a fragment VIEW sharing the element's shadow
+   * child array (same backing store) AND the element's instance id, so
+   * `content.appendChild` emits `append` ops targeted at the template. The
+   * driver routes template-parented ops into `el.content` — the DOM spec's
+   * home for template children anyway. Non-template elements read
+   * undefined.
+   */
+  get content() {
+    if (this.instance.type !== "template") return void 0;
+    let frag = templateContents.get(this);
+    if (frag === void 0) {
+      frag = this.doc.createDocumentFragment();
+      frag._children = this._children;
+      frag.instance = this.instance;
+      templateContents.set(this, frag);
+    }
+    return frag;
+  }
+  /**
+   * Clone as new ops — the copy gets its own instance id (it's a real new
+   * element on the main thread, not a shared record). Attributes, the
+   * namespace and the style-proxy properties are copied; listeners are NOT
+   * (matches the DOM). `deep` clones children polymorphically — comment
+   * children keep nodeType 8, texts and nested elements/fragments their
+   * own kind.
+   */
+  cloneNode(deep) {
+    this.doc._assertAlive();
+    const copy = this.instance.ns === void 0 ? this.doc.createElement(this.instance.type) : this.doc.createElementNS(this.instance.ns, this.instance.type);
+    for (const [name, value] of this._attrs) copy.setAttribute(name, value);
+    for (const [k, v] of Object.entries(this._styleProps)) copy._writeStyle(k, v);
+    if (deep === true) {
+      for (const child of this._children) copy.appendChild(child.cloneNode(true));
+    }
+    return copy;
+  }
+  /* ── Geometry. Two pushed channels: the island container's setSize box
+   *  (root + markContainer()ed elements) and per-element setRects boxes for
+   *  elements the worker asked the driver to measure — via doc.observeSize,
+   *  a ResizeObserver shim, or lazily by any of the reads below. Until the
+   *  first push lands a read keeps the honest 0 and warns once per doc per
+   *  API; a marked element keeps reporting the CONTAINER's box — "marked"
+   *  still means "pretend my box is the container's" and is only honest
+   *  for elements that genuinely fill it. ── */
+  getBoundingClientRect() {
+    const rect = this.doc._rectFor(this);
+    if (rect === void 0) {
+      this.doc._requestMeasure(this);
+      this.doc._warn("getBoundingClientRect");
+      return {
+        x: 0,
+        y: 0,
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        width: 0,
+        height: 0,
+        toJSON: () => ({})
+      };
+    }
+    return {
+      x: rect.x,
+      y: rect.y,
+      top: rect.y,
+      left: rect.x,
+      right: rect.x + rect.w,
+      bottom: rect.y + rect.h,
+      width: rect.w,
+      height: rect.h,
+      toJSON: () => ({})
+    };
+  }
+  get clientWidth() {
+    return this._geom("clientWidth", (r) => r.w);
+  }
+  get clientHeight() {
+    return this._geom("clientHeight", (r) => r.h);
+  }
+  get offsetWidth() {
+    return this._geom("offsetWidth", (r) => r.w);
+  }
+  get offsetHeight() {
+    return this._geom("offsetHeight", (r) => r.h);
+  }
+  /** Border edge widths — honestly 0 (the pushed box doesn't measure borders). */
+  get clientLeft() {
+    return 0;
+  }
+  get clientTop() {
+    return 0;
+  }
+  /** Position within offsetParent — not measured; 0 is honest for root-level boxes. */
+  get offsetLeft() {
+    return 0;
+  }
+  get offsetTop() {
+    return 0;
+  }
+  get offsetParent() {
+    return null;
+  }
+  get scrollTop() {
+    this.doc._scrollWarn("scrollTop");
+    return 0;
+  }
+  set scrollTop(_v) {
+    this.doc._scrollWarn("scrollTop");
+  }
+  get scrollLeft() {
+    this.doc._scrollWarn("scrollLeft");
+    return 0;
+  }
+  set scrollLeft(_v) {
+    this.doc._scrollWarn("scrollLeft");
+  }
+  get scrollHeight() {
+    this.doc._scrollWarn("scrollHeight");
+    return 0;
+  }
+  get scrollWidth() {
+    this.doc._scrollWarn("scrollWidth");
+    return 0;
+  }
+  /**
+   * Reflected properties. Library code assigns `img.src = url`,
+   * `el.tabIndex = 0`, `link.href = '#'` — on a bare class instance those
+   * become silent expandos and nothing crosses the wire. The attribute-backed
+   * accessors below (defined for the properties real libraries poke) make
+   * those assignments emit ordinary `attr` ops. Everything else still falls
+   * through to a plain own-property — which is also exactly what library
+   * expandos like `_leaflet_pos` need, so proxy elements are deliberately
+   * NOT frozen/sealed.
+   */
+  get src() {
+    return this._attrs.get("src") ?? "";
+  }
+  set src(v) {
+    this._setAttr("src", v);
+  }
+  get srcset() {
+    return this._attrs.get("srcset") ?? "";
+  }
+  set srcset(v) {
+    this._setAttr("srcset", v);
+  }
+  get href() {
+    return this._attrs.get("href") ?? "";
+  }
+  set href(v) {
+    this._setAttr("href", v);
+  }
+  get alt() {
+    return this._attrs.get("alt") ?? "";
+  }
+  set alt(v) {
+    this._setAttr("alt", v);
+  }
+  get title() {
+    return this._attrs.get("title") ?? "";
+  }
+  set title(v) {
+    this._setAttr("title", v);
+  }
+  get tabIndex() {
+    return Number(this._attrs.get("tabindex") ?? -1);
+  }
+  set tabIndex(v) {
+    this._setAttr("tabindex", String(v));
+  }
+  get draggable() {
+    return this._attrs.get("draggable") === "true";
+  }
+  set draggable(v) {
+    this._setAttr("draggable", String(v));
+  }
+  get crossOrigin() {
+    return this._attrs.get("crossorigin") ?? null;
+  }
+  set crossOrigin(v) {
+    if (v === null) this.removeAttribute("crossorigin");
+    else this._setAttr("crossorigin", v);
+  }
+  get width() {
+    return Number(this._attrs.get("width") ?? 0);
+  }
+  set width(v) {
+    this._setAttr("width", String(v));
+  }
+  get height() {
+    return Number(this._attrs.get("height") ?? 0);
+  }
+  set height(v) {
+    this._setAttr("height", String(v));
+  }
+  get type() {
+    return this._attrs.get("type") ?? "";
+  }
+  set type(v) {
+    this._setAttr("type", v);
+  }
+  get loading() {
+    return this._attrs.get("loading") ?? "";
+  }
+  set loading(v) {
+    this._setAttr("loading", v);
+  }
+  get decoding() {
+    return this._attrs.get("decoding") ?? "";
+  }
+  set decoding(v) {
+    this._setAttr("decoding", v);
+  }
+  get value() {
+    return this._attrs.get("value") ?? "";
+  }
+  set value(v) {
+    this._setAttr("value", v);
+  }
+  get checked() {
+    return this._attrs.has("checked");
+  }
+  set checked(v) {
+    if (v) this._setAttr("checked", "");
+    else this.removeAttribute("checked");
+  }
+  get disabled() {
+    return this._attrs.has("disabled");
+  }
+  set disabled(v) {
+    if (v) this._setAttr("disabled", "");
+    else this.removeAttribute("disabled");
+  }
+  /* internals */
+  /** Geometry read shared by the size getters above. */
+  _geom(feature, pick) {
+    const rect = this.doc._rectFor(this);
+    if (rect === void 0) {
+      this.doc._requestMeasure(this);
+      this.doc._warn(feature);
+      return 0;
+    }
+    return pick(rect);
+  }
+  _writeStyle(key, value) {
+    this.doc._assertAlive();
+    if (this._styleProps[key] === value) return;
+    this._styleProps[key] = value;
+    this._op({ t: "style", id: this.instance.id, props: { [key]: value } });
+  }
+  /** style.cssText — a FULL replace, not another key. Parse the declarations
+   *  and write each through the dedup path; keys absent from the new text
+   *  clear. Storing the text under a 'cssText' key left stale per-key values
+   *  that deduped real writes away (a hide's `visibility:hidden` stuck after
+   *  a show's cssText replay). */
+  _replaceStyleText(cssText) {
+    const next = /* @__PURE__ */ new Map();
+    for (const decl of cssText.split(";")) {
+      const sep = decl.indexOf(":");
+      if (sep <= 0) continue;
+      const raw = decl.slice(0, sep).trim();
+      const value = decl.slice(sep + 1).trim();
+      if (raw === "" || value === "") continue;
+      next.set(raw.startsWith("--") ? raw : camelize(raw), value);
+    }
+    for (const key of Object.keys(this._styleProps)) {
+      if (!next.has(key)) this._writeStyle(key, "");
+    }
+    for (const [key, value] of next) this._writeStyle(key, value);
+  }
+  _setAttr(name, value) {
+    this.doc._assertAlive();
+    const v = String(value);
+    if (this._attrs.get(name) === v) return;
+    this._attrs.set(name, v);
+    this._afterAttrChange(name);
+    this._op({ t: "attr", id: this.instance.id, name, value: v });
+  }
+  _afterAttrChange(name) {
+    if (name === "class") {
+      this._classes = new Set((this._attrs.get("class") ?? "").split(/\s+/).filter(Boolean));
+    } else if (name === "id") {
+      this.doc._trackId(this);
+    }
+  }
+};
+
+// src/worker/dom/document.ts
+var InternalDocument = class {
+  instance;
+  _root;
+  _wrappers = /* @__PURE__ */ new Map();
+  _ids = /* @__PURE__ */ new Map();
+  /** handler ids this document registered — disposed on rebuild. */
+  _handlerIds = /* @__PURE__ */ new Set();
+  /**
+   * instance ids geometry reads answer for — id 0 (the root) plus every
+   * markContainer()ed element. The pushed box is the ISLAND CONTAINER's,
+   * so a marked element claims "my box is the container's box".
+   */
+  _containerIds = /* @__PURE__ */ new Set([0]);
+  /** Handlers fired when a setSize task pushes a new container size. */
+  _resizeHandlers = /* @__PURE__ */ new Set();
+  /** element id → observeSize callbacks, fired on each setRects push. */
+  _sizeObservers = /* @__PURE__ */ new Map();
+  /** ids a `measure` op was already emitted for — dedupes observeSize and
+   *  the lazy auto-request a bare geometry read performs. */
+  _measureRequested = /* @__PURE__ */ new Set();
+  /** The window facade bundle — built lazily by windowFacadeFor, shared by
+   *  installDomShim and the instance dispatcher. */
+  _windowBundle;
+  /** what `document.defaultView` reads as (`window.getComputedStyle` etc). */
+  get defaultView() {
+    return this._windowBundle?.facade;
+  }
+  /** Document-level listeners — separate table from the root element's, so
+   *  doc.addEventListener and body.addEventListener don't wrongly dedupe
+   *  against each other. Both emit `listen` on id 0. */
+  _docListeners = [];
+  _warned = /* @__PURE__ */ new Set();
+  _disposed = false;
+  /** Set by installDomShim — restore globals when this document dies. */
+  _uninstallShim = null;
+  constructor(instance) {
+    this.instance = instance;
+    this._root = new ProxyElement(this, {
+      kind: "element",
+      id: 0,
+      type: "#root",
+      instance,
+      props: {},
+      listenerSlots: {}
+    });
+    this._wrappers.set(0, this._root);
+  }
+  get body() {
+    return this._root;
+  }
+  get documentElement() {
+    return this._root;
+  }
+  /** No hit-testing exists worker-side — honest null (a11y-layer probing). */
+  elementFromPoint(_x, _y) {
+    this._assertAlive();
+    this._warn("elementFromPoint");
+    return null;
+  }
+  _assertAlive() {
+    if (this._disposed) {
+      throw new Error(
+        "proxyDom: this document was disposed by an updateProps/remount rebuild \u2014 its nodes are detached"
+      );
+    }
+  }
+  _warn(feature, message) {
+    if (this._warned.has(feature)) return;
+    this._warned.add(feature);
+    console.warn(
+      message ?? `[proxyDom] '${feature}' has no synchronous answer \u2014 a measure request was emitted and reads return real geometry once the driver pushes it; subscribe via doc.observeSize or a ResizeObserver for updates.`
+    );
+  }
+  /** Scroll-geometry warn — the measure channel delivers border boxes, not
+   *  scroll offsets/overflow extents, so scroll* reads stay honest 0. */
+  _scrollWarn(feature) {
+    this._warn(
+      feature,
+      `[proxyDom] '${feature}' has no channel \u2014 the worker sees border-box geometry only (setSize/measure pushes); scroll offsets and overflow extents read 0.`
+    );
+  }
+  markContainer(el) {
+    this._assertAlive();
+    this._containerIds.add(el.instance.id);
+  }
+  /**
+   * Emit `measure` for `el` exactly once — shared by observeSize (explicit
+   * subscription) and by geometry reads on unmarked connected elements (the
+   * lazy path: a library reading clientWidth gets the honest 0 for now, and
+   * REAL geometry on subsequent reads once the driver's push lands).
+   * Disconnected/phantom nodes have no driver-side element to measure;
+   * requesting is skipped until the read happens while connected.
+   */
+  _requestMeasure(el) {
+    if (!el.isConnected) return;
+    const id = el.instance.id;
+    if (this._measureRequested.has(id)) return;
+    this._measureRequested.add(id);
+    el._op({ t: "measure", id });
+  }
+  observeSize(el, cb) {
+    this._assertAlive();
+    const id = el.instance.id;
+    let set = this._sizeObservers.get(id);
+    if (set === void 0) this._sizeObservers.set(id, set = /* @__PURE__ */ new Set());
+    set.add(cb);
+    if (!this._measureRequested.has(id)) {
+      this._measureRequested.add(id);
+      el._op({ t: "measure", id });
+    }
+    return () => {
+      const observers = this._sizeObservers.get(id);
+      if (observers === void 0) return;
+      observers.delete(cb);
+      if (observers.size === 0) {
+        this._sizeObservers.delete(id);
+        this._measureRequested.delete(id);
+        el._op({ t: "unmeasure", id });
+      }
+    };
+  }
+  /**
+   * Store pushed rects and fire per-element observers — the `setRects`
+   * task calls this inside the instance's scope, so observer mutations
+   * emit ops and ride back in the task's return batch.
+   */
+  _notifyRects(rects) {
+    for (const rect of rects) {
+      setInstanceRect(this.instance, rect);
+      const observers = this._sizeObservers.get(rect.id);
+      if (observers !== void 0) for (const cb of [...observers]) cb(rect);
+    }
+  }
+  /**
+   * The rect a geometry read on `el` may report: the element's own measured
+   * box when a setRects push arrived for it, else the pushed CONTAINER box
+   * when `el` is the root or was markContainer()ed (the old contract — a
+   * marked element claims "my box is the container's"), undefined otherwise
+   * (also undefined when nothing has been pushed yet — reads return 0).
+   */
+  _rectFor(el) {
+    const measured = getInstanceRect(this.instance, el.instance.id);
+    if (measured !== void 0) return measured;
+    if (!this._containerIds.has(el.instance.id)) return void 0;
+    const size = getInstanceSize(this.instance);
+    return size === void 0 ? void 0 : { x: 0, y: 0, ...size };
+  }
+  onResize(cb) {
+    this._assertAlive();
+    this._resizeHandlers.add(cb);
+  }
+  /**
+   * Fire the doc's resize handlers — the worker's `setSize` task calls this
+   * inside the instance's scope, so handler mutations emit ops on the instance
+   * queue and come back in the task's return batch.
+   */
+  _notifySize(w, h) {
+    for (const cb of [...this._resizeHandlers]) cb(w, h);
+  }
+  /** Keep the getElementById map pointing at each element's CURRENT id. */
+  _trackId(el) {
+    for (const [k, v] of this._ids) if (v === el) this._ids.delete(k);
+    const id = el._attrs.get("id");
+    if (id !== void 0 && id !== "") this._ids.set(id, el);
+  }
+  /** The synthetic text child an element's `textContent` setter leaves in
+   *  the shadow tree — no driver-side node, so its writes retarget parent. */
+  _phantomText(parent, text) {
+    const t = new ProxyText(this, {
+      kind: "text",
+      id: allocPhantomId(),
+      text,
+      instance: parent.instance.instance
+    });
+    t._parent = parent;
+    return t;
+  }
+  /**
+   * Enrich a dispatched payload before handing it to a proxy listener:
+   *  - `target` = the proxy node for targetId, looked up in the shared
+   *    instance space and wrapped in THIS document's wrapper map (so
+   *    `e.target.closest`/`.dataset`/`.contains` behave like the real DOM
+   *    for proxy-created nodes).
+   *  - `currentTarget` = `self` — the node/document/facade the listener was
+   *    attached to (the handler is also invoked with `this` = self). For
+   *    document/window listeners this is the document/facade OBJECT, not
+   *    the id-0 root element dispatch() would otherwise stamp.
+   *  - `composedPath()` = synthesized from the enriched target's parent
+   *    chain, with `self` appended when the chain doesn't already reach it
+   *    (delegated handlers iterate the path until they hit their own
+   *    element — Svelte's handle_event_propagation terminates there).
+   *  - `preventDefault`/`stopPropagation`/`stopImmediatePropagation` =
+   *    synthesized NO-OPS. They cannot cancel anything — the real event
+   *    already dispatched on the main thread before this payload crossed
+   *    postMessage — but library code written against real DOM events calls
+   *    them unconditionally, so the wrapper supplies them.
+   */
+  _enrichEvent(payload, self) {
+    const out = {
+      ...payload,
+      preventDefault: () => {
+      },
+      stopPropagation: () => {
+      },
+      stopImmediatePropagation: () => {
+      }
+    };
+    if (self !== void 0) out.currentTarget = self;
+    const id = payload.targetId;
+    if (typeof id === "number") {
+      const instance = lookupInstance(id);
+      if (instance !== void 0) {
+        const node = this._wrap(instance);
+        if (node instanceof ProxyElement) {
+          if (payload.value !== void 0) node._attrs.set("value", String(payload.value));
+          if (payload.checked !== void 0) {
+            if (payload.checked) node._attrs.set("checked", "");
+            else node._attrs.delete("checked");
+          }
+        }
+        out.target = node;
+      }
+    }
+    if (typeof payload.relatedTargetId === "number") {
+      const related = lookupInstance(payload.relatedTargetId);
+      if (related !== void 0) out.relatedTarget = this._wrap(related);
+    }
+    if (out.composedPath === void 0) {
+      const path = [];
+      let n = out.target;
+      while (n instanceof ProxyNode) {
+        path.push(n);
+        n = n._parent ?? void 0;
+      }
+      if (self !== void 0 && !path.includes(self)) path.push(self);
+      out.composedPath = () => path;
+    }
+    return out;
+  }
+  createElement(tag) {
+    return this._newElement(tag.toLowerCase(), void 0);
+  }
+  createElementNS(ns, tag) {
+    return this._newElement(tag, ns);
+  }
+  _newElement(type, ns) {
+    this._assertAlive();
+    const instance = {
+      kind: "element",
+      id: allocId(),
+      type,
+      ns,
+      instance: this.instance,
+      props: {},
+      listenerSlots: {}
+    };
+    instances.set(instance.id, instance);
+    pushOp(this.instance, { t: "create", id: instance.id, type: instance.type, props: {}, ns: instance.ns });
+    if (getActiveInstance() !== this.instance) bumpOpsVersion();
+    return this._wrap(instance);
+  }
+  createTextNode(text) {
+    this._assertAlive();
+    const instance = {
+      kind: "text",
+      id: allocId(),
+      text: String(text),
+      instance: this.instance
+    };
+    instances.set(instance.id, instance);
+    pushOp(this.instance, { t: "text", id: instance.id, text: instance.text });
+    if (getActiveInstance() !== this.instance) bumpOpsVersion();
+    return this._wrap(instance);
+  }
+  adopt(instance) {
+    this._assertAlive();
+    return this._wrap(instance);
+  }
+  createDocumentFragment() {
+    this._assertAlive();
+    return new ProxyFragment(this, {
+      kind: "element",
+      id: allocPhantomId(),
+      type: "#fragment",
+      instance: this.instance,
+      props: {},
+      listenerSlots: {}
+    });
+  }
+  /**
+   * A comment — nodeType 8 over a real EMPTY text instance. The wire has no
+   * comment op: the `text` op with '' gives it a driver-side node that can
+   * anchor `before:` positions, while `data` stays shadow-only (emitting it
+   * would render comment text on the page).
+   */
+  createComment(data = "") {
+    const backing = this.createTextNode("");
+    const comment = new ProxyComment(this, backing.instance);
+    comment.instance.text = String(data);
+    this._wrappers.set(backing.instance.id, comment);
+    return comment;
+  }
+  /**
+   * DOM `importNode` — a clone through this document. Foreign (non-proxy)
+   * nodes have no shadow shape to copy; they're rejected like any other
+   * foreign child.
+   */
+  importNode(node, deep = false) {
+    this._assertAlive();
+    if (!(node instanceof ProxyNode)) rejectForeignChild(node);
+    return node.cloneNode(deep);
+  }
+  /**
+   * 'about:blank' — no real document URL exists worker-side. A plain field
+   * (not a getter) so adapters may assign it like a normal document prop.
+   */
+  baseURI = "about:blank";
+  /** Wrap (or return the existing wrapper for) a shared instance record. */
+  _wrap(instance) {
+    let node = this._wrappers.get(instance.id);
+    if (node === void 0) {
+      node = instance.kind === "text" ? new ProxyText(this, instance) : new ProxyElement(this, instance);
+      this._wrappers.set(instance.id, node);
+    }
+    return node;
+  }
+  /**
+   * Document-level listener — same currency as element addEventListener but
+   * targeting id 0 (the island's container element). The driver's listen op
+   * attaches a real DOM listener on the container, so events bubbling up
+   * from any island child dispatch back here. Used by library code doing
+   * delegated `document.addEventListener(...)`.
+   */
+  addEventListener(type, fn, options) {
+    this._assertAlive();
+    const opts = normalizeListenerOptions(options);
+    if (this._docListeners.some(
+      (l) => l.type === type && l.fn === fn && l.capture === opts.capture
+    )) {
+      return;
+    }
+    const hid = registerHandler(
+      (p) => {
+        try {
+          fn.call(this, this._enrichEvent(p, this));
+        } finally {
+          if (opts.once) this.removeEventListener(type, fn, { capture: opts.capture });
+        }
+      },
+      this.instance,
+      0
+      // document-level listener → target id 0 is the island root
+    );
+    this._docListeners.push({ type, fn, hid, capture: opts.capture });
+    this._handlerIds.add(hid);
+    pushOp(this.instance, { t: "listen", id: 0, type, handler: hid, opts: listenerOptsForWire(options) });
+    if (getActiveInstance() !== this.instance) bumpOpsVersion();
+  }
+  removeEventListener(type, fn, options) {
+    this._assertAlive();
+    const capture = normalizeListenerOptions(options).capture;
+    const index = this._docListeners.findIndex(
+      (l) => l.type === type && l.fn === fn && l.capture === capture
+    );
+    if (index === -1) return;
+    const [entry] = this._docListeners.splice(index, 1);
+    unregisterHandler(entry.hid);
+    this._handlerIds.delete(entry.hid);
+    pushOp(this.instance, {
+      t: "unlisten",
+      id: 0,
+      type,
+      handler: entry.hid,
+      opts: entry.capture ? { capture: true } : void 0
+    });
+    if (getActiveInstance() !== this.instance) bumpOpsVersion();
+  }
+  getElementById(id) {
+    const el = this._ids.get(id);
+    return el !== void 0 && el.isConnected ? el : null;
+  }
+  querySelector(selector) {
+    return this.querySelectorAll(selector)[0] ?? null;
+  }
+  querySelectorAll(selector) {
+    let chain = parseSelector(selector);
+    const first = chain[0];
+    if ((first.tag === "body" || first.tag === "html") && first.id === void 0 && first.classes.length === 0 && first.attrs.length === 0) {
+      chain = chain.slice(1);
+    }
+    if (chain.length === 0) return [this._root];
+    const out = [];
+    const walk = (node) => {
+      for (const child of node._children) {
+        if (child instanceof ProxyElement && matchesChain(child, chain)) out.push(child);
+        walk(child);
+      }
+    };
+    walk(this._root);
+    return out;
+  }
+  getComputedStyle(el) {
+    const rect = this._rectFor(el);
+    const w = rect === void 0 ? "" : `${rect.w}px`;
+    const h = rect === void 0 ? "" : `${rect.h}px`;
+    if (rect === void 0) {
+      this._requestMeasure(el);
+      this._warn("getComputedStyle");
+    }
+    return new Proxy({ width: w, height: h }, {
+      get: (t, prop) => prop === "getPropertyValue" ? (k) => k === "width" ? w : k === "height" ? h : "" : t[prop] ?? ""
+    });
+  }
+  dispose() {
+    this._uninstallShim?.();
+    this._uninstallShim = null;
+    this._disposed = true;
+    if (instanceDocs.get(this.instance) === this) instanceDocs.delete(this.instance);
+    this._resizeHandlers.clear();
+    this._sizeObservers.clear();
+    this._measureRequested.clear();
+    for (const hid of this._handlerIds) unregisterHandler(hid);
+    this._handlerIds.clear();
+  }
+};
+var instanceDocs = /* @__PURE__ */ new Map();
+var createProxyDocument = (instance) => {
+  const doc = new InternalDocument(instance);
+  instanceDocs.set(instance, doc);
+  return doc;
+};
+var docForInstance = (instance) => instanceDocs.get(instance) ?? createProxyDocument(instance);
+var peekInstanceDoc = (instance) => instanceDocs.get(instance);
+var disposeInstanceDoc = (instance) => {
+  instanceDocs.get(instance)?.dispose();
+};
+var activeInstanceDoc = () => instanceDocs.get(getActiveInstance());
+var ambientDoc = () => instanceDocs.size === 1 ? instanceDocs.values().next().value : instanceDocs.get(getLastActiveInstance());
+
+// src/worker/dom/resizeObserver.ts
+var ProxyResizeObserver = class {
+  _callback;
+  /** proxy el → the observeSize detacher (unobserve/disconnect paths). */
+  _targets = /* @__PURE__ */ new Map();
+  constructor(callback) {
+    this._callback = callback;
+  }
+  observe(target, _options) {
+    const doc = activeInstanceDoc() ?? ambientDoc();
+    if (doc === void 0) return;
+    const el = toProxyElement(doc, target);
+    if (el === null || this._targets.has(el)) return;
+    const unobserve = doc.observeSize(el, (rect) => {
+      this._callback(
+        [entryFor(el, rect)],
+        this
+      );
+    });
+    this._targets.set(el, unobserve);
+  }
+  unobserve(target) {
+    const doc = activeInstanceDoc() ?? ambientDoc();
+    if (doc === void 0) return;
+    const el = toProxyElement(doc, target);
+    if (el === null) return;
+    this._targets.get(el)?.();
+    this._targets.delete(el);
+  }
+  disconnect() {
+    for (const unobserve of this._targets.values()) unobserve();
+    this._targets.clear();
+  }
+};
+var toProxyElement = (doc, target) => {
+  if (target instanceof ProxyElement) return target;
+  if (target !== null && typeof target === "object" && target.kind === "element") {
+    const adopted = doc.adopt(target);
+    return adopted instanceof ProxyElement ? adopted : null;
+  }
+  return null;
+};
+var entryFor = (el, rect) => ({
+  target: el,
+  contentRect: {
+    x: rect.x,
+    y: rect.y,
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.w,
+    bottom: rect.y + rect.h,
+    width: rect.w,
+    height: rect.h,
+    toJSON: () => ({})
+  },
+  borderBoxSize: [{ inlineSize: rect.w, blockSize: rect.h }],
+  contentBoxSize: [{ inlineSize: rect.w, blockSize: rect.h }],
+  devicePixelContentBoxSize: [{ inlineSize: rect.w, blockSize: rect.h }]
+});
+
+// src/worker/dom/window.ts
+var activeShimUninstall = null;
+var buildWindowFacade = (internal) => {
+  const g = globalThis;
+  const windowListeners = /* @__PURE__ */ new Map();
+  const pushDocOp = (op) => {
+    pushOp(internal.instance, op);
+    if (getActiveInstance() !== internal.instance) bumpOpsVersion();
+  };
+  const windowRemoveEventListener = (type, fn, options) => {
+    internal._assertAlive();
+    const capture = normalizeListenerOptions(options).capture;
+    const table = windowListeners.get(type);
+    const index = table?.findIndex((l) => l.fn === fn && l.capture === capture) ?? -1;
+    if (index === -1 || table === void 0) return;
+    const [entry] = table.splice(index, 1);
+    unregisterHandler(entry.hid);
+    internal._handlerIds.delete(entry.hid);
+    pushDocOp({
+      t: "unlisten",
+      id: 0,
+      type,
+      handler: entry.hid,
+      opts: entry.capture ? { capture: true } : void 0
+    });
+  };
+  const windowAddEventListener = (type, fn, options) => {
+    internal._assertAlive();
+    const opts = normalizeListenerOptions(options);
+    let table = windowListeners.get(type);
+    if (table === void 0) windowListeners.set(type, table = []);
+    if (table.some((l) => l.fn === fn && l.capture === opts.capture)) return;
+    const hid = registerHandler(
+      (p) => {
+        try {
+          fn.call(facade, internal._enrichEvent(p, facade));
+        } finally {
+          if (opts.once) windowRemoveEventListener(type, fn, { capture: opts.capture });
+        }
+      },
+      internal.instance,
+      0
+      // window-level listener → target id 0 is the island root
+    );
+    table.push({ fn, hid, capture: opts.capture });
+    internal._handlerIds.add(hid);
+    pushDocOp({ t: "listen", id: 0, type, handler: hid, opts: listenerOptsForWire(options) });
+  };
+  const raf = g.requestAnimationFrame;
+  const caf = g.cancelAnimationFrame;
+  const globalSetTimeout = g.setTimeout;
+  const globalSetInterval = g.setInterval;
+  const globalClearTimeout = g.clearTimeout;
+  const globalClearInterval = g.clearInterval;
+  const timeouts = /* @__PURE__ */ new Set();
+  const intervals = /* @__PURE__ */ new Set();
+  const rafs = /* @__PURE__ */ new Set();
+  const facade = {
+    document: internal,
+    navigator: { userAgent: "atoll-islands" },
+    location: {
+      href: "about:blank",
+      reload() {
+      },
+      assign(_url) {
+      },
+      replace(_url) {
+      }
+    },
+    get innerWidth() {
+      return getInstanceSize(internal.instance)?.w ?? 0;
+    },
+    get innerHeight() {
+      return getInstanceSize(internal.instance)?.h ?? 0;
+    },
+    devicePixelRatio: 1,
+    // Workers normally have no rAF — pass through when one exists (in-process
+    // test), degrade to a 16ms timer otherwise. Schedule through the host
+    // timers but keep track of the handles so teardown can cancel pending
+    // callbacks (Leaflet's drag/zoom animations, etc.).
+    requestAnimationFrame(cb) {
+      let id;
+      const wrapped = (time) => {
+        rafs.delete(id);
+        cb(time);
+      };
+      id = typeof raf === "function" ? raf.call(globalThis, wrapped) : globalSetTimeout((stamp) => wrapped(stamp), 16, Date.now());
+      rafs.add(id);
+      return id;
+    },
+    cancelAnimationFrame(id) {
+      if (id === void 0) return;
+      rafs.delete(id);
+      if (typeof caf === "function") caf.call(globalThis, id);
+      else globalClearTimeout(id);
+    },
+    setTimeout(...args) {
+      const [cb, delay, ...rest] = args;
+      let id;
+      const wrapped = (...a) => {
+        timeouts.delete(id);
+        cb(...a);
+      };
+      id = globalSetTimeout(wrapped, delay, ...rest);
+      timeouts.add(id);
+      return id;
+    },
+    clearTimeout(id) {
+      if (id === void 0) return;
+      timeouts.delete(id);
+      globalClearTimeout(id);
+    },
+    setInterval(...args) {
+      const [cb, delay, ...rest] = args;
+      const id = globalSetInterval(cb, delay, ...rest);
+      intervals.add(id);
+      return id;
+    },
+    clearInterval(id) {
+      if (id === void 0) return;
+      intervals.delete(id);
+      globalClearInterval(id);
+    },
+    // Delegates to doc.getComputedStyle — measured elements report real
+    // width/height ('NNpx'), the unmeasured path warns once doc-side.
+    getComputedStyle: (el) => el instanceof ProxyElement ? internal.getComputedStyle(el) : {},
+    // The measure channel as a DOM-standard observer — chart/map libraries
+    // that size off ResizeObserver (echarts, recharts ResponsiveContainer)
+    // get real pushed boxes unmodified.
+    ResizeObserver: ProxyResizeObserver,
+    // No preference/quiz surface exists worker-side — media queries never
+    // match. The shape is complete enough for feature-detection code.
+    matchMedia: (query) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: () => {
+      },
+      removeListener: () => {
+      },
+      addEventListener: () => {
+      },
+      removeEventListener: () => {
+      },
+      dispatchEvent: () => false
+    }),
+    addEventListener: windowAddEventListener,
+    removeEventListener: windowRemoveEventListener,
+    // No scroll surface exists worker-side — libraries call these during
+    // gesture handlers (Leaflet's Keyboard._onMouseDown scrolls the page
+    // back); honest no-ops.
+    scrollTo: () => {
+    },
+    scrollBy: () => {
+    },
+    scroll: () => {
+    }
+  };
+  const teardown = () => {
+    for (const id of rafs) {
+      if (typeof caf === "function") caf.call(globalThis, id);
+      else globalClearTimeout(id);
+    }
+    rafs.clear();
+    for (const id of timeouts) globalClearTimeout(id);
+    timeouts.clear();
+    for (const id of intervals) globalClearInterval(id);
+    intervals.clear();
+    for (const [type, table] of windowListeners) {
+      for (const entry of table) {
+        unregisterHandler(entry.hid);
+        internal._handlerIds.delete(entry.hid);
+        if (!internal._disposed) {
+          pushOp(internal.instance, { t: "unlisten", id: 0, type, handler: entry.hid });
+        }
+      }
+      table.length = 0;
+    }
+  };
+  return { facade, teardown };
+};
+var windowFacadeFor = (internal) => {
+  if (internal._windowBundle === void 0) {
+    internal._windowBundle = buildWindowFacade(internal);
+  }
+  return internal._windowBundle;
+};
+var instanceDispatcherInstalled = false;
+var HTML_MEDIA_STUB = class HTMLMediaElement {
+};
+var CUSTOM_ELEMENTS_STUB = {
+  get: () => void 0,
+  define: () => {
+  },
+  upgrade: () => {
+  },
+  // Honest answer for "will this element ever upgrade" — it won't.
+  whenDefined: () => new Promise(() => {
+  })
+};
+function installInstanceDispatcher() {
+  if (instanceDispatcherInstalled) return;
+  instanceDispatcherInstalled = true;
+  const g = globalThis;
+  const prevDocument = g.document;
+  const prevWindow = g.window;
+  const prevElement = g.Element;
+  const prevNode = g.Node;
+  const prevText = g.Text;
+  const prevComment = g.Comment;
+  const prevMedia = g.HTMLMediaElement;
+  const prevCustomElements = g.customElements;
+  const prevResizeObserver = g.ResizeObserver;
+  let docOverride;
+  let winOverride;
+  let elOverride;
+  Object.defineProperty(g, "document", {
+    configurable: true,
+    enumerable: true,
+    get: () => activeInstanceDoc() ?? docOverride ?? ambientDoc() ?? prevDocument,
+    set: (v) => {
+      docOverride = v;
+    }
+  });
+  Object.defineProperty(g, "window", {
+    configurable: true,
+    enumerable: true,
+    get: () => {
+      const doc = activeInstanceDoc();
+      if (doc !== void 0) return windowFacadeFor(doc).facade;
+      if (winOverride !== void 0) return winOverride;
+      const ambient = ambientDoc();
+      return ambient !== void 0 ? windowFacadeFor(ambient).facade : prevWindow;
+    },
+    set: (v) => {
+      winOverride = v;
+    }
+  });
+  Object.defineProperty(g, "Element", {
+    configurable: true,
+    enumerable: true,
+    get: () => {
+      if (activeInstanceDoc() !== void 0) return ProxyElement;
+      if (elOverride !== void 0) return elOverride;
+      return ambientDoc() !== void 0 ? ProxyElement : prevElement;
+    },
+    set: (v) => {
+      elOverride = v;
+    }
+  });
+  const installClassGlobal = (name, instanceValue, prev) => {
+    let override;
+    Object.defineProperty(g, name, {
+      configurable: true,
+      enumerable: true,
+      get: () => {
+        if (activeInstanceDoc() !== void 0) return instanceValue;
+        if (override !== void 0) return override;
+        return ambientDoc() !== void 0 ? instanceValue : prev;
+      },
+      set: (v) => {
+        override = v;
+      }
+    });
+  };
+  installClassGlobal("Node", ProxyNode, prevNode);
+  installClassGlobal("Text", ProxyText, prevText);
+  installClassGlobal("Comment", ProxyComment, prevComment);
+  installClassGlobal(
+    "HTMLMediaElement",
+    typeof prevMedia === "function" ? prevMedia : HTML_MEDIA_STUB,
+    prevMedia
+  );
+  installClassGlobal(
+    "customElements",
+    prevCustomElements !== void 0 ? prevCustomElements : CUSTOM_ELEMENTS_STUB,
+    prevCustomElements
+  );
+  installClassGlobal("ResizeObserver", ProxyResizeObserver, prevResizeObserver);
+}
+function installDomShim(doc) {
+  const internal = doc;
+  installInstanceDispatcher();
+  const g = globalThis;
+  activeShimUninstall?.();
+  activeShimUninstall = null;
+  const prevInstance = getLastActiveInstance();
+  const prevDocument = g.document;
+  const prevWindow = g.window;
+  const prevElement = g.Element;
+  const prevNode = g.Node;
+  const prevText = g.Text;
+  const prevComment = g.Comment;
+  const prevMedia = g.HTMLMediaElement;
+  const prevCustomElements = g.customElements;
+  const prevResizeObserver = g.ResizeObserver;
+  markInstanceActive(internal.instance);
+  const bundle = windowFacadeFor(internal);
+  g.document = doc;
+  g.window = bundle.facade;
+  g.Element = ProxyElement;
+  g.Node = ProxyNode;
+  g.Text = ProxyText;
+  g.Comment = ProxyComment;
+  if (typeof g.HTMLMediaElement !== "function") g.HTMLMediaElement = HTML_MEDIA_STUB;
+  if (g.customElements === void 0) g.customElements = CUSTOM_ELEMENTS_STUB;
+  if (g.ResizeObserver === void 0) g.ResizeObserver = ProxyResizeObserver;
+  const uninstall = () => {
+    bundle.teardown();
+    internal._windowBundle = void 0;
+    g.document = prevDocument;
+    g.window = prevWindow;
+    g.Element = prevElement;
+    g.Node = prevNode;
+    g.Text = prevText;
+    g.Comment = prevComment;
+    g.HTMLMediaElement = prevMedia;
+    g.customElements = prevCustomElements;
+    g.ResizeObserver = prevResizeObserver;
+    markInstanceActive(prevInstance);
+    if (activeShimUninstall === uninstall) activeShimUninstall = null;
+  };
+  internal._uninstallShim = uninstall;
+  activeShimUninstall = uninstall;
+  return uninstall;
+}
+
+// src/worker/defineWorkers.ts
+var isImperative = (app) => typeof app === "object" && app !== null && "imperative" in app;
+var isRendered = (app) => typeof app === "object" && app !== null && "mount" in app;
+var callbackFactory = (instance) => (id) => (...args) => {
+  pushOp(instance, { t: "emit", name: CALLBACK_EVENT, payload: { id, args } });
+  bumpOpsVersion();
+};
+var isImperativeInstance = (r) => r.imperative !== void 0;
+var isRenderedInstance = (r) => r.rendered !== void 0;
+var mounts = /* @__PURE__ */ new Map();
+var APP_REGISTRY = /* @__PURE__ */ new Map();
+var registerSingleApp = (name, app) => {
+  APP_REGISTRY.set(name, app);
+};
+var resolveApp = (name) => APP_REGISTRY.get(name) ?? (APP_REGISTRY.size === 1 ? APP_REGISTRY.values().next().value : void 0);
+var newPid = () => `w-${Math.random().toString(36).slice(2, 8)}`;
+var appNameOf = (instance) => {
+  const at = instance.lastIndexOf("@");
+  const name = at === -1 ? instance : instance.slice(0, at);
+  const tilde = name.lastIndexOf("~");
+  return tilde === -1 ? name : name.slice(tilde + 1);
+};
+function createIslandRuntime(sharedMemory = renderMemory) {
+  setDoorbellContract(sharedMemory);
+  installInstanceDispatcher();
+  const parseContractProps = (contract, key, props) => {
+    if (contract?.props === void 0) return props;
+    try {
+      return contract.props.parse(props);
+    } catch (err) {
+      throw new Error(
+        `[island "${contract.app}"] props for "${key}" rejected by contract: ` + (err instanceof Error ? err.message : String(err))
+      );
+    }
+  };
+  function createInstance(key, pid) {
+    const app = resolveApp(appNameOf(key));
+    const contract = contractOf(app);
+    setInstanceContract(key, contract);
+    if (isRendered(app)) {
+      return {
+        key,
+        app: appNameOf(key),
+        pid,
+        contract,
+        rendered: { app, handle: void 0, props: {} }
+      };
+    }
+    if (isImperative(app)) {
+      return {
+        key,
+        app: appNameOf(key),
+        pid,
+        contract,
+        imperative: {
+          build: app.imperative,
+          dispose: app.dispose,
+          doc: createProxyDocument(key),
+          props: {}
+        }
+      };
+    }
+    throw new Error(
+      `createInstance: "${appNameOf(key)}" is a bare component \u2014 registry values must be { imperative } or a framework adapter's RenderedIslandApp (reactIslandApp/vueIslandApp/\u2026, or the package's define*PolyWorker which wraps for you)`
+    );
+  }
+  function rebuildImperative(instance, props) {
+    return runInInstance(instance.key, () => {
+      const imp = instance.imperative;
+      imp.dispose?.(imp.doc);
+      imp.doc.dispose();
+      pushOp(instance.key, { t: "clear" });
+      imp.doc = createProxyDocument(instance.key);
+      imp.props = props;
+      imp.build(imp.doc, props);
+      return takeOps(instance.key);
+    });
+  }
+  function renderCtx(key, props) {
+    return {
+      instance: key,
+      get doc() {
+        return docForInstance(key);
+      },
+      props
+    };
+  }
+  function rebuildRendered(instance, props) {
+    return runInInstance(instance.key, () => {
+      const r = instance.rendered;
+      r.handle?.dispose?.();
+      disposeInstanceDoc(instance.key);
+      pushOp(instance.key, { t: "clear" });
+      r.props = props;
+      r.handle = r.app.mount(renderCtx(instance.key, props));
+      return takeOps(instance.key);
+    });
+  }
+  return defineWorker({
+    sharedMemory,
+    methods: {
+      /**
+       * Mount apps[appNameOf(instance)] into its own root; returns the
+       * initial op batch. The instance key may carry an instance suffix
+       * ('data-table@3') so the same app can mount multiple times.
+       *
+       * Mounting a instance key that is already mounted is a REMOUNT: the old
+       * tree is unmounted first (a `clear` op + GC of its instance records),
+       * then a fresh container renders the new tree — the returned batch
+       * replays cleanly onto an emptied root. The pid is kept across remounts.
+       */
+      async mount(instance, props = {}) {
+        props = unmarshalCallbackProps(props, callbackFactory(instance));
+        const App = resolveApp(appNameOf(instance));
+        if (App === void 0) {
+          throw new Error(
+            `mount: unknown app "${instance}" \u2014 registry has: ${[...APP_REGISTRY.keys()].join(", ")}`
+          );
+        }
+        props = parseContractProps(contractOf(App), instance, props);
+        const mounted = mounts.get(instance);
+        if (mounted !== void 0 && isImperativeInstance(mounted)) {
+          return rebuildImperative(mounted, props);
+        }
+        if (mounted !== void 0) {
+          return rebuildRendered(mounted, props);
+        }
+        const created = createInstance(instance, newPid());
+        mounts.set(instance, created);
+        if (isImperativeInstance(created)) {
+          const imp = created.imperative;
+          imp.props = props;
+          return runInInstance(instance, () => {
+            imp.build(imp.doc, props);
+            return takeOps(instance);
+          });
+        }
+        const r = created.rendered;
+        r.props = props;
+        return runInInstance(instance, () => {
+          r.handle = r.app.mount(renderCtx(instance, props));
+          return takeOps(instance);
+        });
+      },
+      /**
+       * Re-render the instance's root with new props — the shell→island channel.
+       * `updateProps` is how the shell mediates between islands (controls
+       * emits filterChanged → shell → table.updateProps({filter})).
+       */
+      updateProps(instance, props) {
+        props = unmarshalCallbackProps(props, callbackFactory(instance));
+        const mounted = mounts.get(instance);
+        if (mounted === void 0) {
+          throw new Error(`updateProps: "${instance}" is not mounted in this worker \u2014 mount() first`);
+        }
+        props = parseContractProps(mounted.contract, instance, props);
+        if (isImperativeInstance(mounted)) return rebuildImperative(mounted, props);
+        const r = mounted.rendered;
+        if (r.handle?.update === void 0) return rebuildRendered(mounted, props);
+        return runInInstance(instance, () => {
+          r.handle.update(props);
+          r.props = props;
+          return takeOps(instance);
+        });
+      },
+      /**
+       * Run the prop function the main thread identified by handlerId —
+       * `__evt` refs are handles into the worker's handler table. The entry
+       * records which instance registered it, so the re-render's ops land on the
+       * right island's queue.
+       */
+      dispatch(handlerId, payload) {
+        const entry = getHandler(handlerId);
+        if (entry === void 0) return [];
+        const instance = mounts.get(entry.instance);
+        if (instance === void 0) return [];
+        const p = payload;
+        if (p.target === void 0 || p.currentTarget === void 0) {
+          const doc = docForInstance(instance.key);
+          if (p.target === void 0 && typeof p.targetId === "number") {
+            const t = instances.get(p.targetId);
+            if (t !== void 0) p.target = doc.adopt(t);
+          }
+          if (p.currentTarget === void 0 && entry.instanceId !== void 0) {
+            p.currentTarget = entry.instanceId === 0 ? doc._root : instances.get(entry.instanceId) !== void 0 ? doc.adopt(instances.get(entry.instanceId)) : void 0;
+          }
+        }
+        return runInInstance(instance.key, () => {
+          const sync = isRenderedInstance(instance) ? instance.rendered.handle?.sync : void 0;
+          if (sync !== void 0) sync(() => entry.fn(payload));
+          else entry.fn(payload);
+          return takeOps(instance.key);
+        });
+      },
+      /**
+       * The pushed-size channel: the driver measured the island's container
+       * and stores it for the instance (see instanceSizes). Mounts
+       * additionally fire their proxy document's onResize handlers —
+       * inside the instance's scope so their mutations emit ops, which ride
+       * back in this task's return batch.
+       */
+      setSize(instance, width, height) {
+        setInstanceSize(instance, width, height);
+        const mounted = mounts.get(instance);
+        if (mounted === void 0) return takeOps(instance);
+        const doc = isImperativeInstance(mounted) ? mounted.imperative.doc : peekInstanceDoc(instance);
+        if (doc === void 0) return takeOps(instance);
+        return runInInstance(mounted.key, () => {
+          doc._notifySize(width, height);
+          return takeOps(instance);
+        });
+      },
+      /**
+       * The measured-element channel: rects the driver pushed in answer to
+       * `measure` ops. Stored in the instance-level map FIRST so geometry
+       * reads answer even for mounts without a materialized proxy document
+       * (a React element adopted later sees its rect immediately); then
+       * per-element observeSize callbacks fire inside the instance's scope,
+       * their ops riding back in the batch like onResize handlers.
+       */
+      setRects(instance, rects) {
+        const mounted = mounts.get(instance);
+        const doc = mounted !== void 0 && isImperativeInstance(mounted) ? mounted.imperative.doc : peekInstanceDoc(instance);
+        if (doc === void 0) {
+          for (const rect of rects) setInstanceRect(instance, rect);
+          return takeOps(instance);
+        }
+        return runInInstance(mounted?.key ?? instance, () => {
+          doc._notifyRects(rects);
+          return takeOps(instance);
+        });
+      },
+      /**
+       * Tear down ONE instance while the worker keeps serving its others —
+       * the multi-island-per-worker counterpart to process death: disposes
+       * the renderer handle (or the imperative instance's proxy document),
+       * drops the instance entry, and returns the clear op. Stale
+       * handler dispatches then no-op via the mounts.get() guard.
+       */
+      unmount(instance) {
+        const mounted = mounts.get(instance);
+        if (mounted === void 0) return [];
+        mounts.delete(instance);
+        setInstanceContract(instance, void 0);
+        clearInstanceRects(instance);
+        return runInInstance(instance, () => {
+          if (isImperativeInstance(mounted)) {
+            const imp = mounted.imperative;
+            imp.dispose?.(imp.doc);
+            imp.doc.dispose();
+          } else {
+            mounted.rendered.handle?.dispose?.();
+            disposeInstanceDoc(instance);
+          }
+          takeOps(instance);
+          return [{ t: "clear" }];
+        });
+      },
+      /**
+       * Drain one instance's ops committed outside a sync task — passive effects
+       * (useEffect), timers, async setState. The pool protocol has no push
+       * channel, so the main thread polls this (or the doorbell pushes it).
+       */
+      flush(instance) {
+        const mounted = mounts.get(instance);
+        if (mounted === void 0) return [];
+        if (isImperativeInstance(mounted)) return takeOps(instance);
+        const r = mounted.rendered;
+        return runInInstance(mounted.key, () => {
+          r.handle?.flush?.();
+          return takeOps(instance);
+        });
+      },
+      /** The mounted instance's random id — the island's "worker pid" badge. */
+      whoami(instance) {
+        return mounts.get(instance)?.pid ?? "unmounted";
+      },
+      /** The instance's renderer tag (an adapter's `renderer`); null for imperative or unknown. */
+      renderer(instance) {
+        const mounted = mounts.get(instance);
+        return mounted && isRenderedInstance(mounted) && mounted.rendered.app.renderer || null;
+      }
+    }
+  });
+}
+function definePolyWorker(registry, options) {
+  for (const [key, app] of Object.entries(registry.apps)) {
+    const stamped = islandAppNameOf(app);
+    if (stamped !== void 0 && stamped !== key) {
+      console.warn(
+        `[definePolyWorker] app registered as "${key}" but stamped "${stamped}" \u2014 component-reference mounts resolve "${stamped}" and will fail. Fix the key or the stamp.`
+      );
+    }
+    registerSingleApp(key, app);
+  }
+  return createIslandRuntime(registry.sharedMemory ?? options?.sharedMemory);
+}
+function defineMonoWorker(app, options) {
+  const stamp = app.islandAppName;
+  registerSingleApp(typeof stamp === "string" && stamp !== "" ? stamp : "main", app);
+  return createIslandRuntime(options?.sharedMemory);
+}
+
+// src/worker/subIsland.ts
+import { devtoolsEnabled, emitDevtools, estimateCloneBytes, observe, previewValue } from "@atolljs/core";
+var subSeq = 0;
+var clientMounts = /* @__PURE__ */ new WeakMap();
+var ENRICHED_KEYS = /* @__PURE__ */ new Set([
+  "target",
+  "relatedTarget",
+  "currentTarget",
+  "composedPath",
+  "preventDefault",
+  "stopPropagation",
+  "stopImmediatePropagation"
+]);
+async function mountSubIsland(opts) {
+  const {
+    el,
+    onEvent,
+    onActivity,
+    onOps,
+    slots,
+    client: givenClient,
+    worker,
+    app: givenApp,
+    props: givenProps,
+    mode: initialMode,
+    framework,
+    mountTimeout,
+    ...workerConfig
+  } = opts;
+  if (!(el instanceof ProxyElement)) {
+    throw new Error(
+      "mountSubIsland: `el` must be a ProxyElement of a mounted parent island \u2014 a real element mounts through the main-thread driver (mountIsland handles both)."
+    );
+  }
+  const doc = el.doc;
+  const parentInstance = doc.instance;
+  const app = givenApp ?? "main";
+  const instance = `${parentInstance}~${app}@${++subSeq}`;
+  if (givenClient === void 0 && worker === void 0) {
+    throw new Error(
+      "mountSubIsland: pass `worker` (a `() => new Worker(...)`/URL entry \u2014 this call builds the island-owned sub-client) or `client` (a shared connectIslandWorker \u2014 several sub-islands, one sub-worker)"
+    );
+  }
+  const cbTable = /* @__PURE__ */ new Map();
+  let cbSeq = 0;
+  const registerCb = (fn) => {
+    cbTable.set(++cbSeq, fn);
+    return cbSeq;
+  };
+  const props = marshalCallbackProps(givenProps ?? {}, registerCb);
+  assertCloneableProps(props, `mountIsland(${givenApp ?? "main"})`);
+  const client = givenClient ?? connectIslandWorker({
+    name: givenApp,
+    ...workerConfig,
+    worker,
+    doorbell: initialMode !== "poll"
+  });
+  clientMounts.set(client, (clientMounts.get(client) ?? 0) + 1);
+  const nodes = /* @__PURE__ */ new Map([[0, el]]);
+  const proxyIdToSub = /* @__PURE__ */ new Map([[el.instance.id, 0]]);
+  const prevProps = /* @__PURE__ */ new Map();
+  const nodeListeners = /* @__PURE__ */ new Map();
+  const measureCleanups = /* @__PURE__ */ new Map();
+  const slotNodes = /* @__PURE__ */ new Map();
+  const claims = (name) => slots !== void 0 && name in slots;
+  function mountSlot(node, subId, name) {
+    node.setAttribute("data-atoll-sub-slot", name);
+    const prev = slotNodes.get(subId);
+    if (prev !== void 0 && prev !== name) slots?.[prev]?.(null);
+    slotNodes.set(subId, name);
+    slots?.[name]?.(node);
+  }
+  function unmountSlot(subId) {
+    const name = slotNodes.get(subId);
+    if (name === void 0) return;
+    slotNodes.delete(subId);
+    slots?.[name]?.(null);
+  }
+  function releaseDetachedSlots() {
+    for (const subId of [...slotNodes.keys()]) {
+      const node = nodes.get(subId);
+      if (node === void 0 || !el.contains(node)) unmountSlot(subId);
+    }
+  }
+  let unsubscribe = null;
+  let pollTimer = null;
+  let destroyed = false;
+  let opsApplied = 0;
+  let flushCalls = 0;
+  let mode = initialMode ?? "push";
+  function translatePayload(p) {
+    const out = {};
+    for (const [k, v] of Object.entries(p)) {
+      if (!ENRICHED_KEYS.has(k)) out[k] = v;
+    }
+    if (typeof p.targetId === "number") {
+      const subId = proxyIdToSub.get(p.targetId);
+      if (subId !== void 0) out.targetId = subId;
+      else delete out.targetId;
+    }
+    return out;
+  }
+  function dispatchListener(subHid) {
+    return (payload) => {
+      void client.dispatch(subHid, translatePayload(payload)).then((ops) => applyOps(ops, "dispatch")).catch((err) => console.error(`[sub-island ${instance}] dispatch failed`, err));
+    };
+  }
+  function trackListener(subId, key, fn, capture) {
+    let table = nodeListeners.get(subId);
+    if (!table) nodeListeners.set(subId, table = /* @__PURE__ */ new Map());
+    if (!table.has(key)) table.set(key, { fn, capture });
+  }
+  function setProp(node, subId, name, value) {
+    if (name === "data-atoll-slot" && claims(String(value))) {
+      mountSlot(node, subId, String(value));
+      return;
+    }
+    if (isEventRef(value)) {
+      const eventName = name.slice(2).toLowerCase();
+      const key = `${eventName}#${value.__evt}`;
+      if (!nodeListeners.get(subId)?.has(key)) {
+        const fn = dispatchListener(value.__evt);
+        trackListener(subId, key, fn);
+        node.addEventListener(eventName, fn);
+      }
+      return;
+    }
+    if (name === "style" && typeof value === "object" && value !== null) {
+      const next = value;
+      const prev = prevProps.get(subId)?.style ?? {};
+      const style = node.style;
+      for (const k of Object.keys(prev)) if (!(k in next)) style[k] = "";
+      for (const [k, v] of Object.entries(next)) {
+        if (prev[k] !== v) style[k] = cssStyleValue(k, v);
+      }
+      return;
+    }
+    if (name === "className") {
+      node.className = String(value);
+      return;
+    }
+    if (value === true) {
+      node.setAttribute(name, "");
+      return;
+    }
+    if (value === false) {
+      node.removeAttribute(name);
+      return;
+    }
+    if (name in node) {
+      try {
+        node[name] = value;
+        return;
+      } catch {
+      }
+    }
+    node.setAttribute(name, String(value));
+  }
+  function removeProp(node, subId, name, oldValue) {
+    if (name === "data-atoll-slot" && slotNodes.has(subId)) {
+      unmountSlot(subId);
+      node.removeAttribute("data-atoll-sub-slot");
+      return;
+    }
+    if (isEventRef(oldValue)) {
+      const eventName = name.slice(2).toLowerCase();
+      const key = `${eventName}#${oldValue.__evt}`;
+      const entry = nodeListeners.get(subId)?.get(key);
+      if (entry) {
+        node.removeEventListener(eventName, entry.fn, { capture: entry.capture });
+        nodeListeners.get(subId)?.delete(key);
+      }
+      return;
+    }
+    if (name === "style") {
+      for (const k of Object.keys(oldValue ?? {})) {
+        node.style[k] = "";
+      }
+      return;
+    }
+    if (name === "className") {
+      node.className = "";
+      return;
+    }
+    node.removeAttribute(name);
+  }
+  function applyProps(node, subId, prev, next) {
+    for (const name of Object.keys(prev)) {
+      if (!(name in next)) removeProp(node, subId, name, prev[name]);
+    }
+    for (const [name, value] of Object.entries(next)) {
+      if (prev[name] !== value || isEventRef(value)) setProp(node, subId, name, value);
+    }
+  }
+  function applyOp(op) {
+    switch (op.t) {
+      case "create": {
+        const node = op.ns !== void 0 ? doc.createElementNS(op.ns, op.type) : doc.createElement(op.type);
+        nodes.set(op.id, node);
+        proxyIdToSub.set(node.instance.id, op.id);
+        for (const [name, value] of Object.entries(op.props)) setProp(node, op.id, name, value);
+        prevProps.set(op.id, op.props);
+        break;
+      }
+      case "text": {
+        const node = doc.createTextNode(op.text);
+        nodes.set(op.id, node);
+        proxyIdToSub.set(node.instance.id, op.id);
+        break;
+      }
+      case "append": {
+        const parent = nodes.get(op.parent);
+        const child = nodes.get(op.child);
+        if (!parent || !child) {
+          console.error(
+            `[sub-island] append skipped: parent=${op.parent}\u2192${String(parent)} child=${op.child}\u2192${String(child)}`
+          );
+          break;
+        }
+        const before = op.before !== void 0 ? nodes.get(op.before) ?? null : null;
+        parent.insertBefore(child, before);
+        break;
+      }
+      case "remove": {
+        nodes.get(op.child)?.remove();
+        measureCleanups.get(op.child)?.();
+        measureCleanups.delete(op.child);
+        releaseDetachedSlots();
+        break;
+      }
+      case "update": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement)) break;
+        const prev = prevProps.get(op.id) ?? {};
+        applyProps(node, op.id, prev, op.props);
+        prevProps.set(op.id, op.props);
+        break;
+      }
+      case "utext": {
+        const node = nodes.get(op.id);
+        if (node) node.textContent = op.text;
+        break;
+      }
+      case "attr": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement)) break;
+        if (op.name === "data-atoll-slot") {
+          if (op.value === null && slotNodes.has(op.id)) {
+            unmountSlot(op.id);
+            node.removeAttribute("data-atoll-sub-slot");
+            break;
+          }
+          if (op.value !== null && claims(op.value)) {
+            mountSlot(node, op.id, op.value);
+            break;
+          }
+        }
+        if (op.value === null) node.removeAttribute(op.name);
+        else node.setAttribute(op.name, op.value);
+        break;
+      }
+      case "style": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement)) break;
+        const style = node.style;
+        for (const [k, v] of Object.entries(op.props)) style[k] = v;
+        const prev = prevProps.get(op.id) ?? {};
+        prev.style = { ...prev.style ?? {}, ...op.props };
+        prevProps.set(op.id, prev);
+        break;
+      }
+      case "listen": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement) && op.id !== 0) break;
+        const target = node ?? el;
+        const key = `${op.type}#${op.handler}`;
+        if (!nodeListeners.get(op.id)?.has(key)) {
+          const fn = dispatchListener(op.handler);
+          trackListener(op.id, key, fn, op.opts?.capture);
+          target.addEventListener(op.type, fn, op.opts);
+        }
+        break;
+      }
+      case "unlisten": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement)) break;
+        const key = `${op.type}#${op.handler}`;
+        const entry = nodeListeners.get(op.id)?.get(key);
+        if (entry) {
+          node.removeEventListener(op.type, entry.fn, { capture: op.opts?.capture });
+          nodeListeners.get(op.id)?.delete(key);
+        }
+        break;
+      }
+      case "clear": {
+        el.replaceChildren();
+        for (const cleanup of measureCleanups.values()) cleanup();
+        measureCleanups.clear();
+        releaseDetachedSlots();
+        break;
+      }
+      case "measure": {
+        const node = nodes.get(op.id);
+        if (!(node instanceof ProxyElement) || measureCleanups.has(op.id)) break;
+        measureCleanups.set(
+          op.id,
+          doc.observeSize(node, (rect) => {
+            void islandCall(
+              "setRects",
+              client.setRects(instance, [{ id: op.id, x: rect.x, y: rect.y, w: rect.w, h: rect.h }])
+            ).then((ops) => applyOps(ops, "setRects"));
+          })
+        );
+        break;
+      }
+      case "unmeasure": {
+        measureCleanups.get(op.id)?.();
+        measureCleanups.delete(op.id);
+        break;
+      }
+      case "emit": {
+        if (op.name === CALLBACK_EVENT) {
+          const p = op.payload;
+          if (p !== null && typeof p === "object" && typeof p.id === "number") {
+            cbTable.get(p.id)?.(...p.args ?? []);
+          }
+          break;
+        }
+        if (devtoolsEnabled()) {
+          emitDevtools({ type: "island:event", instance, name: op.name, payload: previewValue(op.payload, 1024) });
+        }
+        runInInstance(parentInstance, () => onEvent?.(op.name, op.payload));
+        break;
+      }
+    }
+  }
+  function applyOps(ops, via) {
+    opsApplied += ops.length;
+    onActivity?.();
+    const t0 = performance.now();
+    for (const op of ops) applyOp(op);
+    const replayMs = performance.now() - t0;
+    if (devtoolsEnabled()) {
+      emitDevtools({
+        type: "island:ops",
+        instance,
+        via,
+        count: ops.length,
+        replayMs,
+        bytes: estimateCloneBytes(ops)
+      });
+    }
+    onOps?.(ops, replayMs);
+  }
+  const islandCall = (method, p) => {
+    const t0 = performance.now();
+    return p.then(
+      (r) => {
+        emitDevtools({
+          type: "island:task",
+          instance,
+          method,
+          ms: performance.now() - t0,
+          ops: Array.isArray(r) ? r.length : void 0
+        });
+        return r;
+      },
+      (err) => {
+        emitDevtools({
+          type: "island:task",
+          instance,
+          method,
+          ms: performance.now() - t0,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    );
+  };
+  const doFlush = () => {
+    if (destroyed) return;
+    flushCalls++;
+    void islandCall("flush", client.flush(instance)).then((ops) => applyOps(ops, "flush"));
+  };
+  const doorbell2 = client.sharedMemory ? observe(client.sharedMemory, "opsVersion") : null;
+  function setMode(next) {
+    mode = next;
+    unsubscribe?.();
+    unsubscribe = null;
+    if (pollTimer !== null) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+    if (mode === "push" && doorbell2 !== null) unsubscribe = doorbell2.subscribe(doFlush);
+    else pollTimer = setInterval(doFlush, 50);
+    onActivity?.();
+  }
+  const mountMs = mountTimeout ?? 15e3;
+  const raced = (p) => {
+    if (mountMs <= 0) return p;
+    let timer;
+    return Promise.race([
+      p,
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(
+            new Error(
+              `mountIsland(${app}): the sub-worker never answered within ${mountMs}ms \u2014 check that the entry module loads and calls definePolyWorker/defineMonoWorker.`
+            )
+          ),
+          mountMs
+        );
+      })
+    ]).finally(() => clearTimeout(timer));
+  };
+  let pid;
+  try {
+    applyOps(await raced(islandCall("mount", client.mount(instance, props))), "mount");
+    pid = await raced(islandCall("whoami", client.whoami(instance)));
+    if (devtoolsEnabled()) {
+      const fw = framework ?? await client.renderer(instance).catch(() => null) ?? void 0;
+      emitDevtools({
+        type: "island:mount",
+        instance,
+        app,
+        pid,
+        poolId: client.pool?.poolId,
+        framework: fw
+      });
+      emitDevtools({ type: "island:props", instance, props: propsPreview(givenProps ?? {}) });
+    }
+  } catch (err) {
+    clientMounts.set(client, (clientMounts.get(client) ?? 1) - 1);
+    if (givenClient === void 0) client.terminate();
+    else void islandCall("unmount", client.unmount(instance)).catch(() => {
+    });
+    throw err;
+  }
+  setMode(mode);
+  let measuredEl = false;
+  const pushSize = (w, h) => {
+    if (destroyed) return;
+    void islandCall("setSize", client.setSize(instance, w, h)).then((ops) => applyOps(ops, "setSize"));
+  };
+  const unobserveEl = doc.observeSize(el, (rect) => {
+    if (rect.w === 0 && rect.h === 0) return;
+    measuredEl = true;
+    pushSize(rect.w, rect.h);
+  });
+  doc.onResize((w, h) => {
+    if (!measuredEl) pushSize(w, h);
+  });
+  const initial = getInstanceSize(parentInstance);
+  if (initial !== void 0) pushSize(initial.w, initial.h);
+  const handle = {
+    app,
+    pid,
+    instance,
+    get mode() {
+      return mode;
+    },
+    get opsApplied() {
+      return opsApplied;
+    },
+    get flushCalls() {
+      return flushCalls;
+    },
+    setMode,
+    updateProps: async (next) => {
+      const marshalled = marshalCallbackProps(next, registerCb);
+      applyOps(await islandCall("updateProps", client.updateProps(instance, marshalled)), "updateProps");
+      if (devtoolsEnabled()) emitDevtools({ type: "island:props", instance, props: propsPreview(next) });
+    },
+    flush: async () => {
+      applyOps(await islandCall("flush", client.flush(instance)), "flush");
+    },
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      emitDevtools({ type: "island:unmount", instance });
+      for (const subId of [...slotNodes.keys()]) unmountSlot(subId);
+      unobserveEl();
+      for (const cleanup of measureCleanups.values()) cleanup();
+      measureCleanups.clear();
+      unsubscribe?.();
+      if (pollTimer !== null) clearInterval(pollTimer);
+      const remaining = (clientMounts.get(client) ?? 1) - 1;
+      clientMounts.set(client, remaining);
+      const warm = opts.keepAlive === true || isKeepAliveClient(client);
+      if (!warm && (givenClient === void 0 || remaining <= 0)) client.terminate();
+      else void islandCall("unmount", client.unmount(instance)).catch(() => {
+      });
+    }
+  };
+  return handle;
+}
+registerSubIslandMounter(mountSubIsland);
+export {
+  ProxyComment,
+  ProxyElement,
+  ProxyFragment,
+  ProxyNode,
+  ProxyResizeObserver,
+  ProxyText,
+  ROOT_CONTAINER,
+  allocId,
+  bumpOpsVersion,
+  connectIslandWorker,
+  contractOf,
+  createProxyDocument,
+  defineIslandContract,
+  defineMonoWorker,
+  definePolyWorker,
+  docForInstance,
+  emit,
+  getActiveInstance,
+  getHandler,
+  getInstanceSize,
+  getLastActiveInstance,
+  getLastTouchedInstance,
+  installDomShim,
+  installInstanceDispatcher,
+  instances,
+  isEventRef,
+  isIslandContract,
+  islandApp,
+  islandAppNameOf,
+  mountIsland,
+  mountSubIsland,
+  newElement,
+  newText,
+  proxyInstanceStats,
+  pushOp,
+  registerHandler,
+  renderMemory,
+  runInInstance,
+  serializeProps,
+  setActiveInstance,
+  setDoorbellContract,
+  setInstanceSize,
+  takeOps,
+  unregisterHandler,
+  withContract
+};