@sema-agent/mods-kernel 0.0.0-stage → 7.54.0

package/dist/events.d.ts

@@ -0,0 +1,200 @@
+export declare const KERNEL_CONTRACT_VERSION = 2;
+export declare const MOD_TIERS: readonly ["prepend", "user", "append", "builtin", "core"];
+export type ModTier = (typeof MOD_TIERS)[number];
+export type ModRegistrationTier = Exclude<ModTier, "builtin" | "core">;
+export declare const MOD_SEATS: readonly ["deployment", "task"];
+export type ModSeat = (typeof MOD_SEATS)[number];
+export declare const MOD_EVENT_SIDES: readonly ["engine", "surface", "both"];
+export type ModEventSide = (typeof MOD_EVENT_SIDES)[number];
+export type ModBusSide = Exclude<ModEventSide, "both">;
+export declare const MOD_FAILURE_ANSWERS: readonly ["refuse", "skip"];
+export type ModFailureAnswer = (typeof MOD_FAILURE_ANSWERS)[number];
+export declare const MOD_ABORT_POSTURES: readonly ["immediate", "grace", "caller"];
+export type ModAbortPosture = (typeof MOD_ABORT_POSTURES)[number];
+export declare const NEXT_TO_TABLE: Readonly<{
+    prepend: readonly ["append", "builtin", "core"];
+    user: readonly [];
+    append: readonly ["core"];
+    builtin: readonly [];
+    core: readonly [];
+}>;
+export declare function nextToRefusal(from: ModTier, to: unknown): string | undefined;
+export declare const SEAT_TIER_TABLE: Readonly<{
+    deployment: Readonly<{
+        declared: "required";
+        tiers: readonly ["prepend", "user", "append"];
+    }>;
+    task: Readonly<{
+        declared: "optional";
+        tiers: readonly ["user"];
+    }>;
+}>;
+export interface ModStation {
+    readonly failure: ModFailureAnswer;
+    readonly abort: ModAbortPosture;
+    readonly pinned: readonly string[];
+    readonly method?: {
+        readonly pausesCallerBudget: boolean;
+    };
+}
+export interface ModEventRow {
+    readonly side: ModEventSide;
+    readonly station?: ModStation;
+}
+export declare const MOD_EVENT_TABLE: Readonly<{
+    "classic.PreToolUse": ModEventRow;
+    "classic.PostToolUse": ModEventRow;
+    "classic.PostToolUseFailure": ModEventRow;
+    "classic.PostToolBatch": ModEventRow;
+    "classic.Notification": ModEventRow;
+    "classic.UserPromptSubmit": ModEventRow;
+    "classic.UserPromptExpansion": ModEventRow;
+    "classic.SessionStart": ModEventRow;
+    "classic.SessionEnd": ModEventRow;
+    "classic.Stop": ModEventRow;
+    "classic.StopFailure": ModEventRow;
+    "classic.SubagentStart": ModEventRow;
+    "classic.SubagentStop": ModEventRow;
+    "classic.PreCompact": ModEventRow;
+    "classic.PostCompact": ModEventRow;
+    "classic.PreModelSwitch": ModEventRow;
+    "classic.PostModelSwitch": ModEventRow;
+    "classic.PermissionRequest": ModEventRow;
+    "classic.PermissionDenied": ModEventRow;
+    "classic.Setup": ModEventRow;
+    "classic.TeammateIdle": ModEventRow;
+    "classic.TaskCreated": ModEventRow;
+    "classic.TaskCompleted": ModEventRow;
+    "classic.Elicitation": ModEventRow;
+    "classic.ElicitationResult": ModEventRow;
+    "classic.ConfigChange": ModEventRow;
+    "classic.WorktreeCreate": ModEventRow;
+    "classic.WorktreeRemove": ModEventRow;
+    "classic.InstructionsLoaded": ModEventRow;
+    "classic.CwdChanged": ModEventRow;
+    "classic.FileChanged": ModEventRow;
+    "classic.DirectoryAdded": ModEventRow;
+    "classic.MessageDisplay": ModEventRow;
+    "tool.call": ModEventRow;
+    "tool.check": ModEventRow;
+    "ui.render": ModEventRow;
+    "ui.resolve": ModEventRow;
+    "ui.press": ModEventRow;
+    "ui.input": ModEventRow;
+    "ui.select": ModEventRow;
+    "ui.message": ModEventRow;
+    "ui.fault": ModEventRow;
+    "ui.scroll": ModEventRow;
+    "ui.focus": ModEventRow;
+    "agent.offer": ModEventRow;
+    "agent.spawn": ModEventRow;
+    "prompt.submit": ModEventRow;
+    "prompt.fill": ModEventRow;
+    "prompt.suggest": ModEventRow;
+    "prompt.edit": ModEventRow;
+    "prompt.autocomplete": ModEventRow;
+    "prompt.section": ModEventRow;
+    "prompt.context": ModEventRow;
+    "prompt.attachment": ModEventRow;
+    "prompt.mention": ModEventRow;
+    "prompt.compose": ModEventRow;
+    "tool.describe": ModEventRow;
+    "command.run": ModEventRow;
+    "command.describe": ModEventRow;
+    "config.set": ModEventRow;
+    "config.describe": ModEventRow;
+    "telemetry.log": ModEventRow;
+    "telemetry.mark": ModEventRow;
+    "skill.prompt": ModEventRow;
+    "attribution.text": ModEventRow;
+    "session.start": ModEventRow;
+    "session.receive": ModEventRow;
+    "session.append": ModEventRow;
+    "session.send": ModEventRow;
+    "session.compact": ModEventRow;
+    "session.attach": ModEventRow;
+    "session.detach": ModEventRow;
+    "session.measure": ModEventRow;
+    "session.end": ModEventRow;
+    "plugin.register": Readonly<{
+        side: "both";
+        station: ModStation;
+    }>;
+    "turn.start": ModEventRow;
+    "turn.step": ModEventRow;
+    "turn.complete": ModEventRow;
+    "engine.create": ModEventRow;
+    "model.complete": ModEventRow;
+    "model.classify": ModEventRow;
+    "model.fork": ModEventRow;
+    "audio.play": ModEventRow;
+    "audio.speak": ModEventRow;
+    "mcp.call": ModEventRow;
+    "mcp.connect": ModEventRow;
+    "session.cwd": ModEventRow;
+    "session.root": ModEventRow;
+    "session.model": ModEventRow;
+    "session.turns": ModEventRow;
+    "session.id": ModEventRow;
+    "session.messages": ModEventRow;
+    "session.repo": ModEventRow;
+    "session.surface": ModEventRow;
+    "session.surfaces": ModEventRow;
+    "session.authorize": ModEventRow;
+    "session.usage": ModEventRow;
+    "session.version": ModEventRow;
+    "turn.abort": ModEventRow;
+    "prompt.read": ModEventRow;
+    "flag.value": ModEventRow;
+    "tool.list": ModEventRow;
+    "tool.register": ModEventRow;
+    "command.list": ModEventRow;
+    "command.register": ModEventRow;
+    "config.list": ModEventRow;
+    "agent.list": ModEventRow;
+    "agent.register": ModEventRow;
+    "ui.toast": ModEventRow;
+    "ui.status": ModEventRow;
+    "ui.log": ModEventRow;
+    "ui.notice": ModEventRow;
+    "ui.invalidate": ModEventRow;
+    "ui.open": ModEventRow;
+    "ui.close": ModEventRow;
+    "ui.panes": ModEventRow;
+    "ui.selection": ModEventRow;
+    "ui.copy": ModEventRow;
+    "ui.notify": ModEventRow;
+    "ui.blit": ModEventRow;
+    "fs.read": ModEventRow;
+    "fs.write": ModEventRow;
+    "fs.list": ModEventRow;
+    "fs.exists": ModEventRow;
+    "fs.stat": ModEventRow;
+    "fs.ancestors": ModEventRow;
+    "store.get": ModEventRow;
+    "store.set": ModEventRow;
+    "store.delete": ModEventRow;
+    "store.keys": ModEventRow;
+    "state.get": ModEventRow;
+    "state.set": ModEventRow;
+    "clock.now": ModEventRow;
+    "clock.sleep": ModEventRow;
+    "clock.after": ModEventRow;
+    "clock.every": ModEventRow;
+    "http.fetch": ModEventRow;
+    "process.run": ModEventRow;
+    "process.spawn": ModEventRow;
+    "settings.read": ModEventRow;
+    "env.get": ModEventRow;
+    "env.set": ModEventRow;
+}>;
+export type ModEventName = keyof typeof MOD_EVENT_TABLE;
+export declare function isModEventName(name: unknown): name is ModEventName;
+export declare function stationOn(name: ModEventName, side: ModBusSide): ModStation | undefined;
+export declare function readOnSide(name: ModEventName, side: ModBusSide): boolean;
+export declare function expandModPattern(pattern: unknown): {
+    readonly names: readonly ModEventName[];
+} | {
+    readonly refusal: string;
+};
+export declare function describe(value: unknown): string;

