@songsid/agend 2.3.2 → 2.3.3-beta.10

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

@@ -1,122 +0,0 @@
-/** #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,
-  };
-}

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

@@ -1,151 +0,0 @@
-/** #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);
-}
-
-export const EFFECT_BLOCK_REASONS = Object.freeze([
-  "transport_unavailable", "preview_unavailable", "preview_not_consented", "unsupported_host", "safe_mode", "reduced_motion", "save_data", "hidden", "disabled", "public_link",
-  "baseline_unsupported", "baseline_unavailable", "baseline_timeout", "calibrating", "clock_unavailable", "gates_unknown", "owner_css", "stock_overlay", "modal",
-  "safety_off", "safety_unknown", "interrupted", "paused", "host_budget", "frame_limit", "front_limit", "offscreen", "region_unavailable", "resource_unavailable", "resource_timeout", "runtime_unavailable", "unknown",
-]);
-
-/** Diagnostic names only; the admission policy below still validates every required flag. */
-export function effectPlaybackReason(c) {
-  if (!c || ["safe", "publicLink", "reducedMotion", "hidden", "enabled", "show", "transportReady"].some(k => typeof c[k] !== "boolean")) return "gates_unknown";
-  return c.safe ? "safe_mode" : c.reducedMotion ? "reduced_motion"
-    : c.hidden ? "hidden" : !c.enabled ? "unsupported_host" : !c.show ? "disabled" : !c.transportReady ? "transport_unavailable" : null;
-}
-
-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: "descriptor_invalid", queuePos: null }));
-  const gates = ["safe", "publicLink", "reducedMotion", "hidden", "enabled", "show", "transportReady", "constrained", "modal"];
-  if (gates.some(k => typeof context[k] !== "boolean") || context.openInstance !== null && !instanceName(context.openInstance)) return result.map(r => ({ ...r, reason: "gates_unknown" }));
-  let global = null;
-  if (context.safe === true) global = "safe_mode";
-  else if (context.reducedMotion === true) global = "reduced_motion";
-  else if (context.hidden === true) global = "hidden";
-  else if (context.enabled !== true) global = "unsupported_host";
-  else if (context.show !== true) global = "disabled";
-
-  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 (context.publicLink && (d.region !== "chat" || trial)) { r.reason = "public_link"; continue; }
-    if (!context.transportReady) { r.reason = "transport_unavailable"; 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("")}")` };
-}

package/dist/ui/shared/effect-poster-reader.js

