@songsid/agend 2.2.0-beta.9 → 2.3.0-beta.1

package/dist/ui/shared/effect-frame.js

@@ -0,0 +1,127 @@
+/** #1629: parent-owned Canvas Worker transport; the Chat adapter owns product admission. */
+import { maySendEffectEvent } from "./effect-policy.js";
+const plain = v => !!v && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+const exact = (v, keys) => plain(v) && Object.keys(v).sort().join(",") === keys.slice().sort().join(",");
+const finite = v => typeof v === "number" && Number.isFinite(v);
+const bytes = v => new TextEncoder().encode(v).byteLength;
+
+/** Snapshot only host-validated code, primitives and raster bytes; no HTML or DOM interface exists. */
+function snapshotRender(raw) {
+  if (!exact(raw, ["code", "params", "instance", "width", "height", "dpr", "assets", "wants"]) || typeof raw.code !== "string" || !plain(raw.params) || !Array.isArray(raw.assets) || raw.assets.length > 16 || !Array.isArray(raw.wants) || Array.from(raw.wants).some(v => !["pointer", "state", "reply", "mention", "theme"].includes(v)) || new Set(raw.wants).size !== raw.wants.length) return null;
+  if (raw.instance !== null && (typeof raw.instance !== "string" || raw.instance.length < 1 || raw.instance.length > 128)) return null;
+  if (!Number.isInteger(raw.width) || raw.width < 1 || raw.width > 4096 || !Number.isInteger(raw.height) || raw.height < 1 || raw.height > 4096 || raw.width * raw.height > 8388608 || !finite(raw.dpr) || raw.dpr < 0.5 || raw.dpr > 3) return null;
+  const params = Object.create(null), keys = Object.keys(raw.params);
+  if (keys.length > 16) return null;
+  for (const key of keys) {
+    const value = raw.params[key];
+    if (!/^[a-z][a-z0-9_]{0,31}$/.test(key) || !(typeof value === "boolean" || finite(value) || typeof value === "string" && value.length <= 128)) return null;
+    params[key] = value;
+  }
+  let total = bytes(raw.code) + bytes(JSON.stringify(params));
+  if (total > 1048576) return null;
+  const assets = [], names = new Set();
+  for (const a of raw.assets) {
+    if (!exact(a, ["name", "mime", "bytes"]) || typeof a.name !== "string" || !/^assets\/[a-z0-9][a-z0-9_-]{0,63}\.(?:png|jpe?g|webp|gif)$/.test(a.name) || names.has(a.name) || !["image/png", "image/jpeg", "image/webp", "image/gif"].includes(a.mime) || !(a.bytes instanceof Uint8Array)) return null;
+    total += a.bytes.byteLength;
+    if (total > 1048576) return null;
+    names.add(a.name);
+    assets.push({ name: a.name, mime: a.mime, bytes: new Uint8Array(a.bytes) });
+  }
+  return { code: raw.code, params: { ...params }, instance: raw.instance, width: raw.width, height: raw.height, dpr: raw.dpr, assets, wants: [...raw.wants] };
+}
+
+/**
+ * All options come from the host, never from an agent event or manifest origin. The registry supplies an admitted
+ * root and geometry in a later integration. This primitive alone does not implement caps, clipping or profiling.
+ */
+export function createEffectFrame({ window: host, root, origin, boot, render, clock = () => performance.now(), onReady = () => {}, onRemove = () => {} } = {}) {
+  let url;
+  try { url = new URL(origin); } catch { return { ok: false, reason: "preview_unknown" }; }
+  if (origin !== url.origin || !["http:", "https:"].includes(url.protocol) || typeof boot !== "string" || !/^[0-9a-f]{32}$/.test(boot)) return { ok: false, reason: "preview_unknown" };
+  let hostOrigin; try { hostOrigin = new URL(host.location.origin); } catch { return { ok: false, reason: "preview_unknown" }; }
+  if (!["http:", "https:"].includes(hostOrigin.protocol) || origin === hostOrigin.origin || hostOrigin.protocol === "https:" && url.protocol !== "https:") return { ok: false, reason: "preview_unknown" };
+  const payload = snapshotRender(render);
+  if (!payload || !host || !root || root.ownerDocument !== host.document || typeof root.append !== "function" || typeof host.MessageChannel !== "function" || typeof clock !== "function" || typeof onReady !== "function" || typeof onRemove !== "function") return { ok: false, reason: "unsupported" };
+  let mounted;
+  try { mounted = clock(); } catch { return { ok: false, reason: "clock_unavailable" }; }
+  if (!finite(mounted) || mounted < 0) return { ok: false, reason: "clock_unavailable" };
+  const frame = host.document.createElement("iframe");
+  frame.setAttribute("sandbox", "allow-scripts");
+  frame.setAttribute("tabindex", "-1");
+  frame.setAttribute("aria-hidden", "true");
+  frame.setAttribute("referrerpolicy", "no-referrer");
+  frame.className = "agend-effect-frame";
+  let removed = false, ready = false, transferred = false, loads = 0, channel = null, timer = null, last = mounted;
+  const time = () => {
+    let now; try { now = clock(); } catch { return null; }
+    if (!finite(now) || now < last) return null;
+    last = now; return now;
+  };
+  const state = () => ({ ready, removed, loads });
+  const remove = reason => {
+    if (removed) return;
+    removed = true;
+    host.removeEventListener("message", hello);
+    frame.removeEventListener("load", load);
+    if (timer !== null) host.clearTimeout(timer);
+    if (channel) {
+      channel.port1.removeEventListener("message", portReady);
+      try { channel.port1.close(); } catch { /* already detached */ }
+      try { channel.port2.close(); } catch { /* already transferred */ }
+    }
+    frame.remove();
+    try { onRemove(reason); } catch { /* host callback cannot revive a removed frame */ }
+  };
+  const load = () => { loads++; if (loads > 1) remove("navigation"); };
+  const current = () => {
+    if (removed) return false;
+    if (frame.parentNode !== root || frame.isConnected !== true) { remove("detached"); return false; }
+    const now = time();
+    if (now === null) { remove("clock_unavailable"); return false; }
+    if (!ready && now - mounted >= 10000) { remove("startup_timeout"); return false; }
+    return true;
+  };
+  const portReady = event => {
+    if (removed || ready) return;
+    let data; try { data = event.data; } catch { return; }
+    if (!exact(data, ["type"]) || data.type !== "ready") return;
+    if (!current()) return;
+    ready = true;
+    host.clearTimeout(timer); timer = null;
+    channel.port1.removeEventListener("message", portReady);
+    try { onReady(); } catch { remove("host_callback"); }
+  };
+  const hello = event => {
+    if (removed || transferred) return;
+    let data; try { data = event.data; } catch { return; }
+    // Opaque sandbox messages have origin null. Only this exact WindowProxy and boot may receive the private port.
+    if (event.source !== frame.contentWindow || event.origin !== "null" || event.ports?.length || !exact(data, ["v", "type", "ch", "boot"]) || data.v !== 1 || data.type !== "ready" || data.ch !== null || data.boot !== boot) return;
+    if (!current()) return;
+    transferred = true;
+    host.removeEventListener("message", hello);
+    try {
+      channel = new host.MessageChannel();
+      channel.port1.addEventListener("message", portReady);
+      channel.port1.start();
+      const nonce = new Uint8Array(16); host.crypto.getRandomValues(nonce);
+      const ch = Array.from(nonce, b => b.toString(16).padStart(2, "0")).join("");
+      const { wants, ...message } = payload;
+      // '*' is required for the opaque destination; the source WindowProxy was checked immediately above.
+      frame.contentWindow.postMessage({ v: 1, type: "render", ch, ...message }, "*", [channel.port2]);
+    } catch { remove("transport"); }
+  };
+  const deadline = () => {
+    if (!current() || ready) return;
+    timer = host.setTimeout(deadline, Math.max(1, 10000 - (last - mounted)));
+  };
+  host.addEventListener("message", hello);
+  frame.addEventListener("load", load);
+  timer = host.setTimeout(deadline, 10000);
+  try { frame.src = `${origin}/effect`; root.append(frame); } catch { remove("mount_failed"); }
+  return { ok: true, element: frame, state, remove,
+    send(event) {
+      if (!ready || !current() || !maySendEffectEvent(event, { instance: payload.instance, wants: payload.wants })) return false;
+      try { channel.port1.postMessage(event); return true; } catch { remove("transport"); return false; }
+    },
+  };
+}

