@songsid/agend 2.2.1 → 2.2.6

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

@@ -0,0 +1,125 @@
+/** #1629: host-owned static cursor controller; no product startup, metadata reader, Worker or frame. */
+import { effectHostStyle } from "./effect-host-style.js";
+import { checkStaticEffectCursor } from "./effect-runtime-loader.js";
+const owners = new WeakMap(), ATTRIBUTE = "data-agend-effect-cursor";
+let serial = 0;
+const finite = n => typeof n === "number" && Number.isFinite(n) && n >= 0;
+function selection(value) {
+  try {
+    if (!value || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return null;
+    const fields = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(fields).length !== 3 || !["id", "generation", "hotspot"].every(k => fields[k] && Object.hasOwn(fields[k], "value"))) return null;
+    const { id, generation, hotspot } = value;
+    if (typeof id !== "string" || !/^[a-f0-9]{32}$/.test(id) || !Number.isSafeInteger(generation) || generation < 0 || !Array.isArray(hotspot) || Object.getPrototypeOf(hotspot) !== Array.prototype) return null;
+    const entries = Object.getOwnPropertyDescriptors(hotspot);
+    if (Reflect.ownKeys(entries).length !== 3 || entries.length?.value !== 2 || ![0, 1].every(k => entries[k] && Object.hasOwn(entries[k], "value") && Number.isInteger(entries[k].value) && entries[k].value >= 0 && entries[k].value <= 63)) return null;
+    return Object.freeze({ id, generation, hotspot: Object.freeze([entries[0].value, entries[1].value]) });
+  } catch { return null; }
+}
+function cursorMatches(value, url, hotspot) {
+  const m = typeof value === "string" && /^url\((["']?)(blob:[^"'()\s]+)\1\)\s+(\d+)\s+(\d+),\s*auto$/.exec(value);
+  return !!m && m[2] === url && Number(m[3]) === hotspot[0] && Number(m[4]) === hotspot[1];
+}
+/** readImage must be the existing shared loader's settled cursor operation. enabled is a host gate, never effect data. */
+export function createEffectCursor({ window: host, current, readImage, onChange = () => {} } = {}) {
+  const unavailable = { ok: false, update() {}, snapshot: () => ({ status: "unavailable", id: null }), dispose() {} };
+  if (!host?.document || owners.has(host) || ![current, readImage, onChange, host.getComputedStyle, host.Blob, host.URL?.createObjectURL, host.URL?.revokeObjectURL, host.AbortController, host.setTimeout, host.clearTimeout, host.performance?.now].every(x => typeof x === "function")) return unavailable;
+  const token = {}; owners.set(host, token);
+  const doc = host.document; let dead = false, previous = null, wanted = null, pending = null, active = null, blocked = null, generation = 0, checking = false, notifying = false, status = "off";
+  const safe = fn => { try { return fn(); } catch { return null; } };
+  const release = () => { if (dead && !pending && owners.get(host) === token) owners.delete(host); };
+  function alive() {
+    if (dead || checking) return false;
+    checking = true; const value = safe(() => current() === true && host.document === doc); checking = false;
+    return !dead && value === true;
+  }
+  function now() {
+    const value = safe(() => host.performance.now());
+    if (!finite(value) || previous !== null && value < previous) { dispose(); return null; }
+    previous = value; return value;
+  }
+  function target() {
+    const all = doc.querySelectorAll("#app > .shell"), el = all.length === 1 ? all[0] : null;
+    return el?.ownerDocument === doc && el.isConnected === true ? el : null;
+  }
+  function remove(row) {
+    if (!row) return;
+    // Removing our exact attribute disarms even a stylesheet whose CSSOM has become unreadable.
+    safe(() => { if (row.element.getAttribute(ATTRIBUTE) === row.token) row.element.removeAttribute(ATTRIBUTE); });
+    safe(() => row.rule?.style.removeProperty("cursor"));
+    safe(() => { const at = [...row.sheet.cssRules].indexOf(row.rule); if (at >= 0) row.sheet.deleteRule(at); });
+    if (row.url) { safe(() => host.URL.revokeObjectURL(row.url)); row.url = null; }
+  }
+  function clear() { const old = active; active = null; remove(old); }
+  function tell() { if (dead || notifying) return; notifying = true; try { safe(() => onChange(snapshot())); } finally { notifying = false; } }
+  function snapshot() { return Object.freeze({ status: dead ? "unavailable" : status, id: wanted?.selection.id ?? null }); }
+  function dispose() {
+    if (dead) return; dead = true; generation++; wanted = null; clear();
+    if (pending) { safe(() => pending.controller.abort()); remove(pending); }
+    safe(() => host.removeEventListener?.("pagehide", dispose)); release();
+  }
+  if (!alive() || now() === null || !effectHostStyle(host)) { dispose(); return unavailable; }
+  safe(() => host.addEventListener?.("pagehide", dispose));
+  function valid(op) {
+    if (!alive() || pending !== op || op.generation !== generation || op.controller.signal.aborted || wanted !== op.wanted) return false;
+    const t = now();
+    return t !== null && t >= op.began && t - op.began < 10000 && target() === op.element && effectHostStyle(host) === op.sheet;
+  }
+  function fail(op) {
+    if (!dead && pending === op && generation === op.generation && wanted === op.wanted) { blocked = wanted; status = "unavailable"; tell(); }
+  }
+  async function load(op) {
+    try {
+      if (!valid(op)) return;
+      const bytes = await readImage(op.wanted.selection, op.controller.signal);
+      if (!valid(op)) return;
+      const checked = checkStaticEffectCursor(bytes); if (!checked) { fail(op); return; }
+      const view = new DataView(checked.buffer, checked.byteOffset, checked.byteLength), width = view.getUint32(16), height = view.getUint32(20);
+      if (op.wanted.selection.hotspot.some((v, n) => v >= (n === 0 ? width : height))) { fail(op); return; }
+      op.url = host.URL.createObjectURL(new host.Blob([checked], { type: "image/png" }));
+      const url = new URL(op.url); if (url.protocol !== "blob:" || url.origin !== host.location.origin || !/^blob:[^"'()\s\\]+$/.test(op.url)) { fail(op); return; }
+      const image = doc.createElement("img"); image.alt = ""; image.src = op.url; op.image = image;
+      if (typeof image.decode !== "function") { fail(op); return; }
+      await image.decode();
+      if (!valid(op)) return;
+      if (image.naturalWidth !== width || image.naturalHeight !== height) { fail(op); return; }
+      if (op.element.hasAttribute(ATTRIBUTE)) { fail(op); return; }
+      op.token = `agend-effect-cursor-${++serial}`;
+      const index = op.sheet.insertRule(`#app > .shell[${ATTRIBUTE}="${op.token}"]{}`, op.sheet.cssRules.length); op.rule = op.sheet.cssRules[index];
+      const hotspot = op.wanted.selection.hotspot, value = `url("${op.url}") ${hotspot[0]} ${hotspot[1]}, auto`;
+      op.rule.style.setProperty("cursor", value); op.element.setAttribute(ATTRIBUTE, op.token);
+      if (!valid(op) || !cursorMatches(op.rule.style.getPropertyValue("cursor"), op.url, hotspot) || !cursorMatches(host.getComputedStyle(op.element).cursor, op.url, hotspot)) { fail(op); return; }
+      active = op; status = "running"; tell();
+    } catch { fail(op); }
+    finally {
+      safe(() => host.clearTimeout(op.timer));
+      if (active !== op) remove(op);
+      if (pending === op) { pending = null; if (!dead && wanted === op.wanted && !active && blocked !== wanted) { blocked = wanted; status = "unavailable"; tell(); } }
+      release(); if (!dead) start();
+    }
+  }
+  function start() {
+    if (!alive() || pending || active || !wanted || blocked === wanted) return;
+    const began = now(), element = safe(target), sheet = effectHostStyle(host);
+    if (began === null || !element || !sheet || element.hasAttribute(ATTRIBUTE)) { blocked = wanted; status = "unavailable"; tell(); return; }
+    const op = { wanted, generation, began, element, sheet, controller: new host.AbortController(), url: null, rule: null, token: null, timer: null }; pending = op; status = "loading";
+    op.timer = host.setTimeout(() => { if (pending !== op) return; op.controller.abort(); remove(op); fail(op); }, 10000);
+    tell(); void load(op);
+  }
+  function update(value, enabled) {
+    if (!alive() || now() === null) { dispose(); return; }
+    const next = enabled === true ? selection(value) : null;
+    const same = !!next && wanted && next.id === wanted.selection.id && next.generation === wanted.selection.generation && next.hotspot.every((n, i) => n === wanted.selection.hotspot[i]);
+    if (!same) {
+      generation++; wanted = next ? { selection: next } : null; blocked = null; clear();
+      if (pending) { safe(() => pending.controller.abort()); remove(pending); }
+      status = next ? "loading" : "off";
+    }
+    if (active) {
+      const row = active;
+      if (safe(target) !== row.element || effectHostStyle(host) !== row.sheet || row.element.getAttribute(ATTRIBUTE) !== row.token || !cursorMatches(safe(() => host.getComputedStyle(row.element).cursor), row.url, row.wanted.selection.hotspot)) { clear(); blocked = wanted; status = "unavailable"; }
+    }
+    start(); tell();
+  }
+  return { ok: true, update, snapshot, dispose };
+}

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

@@ -0,0 +1,146 @@
+/** #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] };
+}
+
+/** Listener transport only; this does not grant HTML-preview or ordinary-effect consent. */
+export function effectTransportReady(host, origin, boot) {
+  try {
+    const target = new URL(origin), page = new URL(host.location.origin);
+    return origin === target.origin && ["http:", "https:"].includes(target.protocol) && ["http:", "https:"].includes(page.protocol)
+      && target.origin !== page.origin && !(page.protocol === "https:" && target.protocol !== "https:") && typeof boot === "string" && /^[0-9a-f]{32}$/.test(boot);
+  } catch { return false; }
+}
+
+/** #2118: same URL origin, opaque realm. This helper does not alter product admission or HTML preview consent. */
+export function effectBootstrapReady(host, origin, boot) {
+  try {
+    const target = new URL(origin), page = new URL(host.location.origin);
+    return origin === target.origin && target.origin === page.origin && ["http:", "https:"].includes(target.protocol)
+      && typeof boot === "string" && /^[0-9a-f]{32}$/.test(boot);
+  } catch { return false; }
+}
+
+/**
+ * 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(options = {}) { return ownedEffectFrame(options, false); }
+
+/** Product transport: the same-listener trusted document still has an opaque sandboxed realm. */
+export function createOpaqueEffectFrame(options = {}) { return ownedEffectFrame(options, true); }
+
+function ownedEffectFrame({ window: host, root, origin, boot, render, clock = () => performance.now(), onReady = () => {}, onRemove = () => {} } = {}, sameListener) {
+  if (!(sameListener ? effectBootstrapReady : effectTransportReady)(host, origin, boot)) return { ok: false, reason: sameListener ? "bootstrap_unknown" : "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 + (sameListener ? "/effect-bootstrap" : "/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,137 @@
+/** #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, shown = false;
+    const hide = () => {
+      shown = false;
+      try {
+        rule.style.setProperty("visibility", "hidden", "important");
+        if (frame.isConnected === true && host.getComputedStyle(frame).visibility !== "hidden") { frame.remove(); return false; }
+        return true;
+      } catch { frame.remove(); return false; }
+    };
+    const handle = { ok: true, hide,
+      /** Same-turn host paint snapshot is mandatory, including behind/human placements. No DOM fallback. */
+      sync(rect, stock) {
+        const refuse = () => { hide(); return false; };
+        const proof = effectStockSnapshot(stock);
+        if (!effectStockAllows(proof, { layer, by })) return refuse();
+        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) return refuse();
+        let path = "none";
+        if (layer === "front" && by !== "human") {
+          const clipped = effectTrustClip(rect, proof.rects);
+          if (!clipped.ok) return refuse();
+          path = clipped.path;
+        }
+
+        try {
+          const matches = visibility => {
+            const style = host.getComputedStyle(frame), actual = frame.getBoundingClientRect();
+            return style.position === "fixed" && style.pointerEvents === "none" && style.visibility === visibility
+              && style.opacity === (layer === "front" && by !== "human" ? "0.85" : "1") && style.zIndex === (layer === "front" ? "20" : "0")
+              && sameClip(path, rule.style.getPropertyValue("clip-path")) && sameClip(path, style.clipPath)
+              && ["x", "y", "width", "height"].every(key => number(actual[key]) && Math.abs(actual[key] - rect[key]) < 0.02)
+              && frame.isConnected === true && frame.ownerDocument === host.document;
+          };
+          // A fresh proof and actual viewport/clip are still checked every frame. Rewriting an
+          // already verified presentation makes WebKit repeatedly invalidate the iframe's paint.
+          if (shown && matches("visible")) return true;
+          // Changed or unproven geometry is hidden before writes and verified before reveal.
+          if (!hide()) return false;
+          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.
+          if (!matches("hidden")) return false;
+          rule.style.setProperty("visibility", "visible", "important");
+          shown = true;
+          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,122 @@
+/** #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;
+      // #2188: the stock snapshot walks the whole page (thousands of computed styles). With no slot holding an effect
+      // that could play, there is nothing for it to admit: skipped — every page change (a status, a chat switch) ran it.
+      if (!SLOTS.some(slot => body.slots[slot]?.status === "available" && failed.get(slot) !== body.slots[slot].id)) {
+        for (const slot of SLOTS) drop(slot);
+        return [];
+      }
+      const 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,
+  };
+}