@songsid/agend 2.2.0 → 2.3.0-beta.1

package/dist/ui/shared/effect-chat-runtime.js

@@ -0,0 +1,154 @@
+/** #1629: one committed local Chat lease joins the reviewed host-only effect primitives. */
+import { createEffectRuntimeLoader } from "./effect-runtime-loader.js";
+import { createEffectRegistry } from "./effect-registry.js";
+import { createEffectSafety } from "./effect-safety.js";
+import { stockEffectTrust } from "./effect-stock-trust.js";
+import { createEffectProfileCollector } from "./effect-profiles.js";
+
+const writers = new WeakMap();
+/** Physical write reservations outlive a canceled caller. Responses never supply runtime authority. */
+export function createEffectWriter(host, current) {
+  let dead = false;
+  const own = new Set();
+  if (!writers.has(host)) writers.set(host, new Set());
+  const all = writers.get(host);
+  let previous = null;
+  function stop() { if (dead) return; dead = true; for (const op of own) op.cancel(); }
+  function time() {
+    let now; try { now = host.performance.now(); } catch { stop(); return null; }
+    if (!Number.isFinite(now) || now < 0 || previous !== null && now < previous) { stop(); return null; }
+    previous = now; return now;
+  }
+  return {
+    async post(path, body) {
+      if (dead || !current() || all.size >= 3) return false;
+      const began = time(); if (began === null) return false;
+      const text = JSON.stringify(body); if (new TextEncoder().encode(text).length > 16384) return false;
+      const controller = new host.AbortController(), op = { controller }; own.add(op); all.add(op);
+      let timer, cancel;
+      const aborted = new Promise(resolve => { cancel = () => { controller.abort(); resolve(false); }; }); op.cancel = cancel;
+      const work = Promise.resolve().then(async () => {
+        if (dead || !current() || controller.signal.aborted) return false;
+        const r = await host.fetch(path, { method: "POST", credentials: "same-origin", cache: "no-store", redirect: "error", headers: { "Content-Type": "application/json" }, body: text, signal: controller.signal });
+        // Settle the body before returning the physical reservation, even if the caller already timed out.
+        try { await r.body?.cancel(); } catch { /* no data is consumed */ }
+        const now = time();
+        return !dead && current() && !controller.signal.aborted && Number.isFinite(began) && began >= 0 && now !== null && now >= began && now - began < 10000 && r.ok && !r.redirected;
+      }).catch(() => false).finally(() => { host.clearTimeout(timer); controller.abort(); own.delete(op); all.delete(op); });
+      timer = host.setTimeout(cancel, 10000);
+      return Promise.race([work, aborted]);
+    },
+    dispose: stop,
+  };
+}
+
+/** Frozen, server-rendered session identity only. A header-token/public/View load has no identity. */
+export function chatEffectIdentity(host) {
+  try {
+    const b = host.document.body.dataset, x = JSON.parse(host.document.documentElement.getAttribute("data-prefs") || "null");
+    if (b.mode !== "full" || b.publicLink === "1" || b.webTransport === "poll" || !["person", "operator"].includes(x?.ownerScope) || x.unreadable === true || typeof x.ownerEpoch !== "string" || !/^[a-f0-9]{16}$/.test(x.ownerEpoch)) return null;
+    return Object.freeze({ epoch: x.ownerEpoch, scope: x.ownerScope });
+  } catch { return null; }
+}
+export function chatEffectState(state, name) {
+  const inst = state.instances?.find(i => i.name === name);
+  if (!inst) return null;
+  if (["stopped", "paused"].includes(inst.status)) return "stopped";
+  if (Object.hasOwn(state.awaiting ?? {}, name)) return "needs_you";
+  return ["working", "stuck"].includes(state.exec?.[name]) ? "working" : state.exec?.[name] === "idle" ? "idle" : null;
+}
+
+/** `observe` supplies closed host gates, never event/message content. No timers poll server state. */
+export function createChatEffectRuntime({ window: host, name, element, current, observe, onChange = () => {}, factories = {} }) {
+  let dead = false, error = null, loader = null, registry = null, writer = null, active = null, queued = false, generation = 0, metadata = null, ctx = null, lastContext = null;
+  const paused = new Map(), owners = new Map();
+  const placementIdentity = p => JSON.stringify([p.by, p.manifest.layer, p.params]);
+  const identity = chatEffectIdentity(host), auth = host.AgendAuth;
+  const alive = () => !dead && current() === true && element.isConnected === true && !auth.sessionEnded();
+  const tell = () => { if (!dead && current()) onChange({ error, rows: registry?.snapshot() ?? [], effects: metadata?.effects ?? [], loading: metadata === null && !error }); };
+  const fail = reason => { if (dead) return; error = reason; generation++; metadata = null; active?.controller.abort(); registry?.dispose?.(); registry = null; loader?.dispose?.(); loader = null; writer?.dispose(); tell(); };
+  function dispose() {
+    if (dead) return; dead = true; generation++; active?.controller.abort(); registry?.dispose?.(); loader?.dispose?.(); writer?.dispose(); offAuth?.();
+    for (const value of owners.values()) value.collector.dispose(); owners.clear();
+  }
+  let offAuth = null;
+  if (!identity || typeof auth?.onSessionEnd !== "function" || typeof auth?.sessionEnded !== "function" || typeof name !== "string" || name.length < 1 || name.length > 128 || !current()) return { ok: false, dispose };
+  offAuth = auth.onSessionEnd(dispose); // May synchronously replay an already-ended episode.
+  if (dead || !alive()) { dispose(); return { ok: false, dispose }; }
+  const clock = () => host.performance.now();
+  try {
+    const make = (key, fn) => factories[key] ?? fn;
+    writer = createEffectWriter(host, alive);
+    loader = make("loader", createEffectRuntimeLoader)({ window: host, ownerEpoch: identity.epoch, current: alive });
+    if (!loader.ok) throw Error("runtime_unavailable");
+    registry = make("registry", createEffectRegistry)({ window: host, origin: host.document.body.dataset.previewOrigin, boot: host.document.body.dataset.previewBoot,
+      load: async (d, signal) => {
+        const mine = generation, value = await loader.resource({ id: d.id, instance: name }, signal);
+        if (!alive() || mine !== generation || signal.aborted) return null;
+        if (!value) { fail("resource_unavailable"); return null; }
+        return value;
+      },
+      safety: make("safety", createEffectSafety)({ storage: host.localStorage, crypto: host.crypto }),
+      stockSnapshot: ({ frameRoot }) => make("stock", stockEffectTrust)(host, { frameRoot, ownerCss: observe().ownerCss }),
+      onChange() { tell(); emit(); },
+      onMount(owner) {
+        if (!alive() || !owner.current()) return;
+        const collector = make("collector", createEffectProfileCollector)({ key: owner.key, id: owner.id, device: owner.device, clock });
+        if (collector.ok) owners.set(owner, { collector, began: clock(), attempted: null });
+      },
+      onRetire(owner) { const row = owners.get(owner); row?.collector.dispose(); owners.delete(owner); },
+      onProfile(raw, owner) {
+        const row = owners.get(owner); if (!row || !alive() || !owner.current()) return;
+        row.collector.add(raw);
+        const now = clock();
+        if (now - row.began < 10000 && raw.verdict !== "paused" || row.attempted !== null && now - row.attempted < 10000) return;
+        const report = row.collector.report(); if (!report || !owner.current()) return;
+        row.attempted = now;
+        void writer.post(`/ui/effects/profile/${owner.id}?instance=${encodeURIComponent(name)}&ownerEpoch=${identity.epoch}`, report.profile);
+      }, clock,
+    });
+    if (!registry.ok) throw Error("runtime_unavailable");
+  } catch { fail("runtime_unavailable"); }
+  function descriptors() {
+    return (metadata?.effects ?? []).filter(p => p.manifest.regions.includes("chat")).map((p, order) => ({ key: `chat:${p.id}`, id: p.id, by: p.by, region: "chat", layer: p.manifest.layer,
+      order, paused: paused.get(p.id) === placementIdentity(p), visible: true, instance: name, params: p.params, element }));
+  }
+  function emit() {
+    if (!alive() || error || !registry?.ok) return;
+    const value = observe();
+    if (["idle", "working", "needs_you", "stopped"].includes(value.state)) registry.publish("state", { state: value.state }, name);
+    if (["light", "dark"].includes(value.mode)) registry.publish("theme", { mode: value.mode });
+  }
+  function sync() {
+    if (!alive()) { dispose(); return; } if (error) return;
+    const value = observe(); ctx = value.context;
+    const stamp = JSON.stringify(ctx);
+    if (stamp !== lastContext) { lastContext = stamp; registry.update(descriptors(), ctx); }
+    emit();
+    if (!metadata && !active && ctx.enabled && ctx.show && ctx.previewReady && ctx.optIn && !ctx.safe && !ctx.publicLink && !ctx.reducedMotion && !ctx.saveData && !ctx.hidden) void read();
+  }
+  async function read() {
+    if (!alive() || error || active) return;
+    const op = { controller: new host.AbortController(), generation }; active = op;
+    try {
+      const answer = await loader.placements(name, op.controller.signal);
+      if (!alive() || active !== op) return;
+      if (op.generation !== generation) return;
+      if (!answer) { fail("resource_unavailable"); return; }
+      metadata = answer;
+      for (const [id, stamp] of paused) if (!answer.effects.some(p => p.id === id && placementIdentity(p) === stamp)) paused.delete(id);
+      lastContext = null; sync(); tell();
+    } finally {
+      if (active === op) active = null;
+      if (queued && alive() && !error) { queued = false; sync(); }
+    }
+  }
+  return { ok: !error && !dead, sync,
+    changed() { if (!alive() || error) return; generation++; metadata = null; registry.update([], observe().context); lastContext = null; if (active) queued = true; else sync(); tell(); },
+    reply(event) { if (alive() && !error && event.instance === name) registry.publish("reply", {}, name); },
+    pause(id) { if (!alive() || !metadata?.effects.some(p => p.id === id)) return false; paused.set(id, placementIdentity(metadata.effects.find(p => p.id === id))); lastContext = null; sync(); return true; },
+    resume(id) { if (!alive() || error || !metadata?.effects.some(p => p.id === id)) return false; paused.delete(id); lastContext = null; sync(); return registry.resume(`chat:${id}`); },
+    async remove(id) { if (!alive() || error || !metadata?.effects.some(p => p.id === id)) return false; const mine = generation; const ok = await writer.post("/ui/effects/remove", { instance: name, id }); if (!alive() || mine !== generation) return false; if (ok) this.changed(); return ok; },
+    snapshot: () => ({ error, rows: registry?.snapshot() ?? [], effects: metadata?.effects ?? [], loading: metadata === null && !error }), dispose,
+  };
+}

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,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 };
+}