@sema-agent/core 7.51.2 → 7.52.0

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

@@ -0,0 +1,701 @@
+import { CATCH_BUDGET_MS, createSelfBudget, POST_ABORT_GRACE_MS, RUNAWAY_AFTER_MS, unrefTimer, watchRunaway } from "./budget.js";
+import { expandModPattern, isModEventName, MOD_SEATS, nextToRefusal, stationOn } from "./events.js";
+import { ENGINE_ORIGIN, modsInvalid, screenModSeats, } from "./registration.js";
+import { answerUpward, answerViolation, detachedCopy, matcherMatches, matcherViolation, methodAnswerViolation, NEXT_IN_FLIGHT, pinnedKeyChanged, receiveAnswer, receivePayload, } from "./site-rules.js";
+const TIER_RANK = { prepend: 0, user: 1, append: 2, builtin: 3, core: 4 };
+const bypassed = (floors, tier) => floors.some((f) => TIER_RANK[f.from] < TIER_RANK[tier] && TIER_RANK[tier] < TIER_RANK[f.to]);
+export async function admitMods(input) {
+    const report = safeReport(input.report);
+    const screened = screenModSeats(input.seats, input.side, (err) => report(err));
+    const mounted = [];
+    const records = [];
+    const describe = safeDescribe(input.describeThrown);
+    const bus = createBus(input.side, mounted, input.bottoms, report, records, describe, input.isProxy);
+    const admitted = Object.freeze({ admitted: true });
+    for (const cand of screened) {
+        if (input.signal?.aborted === true)
+            throw input.signal.reason;
+        const e = Object.freeze({
+            name: cand.name,
+            seat: cand.seat,
+            tier: cand.tier,
+            ...(cand.provenance !== undefined ? { provenance: cand.provenance } : {}),
+            uses: Object.freeze({ events: cand.uses.events, calls: cand.uses.calls }),
+        });
+        const outcome = await bus.dispatch("plugin.register", e, {
+            bottom: () => admitted,
+            ...(input.signal !== undefined ? { signal: input.signal } : {}),
+            checkAnswer: (a, judged, by) => a === admitted
+                ? undefined
+                : refusalOf(a) === undefined
+                    ? "takes next(e) or { refuse: <reason> }"
+                    : MOD_SEATS.indexOf(by.seat) > MOD_SEATS.findIndex((s) => s === judged["seat"])
+                        ? `a ${by.seat} registration may not refuse a ${String(judged["seat"])} registration`
+                        : undefined,
+        });
+        if (outcome.kind === "aborted")
+            throw input.signal?.reason ?? new Error("admission aborted");
+        if (outcome.kind === "failed") {
+            records.push(Object.freeze({ name: cand.name, seat: cand.seat, tier: cand.tier, refusedBy: outcome.registration, reason: `${outcome.registration} failed: ${outcome.reason}` }));
+            continue;
+        }
+        const refused = refusalOf(outcome.answer);
+        if (refused !== undefined) {
+            records.push(Object.freeze({ name: cand.name, seat: cand.seat, tier: cand.tier, refusedBy: outcome.answeredBy ?? "engine", reason: refused }));
+            continue;
+        }
+        const own = mountOne(cand, input.side, describe);
+        mounted.push(...own);
+        const events = unique(own.map((h) => h.pattern));
+        const observe = unique(own.filter((h) => h.observe).map((h) => h.pattern));
+        records.push(Object.freeze({
+            name: cand.name,
+            seat: cand.seat,
+            tier: cand.tier,
+            events,
+            ...(observe.length > 0 ? { observe } : {}),
+            ...(outcome.skipped.length > 0 ? { skipped: outcome.skipped } : {}),
+        }));
+    }
+    return bus;
+}
+function refusalOf(a) {
+    if (typeof a !== "object" || a === null || !Object.prototype.hasOwnProperty.call(a, "refuse"))
+        return undefined;
+    const r = Reflect.get(a, "refuse");
+    return typeof r === "string" && r !== "" ? r : undefined;
+}
+function unique(xs) {
+    return Object.freeze([...new Set(xs)]);
+}
+function safeDescribe(describe) {
+    return (err) => {
+        try {
+            const text = describe(err);
+            if (typeof text === "string")
+                return text;
+        }
+        catch {
+        }
+        return "a value the host's renderer could not describe";
+    };
+}
+function safeReport(report) {
+    return (err, classification) => {
+        try {
+            report(err, classification);
+        }
+        catch {
+        }
+    };
+}
+function mountOne(cand, side, describe) {
+    const own = [];
+    let sealed = false;
+    let problem;
+    const fail = (why) => {
+        problem ??= why;
+        throw modsInvalid(`${cand.name}: ${why}`);
+    };
+    const on = (pattern, a, b, c) => {
+        if (sealed)
+            throw modsInvalid(`${cand.name}: on() was called after register() returned`);
+        const withMatcher = typeof a !== "function";
+        const fn = withMatcher ? b : a;
+        const opts = withMatcher ? c : b;
+        if (typeof fn !== "function")
+            fail(`on("${String(pattern)}") takes a handler function`);
+        if (withMatcher) {
+            const why = matcherViolation(a);
+            if (why !== undefined)
+                fail(`on("${String(pattern)}"): ${why}`);
+        }
+        const parsed = handlerOptions(opts);
+        if (typeof parsed === "string")
+            fail(`on("${String(pattern)}"): ${parsed}`);
+        const expanded = expandModPattern(pattern);
+        if ("refusal" in expanded)
+            return void fail(`on(): ${expanded.refusal}`);
+        const outside = expanded.names.filter((n) => !cand.eventsBound.has(n));
+        if (outside.length > 0)
+            fail(`on("${pattern}") selects ${outside.join(", ")}, outside its uses.events`);
+        const events = expanded.names.filter((n) => stationOn(n, side) !== undefined);
+        if (events.length === 0)
+            fail(`on("${pattern}"): no event it selects is raised on the ${side} bus in this version`);
+        if (typeof fn !== "function" || typeof parsed === "string")
+            return;
+        own.push({
+            reg: cand,
+            index: own.length,
+            pattern,
+            events: new Set(events),
+            ...(withMatcher && isMatcher(a) ? { matcher: Object.freeze({ ...a }) } : {}),
+            fn: asHandler(fn),
+            ...(parsed.onCatch !== undefined ? { onCatch: parsed.onCatch } : {}),
+            observe: parsed.observe,
+        });
+    };
+    let returned;
+    try {
+        returned = cand.registration.register(on, cand.registration.options);
+    }
+    catch (err) {
+        if (problem !== undefined)
+            throw modsInvalid(`${cand.name}: ${problem}`);
+        throw modsInvalid(`${cand.name}: register() threw: ${describe(err)}`);
+    }
+    finally {
+        sealed = true;
+    }
+    if (problem !== undefined)
+        throw modsInvalid(`${cand.name}: ${problem}`);
+    if (typeof returned === "object" && returned !== null && typeof Reflect.get(returned, "then") === "function") {
+        throw modsInvalid(`${cand.name}: register() returned a promise; register is synchronous (hang handlers with on() before it returns)`);
+    }
+    return own;
+}
+function isMatcher(v) {
+    return matcherViolation(v) === undefined;
+}
+function asHandler(fn) {
+    return (...args) => (typeof fn === "function" ? Reflect.apply(fn, undefined, args) : undefined);
+}
+function handlerOptions(opts) {
+    if (opts === undefined)
+        return { observe: false };
+    if (typeof opts !== "object" || opts === null)
+        return `options are { catch?, observe? }, not ${typeof opts}`;
+    for (const k of Object.keys(opts))
+        if (k !== "catch" && k !== "observe")
+            return `options are { catch?, observe? }; "${k}" is not one`;
+    const c = Reflect.get(opts, "catch");
+    const o = Reflect.get(opts, "observe");
+    if (c !== undefined && typeof c !== "function")
+        return "catch is a handler function";
+    if (o !== undefined && typeof o !== "boolean")
+        return "observe is true or false";
+    return { ...(c !== undefined ? { onCatch: asHandler(c) } : {}), observe: o === true };
+}
+const HA = "skipped; what is below it ran in its place";
+const MA = "skipped; its last next() run's result stands";
+function createBus(side, mounted, bottoms, report, records, describe, isProxy) {
+    const methods = [];
+    for (const name of Object.keys(bottoms)) {
+        if (!isModEventName(name) || bottoms[name] === undefined)
+            continue;
+        const st = stationOn(name, side);
+        if (st?.method === undefined)
+            continue;
+        const dot = name.indexOf(".");
+        methods.push({ event: name, ns: name.slice(0, dot), method: name.slice(dot + 1), pauses: st.method.pausesCallerBudget });
+    }
+    const bus = {
+        records,
+        mounted: () => Object.freeze(mounted.map((h) => Object.freeze({
+            plugin: h.reg.name,
+            seat: h.reg.seat,
+            pattern: h.pattern,
+            ...(h.matcher !== undefined ? { matcher: h.matcher } : {}),
+            observe: h.observe,
+            caught: h.onCatch !== undefined,
+        }))),
+        hasHandlers: (event, participant) => mounted.some((h) => h.events.has(event) && admits(participant, h)),
+        dispatch: (event, e, options) => {
+            const st = stationOn(event, side);
+            const received = st === undefined ? { refusal: `${event} is not raised on the ${side} bus` } : receivePayload(e);
+            if (st === undefined || "refusal" in received) {
+                const reason = `${event}: ${"refusal" in received ? received.refusal : "not raised"}`;
+                report(new Error(`engine: ${reason} — the dispatch was not run`));
+                return Promise.resolve(Object.freeze({ kind: "failed", registration: ENGINE_ORIGIN.plugin, cause: "violation", reason, skipped: Object.freeze([]) }));
+            }
+            return runDispatch(event, st, received.payload, options);
+        },
+    };
+    function participants(event, e, frames, participant) {
+        const inFrames = (fs, h) => fs.some((f) => f.plugin === h.reg.name && (f.kind === "dollar" || f.handler === h.index));
+        const caller = frames.slice(-1);
+        const above = frames.slice(0, -1);
+        const out = [];
+        for (const h of mounted) {
+            if (!h.events.has(event) || !admits(participant, h) || !matcherMatches(h.matcher, e))
+                continue;
+            if (inFrames(caller, h))
+                continue;
+            if (!inFrames(above, h))
+                out.push({ h, reentry: false });
+            else if (h.onCatch !== undefined && !h.observe)
+                out.push({ h, reentry: true });
+        }
+        return out;
+    }
+    async function callMethod(event, args, caller) {
+        const seat = bottoms[event];
+        if (seat === undefined)
+            throw new Error(`${caller.origin.plugin}: $.${event}: no implementation on the ${side} bus`);
+        const st = stationOn(event, side);
+        if (st === undefined)
+            throw new Error(`${caller.origin.plugin}: $.${event}: not raised on the ${side} bus`);
+        let e0 = args;
+        if (seat.enter !== undefined) {
+            const shaped = receivePayload(seat.enter(args), undefined, isProxy);
+            if ("refusal" in shaped)
+                throw new TypeError(`${caller.origin.plugin}: $.${event}: ${shaped.refusal}`);
+            e0 = shaped.payload;
+        }
+        const outcome = await runDispatch(event, st, e0, {
+            bottom: async (e, ctx) => ({ value: await seat.run(e, ctx) }),
+            frames: caller.frames,
+            origin: caller.origin,
+            signal: caller.signal,
+            checkAnswer: methodAnswerViolation,
+        });
+        if (outcome.kind !== "aborted")
+            for (const s of outcome.skipped)
+                if (s.cause === "violation")
+                    report(new Error(`${s.registration}: $.${event}: ${s.reason} — skipped`));
+        if (outcome.kind === "aborted")
+            throw new Error(`${caller.origin.plugin}: $.${event}: aborted`);
+        if (outcome.kind === "failed")
+            throw new Error(`${caller.origin.plugin}: $.${event}: ${outcome.reason}`);
+        const answer = outcome.answer;
+        const deny = typeof answer === "object" && answer !== null ? Reflect.get(answer, "deny") : undefined;
+        if (typeof deny === "string")
+            throw new Error(`${caller.origin.plugin}: $.${event}: ${deny}`);
+        return typeof answer === "object" && answer !== null ? Reflect.get(answer, "value") : undefined;
+    }
+    function dollarFor(reg, frames, budget, signal) {
+        const origin = Object.freeze({ plugin: reg.name, tier: reg.tier });
+        const callerFrames = Object.freeze([...frames, Object.freeze({ kind: "dollar", plugin: reg.name })]);
+        const namespaces = new Map();
+        for (const m of methods) {
+            const ns = namespaces.get(m.ns) ?? {};
+            namespaces.set(m.ns, ns);
+            ns[m.method] = async (args) => {
+                if (!reg.callsBound.has(m.event))
+                    throw new Error(`${reg.name}: $.${m.event}: not declared in uses.calls`);
+                const received = receivePayload(args === undefined ? {} : args, undefined, isProxy);
+                if ("refusal" in received)
+                    throw new TypeError(`${reg.name}: $.${m.event}: takes one object — ${received.refusal}`);
+                if (m.pauses)
+                    budget.pause();
+                try {
+                    return await callMethod(m.event, received.payload, { frames: callerFrames, origin, signal });
+                }
+                finally {
+                    if (m.pauses)
+                        budget.resume();
+                }
+            };
+        }
+        const out = {};
+        for (const [ns, fns] of namespaces)
+            out[ns] = Object.freeze(fns);
+        return Object.freeze({ ...out, plugin: Object.freeze({ name: reg.name }) });
+    }
+    function runDispatch(event, st, e0, options) {
+        const frames = options.frames ?? [];
+        const origin = options.origin ?? ENGINE_ORIGIN;
+        const all = participants(event, e0, frames, options.participant);
+        const observers = all.filter((p) => !p.reentry && p.h.observe).map((p) => p.h);
+        const chain = all.filter((p) => !p.h.observe).map((p) => p.h);
+        const reentered = new Set(all.filter((p) => p.reentry).map((p) => p.h));
+        const skipped = [];
+        const producers = new Map();
+        const live = new Set();
+        const dispatchAc = new AbortController();
+        const terminal = { kind: "terminal" };
+        let settled = false;
+        let graceTimer;
+        let resolveOut = () => { };
+        let rejectOut = () => { };
+        const out = new Promise((res, rej) => {
+            resolveOut = res;
+            rejectOut = rej;
+        });
+        const signal = options.signal;
+        const onAbort = () => {
+            if (settled)
+                return;
+            if (st.abort === "grace") {
+                graceTimer ??= setTimeout(() => finish({ kind: "aborted" }), POST_ABORT_GRACE_MS);
+                unrefTimer(graceTimer);
+            }
+            else
+                finish({ kind: "aborted" });
+        };
+        function finish(o) {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener("abort", onAbort);
+            if (graceTimer !== undefined)
+                clearTimeout(graceTimer);
+            const why = new Error(`the ${event} dispatch settled`);
+            if (!("kind" in o) || o.kind !== "answered")
+                dispatchAc.abort(why);
+            for (const ac of live)
+                ac.abort(why);
+            live.clear();
+            if ("reject" in o)
+                rejectOut(o.reject);
+            else
+                resolveOut(Object.freeze(o));
+        }
+        const pendingRuns = new Set();
+        const track = (run) => {
+            pendingRuns.add(run);
+            const drop = () => void pendingRuns.delete(run);
+            run.then(drop, drop);
+        };
+        const handOn = (passed) => {
+            if (passed === e0)
+                return { snap: e0 };
+            const received = receivePayload(passed, e0, isProxy);
+            if ("refusal" in received)
+                return { violation: `next() takes the event object: ${received.refusal}` };
+            const k = pinnedKeyChanged(st.pinned, e0, received.payload);
+            return k === undefined ? { snap: received.payload } : { violation: `next() changed the pinned key "${k}"` };
+        };
+        const takeAnswer = (answer, s, e, h) => {
+            let taken = answer;
+            if (!s.answers.some((a) => Object.is(a, answer))) {
+                const received = receiveAnswer(answer, isProxy);
+                if ("refusal" in received)
+                    return { violation: received.refusal };
+                taken = received.answer;
+            }
+            const below = s.pending > 0 ? [...s.answers, NEXT_IN_FLIGHT] : s.answers;
+            const why = answerViolation(taken, options.checkAnswer, e, answererOf(h), below);
+            return why !== undefined ? { violation: why } : { answer: taken };
+        };
+        const traceOf = (sink, index, plugin, tier, outcome, ms) => {
+            sink.push(Object.freeze({ index, plugin, tier, outcome, ms }));
+        };
+        function startBelow(state, selfTime, i, snap, nextFloors, myFrames) {
+            if (state.pending++ === 0)
+                selfTime.pause();
+            const below = [];
+            state.below = below;
+            const run = invoke(i + 1, snap, nextFloors, myFrames, below);
+            state.last = run;
+            const stopCounting = () => {
+                if (--state.pending === 0)
+                    selfTime.resume();
+            };
+            run.then((v) => {
+                state.lastValue = { v };
+                state.answers.push(v);
+                stopCounting();
+            }, (err) => {
+                state.belowError = err;
+                stopCounting();
+            });
+            track(run);
+            return run;
+        }
+        async function invoke(i, e, floors, fr, sink) {
+            if (settled)
+                throw new Error(`the ${event} dispatch already settled`);
+            const h = chain[i];
+            if (h === undefined) {
+                const t0 = Date.now();
+                try {
+                    const v = answerUpward(await options.bottom(e, Object.freeze({ frames: fr, signal: dispatchAc.signal, origin })));
+                    traceOf(sink, i, "core", "core", "returned", Date.now() - t0);
+                    return v;
+                }
+                catch (err) {
+                    traceOf(sink, i, "core", "core", "rejected", Date.now() - t0);
+                    throw err;
+                }
+            }
+            if (bypassed(floors, h.reg.tier)) {
+                traceOf(sink, i, h.reg.name, h.reg.tier, "bypassed", 0);
+                return invoke(i + 1, e, floors, fr, sink);
+            }
+            return runHandler(h, i, e, floors, fr, sink);
+        }
+        function makeNext(base, call, to, caught) {
+            const next = (e) => call(e);
+            Object.defineProperties(next, {
+                to: { value: to, enumerable: true },
+                origin: { value: origin, enumerable: true },
+                signal: { value: base.signal, enumerable: true },
+                trace: { get: base.trace, enumerable: true },
+                budget: { get: () => base.budget.reading(), enumerable: true },
+                ...(caught !== undefined ? { error: { value: caught.error, enumerable: true }, called: { value: caught.called, enumerable: true } } : {}),
+            });
+            const frozen = Object.freeze(next);
+            if (!hasNextShape(frozen))
+                throw new TypeError("next is malformed");
+            return frozen;
+        }
+        async function runHandler(h, i, e, floors, fr, sink) {
+            const name = h.reg.name;
+            const ac = new AbortController();
+            live.add(ac);
+            const budget = createSelfBudget(h.reg.budgetMs, () => ac.abort(new Error(`${name} ran past its ${h.reg.budgetMs}ms budget`)));
+            const myFrames = Object.freeze([...fr, Object.freeze({ kind: "handler", plugin: name, handler: h.index })]);
+            const state = {
+                pending: 0,
+                called: false,
+                below: [],
+                answers: [],
+                done: false,
+            };
+            const descend = (passed, nextFloors) => {
+                if (state.done || settled)
+                    return Promise.reject(new Error(`${name}: next() after it settled`));
+                if (state.called) {
+                    state.violated ??= "next() already called (a handler calls next once; its first run's answer stands)";
+                    return Promise.reject(new Error(`${name}: next() already called`));
+                }
+                const handed = handOn(passed);
+                if ("violation" in handed) {
+                    state.violated ??= handed.violation;
+                    return Promise.reject(new Error(`${name}: ${state.violated}`));
+                }
+                state.called = true;
+                return startBelow(state, budget, i, handed.snap, nextFloors, myFrames);
+            };
+            const to = (passed, tier) => {
+                const why = nextToRefusal(h.reg.tier, tier);
+                if (why !== undefined)
+                    return Promise.reject(new Error(`${name}: ${why}`));
+                return descend(passed, [...floors, { from: h.reg.tier, to: tier }]);
+            };
+            let result;
+            let failure;
+            let handlerP = Promise.resolve();
+            if (reentered.has(h)) {
+                failure = { cause: "reentry", reason: "not run: the dispatch re-entered a frame it is part of" };
+            }
+            else {
+                const next = makeNext({ budget, signal: ac.signal, trace: () => Object.freeze([...state.below]) }, (x) => descend(x, floors), to);
+                const $ = dollarFor(h.reg, myFrames, budget, ac.signal);
+                handlerP = invokeNow(() => h.fn($, e, next));
+                try {
+                    const raced = await Promise.race([handlerP, budget.expired]);
+                    if (raced === "expired" && budget.isExpired())
+                        failure = { cause: "timeout", reason: `ran past its ${h.reg.budgetMs}ms budget` };
+                    else {
+                        const taken = takeAnswer(raced, state, e, h);
+                        if ("violation" in taken)
+                            failure = { cause: "violation", reason: state.violated ?? taken.violation };
+                        else if (state.violated !== undefined)
+                            failure = { cause: "violation", reason: state.violated };
+                        else
+                            result = taken.answer;
+                    }
+                }
+                catch (err) {
+                    failure = state.violated !== undefined ? { cause: "violation", reason: state.violated } : { cause: "threw", error: err, reason: `threw ${describe(err)}` };
+                }
+            }
+            state.done = true;
+            if (failure?.cause !== "timeout")
+                live.delete(ac);
+            const ms = budget.usedMs();
+            budget.clear();
+            if (failure === undefined) {
+                const passed = state.lastValue !== undefined && Object.is(state.lastValue.v, result);
+                if (!passed)
+                    producers.set(result, name);
+                traceOf(sink, i, name, h.reg.tier, passed ? "passed" : "returned", ms);
+                sink.push(...state.below);
+                return result;
+            }
+            if (settled)
+                throw failure.error ?? new Error(`${name}: ${failure.reason}`);
+            if (failure.error === terminal || (failure.cause === "threw" && state.belowError !== undefined && failure.error === state.belowError && h.onCatch === undefined)) {
+                traceOf(sink, i, name, h.reg.tier, "rejected", ms);
+                throw failure.error;
+            }
+            if (failure.cause === "timeout") {
+                watchRunaway(handlerP, () => report(new Error(`${name}: ${event}: still running ${RUNAWAY_AFTER_MS}ms after its budget ran out; it ignores its signal`)));
+            }
+            const caught = h.onCatch !== undefined ? await runCatch(h, i, e, floors, myFrames, state, failure) : undefined;
+            if (caught !== undefined && "answer" in caught) {
+                if (failure.cause !== "violation" && failure.cause !== "reentry")
+                    report(new Error(`${name}: ${event}: ${failure.reason}; its .catch answered`));
+                producers.set(caught.answer, name);
+                traceOf(sink, i, name, h.reg.tier, "caught", ms);
+                return caught.answer;
+            }
+            if (failure.cause === "threw" && state.belowError !== undefined && failure.error === state.belowError) {
+                traceOf(sink, i, name, h.reg.tier, "rejected", ms);
+                throw failure.error;
+            }
+            const reason = caught !== undefined ? `${failure.reason}; ${caught.problem}` : failure.reason;
+            if (st.failure === "refuse") {
+                if (failure.cause !== "violation")
+                    report(new Error(`${name}: ${event}: ${reason} — failed closed: the dispatch ends here`));
+                traceOf(sink, i, name, h.reg.tier, "rejected", ms);
+                finish({ kind: "failed", registration: name, cause: failure.cause, reason, skipped: Object.freeze([...skipped]) });
+                throw terminal;
+            }
+            skipped.push(Object.freeze({ registration: name, cause: failure.cause, reason }));
+            const effect = state.last !== undefined ? MA : HA;
+            if (failure.cause !== "violation")
+                report(new Error(`${name}: ${event}: ${reason} — ${effect}`));
+            if (state.last !== undefined) {
+                traceOf(sink, i, name, h.reg.tier, failure.cause === "timeout" ? "expired" : "kept", ms);
+                return state.last;
+            }
+            traceOf(sink, i, name, h.reg.tier, failure.cause === "timeout" ? "expired" : "skipped", ms);
+            return invoke(i + 1, e, floors, fr, sink);
+        }
+        async function runCatch(h, i, e, floors, myFrames, state, failure) {
+            const onCatch = h.onCatch;
+            if (onCatch === undefined)
+                return { problem: "no .catch" };
+            const ac = new AbortController();
+            live.add(ac);
+            const budget = createSelfBudget(CATCH_BUDGET_MS, () => ac.abort(new Error(`${h.reg.name}: its .catch ran past its ${CATCH_BUDGET_MS}ms budget`)));
+            let done = false;
+            let violated;
+            const replay = (passed, nextFloors) => {
+                if (done || settled)
+                    return Promise.reject(new Error(`${h.reg.name}: next() after its .catch settled`));
+                if (state.last !== undefined) {
+                    const running = state.last;
+                    budget.pause();
+                    const resume = () => budget.resume();
+                    running.then(resume, resume);
+                    return running;
+                }
+                const handed = handOn(passed);
+                if ("violation" in handed) {
+                    violated ??= handed.violation;
+                    return Promise.reject(new Error(`${h.reg.name}: ${violated}`));
+                }
+                return startBelow(state, budget, i, handed.snap, nextFloors, myFrames);
+            };
+            const message = failure.cause === "threw" ? describe(failure.error) : failure.cause === "violation" ? failure.reason : undefined;
+            const error = Object.freeze({ kind: failure.cause, ...(message !== undefined ? { message } : {}), budget: CATCH_BUDGET_MS });
+            const next = makeNext({ budget, signal: ac.signal, trace: () => Object.freeze([...state.below]) }, (x) => replay(x, floors), (x, tier) => {
+                const why = nextToRefusal(h.reg.tier, tier);
+                return why !== undefined ? Promise.reject(new Error(`${h.reg.name}: ${why}`)) : replay(x, [...floors, { from: h.reg.tier, to: tier }]);
+            }, { error, called: state.called });
+            try {
+                const raced = await Promise.race([invokeNow(() => onCatch(dollarFor(h.reg, myFrames, budget, ac.signal), e, next)), budget.expired]);
+                if (raced === "expired" && budget.isExpired())
+                    return { problem: `its .catch ran past its ${CATCH_BUDGET_MS}ms budget` };
+                if (violated !== undefined)
+                    return { problem: `its .catch ${violated}` };
+                const taken = takeAnswer(raced, state, e, h);
+                return "violation" in taken ? { problem: `its .catch ${taken.violation}` } : { answer: taken.answer };
+            }
+            catch (err) {
+                return { problem: violated !== undefined ? `its .catch: ${violated}` : `its .catch threw ${describe(err)}` };
+            }
+            finally {
+                done = true;
+                if (!budget.isExpired())
+                    live.delete(ac);
+                budget.clear();
+            }
+        }
+        async function runObserver(h, fr) {
+            const name = h.reg.name;
+            const ac = new AbortController();
+            live.add(ac);
+            const budget = createSelfBudget(h.reg.budgetMs, () => ac.abort(new Error(`${name} ran past its ${h.reg.budgetMs}ms budget`)));
+            const myFrames = Object.freeze([...fr, Object.freeze({ kind: "handler", plugin: name, handler: h.index })]);
+            const refuse = () => Promise.reject(new Error(`${name}: an observe handler is not in the chain; next() is unavailable`));
+            const next = makeNext({ budget, signal: ac.signal, trace: () => Object.freeze([]) }, refuse, refuse);
+            const verdict = (r) => {
+                if (r === undefined)
+                    return;
+                report(new Error(`${name}: ${event}: an observe handler returned a verdict — not adopted; an observe handler answers undefined`), "observational-hook-verdict-ignored");
+            };
+            try {
+                const raced = await Promise.race([invokeNow(() => h.fn(dollarFor(h.reg, myFrames, budget, ac.signal), detachedCopy(e0), next)), budget.expired]);
+                if (raced === "expired" && budget.isExpired())
+                    throw new Error(`ran past its ${h.reg.budgetMs}ms budget`);
+                verdict(raced);
+            }
+            catch (err) {
+                if (settled)
+                    return;
+                report(new Error(`${name}: ${event}: an observe handler failed (${describe(err)}) — skipped`));
+                const onCatch = h.onCatch;
+                if (onCatch !== undefined) {
+                    const cause = budget.isExpired() ? "timeout" : "threw";
+                    budget.clear();
+                    const cac = new AbortController();
+                    live.add(cac);
+                    const catchBudget = createSelfBudget(CATCH_BUDGET_MS, () => cac.abort(new Error(`${name}: its .catch ran past its ${CATCH_BUDGET_MS}ms budget`)));
+                    const cnext = makeNext({ budget: catchBudget, signal: cac.signal, trace: () => Object.freeze([]) }, refuse, refuse, {
+                        error: Object.freeze({ kind: cause, ...(cause === "threw" ? { message: describe(err) } : {}), budget: CATCH_BUDGET_MS }),
+                        called: false,
+                    });
+                    try {
+                        const caught = await Promise.race([invokeNow(() => onCatch(dollarFor(h.reg, myFrames, catchBudget, cac.signal), detachedCopy(e0), cnext)), catchBudget.expired]);
+                        if (!(caught === "expired" && catchBudget.isExpired()))
+                            verdict(caught);
+                    }
+                    catch {
+                    }
+                    finally {
+                        if (!catchBudget.isExpired())
+                            live.delete(cac);
+                        catchBudget.clear();
+                    }
+                }
+            }
+            finally {
+                if (!budget.isExpired())
+                    live.delete(ac);
+                budget.clear();
+            }
+        }
+        if (signal?.aborted === true && st.abort !== "grace") {
+            finish({ kind: "aborted" });
+            return out;
+        }
+        const root = [];
+        void (async () => {
+            for (const o of observers) {
+                if (settled)
+                    return;
+                await runObserver(o, frames);
+            }
+            if (settled)
+                return;
+            const answer = await invoke(0, e0, [], frames, root);
+            while (st.failure === "refuse" && pendingRuns.size > 0 && !settled)
+                await Promise.allSettled([...pendingRuns]);
+            finish({ kind: "answered", answer, ...(producers.has(answer) ? { answeredBy: producers.get(answer) } : {}), skipped: Object.freeze([...skipped]) });
+        })().catch((err) => {
+            if (err === terminal || settled)
+                return;
+            finish({ reject: err });
+        });
+        if (signal !== undefined) {
+            if (signal.aborted)
+                queueMicrotask(onAbort);
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
+        return out;
+    }
+    return bus;
+}
+function admits(participant, h) {
+    return participant === undefined || participant(Object.freeze({ plugin: h.reg.name, seat: h.reg.seat, observe: h.observe }));
+}
+function answererOf(h) {
+    return { plugin: h.reg.name, seat: h.reg.seat, tier: h.reg.tier };
+}
+function hasNextShape(f) {
+    return typeof f === "function" && "to" in f && "trace" in f && "budget" in f && "signal" in f && "origin" in f;
+}
+function invokeNow(f) {
+    try {
+        return Promise.resolve(f());
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}