package/dist/ui/shared/effect-geometry.js

@@ -0,0 +1,122 @@
+/** #1629: host-only fixed viewport geometry and trust holes through the already-loaded, fixed same-origin app stylesheet. No inline attributes. */
+import { effectHostStyle } from "./effect-host-style.js";
+import { effectTrustClip } from "./effect-policy.js";
+import { effectStockSnapshot, effectStockAllows } from "./effect-stock-snapshot.js";
+let serial = 0;
+// Native CSSOM canonicalizes SVG command whitespace. Compare bounded tokens, never whitespace-stripped digits.
+function sameClip(expected, written) {
+  if (expected === "none") return written === "none";
+  const tokens = value => {
+    if (typeof value !== "string" || value.length > 100000) return null;
+    const m = /^path\(\s*evenodd\s*,\s*["']([^"']*)["']\s*\)$/.exec(value);
+    if (!m) return null;
+    const out = [], rest = m[1].replace(/[MHVZ]|-?\d+(?:\.\d+)?/g, token => { out.push(/[MHVZ]/.test(token) ? token : Number(token)); return ""; });
+    return /^[\s,]*$/.test(rest) ? JSON.stringify(out) : null;
+  };
+  const a = tokens(expected), b = tokens(written);
+  return a !== null && a === b;
+}
+const number = n => typeof n === "number" && Number.isFinite(n) && Math.abs(n) <= 1e7;
+/** A fixed frame must share viewport axes. Unknown transformed/filter/contained ancestors fail closed. */
+export function hostEffectSpace(host, element) {
+  try {
+    if (element?.ownerDocument !== host.document || element.isConnected !== true || typeof host.getComputedStyle !== "function") return false;
+    let el = element, seen = 0;
+    while (el) {
+      if (++seen > 128 || el.ownerDocument !== host.document) return false;
+      const s = host.getComputedStyle(el);
+      for (const key of ["transform", "perspective", "filter", "backdropFilter", "rotate", "scale", "translate", "offsetPath"]) if (s[key] !== undefined && s[key] !== "" && s[key] !== "none") return false;
+      if (s.contain !== "none" || s.willChange !== "auto" || s.contentVisibility !== undefined && s.contentVisibility !== "" && s.contentVisibility !== "visible" || s.zoom !== undefined && !["", "normal", "1"].includes(s.zoom)) return false;
+      if (el === host.document.documentElement) return true;
+      el = el.parentElement;
+    }
+    return false;
+  } catch { return false; }
+}
+export function hostEffectRect(element) {
+  try {
+    if (element?.isConnected !== true) return null;
+    const r = element.getBoundingClientRect();
+    if (![r.x, r.y, r.width, r.height].every(number) || r.width < 1 || r.height < 1) return null;
+    const x = Math.floor(r.x), y = Math.floor(r.y), width = Math.ceil(r.x + r.width) - x, height = Math.ceil(r.y + r.height) - y;
+    return width <= 4096 && height <= 4096 && width * height <= 8388608 ? { x, y, width, height } : null;
+  } catch { return null; }
+}
+export function createEffectGeometry({ window: host } = {}) {
+  let sheet;
+  try {
+    if (!host?.document || host.CSS?.supports("clip-path", 'path(evenodd, "M0 0H1V1H0Z")') !== true) return { ok: false, reason: "geometry_unsupported" };
+    sheet = effectHostStyle(host); if (!sheet) throw Error("app stylesheet unavailable");
+  } catch { return { ok: false, reason: "geometry_unsupported" }; }
+  const bound = new Set(); let disposed = false;
+  function bind(frame, { layer, by } = {}) {
+    if (disposed || !hostEffectSpace(host, frame) || !["front", "behind"].includes(layer) || !frame.classList) {
+      // The caller must also close its factory handle. Never leave its own rejected frame painting.
+      if (frame?.ownerDocument === host.document && typeof frame.remove === "function") frame.remove();
+      return { ok: false, reason: "geometry_unknown" };
+    }
+    const token = `agend-effect-geometry-${++serial}`;
+    let rule;
+    try {
+      const at = sheet.insertRule(`.${token}{}`, sheet.cssRules.length); rule = sheet.cssRules[at];
+      if (!rule?.style) throw Error("rule unavailable");
+      for (const [key, value] of Object.entries({ position: "fixed", border: "0px", margin: "0px", padding: "0px", "pointer-events": "none", "z-index": layer === "front" ? "20" : "0", opacity: layer === "front" && by !== "human" ? "0.85" : "1", visibility: "hidden", "background-color": "transparent", "box-sizing": "border-box", "box-shadow": "none", outline: "none", transition: "none", animation: "none", "min-width": "0px", "min-height": "0px", "max-width": "none", "max-height": "none" })) rule.style.setProperty(key, value, "important");
+      frame.classList.add(token);
+      // Binding is accepted BEFORE the first sync/ready. Prove its initial hidden state before the caller may yield.
+      if (host.getComputedStyle(frame).visibility !== "hidden") throw Error("initial hiding cascade lost");
+    } catch {
+      try { const at = [...sheet.cssRules].indexOf(rule); if (at >= 0) sheet.deleteRule(at); } catch { /* cleanup cannot precede physical refusal */ }
+      try { frame.classList.remove(token); } catch { /* the refused frame will not remain in the document */ }
+      frame.remove();
+      return { ok: false, reason: "geometry_unknown" };
+    }
+    let dead = false;
+    const hide = () => {
+      try {
+        rule.style.setProperty("visibility", "hidden", "important");
+        if (frame.isConnected === true && host.getComputedStyle(frame).visibility !== "hidden") frame.remove();
+      } catch { frame.remove(); }
+    };
+    const handle = { ok: true, hide,
+      /** Same-turn host paint snapshot is mandatory, including behind/human placements. No DOM fallback. */
+      sync(rect, stock) {
+        hide();
+        const proof = effectStockSnapshot(stock);
+        if (!effectStockAllows(proof, { layer, by })) return false;
+        if (dead || disposed || !hostEffectSpace(host, frame) || !rect || ![rect.x, rect.y, rect.width, rect.height].every(number) || ![rect.x, rect.y, rect.width, rect.height].every(Number.isInteger) || rect.width < 1 || rect.height < 1 || rect.width > 4096 || rect.height > 4096 || rect.width * rect.height > 8388608) { hide(); return false; }
+        let path = "none";
+        if (layer === "front" && by !== "human") {
+          const clipped = effectTrustClip(rect, proof.rects);
+          if (!clipped.ok) return false;
+          path = clipped.path;
+        }
+
+        try {
+          for (const key of ["x", "y", "width", "height"]) rule.style.setProperty(key === "x" ? "left" : key === "y" ? "top" : key, `${rect[key]}px`, "important");
+          rule.style.setProperty("clip-path", path, "important");
+          if (!sameClip(path, rule.style.getPropertyValue("clip-path"))) return false;
+          // The stylesheet can lose the cascade to another host rule. Verify the actual viewport and clip
+          // before revealing: holes expressed in planned coordinates cannot protect a transformed frame.
+          const style = host.getComputedStyle(frame), actual = frame.getBoundingClientRect();
+          if (style.position !== "fixed" || style.pointerEvents !== "none" || style.visibility !== "hidden" || style.opacity !== (layer === "front" && by !== "human" ? "0.85" : "1") || style.zIndex !== (layer === "front" ? "20" : "0") || !sameClip(path, style.clipPath) || !["x", "y", "width", "height"].every(key => number(actual[key]) && Math.abs(actual[key] - rect[key]) < 0.02)) return false;
+          rule.style.setProperty("visibility", "visible", "important");
+          return true;
+        } catch { hide(); return false; }
+      },
+      remove() {
+        if (dead) return; dead = true; hide(); bound.delete(handle);
+        if (frame.isConnected === true) frame.remove();
+        try { frame.classList.remove(token); const at = [...sheet.cssRules].indexOf(rule); if (at >= 0) sheet.deleteRule(at); } catch { frame.remove(); }
+      },
+    };
+    bound.add(handle); return handle;
+  }
+  return { ok: true, bind,
+    hide() { for (const h of bound) h.hide(); },
+    dispose() {
+      if (disposed) return; disposed = true;
+      for (const h of [...bound]) h.remove();
+      // The host link and its other rules remain intact. Each binding removed only its own rule.
+    },
+  };
+}