@@ -1,98 +0,0 @@
-/** #1629: closed static-poster reads only. No epoch, library/runtime route, code, or response-derived URL. */
-const pools = new WeakMap(), ID = /^[0-9a-f]{32}$/;
-const plain = x => !!x && (Object.getPrototypeOf(x) === Object.prototype || Object.getPrototypeOf(x) === null);
-const exact = (x, keys) => plain(x) && Reflect.ownKeys(x).length === keys.length && keys.every(k => Object.hasOwn(x, k) && Object.hasOwn(Object.getOwnPropertyDescriptor(x, k), "value"));
-const instanceOK = x => typeof x === "string" && x.length >= 1 && x.length <= 128;
-export function checkEffectPosters(value) {
-  if (!exact(value, ["rev", "posters"]) || !Number.isSafeInteger(value.rev) || value.rev < 0 || !Array.isArray(value.posters) || value.posters.length > 2) return null;
-  const out = [], ids = new Set(), descriptors = Object.getOwnPropertyDescriptors(value.posters);
-  if (Reflect.ownKeys(descriptors).length !== value.posters.length + 1) return null;
-  for (let n = 0; n < value.posters.length; n++) {
-    const descriptor = descriptors[n]; if (!descriptor || !Object.hasOwn(descriptor, "value")) return null;
-    const p = descriptor.value;
-    // Titles are display-only, never selectors/URLs/CSS. The server's normalized UTF-16 input bound is 400.
-    if (!exact(p, ["id", "title"]) || typeof p.id !== "string" || !ID.test(p.id) || ids.has(p.id) || typeof p.title !== "string" || p.title.length < 1 || p.title.length > 400) return null;
-    ids.add(p.id); out.push(Object.freeze({ id: p.id, title: p.title }));
-  }
-  return Object.freeze({ rev: value.rev, posters: Object.freeze(out) });
-}
-/** Refuse animation/non-PNG/oversized images before DOM decode. This is not a CRC or compressed-data decoder. */
-export function checkStaticEffectPoster(bytes) {
-  if (!(bytes instanceof Uint8Array) || bytes.length < 45 || bytes.length > 1048576 || [137, 80, 78, 71, 13, 10, 26, 10].some((b, n) => bytes[n] !== b)) return null;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), width = view.getUint32(16), height = view.getUint32(20);
-  if (!width || !height || width > 4096 || height > 4096 || width * height > 8388608) return null;
-  let offset = 8, count = 0, data = false;
-  while (offset + 12 <= bytes.length && ++count <= 4096) {
-    const length = view.getUint32(offset), type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
-    if (offset + length + 12 > bytes.length || ["acTL", "fcTL", "fdAT"].includes(type) || (count === 1 ? type !== "IHDR" || length !== 13 : type === "IHDR")) return null;
-    if (type === "IDAT" && length) data = true;
-    offset += length + 12;
-    if (type === "IEND") return !length && data && offset === bytes.length ? new Uint8Array(bytes) : null;
-  }
-  return null;
-}
-/** Two physical requests per Window, across canceled/replaced readers; cancellation does not release early. */
-export function createEffectPosterReader({ window: host, current } = {}) {
-  const unavailable = { ok: false, dispose() {} };
-  if (!host || typeof current !== "function" || ![host.fetch, host.AbortController, host.setTimeout, host.clearTimeout, host.performance?.now].every(x => typeof x === "function")) return unavailable;
-  if (!pools.has(host)) pools.set(host, new Set());
-  const all = pools.get(host), own = new Set(); let dead = false, revoked = false, previous = null;
-  const alive = () => !dead && !revoked && current() === true;
-  function stop() { if (dead) return; dead = true; for (const op of own) op.abort(); }
-  function now() {
-    let n; try { n = host.performance.now(); } catch { stop(); return null; }
-    if (!Number.isFinite(n) || n < 0 || previous !== null && n < previous) { stop(); return null; }
-    previous = n; return n;
-  }
-  function read(path, mime, limit, project, signal) {
-    if (!alive() || signal?.aborted || all.size >= 2) return Promise.resolve(null);
-    const began = now(); if (began === null) return Promise.resolve(null);
-    const controller = new host.AbortController(), op = {}; all.add(op); own.add(op);
-    let reader = null, body = null, cancellation = null, timer, release;
-    const cancelled = new Promise(resolve => { release = resolve; });
-    const cancelBody = () => {
-      if (cancellation) return cancellation;
-      try { cancellation = Promise.resolve(reader ? reader.cancel() : body?.cancel?.()).catch(() => {}); }
-      catch { cancellation = Promise.resolve(); }
-      return cancellation;
-    };
-    op.abort = () => { controller.abort(); if (body) void cancelBody(); release(null); };
-    const valid = () => {
-      const t = now();
-      if (!alive() || controller.signal.aborted || t === null || t < began || t - began >= 10000) { op.abort(); return false; }
-      return true;
-    };
-    const work = Promise.resolve().then(async () => {
-      if (!valid()) return null;
-      const response = await host.fetch(path, { credentials: "same-origin", cache: "no-store", redirect: "error", signal: controller.signal }); body = response.body;
-      if (!valid()) return null;
-      if ([401, 403, 409].includes(response.status)) { revoked = true; for (const pending of own) pending.abort(); return null; }
-      if (!response.ok || response.redirected || (response.headers.get("content-type") || "").split(";")[0].trim().toLowerCase() !== mime) return null;
-      const length = response.headers.get("content-length");
-      if (length !== null && (!/^(0|[1-9][0-9]*)$/.test(length) || !Number.isSafeInteger(Number(length)) || Number(length) > limit) || typeof body?.getReader !== "function") return null;
-      reader = body.getReader(); const chunks = []; let size = 0;
-      for (;;) {
-        const part = await reader.read(); if (!valid()) return null;
-        if (part.done) break;
-        if (!(part.value instanceof Uint8Array) || (size += part.value.length) > limit) return null;
-        chunks.push(new Uint8Array(part.value));
-      }
-      const bytes = new Uint8Array(size); let offset = 0; for (const part of chunks) { bytes.set(part, offset); offset += part.length; }
-      if (!valid()) return null; const answer = project(bytes); return valid() ? answer : null;
-    }).catch(() => null).finally(async () => {
-      controller.abort(); await cancelBody(); all.delete(op); own.delete(op); host.clearTimeout(timer); signal?.removeEventListener("abort", op.abort);
-    });
-    timer = host.setTimeout(op.abort, 10000); signal?.addEventListener("abort", op.abort, { once: true });
-    return Promise.race([work, cancelled]);
-  }
-  return { ok: true,
-    summary(instance, signal) {
-      return instanceOK(instance) ? read(`/ui/effect-posters?instance=${encodeURIComponent(instance)}`, "application/json", 8192, bytes => {
-        try { return checkEffectPosters(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))); } catch { return null; }
-      }, signal) : Promise.resolve(null);
-    },
-    image(instance, id, signal) {
-      return instanceOK(instance) && typeof id === "string" && ID.test(id) ? read(`/ui/effect-posters/${id}.png?instance=${encodeURIComponent(instance)}`, "image/png", 1048576, checkStaticEffectPoster, signal) : Promise.resolve(null);
-    }, dispose: stop,
-  };
-}

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