package/dist/events.js

@@ -0,0 +1,210 @@
+export const KERNEL_CONTRACT_VERSION = 2;
+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_ABORT_POSTURES = Object.freeze(["immediate", "grace", "caller"]);
+export const NEXT_TO_TABLE = Object.freeze({
+    prepend: Object.freeze(["append", "builtin", "core"]),
+    user: Object.freeze([]),
+    append: Object.freeze(["core"]),
+    builtin: Object.freeze([]),
+    core: Object.freeze([]),
+});
+const CONTINUABLE = NEXT_TO_TABLE.prepend;
+export function nextToRefusal(from, to) {
+    const allowed = NEXT_TO_TABLE[from];
+    const named = CONTINUABLE.find((t) => t === to);
+    if (named === undefined)
+        return `next.to names ${describe(to)}, which is not a tier a dispatch continues at (${CONTINUABLE.join(", ")})`;
+    if (allowed.length === 0)
+        return `next.to is available to prepend and append handlers only, not to a ${from} handler`;
+    if (!allowed.includes(named))
+        return `next.to("${named}") skips nothing from ${from}; a ${from} handler may continue at ${allowed.join(", ")}`;
+    return undefined;
+}
+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 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" });
+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")),
+    "classic.PostToolUseFailure": engine(station("skip", "grace")),
+    "classic.PostToolBatch": engine(station("skip", "grace")),
+    "classic.Notification": engine(),
+    "classic.UserPromptSubmit": engine(station("refuse", "immediate", ["source", "inputId", "actor", "prompt"])),
+    "classic.UserPromptExpansion": engine(),
+    "classic.SessionStart": engine(),
+    "classic.SessionEnd": engine(),
+    "classic.Stop": engine(station("skip", "immediate")),
+    "classic.StopFailure": engine(station("skip", "grace")),
+    "classic.SubagentStart": engine(),
+    "classic.SubagentStop": engine(station("skip", "immediate")),
+    "classic.PreCompact": engine(station("skip", "grace")),
+    "classic.PostCompact": engine(station("skip", "grace")),
+    "classic.PreModelSwitch": engine(),
+    "classic.PostModelSwitch": engine(),
+    "classic.PermissionRequest": engine(),
+    "classic.PermissionDenied": engine(station("skip", "grace")),
+    "classic.Setup": engine(),
+    "classic.TeammateIdle": engine(),
+    "classic.TaskCreated": engine(),
+    "classic.TaskCompleted": engine(),
+    "classic.Elicitation": engine(),
+    "classic.ElicitationResult": engine(),
+    "classic.ConfigChange": engine(),
+    "classic.WorktreeCreate": engine(),
+    "classic.WorktreeRemove": engine(),
+    "classic.InstructionsLoaded": engine(),
+    "classic.CwdChanged": engine(),
+    "classic.FileChanged": engine(),
+    "classic.DirectoryAdded": engine(),
+    "classic.MessageDisplay": engine(),
+    "tool.call": engine(),
+    "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,
+    "agent.offer": engine(),
+    "agent.spawn": engine(),
+    "prompt.submit": engine(),
+    "prompt.fill": surface,
+    "prompt.suggest": surface,
+    "prompt.edit": surface,
+    "prompt.autocomplete": surface,
+    "prompt.section": engine(station("skip", "grace", ["name", "key", "mountedTools"])),
+    "prompt.context": engine(),
+    "prompt.attachment": engine(),
+    "prompt.mention": surface,
+    "prompt.compose": engine(station("skip", "grace", ["model", "catalog", "selectors"])),
+    "tool.describe": engine(),
+    "command.run": surface,
+    "command.describe": surface,
+    "config.set": surface,
+    "config.describe": surface,
+    "telemetry.log": engine(),
+    "telemetry.mark": engine(),
+    "skill.prompt": engine(),
+    "attribution.text": engine(),
+    "session.start": engine(),
+    "session.receive": engine(),
+    "session.append": engine(),
+    "session.send": engine(),
+    "session.compact": engine(),
+    "session.attach": engine(),
+    "session.detach": engine(),
+    "session.measure": engine(),
+    "session.end": engine(),
+    "plugin.register": Object.freeze({ side: "both", station: station("skip", "immediate", ["name", "seat", "tier", "uses"]) }),
+    "turn.start": engine(),
+    "turn.step": engine(),
+    "turn.complete": engine(),
+    "engine.create": engine(),
+    "model.complete": engine(method(true)),
+    "model.classify": engine(),
+    "model.fork": engine(),
+    "audio.play": surface,
+    "audio.speak": surface,
+    "mcp.call": engine(),
+    "mcp.connect": engine(),
+    "session.cwd": engine(method(true)),
+    "session.root": engine(method(true)),
+    "session.model": engine(method(true)),
+    "session.turns": engine(),
+    "session.id": engine(method(true)),
+    "session.messages": engine(method(true)),
+    "session.repo": engine(),
+    "session.surface": engine(),
+    "session.surfaces": engine(),
+    "session.authorize": engine(),
+    "session.usage": engine(),
+    "session.version": engine(),
+    "turn.abort": engine(),
+    "prompt.read": surface,
+    "flag.value": engine(),
+    "tool.list": engine(method(true)),
+    "tool.register": engine(),
+    "command.list": surface,
+    "command.register": surface,
+    "config.list": surface,
+    "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,
+    "fs.read": engine(),
+    "fs.write": engine(),
+    "fs.list": engine(),
+    "fs.exists": engine(),
+    "fs.stat": engine(),
+    "fs.ancestors": engine(),
+    "store.get": engine(),
+    "store.set": engine(),
+    "store.delete": engine(),
+    "store.keys": engine(),
+    "state.get": engine(),
+    "state.set": engine(),
+    "clock.now": engine(method(false)),
+    "clock.sleep": engine(method(false)),
+    "clock.after": engine(),
+    "clock.every": engine(),
+    "http.fetch": engine(),
+    "process.run": engine(method(true)),
+    "process.spawn": engine(),
+    "settings.read": engine(),
+    "env.get": engine(),
+    "env.set": engine(),
+});
+const EVENT_NAMES = Object.freeze(Object.keys(MOD_EVENT_TABLE).filter(isModEventName));
+export function isModEventName(name) {
+    return typeof name === "string" && Object.prototype.hasOwnProperty.call(MOD_EVENT_TABLE, name);
+}
+export function stationOn(name, side) {
+    const row = MOD_EVENT_TABLE[name];
+    return row.side === side || row.side === "both" ? row.station : undefined;
+}
+export function readOnSide(name, side) {
+    const row = MOD_EVENT_TABLE[name];
+    return row.side === side || row.side === "both";
+}
+export function expandModPattern(pattern) {
+    if (typeof pattern !== "string" || pattern === "")
+        return { refusal: `${describe(pattern)} is not an event name or a "<prefix>.*" pattern` };
+    if (pattern.endsWith(".*")) {
+        const prefix = pattern.slice(0, -2);
+        if (prefix === "" || prefix.includes("*"))
+            return { refusal: `"${pattern}" is not an event name or a "<prefix>.*" pattern` };
+        const names = EVENT_NAMES.filter((n) => n.startsWith(`${prefix}.`));
+        return names.length > 0 ? { names } : { refusal: `"${pattern}" selects no event` };
+    }
+    return isModEventName(pattern) ? { names: [pattern] } : { refusal: `"${pattern}" is not an event` };
+}
+export function describe(value) {
+    if (typeof value === "string")
+        return `"${value}"`;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null)
+        return "null";
+    return typeof value === "object" ? (Array.isArray(value) ? "an array" : "an object") : typeof value;
+}