package/dist/ui/shared/effect-host-style.js

@@ -0,0 +1,10 @@
+/** Fixed same-origin host stylesheet only. No new sheet, inline style, owner CSS or supplied URL. */
+export function effectHostStyle(host) {
+  try {
+    const link = host?.document?.querySelector('link[rel="stylesheet"][href="/assets/app.css"]');
+    const href = new URL("/assets/app.css", host.location.origin).href;
+    if (!link || link.tagName !== "LINK" || link.ownerDocument !== host.document || link.isConnected !== true || link.disabled !== false || !link.sheet || link.sheet.ownerNode !== link || link.sheet.href !== href || link.sheet.disabled !== false) return null;
+    const sheet = link.sheet;
+    return typeof sheet.insertRule === "function" && typeof sheet.deleteRule === "function" && sheet.cssRules ? sheet : null;
+  } catch { return null; }
+}

package/dist/ui/shared/effect-owner-regions.js

@@ -0,0 +1,74 @@
+/** #1629: host-only personal region targets on the currently proven stock shell. No selection, code or frame authority. */
+import { createEffectGeometry, hostEffectRect, hostEffectSpace } from "./effect-geometry.js";
+import { effectStockSnapshot } from "./effect-stock-snapshot.js";
+const finite = n => typeof n === "number" && Number.isFinite(n);
+function viewport(host) {
+  const width = host.innerWidth, height = host.innerHeight;
+  return [width, height].every(n => Number.isInteger(n) && n >= 1 && n <= 4096) && width * height <= 8388608 ? { x: 0, y: 0, width, height } : null;
+}
+/** An anchored box uses edge padding; center ignores the offset. Oversized boxes shrink within that padding. */
+export function ownerEffectBoxRect(box, size) {
+  try {
+    if (!box || ![Object.prototype, null].includes(Object.getPrototypeOf(box))) return null;
+    const fields = Object.getOwnPropertyDescriptors(box), keys = Reflect.ownKeys(fields);
+    if (keys.length !== 4 || !["anchor", "width", "height", "offset"].every(k => fields[k] && Object.hasOwn(fields[k], "value"))) return null;
+    const b = Object.fromEntries(Object.entries(fields).map(([k, d]) => [k, d.value]));
+    if (!["top-left", "top-right", "bottom-left", "bottom-right", "center"].includes(b.anchor) || ![b.width, b.height].every(n => Number.isInteger(n) && n >= 32 && n <= 480) || !Number.isInteger(b.offset) || b.offset < 0 || b.offset > 64 || !size || ![size.width, size.height].every(n => Number.isInteger(n) && n >= 1 && n <= 4096) || size.width * size.height > 8388608) return null;
+    const pad = b.anchor === "center" ? 0 : b.offset, width = Math.min(b.width, size.width - pad * 2), height = Math.min(b.height, size.height - pad * 2);
+    if (width < 1 || height < 1) return null;
+    const x = b.anchor === "center" ? Math.floor((size.width - width) / 2) : b.anchor.endsWith("right") ? size.width - pad - width : pad;
+    const y = b.anchor === "center" ? Math.floor((size.height - height) / 2) : b.anchor.startsWith("bottom") ? size.height - pad - height : pad;
+    return { x, y, width, height };
+  } catch { return null; }
+}
+/** Caller supplies the authenticated lease and fresh stock proof. Header/sidebar are real stock elements;
+ * page/box are empty hidden host DOM references, never author DOM. They consume no frame/cap slot.
+ * A null result requires removing that descriptor; this primitive cannot retire a caller-owned effect frame. */
+export function createOwnerEffectRegions({ window: host, current, factories = {} } = {}) {
+  let dead = false, root = null, geometry = null;
+  const targets = new Map();
+  const dispose = () => { if (dead) return; dead = true; geometry?.dispose?.(); root?.remove(); targets.clear(); };
+  const refuse = () => { for (const row of targets.values()) row.binding.hide(); return null; };
+  const unavailable = () => ({ ok: false, dispose });
+  const alive = () => { if (dead) return false; const valid = current() === true; return !dead && valid && host.document.body.dataset.mode === "full"; };
+  try {
+    if (!host?.document || typeof current !== "function" || typeof host.getComputedStyle !== "function" || !alive()) return unavailable();
+    root = host.document.createElement("div"); root.className = "agend-effect-layer"; host.document.body.append(root);
+    geometry = (factories.geometry ?? createEffectGeometry)({ window: host }); if (!geometry.ok) { dispose(); return unavailable(); }
+  } catch { dispose(); return unavailable(); }
+  function panel() {
+    const nodes = host.document.querySelectorAll(".main > .panel"); if (nodes.length !== 1) return null;
+    const el = nodes[0], kind = el.getAttribute("data-effect-panel");
+    return kind === null ? el.classList.contains("p-chat") ? el : null
+      : ["fleet", "needs", "settings", "view", "log", "details"].includes(kind) && el.classList.contains(`p-${kind}`) ? el : null;
+  }
+  function resolve(slot, box, stock) {
+    try {
+      if (!alive() || !effectStockSnapshot(stock)) return refuse();
+      const surface = panel(), size = viewport(host); if (!surface || !size) return refuse();
+      if (slot === "fx.header" || slot === "fx.sidebar") {
+        const selector = slot === "fx.header" ? ".main > .panel > .panel-head[data-trust=header]" : ".shell > .sidebar";
+        const nodes = host.document.querySelectorAll(selector); if (nodes.length !== 1) return null;
+        const el = nodes[0], s = host.getComputedStyle(el), rect = hostEffectRect(el);
+        return alive() && panel() === surface && s.display !== "none" && s.visibility === "visible" && hostEffectSpace(host, el) && rect && rect.x + rect.width > 0 && rect.y + rect.height > 0 && rect.x < size.width && rect.y < size.height ? el : null;
+      }
+      if (!["fx.page", "fx.box"].includes(slot)) return null;
+      const rect = slot === "fx.page" ? size : ownerEffectBoxRect(box, size); if (!rect) return refuse();
+      let row = targets.get(slot);
+      if (!row) {
+        const element = host.document.createElement("div"); element.className = "agend-owner-effect-target"; element.setAttribute("aria-hidden", "true"); root.append(element);
+        const binding = geometry.bind(element, { layer: "behind", by: "human" });
+        if (!binding.ok) { element.remove(); return null; }
+        row = { element, binding }; targets.set(slot, row);
+      }
+      // Empty reference only: the synchronous existing hidden-first verification is followed by hide before yielding.
+      // The future registry owns the actual effect's layer/provenance/caps and independent fresh paint check.
+      if (!row.binding.sync(rect, stock)) { row.binding.remove(); targets.delete(slot); return null; }
+      row.binding.hide();
+      const actual = hostEffectRect(row.element);
+      if (!alive() || panel() !== surface || row.element.isConnected !== true || host.getComputedStyle(row.element).visibility !== "hidden" || !actual || !["x", "y", "width", "height"].every(k => finite(actual[k]) && actual[k] === rect[k])) { row.binding.remove(); targets.delete(slot); return null; }
+      return row.element;
+    } catch { return refuse(); }
+  }
+  return { ok: true, root, resolve, dispose };
+}