@@ -1,117 +0,0 @@
-/** #1629: static current-chat posters. No Worker, preview frame, events, profile write or personal-slot authority. */
-import { createEffectPosterReader, checkEffectPosters } from "./effect-poster-reader.js";
-import { createEffectGeometry, hostEffectRect } from "./effect-geometry.js";
-import { stockEffectTrust } from "./effect-stock-trust.js";
-import { effectStockSnapshot } from "./effect-stock-snapshot.js";
-const decoding = new WeakMap();
-export function createChatPosters({ window: host, name, element, current, observe, factories = {} } = {}) {
-  let dead = false, failed = false, generation = 0, allowed = false, metadata = null, request = null, queued = false, raf = null;
-  let root = null, geometry = null, reader = null, mutation = null, resize = null, offAuth = null;
-  const rows = new Map(), offs = [];
-  const alive = () => !dead && current() === true && element?.isConnected === true && element.ownerDocument === host.document && host.document.body.dataset.mode === "full" && !host.AgendAuth.sessionEnded();
-  const make = (key, fallback) => factories[key] ?? fallback;
-  const gate = () => {
-    try {
-      const x = observe();
-      if (!alive() || x.shown !== true || x.fallback !== true || host.document.visibilityState !== "visible") return null;
-      const rect = hostEffectRect(element), proof = effectStockSnapshot(make("stock", stockEffectTrust)(host, { frameRoot: root, ownerCss: x.ownerCss }));
-      if (!rect || !proof || rect.x + rect.width <= 0 || rect.y + rect.height <= 0 || rect.x >= host.innerWidth || rect.y >= host.innerHeight) return null;
-      return { rect, proof };
-    } catch { return null; }
-  };
-  function clear() {
-    for (const row of rows.values()) {
-      row.controller.abort(); row.binding?.remove?.(); row.image.remove();
-      if (row.url) host.URL.revokeObjectURL(row.url);
-    }
-    rows.clear(); geometry?.hide?.();
-  }
-  function cancel() { generation++; request?.controller.abort(); clear(); metadata = null; }
-  function fail() { if (dead) return; failed = true; cancel(); }
-  function dispose() {
-    if (dead) return; dead = true; cancel(); reader?.dispose?.();
-    if (raf !== null) host.cancelAnimationFrame(raf); raf = null;
-    for (const off of offs) { try { off(); } catch { /* release all */ } }
-    offAuth?.(); mutation?.disconnect(); resize?.disconnect(); geometry?.dispose?.(); root?.remove();
-  }
-  const unavailable = () => ({ ok: false, dispose });
-  try {
-    if (!host?.document || typeof current !== "function" || typeof observe !== "function" || typeof name !== "string" || !name.length || name.length > 128 || host.document.body.dataset.mode !== "full" ||
-      ![host.MutationObserver, host.ResizeObserver, host.requestAnimationFrame, host.cancelAnimationFrame, host.URL?.createObjectURL, host.URL?.revokeObjectURL, host.Blob, host.AbortController, host.setTimeout, host.clearTimeout, host.performance?.now, host.AgendAuth?.onSessionEnd, host.AgendAuth?.sessionEnded].every(x => typeof x === "function")) return unavailable();
-    offAuth = host.AgendAuth.onSessionEnd(dispose);
-    if (!alive()) { dispose(); return unavailable(); }
-    root = host.document.createElement("div"); root.className = "agend-effect-layer"; host.document.body.append(root);
-    geometry = make("geometry", createEffectGeometry)({ window: host }); if (!geometry.ok) throw Error("geometry unavailable");
-    reader = make("reader", createEffectPosterReader)({ window: host, current: alive }); if (!reader.ok) throw Error("reader unavailable");
-    if (!decoding.has(host)) decoding.set(host, new Set());
-    mutation = new host.MutationObserver(invalidate); mutation.observe(host.document.documentElement, { subtree: true, childList: true, attributes: true, characterData: true });
-    resize = new host.ResizeObserver(invalidate); resize.observe(host.document.documentElement); resize.observe(element);
-    for (const type of ["scroll", "resize", "orientationchange"]) { host.addEventListener(type, invalidate, true); offs.push(() => host.removeEventListener(type, invalidate, true)); }
-    const visibility = () => { if (host.document.visibilityState !== "visible") { cancel(); allowed = false; } invalidate(); };
-    host.document.addEventListener("visibilitychange", visibility); offs.push(() => host.document.removeEventListener("visibilitychange", visibility));
-    host.addEventListener("pagehide", dispose); offs.push(() => host.removeEventListener("pagehide", dispose));
-  } catch { dispose(); return unavailable(); }
-  function schedule() { if (alive() && raf === null) raf = host.requestAnimationFrame(() => { raf = null; sync(); }); }
-  function invalidate() { if (dead) return; geometry.hide(); schedule(); }
-  function valid(mine) { return alive() && generation === mine && !failed && !!gate(); }
-  async function loadImage(row, mine) {
-    try {
-      const bytes = await reader.image(name, row.id, row.controller.signal);
-      if (!valid(mine) || rows.get(row.id) !== row) return;
-      if (!bytes) { fail(); return; }
-      const pending = decoding.get(host); if (pending.size >= 2) { fail(); return; }
-      const token = {}; pending.add(token);
-      let timer = null, aborted = false;
-      const abort = () => { aborted = true; row.controller.abort(); if (rows.get(row.id) === row) fail(); };
-      try {
-        const began = host.performance.now();
-        if (!Number.isFinite(began) || began < 0) { fail(); return; }
-        timer = host.setTimeout(abort, 10000);
-        row.url = host.URL.createObjectURL(new host.Blob([bytes], { type: "image/png" }));
-        row.image.src = row.url;
-        await row.image.decode();
-        if (aborted || !valid(mine) || rows.get(row.id) !== row) return;
-        const ended = host.performance.now();
-        if (!Number.isFinite(ended) || ended < began || ended - began >= 10000) { fail(); return; }
-        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        if (row.image.naturalWidth !== view.getUint32(16) || row.image.naturalHeight !== view.getUint32(20)) { fail(); return; }
-        row.ready = true; sync();
-      } finally { host.clearTimeout(timer); pending.delete(token); }
-    } catch { if (alive() && generation === mine) fail(); }
-  }
-  async function read() {
-    const op = { controller: new host.AbortController(), generation }; request = op;
-    try {
-      const result = await reader.summary(name, op.controller.signal);
-      if (!valid(op.generation) || request !== op) return;
-      const checked = checkEffectPosters(result);
-      if (!checked) { fail(); return; }
-      metadata = checked;
-      for (const p of checked.posters) {
-        const image = host.document.createElement("img"); image.className = "agend-effect-poster"; image.setAttribute("alt", ""); image.setAttribute("aria-hidden", "true"); image.decoding = "async";
-        root.append(image);
-        const binding = geometry.bind(image, { layer: "behind", by: "agent" });
-        if (!binding.ok || typeof image.decode !== "function") { binding.remove?.(); image.remove(); fail(); return; }
-        const row = { id: p.id, image, binding, controller: new host.AbortController(), url: null, ready: false }; rows.set(p.id, row);
-        // The IMG is proved hidden synchronously before any source is assigned or control yields.
-        void loadImage(row, op.generation);
-      }
-    } catch { if (alive() && generation === op.generation) fail(); }
-    finally { if (request === op) request = null; if (queued && alive()) { queued = false; sync(); } }
-  }
-  function sync() {
-    if (!alive()) { dispose(); return; }
-    geometry.hide();
-    const evidence = gate();
-    if (!evidence) { if (allowed) cancel(); allowed = false; return; }
-    allowed = true;
-    if (failed) return;
-    for (const row of rows.values()) if (row.ready && !row.binding.sync(evidence.rect, evidence.proof)) { fail(); return; }
-    if (!metadata && !request) void read();
-    if (rows.size) schedule();
-  }
-  return { ok: true, sync,
-    changed() { if (!alive()) return; cancel(); failed = false; if (request) queued = true; else sync(); },
-    dispose, snapshot: () => ({ failed, count: rows.size, ready: [...rows.values()].filter(r => r.ready).length }),
-  };
-}