@atolljs/islands 0.1.12 → 0.1.13

package/dist/chunk-TX4FAHRB.js

@@ -0,0 +1,1187 @@
+// src/memory.ts
+import { defineSharedMemory, field } from "@atolljs/core";
+var doorbellSpec = {
+  opsVersion: field.number()
+};
+var renderMemory = defineSharedMemory(doorbellSpec);
+var makeDoorbell = () => defineSharedMemory(doorbellSpec);
+
+// src/ops.ts
+var isEventRef = (v) => typeof v === "object" && v !== null && "__evt" in v;
+
+// src/callbackProps.ts
+var CALLBACK_EVENT = "__island_cb__";
+var CALLBACK_WIRE = "__cb";
+var markers = /* @__PURE__ */ new WeakMap();
+function callbackProp(fn) {
+  const marker = { fn };
+  markers.set(marker, marker.fn);
+  return marker;
+}
+var isCallbackMarker = (v) => typeof v === "object" && v !== null && markers.has(v);
+var isPlainObj = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const p = Object.getPrototypeOf(v);
+  return p === Object.prototype || p === null;
+};
+function marshalCallbackProps(value, register) {
+  const fn = markers.get(value);
+  if (fn !== void 0) return { [CALLBACK_WIRE]: register(fn) };
+  if (Array.isArray(value)) return value.map((v) => marshalCallbackProps(v, register));
+  if (!isPlainObj(value)) return value;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = marshalCallbackProps(v, register);
+  return out;
+}
+function unmarshalCallbackProps(value, make) {
+  if (Array.isArray(value)) return value.map((v) => unmarshalCallbackProps(v, make));
+  if (!isPlainObj(value)) return value;
+  const id = value[CALLBACK_WIRE];
+  if (typeof id === "number" && Object.keys(value).length === 1) return make(id);
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = unmarshalCallbackProps(v, make);
+  return out;
+}
+
+// src/island.ts
+import {
+  connectWorker,
+  devtoolsEnabled,
+  emitDevtools,
+  estimateCloneBytes,
+  observe,
+  previewValue as previewValue3
+} from "@atolljs/core";
+
+// src/devtoolsCommands.ts
+import { registerDevtoolsCommand, previewValue as previewValue2 } from "@atolljs/core";
+
+// src/devtoolsPreview.ts
+import { previewValue } from "@atolljs/core";
+var SAFE_BUDGET = 5e3;
+var jsonSafe = (value) => {
+  let nodes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v, depth) => {
+    if (++nodes > SAFE_BUDGET) return "[\u2026]";
+    if (typeof v === "function" || isCallbackMarker(v)) return "[fn]";
+    if (typeof v === "bigint") return `${v}n`;
+    if (typeof v === "number") return Number.isFinite(v) ? v : String(v);
+    if (typeof v !== "object" || v === null) return v;
+    if (v instanceof ArrayBuffer) return `[ArrayBuffer ${v.byteLength}B]`;
+    if (ArrayBuffer.isView(v)) return `[${v.constructor.name} ${v.byteLength}B]`;
+    if (v instanceof Date) return v.toISOString();
+    if (seen.has(v)) return "[cycle]";
+    if (depth > 12) return "[\u2026]";
+    seen.add(v);
+    if (v instanceof Map) return { "[Map]": [...v.entries()].slice(0, 50).map((e) => walk(e, depth + 1)) };
+    if (v instanceof Set) return { "[Set]": [...v].slice(0, 50).map((x) => walk(x, depth + 1)) };
+    if (Array.isArray(v)) return v.map((x) => walk(x, depth + 1));
+    const out = {};
+    for (const k of Object.keys(v)) {
+      const x = v[k];
+      if (x !== void 0) out[k] = walk(x, depth + 1);
+    }
+    return out;
+  };
+  return walk(value, 0);
+};
+var propsPreview = (props) => previewValue(jsonSafe(props), 4096);
+
+// src/devtoolsCommands.ts
+var islands = /* @__PURE__ */ new Map();
+var commandsRegistered = false;
+var trackIslandForDevtools = (entry) => {
+  ensureIslandCommands();
+  const instance = entry.handle.instance;
+  islands.set(instance, entry);
+  return () => {
+    if (islands.get(instance) === entry) islands.delete(instance);
+    if (highlighted?.instance === instance) clearHighlight();
+  };
+};
+var entryOf = (args) => {
+  const instance = String(args.instance ?? "");
+  const entry = islands.get(instance);
+  if (entry) return entry;
+  throw new Error(
+    instance.includes("~") ? `island '${instance}' is nested: its handle lives in the parent worker, so it can't be commanded from the dashboard (inspect the outer island's tree instead)` : `island '${instance}' is not mounted on this page's main thread`
+  );
+};
+var TEXT_CAP = 200;
+var ATTR_CAP = 200;
+var visibleChildren = (n) => [...n.childNodes].filter((c) => c.nodeType === 1 || c.nodeType === 3 && (c.nodeValue ?? "").trim() !== "");
+var shadowOf = (n) => n.nodeType === 1 ? n.shadowRoot ?? null : null;
+var cap = (s, n) => s.length > n ? `${s.slice(0, n)}\u2026` : s;
+var serializeTree = (root, maxNodes) => {
+  let count = 0;
+  let truncated = false;
+  const walk = (n, id) => {
+    count++;
+    if (n.nodeType === 3) {
+      return { id, tag: "#text", attrs: [], text: cap(n.nodeValue ?? "", TEXT_CAP), children: [] };
+    }
+    const isShadow = n.nodeType === 11;
+    const el = n;
+    const node = {
+      id,
+      tag: isShadow ? "#shadow-root" : el.localName ?? el.nodeName.toLowerCase(),
+      attrs: isShadow ? [] : [...el.attributes].map((a) => [a.name, cap(a.value, ATTR_CAP)]),
+      children: []
+    };
+    const kids = [];
+    const shadow = shadowOf(n);
+    if (shadow) kids.push([shadow, `${id}.s`]);
+    visibleChildren(n).forEach((c, i) => kids.push([c, `${id}.${i}`]));
+    for (let i = 0; i < kids.length; i++) {
+      if (count >= maxNodes) {
+        node.more = kids.length - i;
+        truncated = true;
+        break;
+      }
+      node.children.push(walk(kids[i][0], kids[i][1]));
+    }
+    return node;
+  };
+  return { root: walk(root, "0"), count, truncated };
+};
+var resolveId = (root, id) => {
+  const parts = id.split(".");
+  if (parts[0] !== "0") return null;
+  let n = root;
+  for (const p of parts.slice(1)) {
+    if (!n) return null;
+    n = p === "s" ? shadowOf(n) : visibleChildren(n)[Number(p)] ?? null;
+  }
+  return n;
+};
+var overlay = null;
+var overlayLabel = null;
+var highlighted = null;
+var rectOf = (n) => {
+  if (n.nodeType === 1) return n.getBoundingClientRect();
+  if (n.nodeType === 11) return n.host?.getBoundingClientRect() ?? null;
+  if (n.nodeType === 3) {
+    const range = n.ownerDocument?.createRange();
+    if (!range) return null;
+    range.selectNodeContents(n);
+    return range.getBoundingClientRect();
+  }
+  return null;
+};
+var tagOf = (n) => n.nodeType === 3 ? "#text" : n.nodeType === 11 ? "#shadow-root" : n.localName;
+var clearHighlight = () => {
+  highlighted = null;
+  if (overlay) overlay.style.display = "none";
+};
+var showHighlight = (instance, doc, target) => {
+  const r = rectOf(target);
+  if (!r) return null;
+  if (!overlay || overlay.ownerDocument !== doc || !overlay.isConnected) {
+    overlay?.remove();
+    overlay = doc.createElement("div");
+    overlay.setAttribute("data-atoll-devtools", "highlight");
+    overlay.style.cssText = "position:fixed;pointer-events:none;z-index:2147483647;box-sizing:border-box;outline:2px solid #58a6ff;background:rgba(88,166,255,.18);display:none";
+    overlayLabel = doc.createElement("span");
+    overlayLabel.style.cssText = "position:absolute;left:0;white-space:nowrap;font:11px/16px ui-monospace,monospace;padding:0 5px;border-radius:3px;background:#1f6feb;color:#fff";
+    overlay.appendChild(overlayLabel);
+    (doc.body ?? doc.documentElement).appendChild(overlay);
+  }
+  overlay.style.left = `${r.left}px`;
+  overlay.style.top = `${r.top}px`;
+  overlay.style.width = `${r.width}px`;
+  overlay.style.height = `${r.height}px`;
+  overlay.style.display = "block";
+  if (overlayLabel) {
+    overlayLabel.textContent = `${tagOf(target)} ${Math.round(r.width)}\xD7${Math.round(r.height)}`;
+    overlayLabel.style.top = r.top >= 18 ? "-18px" : "100%";
+  }
+  highlighted = { instance };
+  return { x: r.left, y: r.top, w: r.width, h: r.height };
+};
+var restoreFns = (next, current) => {
+  if (next === "[fn]" && (typeof current === "function" || isCallbackMarker(current))) return current;
+  if (Array.isArray(next)) {
+    return next.map((v, i) => restoreFns(v, Array.isArray(current) ? current[i] : void 0));
+  }
+  if (next !== null && typeof next === "object") {
+    const cur = current !== null && typeof current === "object" ? current : {};
+    const out = {};
+    for (const [k, v] of Object.entries(next)) out[k] = restoreFns(v, cur[k]);
+    return out;
+  }
+  return next;
+};
+var ensureIslandCommands = () => {
+  if (commandsRegistered) return;
+  commandsRegistered = true;
+  registerDevtoolsCommand(
+    "island.list",
+    () => [...islands.values()].map(({ handle }) => ({
+      instance: handle.instance,
+      app: handle.app,
+      pid: handle.pid,
+      mode: handle.mode
+    }))
+  );
+  registerDevtoolsCommand("island.tree", (args) => {
+    const { el } = entryOf(args);
+    const max = Math.min(Math.max(Number(args.maxNodes) || 3e3, 1), 2e4);
+    return serializeTree(el, max);
+  });
+  registerDevtoolsCommand("island.highlight", (args) => {
+    const entry = entryOf(args);
+    if (args.id === null || args.id === void 0) {
+      clearHighlight();
+      return { ok: true };
+    }
+    const target = resolveId(entry.el, String(args.id));
+    if (!target) {
+      clearHighlight();
+      return { ok: false };
+    }
+    const rect = showHighlight(entry.handle.instance, entry.el.ownerDocument, target);
+    return { ok: rect !== null, rect };
+  });
+  registerDevtoolsCommand("island.props", (args) => {
+    const raw = entryOf(args).props();
+    return { props: jsonSafe(raw), preview: propsPreview(raw) };
+  });
+  registerDevtoolsCommand("island.updateProps", async (args) => {
+    const entry = entryOf(args);
+    const next = args.props;
+    if (next === null || typeof next !== "object" || Array.isArray(next)) {
+      throw new Error("island.updateProps: `props` must be an object");
+    }
+    const restored = restoreFns(next, entry.props());
+    await entry.handle.updateProps(restored);
+    return { ok: true, preview: previewValue2(jsonSafe(restored), 4096) };
+  });
+  registerDevtoolsCommand("island.setMode", (args) => {
+    const { handle } = entryOf(args);
+    const mode = args.mode;
+    if (mode !== "push" && mode !== "poll") throw new Error("island.setMode: mode must be 'push' or 'poll'");
+    handle.setMode(mode);
+    return { mode: handle.mode };
+  });
+};
+
+// src/island.ts
+var keepAliveClients = /* @__PURE__ */ new WeakSet();
+var isKeepAliveClient = (client) => keepAliveClients.has(client);
+var connectIslandWorker = ({
+  worker,
+  doorbell,
+  keepAlive,
+  ...options
+}) => {
+  const client = connectWorker({
+    ...options,
+    sharedMemory: doorbell === false ? void 0 : makeDoorbell(),
+    worker,
+    workers: 1
+  });
+  if (keepAlive) keepAliveClients.add(client);
+  return client;
+};
+var POINTER_FAMILY = /^(mouse|pointer|drag|drop|wheel|mousewheel|DOMMouseScroll|click|dblclick|auxclick|contextmenu|selectstart|gotpointercapture|lostpointercapture)/;
+var WHEEL_FAMILY = /^(wheel|mousewheel|DOMMouseScroll)$/;
+function buildEventPayload(e, target, targetId, relatedTargetId) {
+  const input = target;
+  const mouse = e;
+  const wheel = e;
+  const pointer = e;
+  const pointerFam = POINTER_FAMILY.test(e.type) || typeof MouseEvent !== "undefined" && e instanceof MouseEvent;
+  const wheelFam = WHEEL_FAMILY.test(e.type) || typeof WheelEvent !== "undefined" && e instanceof WheelEvent;
+  const num = (v) => typeof v === "number" ? v : void 0;
+  const coord = (v) => num(v) ?? (pointerFam ? 0 : void 0);
+  const button = num(mouse.button) ?? (pointerFam ? 0 : void 0);
+  const ct = e.currentTarget;
+  const localRect = ct && typeof ct.getBoundingClientRect === "function" ? ct.getBoundingClientRect() : null;
+  const local = (v, origin) => localRect && typeof v === "number" ? v - origin : void 0;
+  return {
+    type: e.type,
+    value: input && "value" in input ? input.value : void 0,
+    checked: input && "checked" in input ? input.checked : void 0,
+    key: e.key,
+    clientX: coord(mouse.clientX),
+    clientY: coord(mouse.clientY),
+    screenX: coord(mouse.screenX),
+    screenY: coord(mouse.screenY),
+    zrX: local(mouse.clientX, localRect?.left ?? 0),
+    zrY: local(mouse.clientY, localRect?.top ?? 0),
+    button,
+    which: typeof mouse.which === "number" && mouse.which !== 0 ? mouse.which : button !== void 0 ? button + 1 : void 0,
+    shiftKey: typeof mouse.shiftKey === "boolean" ? mouse.shiftKey : void 0,
+    ctrlKey: typeof mouse.ctrlKey === "boolean" ? mouse.ctrlKey : void 0,
+    altKey: typeof mouse.altKey === "boolean" ? mouse.altKey : void 0,
+    metaKey: typeof mouse.metaKey === "boolean" ? mouse.metaKey : void 0,
+    deltaX: num(wheel.deltaX) ?? (wheelFam ? 0 : void 0),
+    deltaY: num(wheel.deltaY) ?? (wheelFam ? 0 : void 0),
+    deltaMode: num(wheel.deltaMode) ?? (wheelFam || typeof wheel.deltaX === "number" || typeof wheel.deltaY === "number" ? 0 : void 0),
+    pointerType: typeof pointer.pointerType === "string" ? pointer.pointerType : void 0,
+    scrollTop: input instanceof HTMLElement ? input.scrollTop : void 0,
+    targetId,
+    relatedTargetId
+  };
+}
+var measureReplay = (instance, via, count, start, end) => {
+  if (typeof performance?.measure !== "function") return;
+  const name = `atoll replay ${instance}`;
+  try {
+    performance.measure(name, {
+      start,
+      end,
+      detail: {
+        devtools: {
+          dataType: "track-entry",
+          trackGroup: "atoll",
+          track: "islands",
+          color: "primary",
+          tooltipText: `${instance} \xB7 ${via} \xB7 ${count} ops`,
+          properties: [["via", via], ["ops", count]]
+        }
+      }
+    });
+    performance.clearMeasures?.(name);
+  } catch {
+  }
+};
+var islandSeq = 0;
+var clientMounts = /* @__PURE__ */ new WeakMap();
+var canClone = (v) => {
+  try {
+    structuredClone(v);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isPlainObject = (v) => {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+var uncloneablePath = (value, path) => {
+  const kids = Array.isArray(value) ? value.map((v, i) => [`[${i}]`, v]) : isPlainObject(value) ? Object.entries(value) : [];
+  for (const [k, v] of kids) {
+    if (!canClone(v)) {
+      const next = path === "" ? k : k.startsWith("[") ? `${path}${k}` : `${path}.${k}`;
+      return uncloneablePath(v, next);
+    }
+  }
+  return path;
+};
+var assertCloneableProps = (props, context) => {
+  if (canClone(props)) return;
+  const path = uncloneablePath(props, "");
+  throw new Error(
+    `[island] ${context}: prop '${path}' is not structured-cloneable \u2014 props cross the worker boundary via postMessage. Pass plain data; behavior crosses through emit/onEvent, callbackProp() for shell functions, slots, or a task method on the worker.`
+  );
+};
+var UNITLESS_CSS = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+var cssStyleValue = (key, value) => {
+  if (typeof value === "number" && value !== 0 && !key.startsWith("--") && !UNITLESS_CSS.has(key)) {
+    return `${value}px`;
+  }
+  return String(value);
+};
+var subMounter = null;
+var registerSubIslandMounter = (fn) => {
+  subMounter = fn;
+};
+var isProxyMountTarget = (el) => typeof el?.doc?.instance === "string";
+async function mountIsland(opts) {
+  const {
+    el: target,
+    onEvent,
+    onActivity,
+    onOps,
+    slots,
+    mode: initialMode,
+    mountTimeout,
+    client: givenClient,
+    worker,
+    app: givenApp,
+    props: givenProps,
+    framework,
+    ...workerConfig
+  } = opts;
+  if (isProxyMountTarget(target)) {
+    if (subMounter === null) {
+      throw new Error(
+        "mountIsland: a proxy-element mount target means a nested island \u2014 the worker entry (`@atolljs/islands/worker`) must be loaded to register the sub-mounter."
+      );
+    }
+    return subMounter(opts);
+  }
+  const el = target;
+  const cbTable = /* @__PURE__ */ new Map();
+  let cbSeq = 0;
+  const registerCb = (fn) => {
+    cbTable.set(++cbSeq, fn);
+    return cbSeq;
+  };
+  const props = marshalCallbackProps(givenProps ?? {}, registerCb);
+  let currentProps = givenProps ?? {};
+  if (givenClient === void 0 && worker === void 0) {
+    throw new Error(
+      "mountIsland: pass `worker` (a `() => new Worker(...)`/URL entry \u2014 this call builds the island-owned client) or `client` (a shared connectIslandWorker \u2014 several islands, one worker)"
+    );
+  }
+  const client = givenClient ?? connectIslandWorker({
+    name: givenApp,
+    ...workerConfig,
+    worker,
+    // Poll-mode shorthand islands don't need SharedArrayBuffer at all —
+    // skip the doorbell contract so the page needs no COOP/COEP headers.
+    doorbell: initialMode !== "poll"
+  });
+  assertCloneableProps(props, `mountIsland(${givenApp ?? "main"})`);
+  const app = givenApp ?? "main";
+  const instance = `${app}@${++islandSeq}`;
+  clientMounts.set(client, (clientMounts.get(client) ?? 0) + 1);
+  const nodes = /* @__PURE__ */ new Map([[0, el]]);
+  const nodeIds = new WeakMap([[el, 0]]);
+  const prevProps = /* @__PURE__ */ new Map();
+  const nodeListeners = /* @__PURE__ */ new Map();
+  const slotNodes = /* @__PURE__ */ new Map();
+  const measuredIds = /* @__PURE__ */ new Set();
+  const pendingRects = /* @__PURE__ */ new Map();
+  let rectObserver = null;
+  let rectTimer = null;
+  let rectLastPush = -Infinity;
+  function flushRects() {
+    rectTimer = null;
+    if (pendingRects.size === 0 || destroyed) return;
+    rectLastPush = Date.now();
+    const batch = [...pendingRects.values()];
+    pendingRects.clear();
+    void islandCall("setRects", client.setRects(instance, batch)).then(
+      (ops) => applyOps(ops, "setRects")
+    );
+  }
+  function scheduleRectFlush() {
+    if (rectTimer !== null) return;
+    const elapsed = Date.now() - rectLastPush;
+    rectTimer = window.setTimeout(flushRects, elapsed >= 100 ? 0 : 100 - elapsed);
+  }
+  const queueRect = (id, node) => {
+    const r = node.getBoundingClientRect();
+    pendingRects.set(id, { id, x: r.x, y: r.y, w: r.width, h: r.height });
+    scheduleRectFlush();
+  };
+  const ensureRectObserver = () => {
+    if (rectObserver === null && typeof ResizeObserver === "function") {
+      rectObserver = new ResizeObserver((entries) => {
+        for (const entry of entries) {
+          const id = nodeIds.get(entry.target);
+          if (id !== void 0) queueRect(id, entry.target);
+        }
+      });
+    }
+  };
+  const unmeasure = (id) => {
+    if (!measuredIds.delete(id)) return;
+    pendingRects.delete(id);
+    const node = nodes.get(id);
+    if (node !== void 0) rectObserver?.unobserve(node);
+  };
+  const mountSlot = (node, id, name) => {
+    node.setAttribute("data-atoll-slot", name);
+    const prev = slotNodes.get(id);
+    if (prev !== void 0 && prev !== name) opts.slots?.[prev]?.(null);
+    slotNodes.set(id, name);
+    slots?.[name]?.(node);
+  };
+  const unmountSlot = (id) => {
+    const name = slotNodes.get(id);
+    if (name !== void 0) {
+      slots?.[name]?.(null);
+      slotNodes.delete(id);
+    }
+  };
+  const isElementNode = (node) => node !== void 0 && node.nodeType === 1;
+  const unmountSlotSubtree = (node) => {
+    if (!isElementNode(node)) return;
+    for (const [id, slotEl] of Array.from(slotNodes.entries()).map(([id2]) => [id2, nodes.get(id2)])) {
+      if (slotEl === node || node.contains(slotEl)) unmountSlot(id);
+    }
+  };
+  const DETACHED_CAP = 1024;
+  const detached = /* @__PURE__ */ new Map();
+  const detachedIds = /* @__PURE__ */ new Map();
+  const tombstoneId = (id, node) => {
+    unmeasure(id);
+    detachedIds.set(node, id);
+    detached.set(id, {
+      node,
+      props: prevProps.get(id),
+      listeners: nodeListeners.get(id),
+      // The slot name survives unmountSlot's slotNodes.delete only on the
+      // element's marker attribute — read it from the DOM, not the map.
+      slot: isElementNode(node) ? node.getAttribute("data-atoll-slot") ?? void 0 : void 0
+    });
+    nodes.delete(id);
+    nodeIds.delete(node);
+    prevProps.delete(id);
+    nodeListeners.delete(id);
+    if (detached.size > DETACHED_CAP) {
+      const oldest = detached.keys().next().value;
+      if (oldest !== void 0) {
+        const dead = detached.get(oldest);
+        detached.delete(oldest);
+        if (dead !== void 0) detachedIds.delete(dead.node);
+      }
+    }
+  };
+  const tombstoneSubtree = (rootId, root) => {
+    const walk = (node) => {
+      const id = node === root ? rootId : nodeIds.get(node);
+      if (id !== void 0 && id !== 0) tombstoneId(id, node);
+      for (const child of Array.from(node.childNodes)) walk(child);
+    };
+    walk(root);
+  };
+  const promoteSubtree = (id) => {
+    const tomb = detached.get(id);
+    if (tomb === void 0) return nodes.get(id);
+    detached.delete(id);
+    detachedIds.delete(tomb.node);
+    nodes.set(id, tomb.node);
+    nodeIds.set(tomb.node, id);
+    if (tomb.props !== void 0) prevProps.set(id, tomb.props);
+    if (tomb.listeners !== void 0) nodeListeners.set(id, tomb.listeners);
+    if (tomb.slot !== void 0) {
+      slotNodes.set(id, tomb.slot);
+      opts.slots?.[tomb.slot]?.(tomb.node);
+    }
+    for (const child of Array.from(tomb.node.childNodes)) {
+      const cid = detachedIds.get(child);
+      if (cid !== void 0) promoteSubtree(cid);
+    }
+    return tomb.node;
+  };
+  const nodeById = (id) => nodes.get(id) ?? promoteSubtree(id);
+  let opsApplied = 0;
+  let flushCalls = 0;
+  let mode = initialMode ?? "push";
+  let unsubscribe = null;
+  let pollTimer = null;
+  let destroyed = false;
+  const COALESCE_EVENTS = /* @__PURE__ */ new Set(["mousemove", "pointermove", "touchmove", "drag", "dragover"]);
+  const MAX_IN_FLIGHT_DISPATCH = 4;
+  const UNMOUNT_GRACE_MS = 1500;
+  const dispatchQueue = [];
+  let inFlightDispatches = 0;
+  const pumpDispatches = () => {
+    while (!destroyed && inFlightDispatches < MAX_IN_FLIGHT_DISPATCH && dispatchQueue.length > 0) {
+      const next = dispatchQueue.shift();
+      inFlightDispatches++;
+      void islandCall("dispatch", client.dispatch(next.handlerId, next.payload)).then((ops) => applyOps(ops, "dispatch")).catch((err) => console.error(`[island ${instance}] dispatch failed`, err)).finally(() => {
+        inFlightDispatches--;
+        pumpDispatches();
+      });
+    }
+  };
+  function listenerFor(handlerId) {
+    return (e) => {
+      if (destroyed) return;
+      const target2 = e.target;
+      const payload = buildEventPayload(
+        e,
+        target2,
+        target2 !== null ? nodeIds.get(target2) : void 0,
+        nodeIds.get(e.relatedTarget)
+      );
+      const key = COALESCE_EVENTS.has(e.type) ? `${handlerId}:${e.type}` : null;
+      if (key !== null) {
+        const stale = dispatchQueue.findIndex((q) => q.key === key);
+        if (stale !== -1) dispatchQueue.splice(stale, 1);
+      }
+      dispatchQueue.push({ handlerId, key, payload });
+      pumpDispatches();
+    };
+  }
+  function setProp(el2, id, name, value) {
+    if (name === "data-atoll-slot") {
+      mountSlot(el2, id, String(value));
+      return;
+    }
+    if (isEventRef(value)) {
+      const eventName = name.slice(2).toLowerCase();
+      let table = nodeListeners.get(id);
+      if (!table) nodeListeners.set(id, table = /* @__PURE__ */ new Map());
+      if (!table.has(eventName)) {
+        const listener = listenerFor(value.__evt);
+        table.set(eventName, listener);
+        el2.addEventListener(eventName, listener);
+      }
+      return;
+    }
+    if (name === "style" && typeof value === "object" && value !== null) {
+      const decl = el2.style;
+      const elStyle = decl;
+      const prevStyle = prevProps.get(id)?.style ?? {};
+      const nextStyle = value;
+      for (const k of Object.keys(prevStyle)) if (!(k in nextStyle)) elStyle[k] = "";
+      for (const [k, v] of Object.entries(nextStyle)) {
+        if (prevStyle[k] !== v) {
+          if (k.startsWith("--") || k.includes("-")) decl.setProperty(k, cssStyleValue(k, v));
+          else elStyle[k] = cssStyleValue(k, v);
+        }
+      }
+      return;
+    }
+    if (name === "className") {
+      if (el2 instanceof SVGElement) el2.setAttribute("class", String(value));
+      else el2.className = String(value);
+      return;
+    }
+    if (value === true) {
+      el2.setAttribute(name, "");
+      if (name in el2) el2[name] = true;
+      return;
+    }
+    if (value === false) {
+      el2.removeAttribute(name);
+      if (name in el2) el2[name] = false;
+      return;
+    }
+    if (name in el2) {
+      try {
+        el2[name] = value;
+        return;
+      } catch {
+      }
+    }
+    el2.setAttribute(name, String(value));
+  }
+  function removeProp(el2, id, name, oldValue) {
+    if (name === "data-atoll-slot") {
+      unmountSlot(id);
+      el2.removeAttribute("data-atoll-slot");
+      return;
+    }
+    if (isEventRef(oldValue)) {
+      const eventName = name.slice(2).toLowerCase();
+      const listener = nodeListeners.get(id)?.get(eventName);
+      if (listener) {
+        el2.removeEventListener(eventName, listener);
+        nodeListeners.get(id)?.delete(eventName);
+      }
+      return;
+    }
+    if (name === "className") {
+      if (el2 instanceof SVGElement) el2.removeAttribute("class");
+      else el2.className = "";
+      return;
+    }
+    if (name === "style") {
+      el2.removeAttribute("style");
+      return;
+    }
+    if (name in el2 && typeof el2[name] === "boolean") {
+      el2[name] = false;
+    }
+    el2.removeAttribute(name);
+  }
+  function applyProps(el2, id, prev, next) {
+    for (const name of Object.keys(prev)) {
+      if (!(name in next)) removeProp(el2, id, name, prev[name]);
+    }
+    for (const [name, value] of Object.entries(next)) {
+      if (prev[name] !== value || isEventRef(value)) setProp(el2, id, name, value);
+    }
+  }
+  function setAttr(node, id, name, value) {
+    if (name === "data-atoll-slot") {
+      if (value === null) {
+        unmountSlot(id);
+        node.removeAttribute("data-atoll-slot");
+      } else {
+        mountSlot(node, id, value);
+      }
+      return;
+    }
+    if (value === null) {
+      if (name === "className") node.className = "";
+      else if (name === "style") node.removeAttribute("style");
+      else {
+        if (name in node && typeof node[name] === "boolean") {
+          node[name] = false;
+        }
+        node.removeAttribute(name);
+      }
+      return;
+    }
+    if (name === "class" || name === "className") {
+      if (node instanceof SVGElement) node.setAttribute("class", value);
+      else node.className = value;
+      return;
+    }
+    if (name === "style") {
+      node.setAttribute("style", value);
+      return;
+    }
+    if (name in node) {
+      try {
+        const cur = node[name];
+        node[name] = typeof cur === "boolean" ? true : value;
+        return;
+      } catch {
+      }
+    }
+    node.setAttribute(name, value);
+  }
+  function mergeStyle(node, id, changes) {
+    const elStyle = node.style;
+    const elStyleMap = elStyle;
+    const hadStyleAttr = node.hasAttribute("style");
+    const prev = prevProps.get(id) ?? {};
+    const merged = { ...prev.style ?? {} };
+    for (const [k, v] of Object.entries(changes)) {
+      const cv = cssStyleValue(k, v);
+      if (k.startsWith("--") || k.includes("-")) {
+        elStyle.setProperty(k, cv);
+      } else if (cv.endsWith("!important")) {
+        elStyle.setProperty(k, cv.replace(/\s*!important$/, ""), "important");
+      } else {
+        elStyleMap[k] = cv;
+      }
+      merged[k] = v;
+    }
+    if (hadStyleAttr && !node.hasAttribute("style")) node.setAttribute("style", "");
+    prev.style = merged;
+    prevProps.set(id, prev);
+  }
+  const realDocument = el.ownerDocument ?? document;
+  function applyOp(op) {
+    switch (op.t) {
+      case "create": {
+        const node = op.ns !== void 0 ? realDocument.createElementNS(op.ns, op.type) : realDocument.createElement(op.type);
+        nodes.set(op.id, node);
+        nodeIds.set(node, 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 = realDocument.createTextNode(op.text);
+        nodes.set(op.id, node);
+        nodeIds.set(node, op.id);
+        break;
+      }
+      case "append": {
+        let parent = nodeById(op.parent);
+        const child = nodeById(op.child);
+        if (!parent || !child) {
+          console.error(`[island] append skipped: parent=${op.parent}\u2192${String(parent)} child=${op.child}\u2192${String(child)}`);
+          break;
+        }
+        if (isElementNode(parent) && parent.tagName === "TEMPLATE") {
+          parent = parent.content;
+        }
+        const before = op.before !== void 0 ? nodeById(op.before) ?? null : null;
+        parent.insertBefore(child, before);
+        break;
+      }
+      case "remove": {
+        const child = nodeById(op.child);
+        if (child !== void 0) {
+          unmountSlotSubtree(child);
+          tombstoneSubtree(op.child, child);
+        }
+        child?.parentNode?.removeChild(child);
+        break;
+      }
+      case "update": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) 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 = nodeById(op.id);
+        if (node) node.textContent = op.text;
+        break;
+      }
+      case "attr": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) break;
+        setAttr(node, op.id, op.name, op.value);
+        break;
+      }
+      case "style": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) break;
+        mergeStyle(node, op.id, op.props);
+        break;
+      }
+      case "listen": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) break;
+        const key = `${op.type}#${op.handler}`;
+        let table = nodeListeners.get(op.id);
+        if (!table) nodeListeners.set(op.id, table = /* @__PURE__ */ new Map());
+        if (!table.has(key)) {
+          const listener = listenerFor(op.handler);
+          table.set(key, listener);
+          node.addEventListener(op.type, listener, op.opts);
+        }
+        break;
+      }
+      case "unlisten": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) break;
+        const key = `${op.type}#${op.handler}`;
+        const listener = nodeListeners.get(op.id)?.get(key);
+        if (listener) {
+          node.removeEventListener(op.type, listener, op.opts?.capture);
+          nodeListeners.get(op.id)?.delete(key);
+        }
+        break;
+      }
+      case "clear": {
+        unmountSlotSubtree(el);
+        for (const child of Array.from(el.childNodes)) {
+          const id = nodeIds.get(child);
+          if (id !== void 0) tombstoneSubtree(id, child);
+        }
+        el.replaceChildren();
+        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: previewValue3(op.payload, 1024) });
+        }
+        onEvent?.(op.name, op.payload);
+        break;
+      }
+      case "measure": {
+        const node = nodeById(op.id);
+        if (!isElementNode(node)) break;
+        measuredIds.add(op.id);
+        ensureRectObserver();
+        rectObserver?.observe(node);
+        queueRect(op.id, node);
+        break;
+      }
+      case "unmeasure": {
+        unmeasure(op.id);
+        break;
+      }
+    }
+  }
+  function applyOps(ops, via) {
+    opsApplied += ops.length;
+    onActivity?.();
+    const t0 = performance.now();
+    for (const op of ops) applyOp(op);
+    const t1 = performance.now();
+    const replayMs = t1 - t0;
+    if (devtoolsEnabled()) {
+      emitDevtools({
+        type: "island:ops",
+        instance,
+        via,
+        count: ops.length,
+        replayMs,
+        bytes: estimateCloneBytes(ops)
+      });
+      measureReplay(instance, via, ops.length, t0, t1);
+    }
+    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 doorbell = 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" && doorbell !== null) unsubscribe = doorbell.subscribe(doFlush);
+    else pollTimer = window.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 worker never answered within ${mountMs}ms \u2014 check that the entry module loads (bundler path, uncaught import errors) and calls definePolyWorker/defineMonoWorker. Pass { mountTimeout: 0 } to disable.`
+            )
+          ),
+          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(currentProps) });
+    }
+  } 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 sizeTimer = null;
+  let sizeLastPush = -Infinity;
+  let lastW = -1;
+  let lastH = -1;
+  const pushSize = () => {
+    const w = el.clientWidth;
+    const h = el.clientHeight;
+    if (w === lastW && h === lastH) return;
+    lastW = w;
+    lastH = h;
+    void islandCall("setSize", client.setSize(instance, w, h)).then((ops) => applyOps(ops, "setSize"));
+  };
+  const resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => {
+    const now = Date.now();
+    const elapsed = now - sizeLastPush;
+    if (elapsed >= 100) {
+      sizeLastPush = now;
+      pushSize();
+    } else if (sizeTimer === null) {
+      sizeTimer = window.setTimeout(() => {
+        sizeTimer = null;
+        sizeLastPush = Date.now();
+        pushSize();
+      }, 100 - elapsed);
+    }
+  }) : null;
+  resizeObserver?.observe(el);
+  sizeLastPush = Date.now();
+  pushSize();
+  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);
+      assertCloneableProps(marshalled, `updateProps(${app})`);
+      applyOps(await islandCall("updateProps", client.updateProps(instance, marshalled)), "updateProps");
+      currentProps = next;
+      if (devtoolsEnabled()) emitDevtools({ type: "island:props", instance, props: propsPreview(next) });
+    },
+    flush: async () => {
+      applyOps(await islandCall("flush", client.flush(instance)), "flush");
+    },
+    destroy: () => {
+      destroyed = true;
+      untrackDevtools?.();
+      untrackDevtools = null;
+      emitDevtools({ type: "island:unmount", instance });
+      unsubscribe?.();
+      resizeObserver?.disconnect();
+      rectObserver?.disconnect();
+      if (pollTimer !== null) clearInterval(pollTimer);
+      if (sizeTimer !== null) clearTimeout(sizeTimer);
+      if (rectTimer !== null) clearTimeout(rectTimer);
+      pendingRects.clear();
+      measuredIds.clear();
+      const remaining = (clientMounts.get(client) ?? 1) - 1;
+      clientMounts.set(client, remaining);
+      let finished = false;
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        nodes.clear();
+        detached.clear();
+        detachedIds.clear();
+        prevProps.clear();
+        nodeListeners.clear();
+        cbTable.clear();
+        slotNodes.clear();
+        dispatchQueue.length = 0;
+        const warm = opts.keepAlive === true || isKeepAliveClient(client);
+        if (remaining <= 0 && !warm && (clientMounts.get(client) ?? 0) === 0)
+          client.terminate();
+      };
+      void islandCall("unmount", client.unmount(instance)).then((ops) => applyOps(ops, "unmount")).catch(() => {
+      }).finally(finish);
+      setTimeout(finish, UNMOUNT_GRACE_MS);
+    }
+  };
+  let untrackDevtools = devtoolsEnabled() ? trackIslandForDevtools({ handle, el, props: () => currentProps }) : null;
+  return handle;
+}
+
+// src/contract.ts
+var CONTRACT_MARK = "islandContract";
+var APP_CONTRACT = "appContract";
+function defineIslandContract(contract) {
+  return { ...contract, [CONTRACT_MARK]: true };
+}
+var isIslandContract = (value) => typeof value === "object" && value !== null && value[CONTRACT_MARK] === true;
+function withContract(contract, app) {
+  app[APP_CONTRACT] = contract;
+  return app;
+}
+var contractOf = (app) => {
+  if (typeof app !== "object" && typeof app !== "function") return void 0;
+  if (app === null) return void 0;
+  const c = app[APP_CONTRACT];
+  return isIslandContract(c) ? c : void 0;
+};
+var contractWorkerOf = (app) => isIslandContract(app) ? app.worker : void 0;
+
+// src/app.ts
+var ISLAND_APP_NAME = "islandAppName";
+var islandApp = (name, app) => {
+  app[ISLAND_APP_NAME] = name;
+  return app;
+};
+var islandAppNameOf = (app) => {
+  if (typeof app === "string") return app === "" ? void 0 : app;
+  if (app === null || typeof app !== "function" && typeof app !== "object") return void 0;
+  if (isIslandContract(app)) return app.app === "" ? void 0 : app.app;
+  const stamped = app[ISLAND_APP_NAME];
+  if (typeof stamped === "string" && stamped !== "") return stamped;
+  if (typeof app === "function") {
+    const named = app;
+    return named.displayName ?? (named.name !== "" ? named.name : void 0);
+  }
+  const imp = app.imperative;
+  if (typeof imp === "function") {
+    const stampedImp = imp[ISLAND_APP_NAME];
+    if (typeof stampedImp === "string" && stampedImp !== "") return stampedImp;
+    return imp.name !== "" ? imp.name : void 0;
+  }
+  return void 0;
+};
+
+export {
+  renderMemory,
+  makeDoorbell,
+  isEventRef,
+  CALLBACK_EVENT,
+  callbackProp,
+  marshalCallbackProps,
+  unmarshalCallbackProps,
+  propsPreview,
+  isKeepAliveClient,
+  connectIslandWorker,
+  assertCloneableProps,
+  cssStyleValue,
+  registerSubIslandMounter,
+  mountIsland,
+  defineIslandContract,
+  isIslandContract,
+  withContract,
+  contractOf,
+  contractWorkerOf,
+  islandApp,
+  islandAppNameOf
+};