package/dist/ui/shared/effect-owner-source.js

@@ -0,0 +1,115 @@
+/** #1629: host-only personal contribution model. No fetch, timer, DOM creation, registry or playback. */
+import { checkEffectOwnerSlots } from "./effect-runtime-loader.js";
+import { effectStockSnapshot } from "./effect-stock-snapshot.js";
+const SLOTS = ["fx.page", "fx.header", "fx.sidebar", "fx.box"], ALL_SLOTS = [...SLOTS, "fx.cursor"];
+
+/** The app supplies its one loader/metadata scheduler, lifetime and fixed stock target resolver. */
+export function createOwnerEffectSource({ current, readMetadata, readResource, resolveTarget, stock, onChange = () => {}, onUnavailable = () => {} } = {}) {
+  let dead = false, generation = 0, serial = 0, metadata = null, error = null, active = null, rev = -1, checking = false, cursor = null;
+  const bySlot = new Map(), byKey = new Map(), paused = new Map(), failed = new Map();
+  const safe = fn => { try { return fn(); } catch { return null; } };
+  function alive() {
+    if (dead || checking) return false;
+    const before = generation; checking = true;
+    let value; try { value = current() === true; } catch { value = false; } finally { checking = false; }
+    return !dead && before === generation && value;
+  }
+  const fresh = (body, gen) => alive() && generation === gen && metadata === body;
+  function drop(slot) { const b = bySlot.get(slot); if (b) byKey.delete(b.key); bySlot.delete(slot); }
+  function clear() { bySlot.clear(); byKey.clear(); }
+  const notify = () => { if (alive()) safe(onChange); };
+  function dispose() { if (dead) return; dead = true; generation++; metadata = null; cursor = null; clear(); paused.clear(); failed.clear(); }
+  const unavailable = { ok: false, dispose };
+  if (![current, readMetadata, readResource, resolveTarget, stock, onChange, onUnavailable].every(x => typeof x === "function")) return unavailable;
+  function row(slot) { return alive() && SLOTS.includes(slot) ? metadata?.slots[slot] ?? null : null; }
+  function bindingCurrent(b) {
+    if (!b || !alive() || generation !== b.generation || bySlot.get(b.slot) !== b || byKey.get(b.key) !== b || failed.get(b.slot) === b.id) return false;
+    const selected = metadata?.slots[b.slot];
+    return selected?.status === "available" && selected.id === b.id && b.element.isConnected === true && !dead && generation === b.generation;
+  }
+  function cursorSelection() {
+    const body = metadata, gen = generation;
+    if (!alive() || !body || error) return null;
+    const selected = body.slots["fx.cursor"];
+    if (selected.status !== "available" || failed.get("fx.cursor") === selected.id || !selected.manifest.cursor) return null;
+    if (!cursor || cursor.id !== selected.id || cursor.generation !== gen) cursor = Object.freeze({ id: selected.id, generation: gen, hotspot: Object.freeze([...selected.manifest.cursor.hotspot]) });
+    return fresh(body, gen) && failed.get("fx.cursor") !== selected.id ? cursor : null;
+  }
+  function cursorCurrent(value) {
+    try {
+      const expected = cursorSelection(); if (!expected || !value || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return false;
+      const d = Object.getOwnPropertyDescriptors(value);
+      if (Reflect.ownKeys(d).length !== 3 || !["id", "generation", "hotspot"].every(k => d[k] && Object.hasOwn(d[k], "value")) || d.id.value !== expected.id || d.generation.value !== expected.generation) return false;
+      const a = d.hotspot.value; if (!Array.isArray(a) || Object.getPrototypeOf(a) !== Array.prototype) return false;
+      const h = Object.getOwnPropertyDescriptors(a);
+      return Reflect.ownKeys(h).length === 3 && h.length.value === 2 && [0, 1].every(k => h[k] && Object.hasOwn(h[k], "value") && h[k].value === expected.hotspot[k]) && cursorSelection() === expected;
+    } catch { return false; }
+  }
+  function refuse(b) {
+    if (!bindingCurrent(b)) return;
+    failed.set(b.slot, b.id); drop(b.slot); notify();
+    if (!dead && generation === b.generation && failed.get(b.slot) === b.id && metadata?.slots[b.slot]?.id === b.id) safe(() => onUnavailable(b.slot, b.id));
+  }
+  return { ok: true, cursorSelection, cursorCurrent,
+    refuseCursor(value) {
+      const own = cursorSelection(); if (!own || !cursorCurrent(value)) return;
+      failed.set("fx.cursor", own.id); notify();
+      if (!dead && generation === own.generation && failed.get("fx.cursor") === own.id && metadata?.slots["fx.cursor"]?.id === own.id) safe(() => onUnavailable("fx.cursor", own.id));
+    },
+    needsMetadata() { return alive() && metadata === null && error === null; },
+    invalidate() { if (dead) return; generation++; metadata = null; cursor = null; error = null; clear(); failed.clear(); notify(); },
+    async read(signal) {
+      if (!alive() || metadata !== null || error !== null || active || signal?.aborted) return false;
+      const op = { generation }; active = op;
+      const valid = () => alive() && generation === op.generation && active === op && !signal?.aborted;
+      try {
+        const answer = await readMetadata(signal); if (!valid()) return false;
+        const next = checkEffectOwnerSlots(answer);
+        if (!next || next.rev < rev) { error = next ? "stale" : "unreadable"; clear(); notify(); return false; }
+        rev = next.rev; metadata = next;
+        for (const [slot, id] of paused) if (next.slots[slot]?.id !== id) paused.delete(slot);
+        notify(); return valid() && metadata === next;
+      } catch { if (valid()) { error = "unreadable"; clear(); notify(); } return false; }
+      finally { if (active === op) active = null; }
+    },
+    descriptors() {
+      if (!alive() || !metadata || error) return [];
+      const body = metadata, gen = generation, proof = safe(() => effectStockSnapshot(stock()));
+      if (!fresh(body, gen)) return [];
+      if (!proof) { clear(); return []; }
+      const result = [];
+      for (const slot of SLOTS) {
+        const selected = body.slots[slot];
+        if (selected.status !== "available" || failed.get(slot) === selected.id) { drop(slot); continue; }
+        const element = safe(() => resolveTarget(slot, selected.manifest, proof));
+        if (!fresh(body, gen)) return [];
+        if (!element || element.isConnected !== true) { drop(slot); continue; }
+        let b = bySlot.get(slot);
+        if (!b || b.id !== selected.id || b.element !== element || b.generation !== gen) {
+          drop(slot); b = Object.freeze({ kind: "owner", slot, id: selected.id, key: `owner:${++serial}:${slot}:${selected.id}`, generation: gen, element });
+          bySlot.set(slot, b); byKey.set(b.key, b);
+        }
+        result.push({ key: b.key, id: b.id, by: "human", region: slot.slice(3), layer: selected.manifest.layer, order: 0, paused: paused.get(slot) === b.id, visible: true, instance: null, element });
+      }
+      return fresh(body, gen) ? result : [];
+    },
+    binding(key, id) { const b = byKey.get(key); return b?.id === id && bindingCurrent(b) ? b : null; },
+    slotBinding(slot) { const b = bySlot.get(slot); return bindingCurrent(b) ? b : null; },
+    current: bindingCurrent,
+    async load(b, signal) {
+      if (!bindingCurrent(b) || signal?.aborted) return null;
+      let value; try { value = await readResource({ id: b.id, slot: b.slot }, signal); } catch { value = null; }
+      if (!bindingCurrent(b) || signal?.aborted) return null;
+      if (!value) { refuse(b); return null; }
+      return value;
+    },
+    pause(slot) { const selected = row(slot); if (selected?.status !== "available") return false; paused.set(slot, selected.id); notify(); return true; },
+    unpause(slot) { const selected = row(slot); if (selected?.status !== "available") return false; paused.delete(slot); notify(); return true; },
+    snapshot() {
+      const live = alive();
+      return { error: live ? error : null, rev, loading: live && metadata === null && error === null,
+        slots: Object.fromEntries(ALL_SLOTS.map(slot => { const selected = live ? metadata?.slots[slot] : null; return [slot, selected ? failed.get(slot) === selected.id ? { status: "unavailable", id: selected.id } : selected : { status: "unknown", id: null }]; })) };
+    },
+    dispose,
+  };
+}

package/dist/ui/shared/effect-policy.js

@@ -0,0 +1,137 @@
+/** #1629 r3: pure host policy. No frame creation, DOM reads, content reads or network. */
+import { effectTrialStageIdentity } from "./effect-trial-stage.js";
+const OWN = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+const plain = o => !!o && (Object.getPrototypeOf(o) === Object.prototype || Object.getPrototypeOf(o) === null);
+const finite = v => typeof v === "number" && Number.isFinite(v);
+const instanceName = v => typeof v === "string" && v.length >= 1 && v.length <= 128;
+const TYPES = Object.freeze({ state: ["state"], reply: [], mention: [], theme: ["mode"], env: ["width", "height", "dpr", "quality"], pointer: ["kind", "x", "y", "buttons"] });
+/** Reserved for host-drawn widgets, never exposed to a Canvas Worker. */
+export const WIDGET_SIGNAL_KINDS = Object.freeze(["status", "usage", "fleet"]);
+
+/** Build a fresh content-free signal. Unknown fields are never copied or read. */
+export function effectEvent(type, fields, instance, ts) {
+  if (!OWN(TYPES, type) || !plain(fields) || !finite(ts) || ts < 0 || instance !== null && !instanceName(instance)) return null;
+  const out = { v: 1, type, ts };
+  if (["state", "reply", "mention"].includes(type)) {
+    if (OWN(fields, "instance") && fields.instance !== instance) return null;
+    if (instance !== null) out.instance = instance;
+  }
+  for (const key of TYPES[type]) out[key] = fields[key];
+  if (type === "pointer") for (const key of ["dx", "dy"]) if (OWN(fields, key)) out[key] = fields[key];
+  return validEffectEvent(out, instance) ? out : null;
+}
+
+/** Independent send fence: exact keys, enums, numeric bounds and the current region's own instance. */
+export function validEffectEvent(d, instance) {
+  if (instance !== null && !instanceName(instance)) return false;
+  if (!plain(d) || d.v !== 1 || !OWN(TYPES, d.type) || !finite(d.ts) || d.ts < 0) return false;
+  const keys = ["v", "type", "ts", ...TYPES[d.type]];
+  if (["state", "reply", "mention"].includes(d.type) && OWN(d, "instance")) {
+    if (!instanceName(instance) || d.instance !== instance) return false;
+    keys.push("instance");
+  }
+  if (d.type === "pointer") for (const key of ["dx", "dy"]) if (OWN(d, key)) {
+    if (!finite(d[key]) || Math.abs(d[key]) > 10000) return false;
+    keys.push(key);
+  }
+  if (Object.keys(d).sort().join(",") !== keys.sort().join(",")) return false;
+  switch (d.type) {
+    case "state": return ["idle", "working", "needs_you", "stopped"].includes(d.state);
+    case "reply": case "mention": return true;
+    case "theme": return ["light", "dark"].includes(d.mode);
+    case "env": return Number.isInteger(d.width) && d.width >= 1 && d.width <= 4096 && Number.isInteger(d.height) && d.height >= 1 && d.height <= 4096 && d.width * d.height <= 8388608 && finite(d.dpr) && d.dpr >= 0.5 && d.dpr <= 3 && ["normal", "low"].includes(d.quality);
+    case "pointer": return ["move", "down", "up", "click", "wheel"].includes(d.kind) && finite(d.x) && d.x >= 0 && d.x <= 4096 && finite(d.y) && d.y >= 0 && d.y <= 4096 && Number.isInteger(d.buttons) && d.buttons >= 0 && d.buttons <= 31;
+  }
+  return false;
+}
+
+/** Least privilege at the final send; the instance is the host's binding, never taken from event data. */
+export function maySendEffectEvent(event, binding) {
+  if (!plain(binding) || !validEffectEvent(event, binding.instance) || !Array.isArray(binding.wants) || event.type === "mention") return false;
+  if (["state", "reply", "mention"].includes(event.type)) {
+    if (binding.instance === null ? OWN(event, "instance") : !OWN(event, "instance") || event.instance !== binding.instance) return false;
+  }
+  return event.type === "env" || binding.wants.includes(event.type);
+}
+
+export function constrainedDevice(signals) {
+  return !!signals && (finite(signals.memory) && signals.memory > 0 && signals.memory <= 4 || finite(signals.cores) && signals.cores > 0 && signals.cores <= 4 || signals.coarse === true && finite(signals.width) && signals.width > 0 && signals.width <= 900);
+}
+
+const OWNER_ORDER = Object.freeze({ page: 0, header: 1, sidebar: 2, box: 3 });
+/** Recomputed from host descriptors; queued/off/unknown descriptors never get a frame reservation. */
+export function allocateEffectFrames(descriptors, context) {
+  if (!Array.isArray(descriptors) || descriptors.length > 128 || !plain(context)) return [];
+  const keys = new Set(), duplicate = new Set();
+  for (const d of descriptors) if (d && typeof d.key === "string") { if (keys.has(d.key)) duplicate.add(d.key); keys.add(d.key); }
+  const result = descriptors.map(d => ({ key: d?.key, verdict: "off", reason: "unknown", queuePos: null }));
+  const gates = ["safe", "publicLink", "reducedMotion", "saveData", "hidden", "enabled", "show", "previewReady", "optIn", "constrained", "modal"];
+  if (gates.some(k => typeof context[k] !== "boolean") || context.openInstance !== null && !instanceName(context.openInstance)) return result;
+  let global = null;
+  if (context.safe === true) global = "safe_mode";
+  else if (context.publicLink === true) global = "public_link";
+  else if (context.reducedMotion === true) global = "reduced_motion";
+  else if (context.saveData === true) global = "save_data";
+  else if (context.hidden === true) global = "hidden";
+  else if (context.enabled !== true || context.show !== true) global = "disabled";
+  else if (context.previewReady !== true || context.optIn !== true) global = "preview_unavailable";
+  const candidates = [];
+  for (let i = 0; i < descriptors.length; i++) {
+    const d = descriptors[i], r = result[i];
+    if (!plain(d) || typeof d.key !== "string" || d.key.length < 1 || d.key.length > 256 || duplicate.has(d.key) || !/^[0-9a-f]{32}$/.test(d.id) || !["chat", "page", "header", "sidebar", "box"].includes(d.region) || !["front", "behind"].includes(d.layer) || !Number.isSafeInteger(d.order) || d.order < 0 || typeof d.paused !== "boolean") continue;
+    // Missing/unknown provenance always receives the agent restrictions.
+    const trialIdentity = d.trialStage === undefined || d.trialStage === null ? null : effectTrialStageIdentity(d.trialStage);
+    const trial = !!trialIdentity && d.region === "chat" && trialIdentity.key === d.key && trialIdentity.id === d.id && trialIdentity.instance === d.instance && trialIdentity.generation === d.generation;
+    if (d.trialStage != null && !trial) { r.reason = "trial_unknown"; continue; }
+    const owner = !trial && d.by === "human";
+    if (!owner && d.region !== "chat") { r.reason = "scope"; continue; }
+    if (d.region === "chat" && (!instanceName(d.instance) || d.instance !== context.openInstance)) { r.reason = "closed_chat"; continue; }
+    if (global) { r.reason = global; continue; }
+    if (d.paused === true) { r.reason = "paused"; continue; }
+    if (d.visible !== true) { r.reason = "offscreen"; continue; }
+    if (d.layer === "front" && context.modal === true && !trial) { r.reason = "modal"; continue; }
+    candidates.push({ i, d, priority: owner && OWN(OWNER_ORDER, d.region) ? OWNER_ORDER[d.region] : 4 });
+  }
+  candidates.sort((a, b) => a.priority - b.priority || a.d.order - b.d.order || a.i - b.i);
+  const max = context.constrained === true ? 1 : 3, frontMax = context.constrained === true ? 1 : 2;
+  let active = 0, front = 0, queued = 0;
+  for (const { i, d } of candidates) {
+    const r = result[i];
+    if (active >= max || d.layer === "front" && front >= frontMax) {
+      r.verdict = "queued"; r.reason = active >= max ? "frame_limit" : "front_limit"; r.queuePos = ++queued;
+    } else {
+      r.verdict = "active"; r.reason = null; active++; if (d.layer === "front") front++;
+    }
+  }
+  return result;
+}
+
+const finiteRect = r => plain(r) && ["x", "y", "width", "height"].every(k => finite(r[k]) && Math.abs(r[k]) <= 1e7) && r.width >= 0 && r.height >= 0;
+/**
+ * Integer padded holes are unioned before evenodd: overlapping holes must never repaint trusted pixels.
+ * Input is the host's viewport rects, not mod geometry. Unknown/overflow means hide, never an unclipped fallback.
+ */
+export function effectTrustClip(frame, trusted) {
+  const unknown = { ok: false, reason: "trust_geometry_unknown" };
+  if (!finiteRect(frame) || frame.width < 1 || frame.height < 1 || frame.width > 4096 || frame.height > 4096 || !Number.isInteger(frame.width) || !Number.isInteger(frame.height) || !Array.isArray(trusted) || trusted.length > 128) return unknown;
+  const rects = [];
+  for (const r of trusted) {
+    if (!finiteRect(r)) return unknown;
+    const x1 = Math.max(0, Math.floor(r.x - frame.x - 8)), y1 = Math.max(0, Math.floor(r.y - frame.y - 8));
+    const x2 = Math.min(frame.width, Math.ceil(r.x + r.width - frame.x + 8)), y2 = Math.min(frame.height, Math.ceil(r.y + r.height - frame.y + 8));
+    if (x2 > x1 && y2 > y1) rects.push({ x1, y1, x2, y2 });
+  }
+  const ys = [...new Set(rects.flatMap(r => [r.y1, r.y2]))].sort((a, b) => a - b), holes = [];
+  for (let i = 0; i + 1 < ys.length; i++) {
+    const y1 = ys[i], y2 = ys[i + 1], spans = rects.filter(r => r.y1 <= y1 && r.y2 >= y2).map(r => [r.x1, r.x2]).sort((a, b) => a[0] - b[0]);
+    let span = null;
+    for (const next of spans) {
+      if (span && next[0] <= span[1]) span[1] = Math.max(span[1], next[1]);
+      else { if (span) holes.push({ x: span[0], y: y1, width: span[1] - span[0], height: y2 - y1 }); span = [...next]; }
+    }
+    if (span) holes.push({ x: span[0], y: y1, width: span[1] - span[0], height: y2 - y1 });
+    if (holes.length > 512) return { ok: false, reason: "trust_geometry_limit" };
+  }
+  const rectPath = r => `M${r.x} ${r.y}H${r.x + r.width}V${r.y + r.height}H${r.x}Z`;
+  return { ok: true, holes, path: `path(evenodd, "${rectPath({ x: 0, y: 0, width: frame.width, height: frame.height })}${holes.map(rectPath).join("")}")` };
+}