package/dist/index.d.ts

@@ -0,0 +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 { 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";

package/dist/index.js

@@ -0,0 +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 { 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 { 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

@@ -0,0 +1,27 @@
+export interface ReceiptMode {
+    readonly accessors: "call-once" | "refuse";
+    readonly depth: number;
+    readonly others: "as-is" | "refuse" | "copy";
+    readonly past?: "refuse";
+    readonly contain?: true;
+    readonly freeze?: boolean;
+    readonly isProxy?: (value: object) => boolean;
+}
+export declare const RECEIPT_FAULTS: readonly ["proxy", "accessor", "hidden", "getter-threw", "prototype-moved", "not-data", "cycle", "too-deep", "uncopyable"];
+export type ReceiptFaultKind = (typeof RECEIPT_FAULTS)[number];
+export interface ReceiptFault {
+    readonly kind: ReceiptFaultKind;
+    readonly path: readonly string[];
+}
+export type Receipt = {
+    readonly ok: true;
+    readonly value: unknown;
+    readonly faults?: readonly ReceiptFault[];
+} | {
+    readonly ok: false;
+    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 const MODS_PAYLOAD_MODE: ReceiptMode;
+export declare function describeFault(fault: ReceiptFault): string;

package/dist/receive.js

@@ -0,0 +1,193 @@
+export const RECEIPT_FAULTS = Object.freeze(["proxy", "accessor", "hidden", "getter-threw", "prototype-moved", "not-data", "cycle", "too-deep", "uncopyable"]);
+export function isPlainRecord(v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+function isOrdinaryArray(v) {
+    return Array.isArray(v) && Object.getPrototypeOf(v) === Array.prototype;
+}
+export function receive(value, mode, held) {
+    const seen = new Map();
+    const path = [];
+    const open = new Set();
+    const heights = new Map();
+    const faults = [];
+    const refusedAt = new Map();
+    const stack = [];
+    const refusals = new Set();
+    const refuse = (kind) => {
+        const fault = Object.freeze({ kind, path: Object.freeze([...path]) });
+        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 refuseContainer = (v, kind) => {
+        if (mode.contain === true) {
+            refusedAt.set(v, kind);
+            open.delete(v);
+        }
+        return refuse(kind);
+    };
+    const memberOf = (v, d) => {
+        if (Object.hasOwn(d, "value")) {
+            if (mode.accessors === "refuse" && d.enumerable !== true)
+                refuse("hidden");
+            return d.value;
+        }
+        if (mode.accessors === "refuse")
+            refuse("accessor");
+        const get = Object.hasOwn(d, "get") ? d.get : undefined;
+        try {
+            return get === undefined ? undefined : Reflect.apply(get, v, []);
+        }
+        catch {
+            return refuse("getter-threw");
+        }
+    };
+    const measured = mode.past === "refuse" || mode.others !== "as-is";
+    const heightOf = (v) => heights.get(v) ?? (open.has(v) || (held?.has(v) === true && mode.isProxy?.(v) !== true && (isOrdinaryArray(v) || isPlainRecord(v))) ? 1 : 0);
+    const pastDepth = (v, level) => measured && level + heightOf(v) > mode.depth;
+    const meet = (v, level) => {
+        if (v === null || v === undefined || typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+            return v;
+        if (typeof v !== "object")
+            return other(v, "not-data");
+        if (held?.has(v) === true)
+            return pastDepth(v, level) ? refuse("too-deep") : v;
+        if (seen.has(v)) {
+            if (refusedAt.has(v))
+                return refuse(refusedAt.get(v));
+            if (open.has(v) && mode.others !== "as-is")
+                return refuse("cycle");
+            return pastDepth(v, level) ? refuse("too-deep") : seen.get(v);
+        }
+        if (level >= mode.depth && mode.past === "refuse") {
+            if (mode.isProxy?.(v) === true)
+                return refuse("proxy");
+            if (isOrdinaryArray(v) || isPlainRecord(v))
+                return refuse("too-deep");
+        }
+        if (level >= mode.depth)
+            return other(v, "too-deep");
+        if (mode.isProxy?.(v) === true)
+            return refuse("proxy");
+        const list = isOrdinaryArray(v) || (mode.others === "copy" && Array.isArray(v));
+        if (!list && !isPlainRecord(v) && mode.others !== "copy")
+            return other(v, "not-data");
+        const proto = Object.getPrototypeOf(v);
+        const captured = Object.getOwnPropertyDescriptors(v);
+        const out = list ? [] : {};
+        seen.set(v, out);
+        open.add(v);
+        if (mode.accessors === "refuse") {
+            const symbols = Object.getOwnPropertySymbols(captured);
+            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)]) }));
+        }
+        stack.push({ v, out, list, proto, captured, keys: Object.getOwnPropertyNames(captured), level, next: 0, height: 1, key: "", member: undefined });
+        return out;
+    };
+    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 });
+        path.length = f.level;
+    };
+    const finish = (f) => {
+        heights.set(f.v, f.height);
+        if (mode.accessors === "call-once" && mode.others !== "copy" && Object.getPrototypeOf(f.v) !== f.proto)
+            refuseContainer(f.v, "prototype-moved");
+        if (Array.isArray(f.out)) {
+            const length = f.captured["length"]?.value;
+            if (typeof length === "number")
+                f.out.length = length;
+        }
+        if (mode.freeze === true)
+            Object.freeze(f.out);
+        open.delete(f.v);
+        return f.out;
+    };
+    const received = (copy) => (mode.contain === true ? { ok: true, value: copy, faults: Object.freeze(faults) } : { ok: true, value: copy });
+    try {
+        const copy = meet(value, 0);
+        if (stack.length === 0)
+            return received(copy);
+    }
+    catch (err) {
+        return { ok: false, fault: faultOf(err) };
+    }
+    for (;;) {
+        const f = stack[stack.length - 1];
+        if (f.next < f.keys.length) {
+            const key = f.keys[f.next++];
+            if (f.list && key === "length")
+                continue;
+            path.push(key);
+            try {
+                const member = memberOf(f.v, f.captured[key]);
+                const frames = stack.length;
+                const copy = meet(member, f.level + 1);
+                if (stack.length > frames) {
+                    f.key = key;
+                    f.member = member;
+                }
+                else
+                    land(f, key, copy, member);
+            }
+            catch (err) {
+                if (mode.contain !== true)
+                    return { ok: false, fault: faultOf(err) };
+                faults.push(faultOf(err));
+                path.length = f.level;
+            }
+            continue;
+        }
+        let copy;
+        try {
+            copy = finish(f);
+        }
+        catch (err) {
+            stack.pop();
+            const holder = stack[stack.length - 1];
+            if (mode.contain !== true || holder === undefined)
+                return { ok: false, fault: faultOf(err) };
+            faults.push(faultOf(err));
+            path.length = holder.level;
+            continue;
+        }
+        stack.pop();
+        const holder = stack[stack.length - 1];
+        if (holder === undefined)
+            return received(copy);
+        land(holder, holder.key, copy, holder.member);
+    }
+}
+export const MODS_PAYLOAD_MODE = Object.freeze({ accessors: "refuse", depth: Infinity, others: "as-is", freeze: true });
+export function describeFault(fault) {
+    const at = fault.path.length > 0 ? ` at ${fault.path.join(".")}` : "";
+    switch (fault.kind) {
+        case "proxy":
+            return `a Proxy${at}`;
+        case "accessor":
+            return `an accessor${at} (a getter is never run)`;
+        case "hidden":
+            return `a member that is not an enumerable data property${at}`;
+        case "getter-threw":
+            return `a getter that threw${at}`;
+        case "prototype-moved":
+            return `a prototype that moved while it was read${at}`;
+        case "not-data":
+            return `a value that is not data${at}`;
+        case "cycle":
+            return `a cycle${at}`;
+        case "too-deep":
+            return `a value nested too deep${at}`;
+        case "uncopyable":
+            return `a value that could not be copied whole${at}`;
+    }
+}