@sema-agent/core 7.55.0 → 7.57.0

package/dist/core/mods/kernel/receive.js

@@ -5,25 +5,134 @@ export function isPlainRecord(v) {
     const proto = Object.getPrototypeOf(v);
     return proto === Object.prototype || proto === null;
 }
+function isIndexName(k) {
+    const n = Number(k);
+    return String(n >>> 0) === k && n !== 4_294_967_295;
+}
 function isOrdinaryArray(v) {
     return Array.isArray(v) && Object.getPrototypeOf(v) === Array.prototype;
 }
+const DATE_TO_JSON = Date.prototype.toJSON;
+const DATE_TIME = Date.prototype.getTime;
+const DATE_ISO = Date.prototype.toISOString;
+const TYPED_ARRAY_PROTO = Object.getPrototypeOf(Uint8Array.prototype);
+const TYPED_ARRAY_NAME = Object.getOwnPropertyDescriptor(TYPED_ARRAY_PROTO, Symbol.toStringTag).get;
+const TYPED_ARRAY_LENGTH = Object.getOwnPropertyDescriptor(TYPED_ARRAY_PROTO, "length").get;
+const TYPED_ARRAY_SET = TYPED_ARRAY_PROTO.set;
+const FLOAT64_ARRAY = Float64Array;
+const ARRAY = Array;
+const ARRAY_PROTOTYPE = Array.prototype;
+const ARRAY_SLICE = Array.prototype.slice;
+const OBJECT_PROTOTYPE = Object.prototype;
+const HAS_OWN = Object.hasOwn;
+const OWN_KEYS_ENUMERABLE = Object.keys;
+const SET_PROTOTYPE = Object.setPrototypeOf;
+const DEFINE = Reflect.defineProperty;
+export function dataMember(value) {
+    const d = Object.create(null);
+    d.value = value;
+    d.writable = true;
+    d.enumerable = true;
+    d.configurable = true;
+    return d;
+}
+export function appendOwn(list, value) {
+    DEFINE(list, list.length, dataMember(value));
+}
+function listOnNoPrototype(list = []) {
+    return SET_PROTOTYPE(list, null);
+}
+const recordOnNoPrototype = () => Object.create(null);
+function typedArrayIndices(v, name, length) {
+    const out = recordOnNoPrototype();
+    if (name === "BigInt64Array" || name === "BigUint64Array")
+        return out;
+    const copy = new FLOAT64_ARRAY(length);
+    Reflect.apply(TYPED_ARRAY_SET, copy, [v]);
+    for (let i = 0; i < length; i++)
+        out[i] = copy[i];
+    return out;
+}
+function readOwnMember(v, key, cell) {
+    try {
+        cell.value = v[key];
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const NO_MEMBERS = Object.freeze(Object.create(null));
+const NO_KEYS = Object.freeze([]);
+function denseList(v, length) {
+    let holes = 0;
+    for (let i = 0; i < length; i++)
+        if (!HAS_OWN(v, i) && ++holes > 64 && holes * 2 > i + 1)
+            return false;
+    return true;
+}
 export function receive(value, mode, held) {
     const seen = new Map();
-    const path = [];
+    const path = listOnNoPrototype();
+    const pathTo = (below) => {
+        const names = Reflect.apply(ARRAY_SLICE, path, []);
+        if (below !== undefined)
+            appendOwn(names, below);
+        return Object.freeze(names);
+    };
     const open = new Set();
     const heights = new Map();
     const faults = [];
     const refusedAt = new Map();
-    const stack = [];
+    const stack = listOnNoPrototype();
     const refusals = new Set();
     const refuse = (kind) => {
-        const fault = Object.freeze({ kind, path: Object.freeze([...path]) });
+        const fault = Object.freeze({ kind, path: pathTo() });
         refusals.add(fault);
         throw fault;
     };
-    const faultOf = (err) => typeof err === "object" && err !== null && refusals.has(err) ? err : Object.freeze({ kind: "uncopyable", path: Object.freeze([...path]) });
-    const other = (v, kind) => (mode.others === "as-is" ? v : refuse(kind));
+    const faultOf = (err) => typeof err === "object" && err !== null && refusals.has(err) ? err : Object.freeze({ kind: "uncopyable", path: pathTo() });
+    const clones = new Map();
+    const leafOf = (v) => {
+        if (!clones.has(v)) {
+            let own = v;
+            try {
+                if (typeof v !== "function")
+                    own = structuredClone(v);
+            }
+            catch {
+            }
+            clones.set(v, own);
+        }
+        return clones.get(v);
+    };
+    const other = (v, kind) => {
+        if (mode.others !== "as-is")
+            return refuse(kind);
+        return mode.leaves !== undefined && kind === "not-data" && v !== null && (typeof v === "object" || typeof v === "function") ? leafOf(v) : v;
+    };
+    const wireForm = (v) => {
+        for (let o = v; o !== null; o = Object.getPrototypeOf(o)) {
+            if (o !== v && mode.isProxy?.(o) === true)
+                return refuse("proxy");
+            const d = Object.getOwnPropertyDescriptor(o, "toJSON");
+            if (d === undefined)
+                continue;
+            if (!Object.hasOwn(d, "value"))
+                return refuse("not-data");
+            if (typeof d.value !== "function")
+                return v;
+            if (d.value !== DATE_TO_JSON)
+                return refuse("not-data");
+            try {
+                return Number.isFinite(Reflect.apply(DATE_TIME, v, [])) ? Reflect.apply(DATE_ISO, v, []) : null;
+            }
+            catch {
+                return refuse("not-data");
+            }
+        }
+        return v;
+    };
     const refuseContainer = (v, kind) => {
         if (mode.contain === true) {
             refusedAt.set(v, kind);
@@ -74,12 +183,44 @@ export function receive(value, mode, held) {
             return other(v, "too-deep");
         if (mode.isProxy?.(v) === true)
             return refuse("proxy");
+        if (mode.wire === true) {
+            const form = wireForm(v);
+            if (form !== v)
+                return form;
+            const name = Reflect.apply(TYPED_ARRAY_NAME, v, []);
+            if (typeof name === "string") {
+                const length = Reflect.apply(TYPED_ARRAY_LENGTH, v, []);
+                let out;
+                try {
+                    out = typedArrayIndices(v, name, length);
+                }
+                catch {
+                    out = recordOnNoPrototype();
+                }
+                const captured = Object.create(null);
+                const names = Object.keys(v);
+                let first = names.length;
+                while (first > 0 && !isIndexName(names[first - 1]))
+                    first--;
+                for (const k of names.slice(first)) {
+                    const d = Object.getOwnPropertyDescriptor(v, k);
+                    if (d !== undefined)
+                        captured[k] = d;
+                }
+                seen.set(v, out);
+                open.add(v);
+                stack[stack.length] = { v, out, list: false, proto: Object.getPrototypeOf(v), captured, keys: Object.keys(captured), level, next: 0, height: 1, key: "", member: undefined };
+                return out;
+            }
+        }
         const list = isOrdinaryArray(v) || (mode.others === "copy" && Array.isArray(v));
         if (!list && !isPlainRecord(v) && mode.others !== "copy")
             return other(v, "not-data");
+        if (mode.wire === true && (!list || denseList(v, v.length)))
+            return readInOnePass(v, list, level);
         const proto = Object.getPrototypeOf(v);
         const captured = Object.getOwnPropertyDescriptors(v);
-        const out = list ? [] : {};
+        const out = list ? listOnNoPrototype() : recordOnNoPrototype();
         seen.set(v, out);
         open.add(v);
         if (mode.accessors === "refuse") {
@@ -87,15 +228,64 @@ export function receive(value, mode, held) {
             if (symbols.length > 0 && mode.contain !== true)
                 refuseContainer(v, "hidden");
             for (const s of symbols)
-                faults.push(Object.freeze({ kind: "hidden", path: Object.freeze([...path, String(s)]) }));
+                appendOwn(faults, Object.freeze({ kind: "hidden", path: pathTo(String(s)) }));
         }
-        stack.push({ v, out, list, proto, captured, keys: Object.getOwnPropertyNames(captured), level, next: 0, height: 1, key: "", member: undefined });
+        const names = Object.getOwnPropertyNames(captured);
+        const keys = mode.wire !== true ? names : names.filter((k) => (list ? isIndexName(k) : captured[k].enumerable === true));
+        stack[stack.length] = { v, out, list, proto, captured, keys, level, next: 0, height: 1, key: "", member: undefined };
         return out;
     };
+    const readInOnePass = (v, list, level) => {
+        const names = list ? undefined : OWN_KEYS_ENUMERABLE(v);
+        const count = list ? v.length : names.length;
+        const out = (list ? listOnNoPrototype(new ARRAY(count)) : recordOnNoPrototype());
+        seen.set(v, out);
+        open.add(v);
+        const f = { v, out, list, proto: Object.getPrototypeOf(v), captured: NO_MEMBERS, keys: NO_KEYS, live: { names, count, pending: undefined }, level, next: 0, height: 1, key: "", member: undefined };
+        f.live.pending = primitivesUpToAnObject(f);
+        if (f.live.pending === undefined)
+            return finish(f);
+        stack[stack.length] = f;
+        return out;
+    };
+    const read = { value: undefined };
+    const primitivesUpToAnObject = (f) => {
+        const { names, count } = f.live;
+        const v = f.v;
+        const into = f.out;
+        while (f.next < count) {
+            const key = names === undefined ? f.next : names[f.next];
+            f.next++;
+            if (!HAS_OWN(v, key))
+                continue;
+            if (!readOwnMember(v, key, read)) {
+                memberLeftOut(String(key), "getter-threw");
+                continue;
+            }
+            const member = read.value;
+            read.value = undefined;
+            if (member === null || member === undefined || typeof member === "string" || typeof member === "number" || typeof member === "boolean")
+                into[key] = member;
+            else if (typeof member === "object") {
+                into[key] = undefined;
+                return { key: String(key), member };
+            }
+            else
+                memberLeftOut(String(key), "not-data");
+        }
+        return undefined;
+    };
+    const memberLeftOut = (key, kind) => {
+        if (mode.contain !== true) {
+            path[path.length] = key;
+            refuse(kind);
+        }
+        appendOwn(faults, Object.freeze({ kind, path: pathTo(key) }));
+    };
     const land = (f, key, copy, member) => {
         if (measured && typeof member === "object" && member !== null)
             f.height = Math.max(f.height, heightOf(member) + 1);
-        Object.defineProperty(f.out, key, { value: copy, enumerable: true, writable: true, configurable: true });
+        f.out[key] = copy;
         path.length = f.level;
     };
     const finish = (f) => {
@@ -107,6 +297,7 @@ export function receive(value, mode, held) {
             if (typeof length === "number")
                 f.out.length = length;
         }
+        SET_PROTOTYPE(f.out, Array.isArray(f.out) ? ARRAY_PROTOTYPE : OBJECT_PROTOTYPE);
         if (mode.freeze === true)
             Object.freeze(f.out);
         open.delete(f.v);
@@ -123,13 +314,34 @@ export function receive(value, mode, held) {
     }
     for (;;) {
         const f = stack[stack.length - 1];
-        if (f.next < f.keys.length) {
-            const key = f.keys[f.next++];
+        let key;
+        let captured;
+        let member;
+        if (f.live !== undefined) {
+            let next = f.live.pending;
+            f.live.pending = undefined;
+            if (next === undefined) {
+                try {
+                    next = primitivesUpToAnObject(f);
+                }
+                catch (err) {
+                    return { ok: false, fault: faultOf(err) };
+                }
+            }
+            if (next !== undefined)
+                ({ key, member } = next);
+        }
+        else if (f.next < f.keys.length) {
+            key = f.keys[f.next++];
             if (f.list && key === "length")
                 continue;
-            path.push(key);
+            captured = f.captured[key];
+        }
+        if (key !== undefined) {
+            path[path.length] = key;
             try {
-                const member = memberOf(f.v, f.captured[key]);
+                if (captured !== undefined)
+                    member = memberOf(f.v, captured);
                 const frames = stack.length;
                 const copy = meet(member, f.level + 1);
                 if (stack.length > frames) {
@@ -142,7 +354,8 @@ export function receive(value, mode, held) {
             catch (err) {
                 if (mode.contain !== true)
                     return { ok: false, fault: faultOf(err) };
-                faults.push(faultOf(err));
+                appendOwn(faults, faultOf(err));
+                delete f.out[key];
                 path.length = f.level;
             }
             continue;
@@ -152,15 +365,16 @@ export function receive(value, mode, held) {
             copy = finish(f);
         }
         catch (err) {
-            stack.pop();
+            stack.length -= 1;
             const holder = stack[stack.length - 1];
             if (mode.contain !== true || holder === undefined)
                 return { ok: false, fault: faultOf(err) };
-            faults.push(faultOf(err));
+            appendOwn(faults, faultOf(err));
+            delete holder.out[holder.key];
             path.length = holder.level;
             continue;
         }
-        stack.pop();
+        stack.length -= 1;
         const holder = stack[stack.length - 1];
         if (holder === undefined)
             return received(copy);
@@ -191,3 +405,62 @@ export function describeFault(fault) {
             return `a value that could not be copied whole${at}`;
     }
 }
+export function sealedObjects(roots) {
+    const holders = new WeakMap();
+    const met = new Set();
+    const unsealed = [];
+    const stack = [...roots];
+    while (stack.length > 0) {
+        const v = stack.pop();
+        if (typeof v !== "object" || v === null || met.has(v))
+            continue;
+        met.add(v);
+        const container = isPlainRecord(v) || (Array.isArray(v) && Object.getPrototypeOf(v) === Array.prototype);
+        if (!container) {
+            unsealed.push(v);
+            continue;
+        }
+        if (!Object.isFrozen(v))
+            unsealed.push(v);
+        const descriptors = Object.getOwnPropertyDescriptors(v);
+        if (Object.getOwnPropertySymbols(descriptors).length > 0)
+            unsealed.push(v);
+        for (const k of Object.getOwnPropertyNames(descriptors)) {
+            if (Array.isArray(v) && k === "length")
+                continue;
+            const d = descriptors[k];
+            if (!Object.hasOwn(d, "value") || d.enumerable !== true) {
+                unsealed.push(v);
+                continue;
+            }
+            const m = d.value;
+            if (typeof m === "bigint" || typeof m === "symbol" || typeof m === "function")
+                unsealed.push(v);
+            else if (typeof m === "object" && m !== null) {
+                const by = holders.get(m);
+                if (by === undefined)
+                    holders.set(m, [v]);
+                else
+                    by.push(v);
+                stack.push(m);
+            }
+        }
+    }
+    return withoutUnsealed(met, unsealed, holders);
+}
+function withoutUnsealed(objects, unsealed, holders) {
+    const bad = new Set();
+    while (unsealed.length > 0) {
+        const v = unsealed.pop();
+        if (bad.has(v))
+            continue;
+        bad.add(v);
+        for (const h of holders.get(v) ?? [])
+            unsealed.push(h);
+    }
+    const sealed = new Set();
+    for (const v of objects)
+        if (!bad.has(v))
+            sealed.add(v);
+    return sealed;
+}

package/dist/core/mods/kernel/registration.d.ts

@@ -11,9 +11,9 @@ export declare const MODS_INVALID_CODE = "config.mods_invalid";
 export declare const MODS_REGISTRATION_REFUSED_CODE = "mods.registration_refused";
 /** What a registration declares it will touch — the upper bound the kernel holds it to. */
 export interface ModUses {
-    /** Events it hangs handlers on (names or `<prefix>.*`). */
+    /** Events it hangs handlers on (names or `<prefix>.*`, of its bus's side). */
     readonly events: readonly string[];
-    /** `$` methods it calls (method event names). */
+    /** The `$` members it calls — methods and callable events (names or `<prefix>.*`, of its bus's side). */
     readonly calls: readonly string[];
 }
 /** Who raised a dispatch: a registration (through its `$`), or the engine (`{plugin: "engine", tier: "core"}`). */
@@ -69,11 +69,42 @@ export interface ModHandlerOptions<D extends ModDollarBase = ModDollarBase> {
     /** Watch only: a detached `e`, outside the chain, its answer refused and disclosed. */
     readonly observe?: boolean;
 }
+/** One event's `e` and answer form, as an event map pairs them. */
+export interface ModEventPair {
+    readonly e: object;
+    readonly answer: unknown;
+}
+/** A side's typing of its events: each event name with its `e` and its answer form (the engine's is `ClassicEventMap`). */
+export type ModEventMap = {
+    readonly [name: string]: ModEventPair;
+};
+/** `next` as a handler of a mapped event sees it: it takes that event's `e` and resolves with its answer form. */
+export interface ModTypedNext<P extends ModEventPair> {
+    (e: P["e"]): Promise<P["answer"]>;
+    to(e: P["e"], tier: ModTier): Promise<P["answer"]>;
+    readonly origin: ModOrigin;
+    readonly signal: AbortSignal;
+    readonly trace: readonly ModTraceEntry[];
+    readonly budget: ModBudgetReading;
+    readonly error?: ModCaughtError;
+    readonly called?: boolean;
+}
+/** A handler of a mapped event: its `e` and its answer typed by the map. */
+export type ModTypedHandler<D extends ModDollarBase, P extends ModEventPair> = ($: D, e: P["e"], next: ModTypedNext<P>) => P["answer"] | Promise<P["answer"]>;
 /** `on(pattern, handler, options?)` or `on(pattern, matcher, handler, options?)`. */
 export interface On<D extends ModDollarBase = ModDollarBase> {
     (pattern: string, handler: ModHandler<D>, options?: ModHandlerOptions<D>): void;
     (pattern: string, matcher: ModMatcher, handler: ModHandler<D>, options?: ModHandlerOptions<D>): void;
 }
+/** {@link On} given its side's event map `M`: a pattern that is one of the map's names types its handler by that event;
+ *  any other pattern (a `<prefix>.*`, a name the map does not pair) takes the untyped handler. A side types its own
+ *  registrations by declaring `register(on: MappedOn<D, M>, options)` — they stay registrations of the kernel's form. */
+export interface MappedOn<D extends ModDollarBase, M extends ModEventMap> {
+    <K extends keyof M & string>(pattern: K, handler: ModTypedHandler<D, M[K]>, options?: ModHandlerOptions<D>): void;
+    <K extends keyof M & string>(pattern: K, matcher: ModMatcher, handler: ModTypedHandler<D, M[K]>, options?: ModHandlerOptions<D>): void;
+    (pattern: string, handler: ModHandler<D>, options?: ModHandlerOptions<D>): void;
+    (pattern: string, matcher: ModMatcher, handler: ModHandler<D>, options?: ModHandlerOptions<D>): void;
+}
 export interface ModRegistration<D extends ModDollarBase = ModDollarBase> {
     /** Unique in the run; names the registration everywhere (origin, trace, disclosures, admission). */
     readonly name: string;

package/dist/core/mods/kernel/registration.js

@@ -1,4 +1,4 @@
-import { describe, expandModPattern, MOD_SEATS, readOnSide, SEAT_TIER_TABLE, } from "./events.js";
+import { describe, expandOnSide, MOD_SEATS, SEAT_TIER_TABLE, } from "./events.js";
 import { resolveModBudgetMs } from "./budget.js";
 export const MODS_INVALID_CODE = "config.mods_invalid";
 export const MODS_REGISTRATION_REFUSED_CODE = "mods.registration_refused";
@@ -44,13 +44,12 @@ function screenOne(item, seat, side, report) {
         throw modsInvalid(`${name}: provenance is ${describe(item.provenance)}; it is a label (a string)`);
     const eventsBound = new Set();
     for (const p of uses.events)
-        for (const n of namesOf(p, name, "uses.events"))
+        for (const n of namesOf(p, name, "uses.events", side))
             eventsBound.add(n);
     const callsBound = new Set();
     for (const c of uses.calls)
-        for (const n of namesOf(c, name, "uses.calls"))
-            if (readOnSide(n, side))
-                callsBound.add(n);
+        for (const n of namesOf(c, name, "uses.calls", side))
+            callsBound.add(n);
     return {
         registration: item,
         name,
@@ -94,8 +93,8 @@ function stringList(v, name, field) {
     }
     return Object.freeze(out);
 }
-function namesOf(pattern, name, field) {
-    const expanded = expandModPattern(pattern);
+function namesOf(pattern, name, field, side) {
+    const expanded = expandOnSide(pattern, side);
     if ("refusal" in expanded)
         throw modsInvalid(`${name}: ${field}: ${expanded.refusal}`);
     return expanded.names;

package/dist/core/mods/kernel/site-rules.d.ts

@@ -4,6 +4,7 @@
  * failure column like a crash but never reported as one (no code crashed).
  */
 import { type ModSeat, type ModTier } from "./events.js";
+export { sealedObjects } from "./receive.js";
 /** The host's Proxy probe (this folder cannot recognise a Proxy on its own): with one, a handler's Proxy is refused
  *  before any of its traps runs; without one, it is read like any object. */
 export type ProxyProbe = (value: object) => boolean;
@@ -42,10 +43,24 @@ export interface ModAnswerer {
 export declare const NEXT_IN_FLIGHT: Readonly<{
     inFlight: true;
 }>;
+/** What a dispatch records of its own run, as a station's answer check reads it. */
+export interface ModDispatchRun {
+    /** Whether the chain's bottom (the core of the event — on an effect event, the effect) has started in this dispatch. */
+    readonly bottomStarted: boolean;
+}
 /** The station's own reading of an answer: undefined when it is one the station takes, else why not. `below` is every
  *  answer the handler's `next` resolved with, plus `NEXT_IN_FLIGHT` while its `next` is still in flight —
- *  empty when it never called `next`. */
-export type ModAnswerCheck = (answer: unknown, e: ModEventPayload, by: ModAnswerer, below: readonly unknown[]) => string | undefined;
+ *  empty when it never called `next`. `run` is what the dispatch records of its run when the answer is read. */
+export type ModAnswerCheck = (answer: unknown, e: ModEventPayload, by: ModAnswerer, below: readonly unknown[], run: ModDispatchRun) => string | undefined;
+/**
+ * A refusing event's ranking of its answers by how much they refuse: `of(answer)` is 0 for an answer that passes the
+ * event on as it stands and higher for one that refuses more; `top` is the rank of an outright refusal. The seat-trust
+ * law reads it: an answer from a less trusted seat never stands over a stricter one a more trusted seat gave below it.
+ */
+export interface ModAnswerRanks {
+    readonly of: (answer: unknown) => number;
+    readonly top: number;
+}
 /** A matcher: top-level fields of `e` that must equal these values exactly. */
 export type ModMatcher = Readonly<Record<string, string | number | boolean>>;
 /** Why a pinned key of what a handler handed on is not taken: it holds another value, or it is a copy the comparison
@@ -93,7 +108,7 @@ export declare function pinnedHandOn(pinned: readonly string[], held: ModEventPa
     readonly violation: string;
 };
 /** Why a handler's answer breaks the site, or undefined. No answer at all is never an answer. */
-export declare function answerViolation(answer: unknown, check: ModAnswerCheck | undefined, e: ModEventPayload, by: ModAnswerer, below: readonly unknown[]): string | undefined;
+export declare function answerViolation(answer: unknown, check: ModAnswerCheck | undefined, e: ModEventPayload, by: ModAnswerer, below: readonly unknown[], run: ModDispatchRun): string | undefined;
 /**
  * A `$` method's answer form: `{ value }` (the call's result) or `{ deny }` (the call throws). A `{ deny }` given after
  * the handler's `next` was answered with something that is not a deny — or while that `next` is still running — breaks
@@ -124,15 +139,28 @@ export declare function receiveEvent(e: unknown): {
     readonly refusal: string;
 };
 /**
- * The bottom's answer as it starts up the chain: its top level frozen, so no handler can turn the answer it got from
- * `next` into another one (a deny in place of a result that already ran). A plain record or array the bottom made is
- * copied once and frozen; an answer already frozen (an engine sentinel) or not a plain container is itself.
+ * The bottom's answer as it starts up the chain — a seat's value handed to the handlers above it — received by the one
+ * receipt as data, frozen all the way down, so no handler can turn what its `next` answered into something else (a deny
+ * in place of a result that already ran, a member planted in a seat's value the caller then reads): a mutation attempt
+ * throws, and the handler's failure is reported like any other. A value sealed already (frozen data all the way down —
+ * an engine sentinel, a station's view) is itself; any other plain container is copied, every level frozen; an object of
+ * another kind (an engine object, not data) is handed as it is. A value the receipt refuses (an accessor, a Proxy) is the
+ * bottom's own fault: thrown.
+ */
+export declare function answerUpward(v: unknown, isProxy?: ProxyProbe): unknown;
+/** The objects an answer may hold as themselves: an object the bus already holds (`has`), never walked by the receipt. */
+export interface ModHeldObjects {
+    has(value: object): boolean;
+}
+/**
+ * A handler's answer, received as DATA — the one place an answer becomes what the station reads: a primitive, or an
+ * ordinary record or array copied whole and frozen (no accessor runs, held to {@link MODS_VALUE_DEPTH}), every value in
+ * it data too. A function, an object of another kind (a class instance, a `Map`), a symbol, a bigint or a cycle the
+ * handler built refuses the answer — a violation of the site — so what a station checks is what it reads, however often
+ * it reads it. An object the bus already holds (`held`: the dispatch's own event, and what the handler's `next` answered)
+ * is kept as itself, never walked.
  */
-export declare function answerUpward(v: unknown): unknown;
-/** A handler's answer, received by the same receipt held to {@link MODS_VALUE_DEPTH} (an answer need not be a record; a
- *  primitive is itself); an object of the dispatch's own event in it (`engines`, {@link engineObjectsOnce}) is kept as
- *  itself, never walked. */
-export declare function receiveAnswer(answer: unknown, engines: ReadonlySet<object>, isProxy?: ProxyProbe): {
+export declare function receiveAnswer(answer: unknown, held: ModHeldObjects, isProxy?: ProxyProbe): {
     readonly answer: unknown;
 } | {
     readonly refusal: string;
@@ -140,10 +168,10 @@ export declare function receiveAnswer(answer: unknown, engines: ReadonlySet<obje
 /**
  * A copy for an observe handler, made by the one receipt (its own stack, so no depth of the event decides whether an
  * observer runs — the event it observes was received at any depth too): every data container (a plain object, an
- * ordinary array) detached at any depth; then every other object the copy holds — a tool result's `Map`, `Date` or
- * typed array — detached by a structured clone of that object alone (one clone per object, so a shared one stays shared),
- * and one the clone refuses (a function, a handle, a class instance holding one) handed as is. The engine's own event
- * holds data properties only, so the copy is whole; a receipt that could not make it (a Proxy whose trap throws, on a bus
- * given no probe) is the observer's failure, reported like any other.
+ * ordinary array) detached at any depth, and every other object the copy holds — a tool result's `Map`, `Date` or typed
+ * array — detached by the receipt's leaf law (a structured clone of that object alone; one the clone refuses — a
+ * function, a handle, a class instance holding one — handed as is). The engine's own event holds data properties only,
+ * so the copy is whole; a receipt that could not make it (a Proxy whose trap throws, on a bus given no probe) is the
+ * observer's failure, reported like any other.
  */
 export declare function detachedCopy(e: ModEventPayload): Record<string, unknown>;