@sema-agent/mods-kernel 7.55.0 → 7.56.0

package/dist/events.js

@@ -1,8 +1,11 @@
-export const KERNEL_CONTRACT_VERSION = 2;
+export const KERNEL_CONTRACT_VERSION = 3;
 export const MOD_TIERS = Object.freeze(["prepend", "user", "append", "builtin", "core"]);
 export const MOD_SEATS = Object.freeze(["deployment", "task"]);
 export const MOD_EVENT_SIDES = Object.freeze(["engine", "surface", "both"]);
-export const MOD_FAILURE_ANSWERS = Object.freeze(["refuse", "skip"]);
+export const MOD_FAILURE_ANSWERS = Object.freeze(["refuse", "skip", "refuse_until_run"]);
+export function failureRefuses(failure) {
+    return failure !== "skip";
+}
 export const MOD_ABORT_POSTURES = Object.freeze(["immediate", "grace", "caller"]);
 export const NEXT_TO_TABLE = Object.freeze({
     prepend: Object.freeze(["append", "builtin", "core"]),
@@ -27,10 +30,19 @@ export const SEAT_TIER_TABLE = Object.freeze({
     deployment: Object.freeze({ declared: "required", tiers: Object.freeze(["prepend", "user", "append"]) }),
     task: Object.freeze({ declared: "optional", tiers: Object.freeze(["user"]) }),
 });
-const station = (failure, abort, pinned = []) => Object.freeze({ failure, abort, pinned: Object.freeze([...pinned]) });
+const station = (failure, abort, pinned = [], more = {}) => Object.freeze({
+    failure,
+    abort,
+    pinned: Object.freeze([...pinned]),
+    ...(more.call === true ? { call: Object.freeze({ pausesCallerBudget: true }) } : {}),
+    ...(more.budgetMs !== undefined ? { budgetMs: more.budgetMs } : {}),
+});
 const method = (pausesCallerBudget) => Object.freeze({ failure: "skip", abort: "caller", pinned: Object.freeze([]), method: Object.freeze({ pausesCallerBudget }) });
 const engine = (s) => Object.freeze(s === undefined ? { side: "engine" } : { side: "engine", station: s });
-const surface = Object.freeze({ side: "surface" });
+const surface = (s) => Object.freeze(s === undefined ? { side: "surface" } : { side: "surface", station: s });
+const RENDER_PINNED = ["surface", "component", "requestId", "viewport"];
+const ELEMENT_PINNED = ["plugin", "element", "component", "requestId", "surface"];
+const PROMPT_EDIT_BUDGET_MS = 50;
 export const MOD_EVENT_TABLE = Object.freeze({
     "classic.PreToolUse": engine(station("refuse", "immediate", ["tool", "tool_use_id", "agentId", "input"])),
     "classic.PostToolUse": engine(station("skip", "grace")),
@@ -65,34 +77,34 @@ export const MOD_EVENT_TABLE = Object.freeze({
     "classic.FileChanged": engine(),
     "classic.DirectoryAdded": engine(),
     "classic.MessageDisplay": engine(),
-    "tool.call": engine(),
+    "tool.call": engine(station("refuse_until_run", "immediate", ["tool", "tool_use_id", "agentId", "input"], { call: true })),
     "tool.check": engine(station("refuse", "immediate", ["tool", "input", "tool_use_id", "agentId", "ceiling"])),
-    "ui.render": surface,
-    "ui.resolve": surface,
-    "ui.press": surface,
-    "ui.input": surface,
-    "ui.select": surface,
-    "ui.message": surface,
-    "ui.fault": surface,
-    "ui.scroll": surface,
-    "ui.focus": surface,
+    "ui.render": surface(station("skip", "grace", RENDER_PINNED)),
+    "ui.resolve": surface(station("skip", "grace", ["surface", "component"])),
+    "ui.press": surface(station("skip", "grace", ELEMENT_PINNED)),
+    "ui.input": surface(station("skip", "grace", ELEMENT_PINNED)),
+    "ui.select": surface(station("skip", "grace", ELEMENT_PINNED)),
+    "ui.message": surface(),
+    "ui.fault": surface(),
+    "ui.scroll": surface(station("skip", "grace", ["component", "requestId", "by", "bodyRows", "contentRows", "origin", "pointer"], { call: true })),
+    "ui.focus": surface(station("skip", "grace", ["component", "requestId", "plugin", "origin", "element"], { call: true })),
     "agent.offer": engine(),
     "agent.spawn": engine(),
     "prompt.submit": engine(),
-    "prompt.fill": surface,
-    "prompt.suggest": surface,
-    "prompt.edit": surface,
-    "prompt.autocomplete": surface,
+    "prompt.fill": surface(station("skip", "grace", ["origin", "mode"], { call: true })),
+    "prompt.suggest": surface(station("skip", "grace", ["origin"], { call: true })),
+    "prompt.edit": surface(station("skip", "grace", ["origin", "key"], { budgetMs: PROMPT_EDIT_BUDGET_MS })),
+    "prompt.autocomplete": surface(),
     "prompt.section": engine(station("skip", "grace", ["name", "key", "mountedTools"])),
     "prompt.context": engine(),
     "prompt.attachment": engine(),
-    "prompt.mention": surface,
+    "prompt.mention": engine(station("refuse", "immediate", ["mention", "agentId"])),
     "prompt.compose": engine(station("skip", "grace", ["model", "catalog", "selectors"])),
     "tool.describe": engine(),
-    "command.run": surface,
-    "command.describe": surface,
-    "config.set": surface,
-    "config.describe": surface,
+    "command.run": surface(station("skip", "grace", ["command", "presentation", "origin"], { call: true })),
+    "command.describe": surface(station("skip", "grace", ["command", "immediate", "provider"])),
+    "config.set": surface(station("refuse", "immediate", ["key", "previous", "provider", "origin"], { call: true })),
+    "config.describe": surface(station("skip", "grace", ["key", "provider"])),
     "telemetry.log": engine(),
     "telemetry.mark": engine(),
     "skill.prompt": engine(),
@@ -106,7 +118,7 @@ export const MOD_EVENT_TABLE = Object.freeze({
     "session.detach": engine(),
     "session.measure": engine(),
     "session.end": engine(),
-    "plugin.register": Object.freeze({ side: "both", station: station("skip", "immediate", ["name", "seat", "tier", "uses"]) }),
+    "plugin.register": Object.freeze({ side: "both", station: station("refuse", "immediate", ["name", "seat", "tier", "uses"]) }),
     "turn.start": engine(),
     "turn.step": engine(),
     "turn.complete": engine(),
@@ -114,8 +126,8 @@ export const MOD_EVENT_TABLE = Object.freeze({
     "model.complete": engine(method(true)),
     "model.classify": engine(),
     "model.fork": engine(),
-    "audio.play": surface,
-    "audio.speak": surface,
+    "audio.play": surface(),
+    "audio.speak": surface(),
     "mcp.call": engine(),
     "mcp.connect": engine(),
     "session.cwd": engine(method(true)),
@@ -131,27 +143,27 @@ export const MOD_EVENT_TABLE = Object.freeze({
     "session.usage": engine(),
     "session.version": engine(),
     "turn.abort": engine(),
-    "prompt.read": surface,
+    "prompt.read": surface(method(true)),
     "flag.value": engine(),
     "tool.list": engine(method(true)),
     "tool.register": engine(),
-    "command.list": surface,
-    "command.register": surface,
-    "config.list": surface,
+    "command.list": surface(method(true)),
+    "command.register": surface(method(true)),
+    "config.list": surface(method(true)),
     "agent.list": engine(method(true)),
     "agent.register": engine(),
-    "ui.toast": surface,
-    "ui.status": surface,
-    "ui.log": surface,
-    "ui.notice": surface,
-    "ui.invalidate": surface,
-    "ui.open": surface,
-    "ui.close": surface,
-    "ui.panes": surface,
-    "ui.selection": surface,
-    "ui.copy": surface,
-    "ui.notify": surface,
-    "ui.blit": surface,
+    "ui.toast": surface(method(true)),
+    "ui.status": surface(),
+    "ui.log": surface(method(true)),
+    "ui.notice": surface(method(true)),
+    "ui.invalidate": surface(method(true)),
+    "ui.open": surface(),
+    "ui.close": surface(),
+    "ui.panes": surface(),
+    "ui.selection": surface(method(true)),
+    "ui.copy": surface(method(true)),
+    "ui.notify": surface(),
+    "ui.blit": surface(),
     "fs.read": engine(),
     "fs.write": engine(),
     "fs.list": engine(),
@@ -199,6 +211,18 @@ export function expandModPattern(pattern) {
     }
     return isModEventName(pattern) ? { names: [pattern] } : { refusal: `"${pattern}" is not an event` };
 }
+export function expandOnSide(pattern, side) {
+    const expanded = expandModPattern(pattern);
+    if ("refusal" in expanded)
+        return expanded;
+    const own = expanded.names.filter((n) => readOnSide(n, side));
+    if (own.length > 0)
+        return { names: own };
+    const named = String(pattern);
+    return named.endsWith(".*")
+        ? { refusal: `"${named}" selects no event the ${side} bus reads (${expanded.names.length === 1 ? "its one name is" : "its names are"} the ${MOD_EVENT_TABLE[expanded.names[0]].side} side's)` }
+        : { refusal: `"${named}" is a ${MOD_EVENT_TABLE[expanded.names[0]].side} event, read on that side's bus only — never on the ${side} bus` };
+}
 export function describe(value) {
     if (typeof value === "string")
         return `"${value}"`;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, isModEventName, stationOn, readOnSide, type ModTier, type ModRegistrationTier, type ModSeat, type ModEventSide, type ModBusSide, type ModFailureAnswer, type ModAbortPosture, type ModStation, type ModEventRow, type ModEventName, } from "./events.js";
+export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, expandOnSide, failureRefuses, isModEventName, stationOn, readOnSide, type ModTier, type ModRegistrationTier, type ModSeat, type ModEventSide, type ModBusSide, type ModFailureAnswer, type ModAbortPosture, type ModStation, type ModEventRow, type ModEventName, } from "./events.js";
 export { DEFAULT_MOD_BUDGET_MS, CATCH_BUDGET_MS, RUNAWAY_AFTER_MS, POST_ABORT_GRACE_MS, MAX_TIMER_MS, resolveModBudgetMs, type ModBudgetReading, } from "./budget.js";
-export { MOD_FAILURE_CAUSES, type ModFailureCause, type ModEventPayload, type ModAnswerCheck, type ModAnswerer, type ModMatcher, type ModSkip } from "./site-rules.js";
-export { ENGINE_ORIGIN, MODS_INVALID_CODE, MODS_REGISTRATION_REFUSED_CODE, MOD_TRACE_OUTCOMES, type ModTraceOutcome, type ModUses, type ModOrigin, type ModPluginFacts, type ModDollarBase, type ModTraceEntry, type ModCaughtError, type ModNext, type ModHandler, type ModHandlerOptions, type On, type ModRegistration, type ModAdmissionRecord, type ModSeats, } from "./registration.js";
-export { admitMods, type ModFrame, type ModBottomContext, type ModMethodBottom, type ModMethodSeat, type ModMethodBottoms, type ModDispatchOutcome, type ModDispatchOptions, type ModBus, type ModMountedHandler, type ModBusInput, } from "./dispatch.js";
+export { MOD_FAILURE_CAUSES, type ModFailureCause, type ModEventPayload, type ModAnswerCheck, type ModAnswerRanks, type ModDispatchRun, type ModAnswerer, type ModMatcher, type ModSkip, } from "./site-rules.js";
+export { ENGINE_ORIGIN, MODS_INVALID_CODE, MODS_REGISTRATION_REFUSED_CODE, MOD_TRACE_OUTCOMES, type ModTraceOutcome, type ModUses, type ModOrigin, type ModPluginFacts, type ModDollarBase, type ModTraceEntry, type ModCaughtError, type ModNext, type ModHandler, type ModHandlerOptions, type ModEventPair, type ModEventMap, type ModTypedNext, type ModTypedHandler, type On, type MappedOn, type ModRegistration, type ModAdmissionRecord, type ModSeats, } from "./registration.js";
+export { admitMods, type ModFrame, type ModBottomContext, type ModMethodBottom, type ModMethodSeat, type ModMethodBottoms, type ModCallEntry, type ModCallEntries, type ModDispatchOutcome, type ModDispatchOptions, type ModBus, type ModMountedHandler, type ModBusInput, } from "./dispatch.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, isModEventName, stationOn, readOnSide, } from "./events.js";
+export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, expandOnSide, failureRefuses, isModEventName, stationOn, readOnSide, } from "./events.js";
 export { DEFAULT_MOD_BUDGET_MS, CATCH_BUDGET_MS, RUNAWAY_AFTER_MS, POST_ABORT_GRACE_MS, MAX_TIMER_MS, resolveModBudgetMs, } from "./budget.js";
-export { MOD_FAILURE_CAUSES } from "./site-rules.js";
+export { MOD_FAILURE_CAUSES, } from "./site-rules.js";
 export { ENGINE_ORIGIN, MODS_INVALID_CODE, MODS_REGISTRATION_REFUSED_CODE, MOD_TRACE_OUTCOMES, } from "./registration.js";
 export { admitMods, } from "./dispatch.js";

package/dist/receive.d.ts

@@ -5,6 +5,8 @@ export interface ReceiptMode {
     readonly past?: "refuse";
     readonly contain?: true;
     readonly freeze?: boolean;
+    readonly wire?: true;
+    readonly leaves?: "cloned";
     readonly isProxy?: (value: object) => boolean;
 }
 export declare const RECEIPT_FAULTS: readonly ["proxy", "accessor", "hidden", "getter-threw", "prototype-moved", "not-data", "cycle", "too-deep", "uncopyable"];
@@ -22,6 +24,11 @@ export type Receipt = {
     readonly fault: ReceiptFault;
 };
 export declare function isPlainRecord(v: unknown): v is Record<string, unknown>;
-export declare function receive(value: unknown, mode: ReceiptMode, held?: ReadonlySet<object>): Receipt;
+export declare function dataMember(value: unknown): PropertyDescriptor;
+export declare function appendOwn<T>(list: T[], value: T): void;
+export declare function receive(value: unknown, mode: ReceiptMode, held?: {
+    has(value: object): boolean;
+}): Receipt;
 export declare const MODS_PAYLOAD_MODE: ReceiptMode;
 export declare function describeFault(fault: ReceiptFault): string;
+export declare function sealedObjects(roots: readonly unknown[]): ReadonlySet<object>;

package/dist/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/registration.d.ts

@@ -47,10 +47,34 @@ export interface ModHandlerOptions<D extends ModDollarBase = ModDollarBase> {
     readonly catch?: ModHandler<D>;
     readonly observe?: boolean;
 }
+export interface ModEventPair {
+    readonly e: object;
+    readonly answer: unknown;
+}
+export type ModEventMap = {
+    readonly [name: string]: ModEventPair;
+};
+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;
+}
+export type ModTypedHandler<D extends ModDollarBase, P extends ModEventPair> = ($: D, e: P["e"], next: ModTypedNext<P>) => P["answer"] | Promise<P["answer"]>;
 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;
 }
+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> {
     readonly name: string;
     readonly tier?: ModRegistrationTier;