@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/localEngineStep.js

@@ -0,0 +1,1086 @@
+import { engineIdentityOf, engineIdentityVerdict } from './engineIdentity.js';
+import { localEngineIdle } from './localEngineOccupancy.js';
+import { engineSwapCardOf, localEngineSwapAutoable, LOCAL_ENGINE_SWAP_CAUSES, } from './localEngineSwapCard.js';
+import { LOCAL_ENGINE_STOP_LADDER, stopLadderStep } from './localEngineStopLadder.js';
+import { LOCAL_ENGINE_TIMING } from './localEngineTiming.js';
+import { ownSnapshotTyped, readOwnDataValue } from './ownKey.js';
+import { slotReadOf } from './wireFailureShape.js';
+export const LOCAL_ENGINE_FAIL_CODES = Object.freeze([
+    'local_engine.behind',
+    'local_engine.legacy_below_floor',
+    'local_engine.unresponsive',
+    'local_engine.swap_pending',
+    'local_engine.drain_overdue',
+    'local_engine.unanswered_unverifiable',
+    'local_engine.lock_unavailable',
+    'local_engine.spawn_failed',
+    'local_engine.spawn_refused',
+    'local_engine.stop_failed',
+    'local_engine.crash_loop',
+    'local_engine.high_water_unreadable',
+    'local_engine.principal_unknown',
+]);
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTime(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+function isOp(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+function isCause(v) {
+    return typeof v === 'string' && LOCAL_ENGINE_SWAP_CAUSES.includes(v);
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null && !Object.isFrozen(v)) {
+        for (const k of Object.keys(v))
+            deepFreeze(v[k]);
+        Object.freeze(v);
+    }
+    return v;
+}
+const T = LOCAL_ENGINE_TIMING;
+export const LOCAL_ENGINE_INITIAL_STATE = deepFreeze({
+    kind: 'unbound',
+    ctx: { causes: [], autoTried: [], opSeq: 0, lockRetry: 0, attached: null, demand: false, deaths: [], cooldown: 0 },
+});
+function isRef(t) {
+    return isRecord(own(t, 'identity'));
+}
+function idOf(t) {
+    if (isRef(t)) {
+        const id = engineIdentityOf(t.identity);
+        return id.pid !== undefined ? id : { ...id, pid: t.pid };
+    }
+    return engineIdentityOf(t);
+}
+function sameTarget(a, b) {
+    if (a === null || a === undefined || b === null || b === undefined)
+        return false;
+    return engineIdentityVerdict(idOf(a), idOf(b)) === 'same' && a.pid === b.pid;
+}
+function sameGeneration(a, b) {
+    if (a === null || a === undefined || b === null || b === undefined || !sameTarget(a, b))
+        return false;
+    const x = idOf(a);
+    const y = idOf(b);
+    return engineIdentityVerdict({ instanceId: x.instanceId, startedAt: x.startedAt }, { instanceId: y.instanceId, startedAt: y.startedAt }) === 'same';
+}
+function stoppable(t) {
+    if (t === null || t === undefined)
+        return false;
+    if (isRef(t))
+        return t.identity.pid === t.pid && t.identity.startedAt !== undefined;
+    return t.startedAt !== undefined;
+}
+function causeFp(causes, c) {
+    return causes.find((x) => x.cause === c)?.fingerprint;
+}
+function setCause(causes, c, fingerprint) {
+    const next = causes.filter((x) => x.cause !== c).concat([{ cause: c, fingerprint }]);
+    return LOCAL_ENGINE_SWAP_CAUSES.flatMap((k) => next.filter((x) => x.cause === k));
+}
+function dropCause(causes, c) {
+    return causes.filter((x) => x.cause !== c);
+}
+function tried(ctx, c, t) {
+    const id = idOf(t);
+    return ctx.autoTried.some((x) => x.cause === c && engineIdentityVerdict(x.target, id) === 'same');
+}
+function addTried(ctx, c, t) {
+    return tried(ctx, c, t) ? [...ctx.autoTried] : [...ctx.autoTried, { cause: c, target: idOf(t) }];
+}
+function idle(occ) {
+    if (occ === undefined || occ === null)
+        return false;
+    try {
+        return localEngineIdle(occ) === true;
+    }
+    catch {
+        return false;
+    }
+}
+function interactive(policy) {
+    return own(policy, 'lane') === 'interactive';
+}
+function headless(policy) {
+    return own(policy, 'lane') !== 'interactive';
+}
+function nextOp(ctx) {
+    const op = ctx.opSeq + 1;
+    return { op, ctx: { ...ctx, opSeq: op } };
+}
+function heldInstance(s) {
+    switch (s.kind) {
+        case 'attached':
+            return idOf(s.engine);
+        case 'pending':
+            return s.target === null ? undefined : idOf(s.target);
+        case 'draining-wait':
+            return idOf(s.engine);
+        case 'unanswered':
+            return s.startedAt === undefined ? undefined : { pid: s.pid, startedAt: s.startedAt };
+        default:
+            return undefined;
+    }
+}
+function holdsInstance(s) {
+    return s.kind === 'attached' || s.kind === 'pending' || s.kind === 'draining-wait' || s.kind === 'unanswered';
+}
+function attachedRef(s) {
+    if (s.kind === 'attached')
+        return s.engine;
+    if (s.kind === 'pending' && s.serving && s.target !== null && isRef(s.target))
+        return s.target;
+    return undefined;
+}
+function accountDeath(ctx, instance, clean, fromDraining, nowMs) {
+    const counted = deathCounted(ctx, clean, fromDraining);
+    const livedFull = ctx.attached !== null && instance !== undefined && engineIdentityVerdict(instance, ctx.attached.instance) === 'same' && nowMs - ctx.attached.at >= T.crashWindowMs;
+    const base = { ...ctx, causes: [], autoTried: [] };
+    if (counted)
+        return livedFull ? { ...base, deaths: [nowMs], cooldown: 0 } : { ...base, deaths: [...ctx.deaths, nowMs] };
+    return livedFull ? { ...base, deaths: [], cooldown: 0 } : base;
+}
+function deathOf(ctx, instance, clean, fromDraining, nowMs) {
+    const next = accountDeath(ctx, instance, clean, fromDraining, nowMs);
+    return { ctx: next, notice: { kind: 'notice', notice: { key: 'engineExited', counted: deathCounted(ctx, clean, fromDraining), crashLoopNext: next.deaths.length > T.crashMaxDeaths } } };
+}
+function deathCounted(ctx, clean, fromDraining) {
+    return ctx.demand && clean !== true && !fromDraining;
+}
+function fpOfVersion(engine, running, mine) {
+    const id = idOf(engine);
+    return JSON.stringify(['version', engine.pid, id.instanceId ?? null, id.startedAt ?? null, running, mine]);
+}
+function fpOfProcess(cause, p) {
+    return JSON.stringify([cause, p.pid, p.startedAt ?? null]);
+}
+const UNKNOWN_OCC = Object.freeze({
+    others: Object.freeze({ total: 0, midTurn: 0, known: false }),
+    inflight: 'unknown',
+    bgLive: 'unknown',
+    self: 'unknown',
+    bgIds: null,
+});
+function mintCard(hold, target, occ) {
+    const o = occ ?? hold.occupancy ?? UNKNOWN_OCC;
+    return engineSwapCardOf({
+        cause: hold.cause,
+        target: target ?? hold.target,
+        ...(hold.running !== undefined ? { running: hold.running } : {}),
+        ...(hold.own !== undefined ? { own: hold.own } : {}),
+        occupancy: o,
+        bgIds: own(o, 'bgIds') === undefined ? null : (o.bgIds ?? null),
+    });
+}
+const CARD_FAIL = Object.freeze({
+    version: 'local_engine.legacy_below_floor',
+    unresponsive: 'local_engine.unresponsive',
+    config: 'local_engine.swap_pending',
+    credential: 'local_engine.swap_pending',
+    'model-default': 'local_engine.swap_pending',
+    user: 'local_engine.swap_pending',
+});
+const DOWN_FAIL = Object.freeze({
+    'lock-unavailable': 'local_engine.lock_unavailable',
+    'spawn-failed': 'local_engine.spawn_failed',
+    'spawn-refused': 'local_engine.spawn_refused',
+    'stop-failed': 'local_engine.stop_failed',
+    'crash-loop': 'local_engine.crash_loop',
+    'high-water-unreadable': 'local_engine.high_water_unreadable',
+});
+function showCard(p, hold, occ, fx, policy) {
+    if (headless(policy)) {
+        fx.push({ kind: 'fail', code: CARD_FAIL[hold.cause] });
+        p.card = 'hidden';
+        delete p.hold;
+        return;
+    }
+    const stored = { ...hold, occupancy: occ ?? hold.occupancy };
+    const card = mintCard(stored, p.target, occ);
+    if (card === undefined)
+        return;
+    fx.push({ kind: 'card', show: card });
+    p.card = 'shown';
+    p.hold = stored;
+}
+function hideCard(p, fx) {
+    fx.push({ kind: 'card', show: null });
+    p.card = 'hidden';
+    delete p.hold;
+}
+function pendingOf(target, serving, ctx, carry) {
+    const p = { kind: 'pending', target, serving, card: carry?.card ?? 'hidden', ctx };
+    if (carry?.relation !== undefined)
+        p.relation = carry.relation;
+    if (p.card === 'shown' && carry?.hold !== undefined)
+        p.hold = carry.hold;
+    else
+        p.card = 'hidden';
+    return p;
+}
+function refOf(v) {
+    const pid = own(v, 'pid');
+    const port = own(v, 'port');
+    const identity = own(v, 'identity');
+    if (!isPid(pid) || typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535 || !isRecord(identity))
+        return undefined;
+    const version = own(v, 'version');
+    return { pid, port, identity: engineIdentityOf(identity), ...(typeof version === 'string' && version.length > 0 ? { version } : {}) };
+}
+function processOf(v) {
+    const pid = own(v, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const startedAt = own(v, 'startedAt');
+    return isTime(startedAt) && startedAt > 0 ? { pid, startedAt } : { pid };
+}
+function verdictOf(v) {
+    const kind = own(v, 'kind');
+    switch (kind) {
+        case 'none': {
+            const b = slotReadOf(v, 'blocked');
+            if (b.presence === 'absent' || (b.presence === 'present' && b.value === undefined))
+                return { kind };
+            return b.presence === 'present' && b.value === 'high-water-unreadable' ? { kind, blocked: b.value } : undefined;
+        }
+        case 'unanswered': {
+            const p = processOf(v);
+            const reason = own(v, 'reason');
+            if (p === undefined || (reason !== 'no-answer' && reason !== 'unverifiable'))
+                return undefined;
+            return { kind, ...p, reason };
+        }
+        case 'stranger': {
+            const mismatch = own(v, 'mismatch');
+            if (mismatch !== 'pid' && mismatch !== 'generation' && mismatch !== 'data-root')
+                return undefined;
+            const a = own(v, 'anchored');
+            const anchored = a === null || a === undefined ? null : processOf(a);
+            if (anchored === undefined)
+                return undefined;
+            return { kind, mismatch, anchored };
+        }
+        case 'draining': {
+            const engine = refOf(own(v, 'engine'));
+            const deadlineAt = own(v, 'deadlineAt');
+            if (engine === undefined || !isTime(deadlineAt))
+                return undefined;
+            return { kind, engine, deadlineAt };
+        }
+        case 'attach':
+        case 'version-unknown': {
+            const engine = refOf(own(v, 'engine'));
+            return engine === undefined ? undefined : { kind, engine };
+        }
+        case 'ahead': {
+            const engine = refOf(own(v, 'engine'));
+            const running = own(v, 'running');
+            const mine = own(v, 'own');
+            const servesWhileWaiting = own(v, 'servesWhileWaiting');
+            if (engine === undefined || typeof running !== 'string' || typeof mine !== 'string' || typeof servesWhileWaiting !== 'boolean')
+                return undefined;
+            return { kind, engine, running, own: mine, servesWhileWaiting };
+        }
+        case 'behind': {
+            const e = own(v, 'engine');
+            const engine = e === null ? null : refOf(e);
+            const running = own(v, 'running');
+            const mine = own(v, 'own');
+            const source = own(v, 'source');
+            if (engine === undefined || typeof running !== 'string' || typeof mine !== 'string' || (source !== 'running' && source !== 'high-water'))
+                return undefined;
+            return { kind, engine, running, own: mine, source };
+        }
+        default:
+            return undefined;
+    }
+}
+function verdictTarget(v) {
+    switch (v.kind) {
+        case 'draining':
+        case 'attach':
+        case 'version-unknown':
+        case 'ahead':
+            return v.engine;
+        case 'behind':
+            return v.engine ?? undefined;
+        case 'unanswered':
+            return v.reason === 'no-answer' && v.startedAt !== undefined ? { pid: v.pid, startedAt: v.startedAt } : undefined;
+        case 'stranger':
+            return v.mismatch === 'data-root' && v.anchored !== null ? v.anchored : undefined;
+        default:
+            return undefined;
+    }
+}
+function occOf(v) {
+    return isRecord(v) ? ownSnapshotTyped(v) : undefined;
+}
+function a8(v, fx, policy) {
+    fx.push({ kind: 'submits', open: false, sentence: 'behind' }, { kind: 'card', show: null }, { kind: 'banner', key: null });
+    if (headless(policy))
+        fx.push({ kind: 'fail', code: 'local_engine.behind' });
+    else
+        fx.push({ kind: 'hand-off' }, { kind: 'prompt-upgrade', running: v.running, own: v.own, source: v.source });
+    return { state: { kind: 'behind', running: v.running, own: v.own, source: v.source }, effects: fx };
+}
+function aRows(from, v, ctx0, occ, nowMs, policy, fx) {
+    let ctx = ctx0;
+    switch (v.kind) {
+        case 'none': {
+            if (v.blocked === 'high-water-unreadable') {
+                fx.push({ kind: 'submits', open: false }, { kind: 'notice', notice: { key: 'highWaterUnreadable' } });
+                return { state: { kind: 'down', reason: 'high-water-unreadable', since: nowMs, ctx }, effects: fx };
+            }
+            if (holdsInstance(from)) {
+                const d = deathOf(ctx, heldInstance(from), from.kind === 'draining-wait' ? true : 'unknown', from.kind === 'draining-wait', nowMs);
+                ctx = d.ctx;
+                fx.push(d.notice);
+            }
+            if (ctx.deaths.length > T.crashMaxDeaths) {
+                fx.push({ kind: 'submits', open: false }, { kind: 'notice', notice: { key: 'crashLoop', retryInMs: T.cooldownMs[ctx.cooldown] ?? null } });
+                return { state: { kind: 'down', reason: 'crash-loop', since: nowMs, ctx }, effects: fx };
+            }
+            const n = nextOp(ctx);
+            fx.push({ kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false });
+            return { state: { kind: 'locking', intent: { kind: 'spawn' }, held: false, entry: null, op: n.op, since: nowMs, plan: null, ctx: n.ctx }, effects: fx };
+        }
+        case 'stranger': {
+            if (v.mismatch === 'data-root' && v.anchored !== null) {
+                const target = v.anchored;
+                const p = pendingOf(target, false, { ...ctx, causes: setCause(ctx.causes, 'config', fpOfProcess('data-root', target)) });
+                fx.push({ kind: 'submits', open: false });
+                showCard(p, { cause: 'config', target, occupancy: occ ?? null }, occ, fx, policy);
+                return { state: p, effects: fx };
+            }
+            const n = nextOp(ctx);
+            fx.push({ kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false });
+            return { state: { kind: 'locking', intent: { kind: 'spawn' }, held: false, entry: null, op: n.op, since: nowMs, plan: null, ctx: n.ctx }, effects: fx };
+        }
+        case 'unanswered': {
+            if (from.kind === 'unanswered' && from.pid === v.pid && from.startedAt === v.startedAt && from.reason === v.reason) {
+                return { state: { ...from, ctx }, effects: fx };
+            }
+            fx.push({ kind: 'submits', open: false });
+            if (v.reason === 'unverifiable' && headless(policy))
+                fx.push({ kind: 'fail', code: 'local_engine.unanswered_unverifiable' });
+            const s = { kind: 'unanswered', pid: v.pid, reason: v.reason, since: nowMs, ctx };
+            if (v.startedAt !== undefined)
+                s.startedAt = v.startedAt;
+            return { state: s, effects: fx };
+        }
+        case 'draining': {
+            if (from.kind === 'draining-wait' && sameTarget(from.engine, v.engine) && from.deadlineAt === v.deadlineAt)
+                return { state: { ...from, ctx }, effects: fx };
+            if (!(from.kind === 'draining-wait' && sameTarget(from.engine, v.engine)))
+                fx.push({ kind: 'submits', open: false });
+            return { state: { kind: 'draining-wait', engine: v.engine, deadlineAt: v.deadlineAt, overdue: false, ctx }, effects: fx };
+        }
+        case 'attach':
+        case 'version-unknown': {
+            const causes = dropCause(ctx.causes, 'version');
+            const prev = attachedRef(from);
+            const sameInst = prev !== undefined && sameTarget(prev, v.engine);
+            if (from.kind === 'attached' && sameInst && from.relation === v.kind && causes.length === 0)
+                return { state: { ...from, ctx }, effects: fx };
+            if (from.kind === 'pending' && from.serving && sameInst && causes.length === from.ctx.causes.length && causes.every((c, i) => c.cause === from.ctx.causes[i]?.cause)) {
+                return { state: { ...from, ctx }, effects: fx };
+            }
+            ctx = { ...ctx, causes, lockRetry: 0 };
+            if (!sameInst) {
+                fx.push({ kind: 'attach', engine: v.engine });
+                if (ctx.attached === null || engineIdentityVerdict(ctx.attached.instance, idOf(v.engine)) !== 'same')
+                    ctx = { ...ctx, attached: { instance: idOf(v.engine), at: nowMs } };
+            }
+            fx.push({ kind: 'submits', open: true }, { kind: 'card', show: null }, { kind: 'banner', key: causes.length > 0 ? 'pending' : null });
+            const prevRelation = from.kind === 'attached' ? from.relation : from.kind === 'pending' ? from.relation : undefined;
+            if (v.kind === 'version-unknown' && (!sameInst || prevRelation !== 'version-unknown'))
+                fx.push({ kind: 'notice', notice: { key: 'versionUnknown' } });
+            if (causes.length > 0)
+                return { state: pendingOf(v.engine, true, ctx, { relation: v.kind }), effects: fx };
+            const since = from.kind === 'attached' && sameInst ? from.since : nowMs;
+            return { state: { kind: 'attached', engine: v.engine, relation: v.kind, since, ctx }, effects: fx };
+        }
+        case 'ahead': {
+            const fp = fpOfVersion(v.engine, v.running, v.own);
+            const cardShownServing = from.kind === 'pending' && from.serving && from.card === 'shown';
+            const othersAutoable = ctx.causes.filter((c) => c.cause !== 'version').every((c) => localEngineSwapAutoable(c.cause, true, { credentialAuto: own(policy, 'credentialAuto') === true }));
+            if (v.servesWhileWaiting && stoppable(v.engine) && idle(occ) && !cardShownServing && !tried(ctx, 'version', v.engine) && othersAutoable && interactive(policy)) {
+                const n = nextOp({ ...ctx, causes: setCause(ctx.causes, 'version', fp), autoTried: addTried(ctx, 'version', v.engine) });
+                fx.push({ kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false });
+                return {
+                    state: { kind: 'locking', intent: { kind: 'stop', mode: 'idle', serving: true }, held: false, entry: v.engine, op: n.op, since: nowMs, plan: null, ctx: n.ctx },
+                    effects: fx,
+                };
+            }
+            if (from.kind === 'pending' && sameTarget(from.target, v.engine) && from.serving === v.servesWhileWaiting)
+                return { state: { ...from, ctx }, effects: fx };
+            ctx = { ...ctx, causes: setCause(ctx.causes, 'version', fp) };
+            if (v.servesWhileWaiting) {
+                ctx = { ...ctx, lockRetry: 0 };
+                if (ctx.attached === null || engineIdentityVerdict(ctx.attached.instance, idOf(v.engine)) !== 'same')
+                    ctx = { ...ctx, attached: { instance: idOf(v.engine), at: nowMs } };
+                fx.push({ kind: 'attach', engine: v.engine }, { kind: 'submits', open: true }, { kind: 'banner', key: 'pending' });
+                const carry = from.kind === 'pending' ? { card: from.card, hold: from.hold } : {};
+                return { state: pendingOf(v.engine, true, ctx, carry), effects: fx };
+            }
+            const p = pendingOf(v.engine, false, ctx);
+            fx.push({ kind: 'submits', open: false, sentence: 'legacyBelowFloor' });
+            showCard(p, { cause: 'version', target: v.engine, running: v.running, own: v.own, occupancy: occ ?? null }, occ, fx, policy);
+            return { state: p, effects: fx };
+        }
+        case 'behind':
+            return a8(v, fx, policy);
+    }
+}
+function a0(from, v, ctx) {
+    if (from.kind === 'unbound')
+        return { state: { kind: 'unbound', ctx }, effects: [] };
+    const cleared = holdsInstance(from) && v.kind === 'none' ? { ...ctx, causes: [], autoTried: [] } : ctx;
+    return { state: { kind: 'unbound', ctx: cleared }, effects: [{ kind: 'submits', open: false }, { kind: 'card', show: null }, { kind: 'banner', key: null }] };
+}
+function onObserved(s, ev, policy) {
+    const { verdict: v, nowMs, demand } = ev;
+    const occ = ev.occupancy;
+    switch (s.kind) {
+        case 'unbound':
+        case 'attached':
+        case 'pending':
+        case 'draining-wait':
+        case 'unanswered': {
+            const ctx = { ...s.ctx, demand };
+            if (!demand)
+                return a0(s, v, ctx);
+            return aRows(s, v, ctx, occ, nowMs, policy, []);
+        }
+        case 'down': {
+            if (!demand)
+                return undefined;
+            const ctx = { ...s.ctx, demand };
+            if (v.kind === 'attach' || v.kind === 'version-unknown' || v.kind === 'behind')
+                return aRows(s, v, ctx, occ, nowMs, policy, []);
+            if (v.kind === 'ahead')
+                return aRows(s, v, { ...ctx, autoTried: addTried(ctx, 'version', v.engine) }, occ, nowMs, policy, []);
+            if (v.kind === 'none' && v.blocked === undefined && s.reason === 'lock-unavailable' && s.ctx.lockRetry === 0 && s.ctx.deaths.length <= T.crashMaxDeaths) {
+                const n = nextOp({ ...ctx, lockRetry: 1 });
+                return {
+                    state: { kind: 'locking', intent: { kind: 'spawn' }, held: false, entry: null, op: n.op, since: nowMs, plan: null, ctx: n.ctx },
+                    effects: [{ kind: 'acquire-lock', op: n.op }],
+                };
+            }
+            return undefined;
+        }
+        case 'locking': {
+            if (s.held)
+                return undefined;
+            if (!demand) {
+                const ctx = { ...s.ctx, demand };
+                return { state: { kind: 'unbound', ctx }, effects: [{ kind: 'cancel-lock', op: s.op }, { kind: 'submits', open: false }, { kind: 'card', show: null }, { kind: 'banner', key: null }] };
+            }
+            const ctx = { ...s.ctx, demand };
+            if (s.intent.kind === 'spawn') {
+                if (v.kind === 'attach' || v.kind === 'version-unknown' || v.kind === 'ahead' || v.kind === 'behind' || v.kind === 'draining') {
+                    return aRows(s, v, ctx, occ, nowMs, policy, [{ kind: 'cancel-lock', op: s.op }]);
+                }
+                return undefined;
+            }
+            const t = verdictTarget(v);
+            const elsewhere = (v.kind === 'attach' || v.kind === 'version-unknown' || v.kind === 'ahead' || v.kind === 'draining') && !sameTarget(t, s.entry);
+            if (v.kind === 'behind' || elsewhere)
+                return aRows(s, v, ctx, occ, nowMs, policy, [{ kind: 'cancel-lock', op: s.op }]);
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function onRelooked(s, ev, policy) {
+    if (s.kind !== 'locking' || !s.held || s.op !== ev.op || s.plan !== null)
+        return undefined;
+    const { verdict: v, nowMs } = ev;
+    const occ = ev.occupancy;
+    const rel = [{ kind: 'release-lock', op: s.op }];
+    if (v.kind === 'behind')
+        return a8(v, rel, policy);
+    if (v.kind === 'draining')
+        return { state: { kind: 'draining-wait', engine: v.engine, deadlineAt: v.deadlineAt, overdue: false, ctx: s.ctx }, effects: rel };
+    const intent = s.intent;
+    const t = verdictTarget(v);
+    if (intent.kind === 'stop' && (v.kind === 'attach' || v.kind === 'version-unknown') && sameTarget(t, s.entry)) {
+        const causes = dropCause(s.ctx.causes, 'version');
+        if (causes.length === 0)
+            return aRows(s, v, { ...s.ctx, causes }, occ, nowMs, policy, rel);
+    }
+    const plan = (p, ctx) => ({ state: { ...s, plan: p, since: nowMs, ctx }, effects: [{ kind: 'prepare', plan: p, op: s.op }] });
+    if (intent.kind === 'spawn' && ((v.kind === 'none' && v.blocked === undefined) || (v.kind === 'stranger' && v.anchored === null)))
+        return plan({ kind: 'spawn' }, s.ctx);
+    if (intent.kind === 'stop' && v.kind === 'none' && v.blocked === undefined)
+        return plan({ kind: 'spawn' }, s.ctx);
+    if (intent.kind === 'stop' && t !== undefined && stoppable(t) && sameGeneration(t, s.entry)) {
+        const causes = v.kind === 'attach' || v.kind === 'version-unknown' ? dropCause(s.ctx.causes, 'version') : s.ctx.causes;
+        const ctx = { ...s.ctx, causes };
+        if (causes.length > 0 && (intent.mode === 'forced' || idle(occ)))
+            return plan({ kind: 'stop', target: t, mode: intent.mode }, ctx);
+        if (intent.mode === 'idle' && causes.length > 0) {
+            const serving = v.kind === 'attach' || v.kind === 'version-unknown' ? true : v.kind === 'ahead' ? v.servesWhileWaiting : false;
+            const fx = [...rel, { kind: 'banner', key: 'pending' }];
+            if (serving)
+                fx.push({ kind: 'submits', open: true });
+            return { state: pendingOf(t, serving, ctx), effects: fx };
+        }
+    }
+    return aRows(s, v, s.ctx, occ, nowMs, policy, rel);
+}
+function lockUnavailable(s, nowMs, fx) {
+    fx.push({ kind: 'notice', notice: { key: 'lockUnavailable' } });
+    if (s.intent.kind === 'stop') {
+        fx.push({ kind: 'banner', key: 'pending' });
+        if (s.intent.serving)
+            fx.push({ kind: 'submits', open: true });
+        return { state: pendingOf(s.entry, s.intent.serving, s.ctx), effects: fx };
+    }
+    return { state: { kind: 'down', reason: 'lock-unavailable', since: nowMs, ctx: s.ctx }, effects: fx };
+}
+function prepareFailed(s, plan, reason, nowMs) {
+    const fx = [{ kind: 'release-lock', op: s.op }, { kind: 'notice', notice: { key: 'prepareFailed', reason } }];
+    if (plan.kind === 'stop') {
+        const serving = s.intent.kind === 'stop' && s.intent.serving;
+        if (serving)
+            fx.push({ kind: 'submits', open: true });
+        return { state: pendingOf(plan.target, serving, s.ctx), effects: fx };
+    }
+    return { state: { kind: 'down', reason: 'spawn-refused', since: nowMs, ctx: s.ctx }, effects: fx };
+}
+function onTick(s, ev, policy) {
+    const { nowMs } = ev;
+    const occ = ev.occupancy;
+    switch (s.kind) {
+        case 'pending': {
+            if (!stoppable(s.target) || !idle(occ) || (s.serving && s.card === 'shown') || !interactive(policy) || s.ctx.causes.length === 0)
+                return undefined;
+            const target = s.target;
+            const credentialAuto = own(policy, 'credentialAuto') === true;
+            if (!s.ctx.causes.every((c) => localEngineSwapAutoable(c.cause, s.serving, { credentialAuto })))
+                return undefined;
+            const fresh = s.ctx.causes.filter((c) => !tried(s.ctx, c.cause, target));
+            if (fresh.length === 0)
+                return undefined;
+            let ctx = s.ctx;
+            for (const c of fresh)
+                ctx = { ...ctx, autoTried: addTried(ctx, c.cause, target) };
+            const n = nextOp(ctx);
+            return {
+                state: { kind: 'locking', intent: { kind: 'stop', mode: 'idle', serving: s.serving }, held: false, entry: target, op: n.op, since: nowMs, plan: null, ctx: n.ctx },
+                effects: [{ kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false }],
+            };
+        }
+        case 'draining-wait': {
+            if (s.overdue || nowMs < s.deadlineAt + LOCAL_ENGINE_STOP_LADDER.H)
+                return undefined;
+            const fx = headless(policy) ? [{ kind: 'fail', code: 'local_engine.drain_overdue' }] : [{ kind: 'notice', notice: { key: 'drainOverdue' } }];
+            return { state: { ...s, overdue: true }, effects: fx };
+        }
+        case 'unanswered': {
+            if (s.reason !== 'no-answer' || nowMs < s.since + T.unansweredWaitMs || causeFp(s.ctx.causes, 'unresponsive') !== undefined)
+                return undefined;
+            const target = s.startedAt !== undefined ? { pid: s.pid, startedAt: s.startedAt } : { pid: s.pid };
+            const p = pendingOf(target, false, { ...s.ctx, causes: setCause(s.ctx.causes, 'unresponsive', fpOfProcess('unresponsive', target)) });
+            const fx = [];
+            showCard(p, { cause: 'unresponsive', target, occupancy: occ ?? null }, occ, fx, policy);
+            return { state: p, effects: fx };
+        }
+        case 'down': {
+            if (s.reason !== 'crash-loop')
+                return undefined;
+            const wait = T.cooldownMs[s.ctx.cooldown];
+            if (wait === undefined || nowMs < s.since + wait)
+                return undefined;
+            return {
+                state: { kind: 'unbound', ctx: { ...s.ctx, cooldown: s.ctx.cooldown + 1, deaths: [] } },
+                effects: [{ kind: 'reread' }, { kind: 'notice', notice: { key: 'crashLoopRetry' } }],
+            };
+        }
+        case 'locking': {
+            if (!s.held) {
+                const budget = own(own(policy, 'budgets'), 'lockWaitMs');
+                if (!isTime(budget) || nowMs < s.since + budget)
+                    return undefined;
+                return lockUnavailable(s, nowMs, [{ kind: 'cancel-lock', op: s.op }]);
+            }
+            if (nowMs < s.since + T.prepareTimeoutMs)
+                return undefined;
+            if (s.plan === null)
+                return { state: { kind: 'unbound', ctx: s.ctx }, effects: [{ kind: 'release-lock', op: s.op }, { kind: 'reread' }] };
+            return prepareFailed(s, s.plan, 'timeout', nowMs);
+        }
+        case 'stopping': {
+            const alive = ev.alive === 'alive' || ev.alive === 'gone' ? ev.alive : 'unknown';
+            if (alive === 'gone')
+                return toSpawning(s, nowMs);
+            const r = stopLadderStep(s.ladder, { nowMs, alive, health: ev.health === undefined ? null : ev.health });
+            if (r.action === 'gave-up') {
+                return { state: { kind: 'down', reason: 'stop-failed', since: nowMs, ctx: s.ctx }, effects: [{ kind: 'release-lock', op: s.op }, { kind: 'notice', notice: { key: 'stopFailed' } }] };
+            }
+            if (r.action === 'done')
+                return toSpawning(s, nowMs);
+            const fx = [];
+            if (r.action === 'term-2' || r.action === 'term')
+                fx.push(signalOf(s.target, 'term'));
+            else if (r.action === 'kill')
+                fx.push(signalOf(s.target, 'kill'));
+            return { state: { ...s, ladder: r.state }, effects: fx };
+        }
+        case 'spawning': {
+            const budget = own(own(policy, 'budgets'), 'healthWaitBudgetMs');
+            if (!isTime(budget) || nowMs < s.since + budget)
+                return undefined;
+            return {
+                state: { kind: 'down', reason: 'spawn-failed', since: nowMs, ctx: s.ctx },
+                effects: [{ kind: 'abandon-spawn', op: s.op }, { kind: 'release-lock', op: s.op }, { kind: 'notice', notice: { key: 'spawnFailed', timeout: true } }],
+            };
+        }
+        default:
+            return undefined;
+    }
+}
+function signalOf(t, sig) {
+    const startedAt = isRef(t) ? t.identity.startedAt : t.startedAt;
+    return startedAt !== undefined ? { kind: 'signal', pid: t.pid, startedAt, sig } : { kind: 'signal', pid: t.pid, sig };
+}
+function toSpawning(s, nowMs) {
+    return { state: { kind: 'spawning', forced: s.mode === 'forced', deferred: [], op: s.op, since: nowMs, ctx: s.ctx }, effects: [{ kind: 'spawn', op: s.op }] };
+}
+function onCause(s, ev, policy) {
+    const { cause: c, fingerprint: fp, nowMs } = ev;
+    const occ = ev.occupancy;
+    if (s.kind !== 'behind' && causeFp(s.ctx.causes, c) === fp)
+        return undefined;
+    switch (s.kind) {
+        case 'draining-wait':
+            return { state: { ...s, ctx: { ...s.ctx, causes: setCause(s.ctx.causes, c, fp) } }, effects: [{ kind: 'banner', key: 'pending' }] };
+        case 'attached':
+        case 'pending':
+        case 'unanswered': {
+            const target = s.kind === 'attached'
+                ? s.engine
+                : s.kind === 'pending'
+                    ? s.target
+                    : s.kind === 'unanswered' && s.reason === 'no-answer' && s.startedAt !== undefined
+                        ? { pid: s.pid, startedAt: s.startedAt }
+                        : null;
+            const display = s.kind === 'attached'
+                ? s.engine
+                : s.kind === 'pending'
+                    ? (s.target ?? s.hold?.target)
+                    : { pid: s.pid, ...(s.startedAt !== undefined ? { startedAt: s.startedAt } : {}) };
+            if (c === 'user' && stoppable(target) && idle(occ) && interactive(policy)) {
+                const serving = s.kind === 'attached' || (s.kind === 'pending' && s.serving);
+                const n = nextOp({ ...s.ctx, causes: setCause(s.ctx.causes, 'user', fp), autoTried: addTried(s.ctx, 'user', target) });
+                return {
+                    state: { kind: 'locking', intent: { kind: 'stop', mode: 'idle', serving }, held: false, entry: target, op: n.op, since: nowMs, plan: null, ctx: n.ctx },
+                    effects: [{ kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false }],
+                };
+            }
+            const serving = s.kind === 'attached' || (s.kind === 'pending' && s.serving);
+            const relation = s.kind === 'attached' ? s.relation : s.kind === 'pending' ? s.relation : undefined;
+            const carry = s.kind === 'pending' ? { relation, card: s.card, hold: s.hold } : { relation };
+            const p = pendingOf(target, serving, { ...s.ctx, causes: setCause(s.ctx.causes, c, fp) }, carry);
+            const fx = [];
+            if ((c === 'unresponsive' || c === 'user') && display !== undefined) {
+                const hold = {
+                    cause: c,
+                    target: display,
+                    ...(s.kind === 'pending' && s.hold?.running !== undefined ? { running: s.hold.running } : {}),
+                    ...(s.kind === 'pending' && s.hold?.own !== undefined ? { own: s.hold.own } : {}),
+                    occupancy: occ ?? null,
+                };
+                showCard(p, hold, occ, fx, policy);
+            }
+            else if (c !== 'unresponsive' && c !== 'user')
+                fx.push({ kind: 'banner', key: 'pending' });
+            return { state: p, effects: fx };
+        }
+        case 'down':
+            if (c !== 'user')
+                return undefined;
+            return { state: { kind: 'unbound', ctx: { ...s.ctx, deaths: [], cooldown: 0, lockRetry: 0 } }, effects: [{ kind: 'reread' }] };
+        case 'locking':
+        case 'stopping':
+            return { state: { ...s, ctx: { ...s.ctx, causes: setCause(s.ctx.causes, c, fp) } }, effects: [] };
+        case 'spawning':
+            if (causeFp(s.deferred, c) === fp)
+                return undefined;
+            return { state: { ...s, deferred: setCause(s.deferred, c, fp) }, effects: [] };
+        default:
+            return undefined;
+    }
+}
+function onCauseResolved(s, ev) {
+    const { cause: c, fingerprint: fp, nowMs } = ev;
+    switch (s.kind) {
+        case 'pending': {
+            if (causeFp(s.ctx.causes, c) !== fp)
+                return undefined;
+            const causes = dropCause(s.ctx.causes, c);
+            const ctx = { ...s.ctx, causes };
+            if (causes.length === 0) {
+                const fx = [{ kind: 'card', show: null }, { kind: 'banner', key: null }];
+                if (s.serving && s.target !== null && isRef(s.target))
+                    return { state: { kind: 'attached', engine: s.target, relation: s.relation ?? 'attach', since: nowMs, ctx }, effects: fx };
+                return { state: pendingOf(s.target, s.serving, ctx, { relation: s.relation }), effects: fx };
+            }
+            return { state: pendingOf(s.target, s.serving, ctx, { relation: s.relation, card: s.card, hold: s.hold }), effects: [{ kind: 'banner', key: 'pending' }] };
+        }
+        case 'locking':
+        case 'stopping':
+            if (causeFp(s.ctx.causes, c) !== fp)
+                return undefined;
+            return { state: { ...s, ctx: { ...s.ctx, causes: dropCause(s.ctx.causes, c) } }, effects: [] };
+        case 'spawning': {
+            const inCauses = causeFp(s.ctx.causes, c) === fp;
+            const inDeferred = causeFp(s.deferred, c) === fp;
+            if (!inCauses && !inDeferred)
+                return undefined;
+            return { state: { ...s, deferred: inDeferred ? dropCause(s.deferred, c) : s.deferred, ctx: inCauses ? { ...s.ctx, causes: dropCause(s.ctx.causes, c) } : s.ctx }, effects: [] };
+        }
+        default:
+            return undefined;
+    }
+}
+export function localEngineCurrentCard(s) {
+    try {
+        if (s.kind !== 'pending' || s.card !== 'shown' || s.hold === undefined)
+            return undefined;
+        return mintCard(s.hold, s.target, undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
+function answerRowOf(s, ev, policy) {
+    if (s.kind !== 'pending' || s.card !== 'shown')
+        return null;
+    if (ev.choice === 'wait')
+        return { row: 'B5' };
+    const first = s.ctx.causes[0];
+    const hold = s.hold ?? (first !== undefined && s.target !== null ? { cause: first.cause, target: s.target, occupancy: null } : undefined);
+    const current = hold === undefined ? undefined : mintCard(hold, s.target, ev.occupancy);
+    const matches = current !== undefined && current.fingerprint === ev.fingerprint && interactive(policy);
+    if (!matches)
+        return { row: 'B4', current };
+    return { row: stoppable(s.target) ? 'B3' : 'B3p', current };
+}
+function onAnswer(s, ev, policy) {
+    const r = answerRowOf(s, ev, policy);
+    if (r === null || s.kind !== 'pending')
+        return undefined;
+    const p = pendingOf(s.target, s.serving, s.ctx, { relation: s.relation, card: s.card, hold: s.hold });
+    const fx = [];
+    if (r.row === 'B5') {
+        hideCard(p, fx);
+        fx.push({ kind: 'banner', key: 'pending' });
+        return { state: p, effects: fx };
+    }
+    if (r.row === 'B3' && stoppable(s.target)) {
+        const n = nextOp(s.ctx);
+        return {
+            state: { kind: 'locking', intent: { kind: 'stop', mode: 'forced', serving: s.serving }, held: false, entry: s.target, op: n.op, since: ev.nowMs, plan: null, ctx: n.ctx },
+            effects: [{ kind: 'card', show: null }, { kind: 'acquire-lock', op: n.op }, { kind: 'submits', open: false }],
+        };
+    }
+    if (r.row === 'B3p') {
+        hideCard(p, fx);
+        fx.push({ kind: 'notice', notice: { key: 'cannotVerifyEngine' } });
+        return { state: p, effects: fx };
+    }
+    const hold = s.hold ?? (r.current !== undefined ? { cause: r.current.cause, target: r.current.target, occupancy: ev.occupancy ?? null } : undefined);
+    if (hold === undefined) {
+        hideCard(p, fx);
+        return { state: p, effects: fx };
+    }
+    showCard(p, { ...hold, occupancy: ev.occupancy ?? hold.occupancy }, ev.occupancy, fx, policy);
+    return { state: p, effects: fx };
+}
+function onGone(s, ev) {
+    const { instance, clean, nowMs } = ev;
+    if (s.kind === 'stopping') {
+        if (engineIdentityVerdict(idOf(s.target), instance) !== 'same')
+            return undefined;
+        return toSpawning(s, nowMs);
+    }
+    if (s.kind !== 'attached' && s.kind !== 'pending' && s.kind !== 'draining-wait' && s.kind !== 'unanswered')
+        return undefined;
+    const mine = heldInstance(s);
+    if (mine === undefined || engineIdentityVerdict(mine, instance) !== 'same')
+        return undefined;
+    const d = deathOf(s.ctx, mine, clean, s.kind === 'draining-wait', nowMs);
+    return { state: { kind: 'unbound', ctx: d.ctx }, effects: [{ kind: 'reread' }, { kind: 'submits', open: false }, d.notice] };
+}
+function onOpEvent(s, ev, policy) {
+    const lstate = s.kind === 'locking' || s.kind === 'stopping' || s.kind === 'spawning' ? s : undefined;
+    const op = ev.op;
+    if (lstate === undefined || lstate.op !== op) {
+        if (ev.kind === 'lock' && ev.held)
+            return { state: s, effects: [{ kind: 'release-lock', op }] };
+        return undefined;
+    }
+    switch (ev.kind) {
+        case 'lock':
+            if (lstate.kind !== 'locking' || lstate.held)
+                return undefined;
+            if (ev.held)
+                return { state: { ...lstate, held: true, since: ev.nowMs }, effects: [{ kind: 'reread' }] };
+            return lockUnavailable(lstate, ev.nowMs, []);
+        case 'lock-lost': {
+            if (lstate.kind === 'locking' && !lstate.held)
+                return undefined;
+            const fx = [{ kind: 'reread' }, { kind: 'notice', notice: { key: 'lockLost' } }];
+            if (lstate.kind === 'spawning')
+                fx.push({ kind: 'abandon-spawn', op: lstate.op });
+            return { state: { kind: 'unbound', ctx: lstate.ctx }, effects: fx };
+        }
+        case 'relooked':
+            return onRelooked(s, ev, policy);
+        case 'prepared': {
+            if (lstate.kind !== 'locking' || !lstate.held || lstate.plan === null)
+                return undefined;
+            const plan = lstate.plan;
+            if (!ev.ok)
+                return prepareFailed(lstate, plan, typeof ev.reason === 'string' && ev.reason.length > 0 ? ev.reason : 'unknown', ev.nowMs);
+            if (plan.kind === 'spawn')
+                return { state: { kind: 'spawning', forced: false, deferred: [], op: lstate.op, since: ev.nowMs, ctx: lstate.ctx }, effects: [{ kind: 'spawn', op: lstate.op }] };
+            if (lstate.ctx.causes.length === 0 || (plan.mode === 'idle' && !idle(ev.occupancy))) {
+                return { state: { kind: 'unbound', ctx: lstate.ctx }, effects: [{ kind: 'release-lock', op: lstate.op }, { kind: 'reread' }] };
+            }
+            const t = plan.target;
+            const startedAt = isRef(t) ? t.identity.startedAt : t.startedAt;
+            const ladder0 = { mode: plan.mode, target: startedAt !== undefined ? { pid: t.pid, startedAt } : { pid: t.pid }, t0: ev.nowMs, sent: [] };
+            const r = stopLadderStep(ladder0, { nowMs: ev.nowMs, alive: 'alive', health: null });
+            return { state: { kind: 'stopping', target: t, mode: plan.mode, ladder: r.state, op: lstate.op, ctx: lstate.ctx }, effects: r.action === 'term' ? [signalOf(t, 'term')] : [] };
+        }
+        case 'spawned': {
+            if (lstate.kind !== 'spawning')
+                return undefined;
+            const v = ev.verdict;
+            let ctx = { ...lstate.ctx, causes: [...lstate.deferred], autoTried: [] };
+            if (v.kind === 'ahead')
+                ctx = { ...ctx, autoTried: addTried(ctx, 'version', v.engine) };
+            const out = aRows(s, v, ctx, undefined, ev.nowMs, policy, [{ kind: 'release-lock', op: lstate.op }]);
+            if (lstate.forced)
+                out.effects.push({ kind: 'notice', notice: { key: 'forcedLine' } });
+            return out;
+        }
+        case 'spawn-failed':
+            if (lstate.kind !== 'spawning')
+                return undefined;
+            return {
+                state: { kind: 'down', reason: 'spawn-failed', since: ev.nowMs, ctx: lstate.ctx },
+                effects: [{ kind: 'release-lock', op: lstate.op }, { kind: 'notice', notice: { key: 'spawnFailed', timeout: false } }],
+            };
+        default:
+            return undefined;
+    }
+}
+function eventOf(e) {
+    const kind = own(e, 'kind');
+    const nowMs = own(e, 'nowMs');
+    if (!isTime(nowMs))
+        return undefined;
+    const occRaw = own(e, 'occupancy');
+    const occupancy = occOf(occRaw);
+    const withOcc = occupancy !== undefined ? { occupancy } : {};
+    const op = own(e, 'op');
+    switch (kind) {
+        case 'observed': {
+            const verdict = verdictOf(own(e, 'verdict'));
+            if (verdict === undefined)
+                return undefined;
+            return { kind, verdict, demand: own(e, 'demand') === true, nowMs, ...withOcc };
+        }
+        case 'relooked': {
+            const verdict = verdictOf(own(e, 'verdict'));
+            if (verdict === undefined || !isOp(op))
+                return undefined;
+            return { kind, verdict, nowMs, op, ...withOcc };
+        }
+        case 'lock': {
+            const held = own(e, 'held');
+            if (typeof held !== 'boolean' || !isOp(op))
+                return undefined;
+            return { kind, held, op, nowMs };
+        }
+        case 'lock-lost':
+            return isOp(op) ? { kind, op, nowMs } : undefined;
+        case 'prepared': {
+            const ok = own(e, 'ok');
+            const reason = own(e, 'reason');
+            if (typeof ok !== 'boolean' || !isOp(op))
+                return undefined;
+            return { kind, ok, nowMs, op, ...withOcc, ...(typeof reason === 'string' ? { reason } : {}) };
+        }
+        case 'tick': {
+            const alive = own(e, 'alive');
+            const health = own(e, 'health');
+            return {
+                kind,
+                nowMs,
+                ...withOcc,
+                ...(alive === 'alive' || alive === 'gone' || alive === 'unknown' ? { alive } : {}),
+                ...(typeof health === 'object' ? { health: health } : {}),
+            };
+        }
+        case 'cause':
+        case 'cause-resolved': {
+            const cause = own(e, 'cause');
+            const fingerprint = own(e, 'fingerprint');
+            if (!isCause(cause) || typeof fingerprint !== 'string' || fingerprint.length === 0)
+                return undefined;
+            return kind === 'cause' ? { kind, cause, fingerprint, nowMs, ...withOcc } : { kind, cause, fingerprint, nowMs };
+        }
+        case 'answer': {
+            const choice = own(e, 'choice');
+            const fingerprint = own(e, 'fingerprint');
+            if ((choice !== 'force' && choice !== 'wait') || typeof fingerprint !== 'string')
+                return undefined;
+            return { kind, choice, fingerprint, nowMs, ...withOcc };
+        }
+        case 'spawned': {
+            const verdict = verdictOf(own(e, 'verdict'));
+            if (verdict === undefined || !isOp(op))
+                return undefined;
+            return { kind, verdict, op, nowMs };
+        }
+        case 'spawn-failed': {
+            const reason = own(e, 'reason');
+            if (!isOp(op))
+                return undefined;
+            return { kind, op, nowMs, ...(typeof reason === 'string' ? { reason } : {}) };
+        }
+        case 'gone': {
+            const inst = own(e, 'instance');
+            const clean = own(e, 'clean');
+            if (!isRecord(inst) || (clean !== true && clean !== false && clean !== 'unknown'))
+                return undefined;
+            return { kind, instance: engineIdentityOf(inst), clean, nowMs };
+        }
+        default:
+            return undefined;
+    }
+}
+const STATE_KINDS = Object.freeze(['unbound', 'attached', 'pending', 'draining-wait', 'unanswered', 'down', 'locking', 'stopping', 'spawning', 'behind']);
+function stateOk(s) {
+    const kind = own(s, 'kind');
+    if (typeof kind !== 'string' || !STATE_KINDS.includes(kind))
+        return false;
+    if (kind === 'behind')
+        return true;
+    const ctx = own(s, 'ctx');
+    return isRecord(ctx) && Array.isArray(own(ctx, 'causes')) && Array.isArray(own(ctx, 'autoTried')) && Array.isArray(own(ctx, 'deaths'));
+}
+export function localEngineStep(state, event, policy) {
+    try {
+        if (!stateOk(state))
+            return Object.freeze({ state, effects: Object.freeze([]) });
+        return stepSampled(ownSnapshotTyped(state), state, event, policy);
+    }
+    catch {
+        return Object.freeze({ state, effects: Object.freeze([]) });
+    }
+}
+function stepSampled(sampled, original, event, policy) {
+    if (sampled === undefined || !stateOk(sampled))
+        return Object.freeze({ state: original, effects: Object.freeze([]) });
+    const state = sampled;
+    const ev = eventOf(event);
+    if (ev === undefined)
+        return unchanged(state);
+    if (state.kind === 'behind')
+        return unchanged(state);
+    let out;
+    switch (ev.kind) {
+        case 'observed':
+            out = onObserved(state, ev, policy);
+            break;
+        case 'tick':
+            out = onTick(state, ev, policy);
+            break;
+        case 'cause':
+            out = onCause(state, ev, policy);
+            break;
+        case 'cause-resolved':
+            out = onCauseResolved(state, ev);
+            break;
+        case 'answer':
+            out = onAnswer(state, ev, policy);
+            break;
+        case 'gone':
+            out = onGone(state, ev);
+            break;
+        default:
+            out = onOpEvent(state, ev, policy);
+    }
+    if (out === undefined)
+        return unchanged(state);
+    if (headless(policy) && out.state.kind === 'down' && state.kind !== 'down')
+        out.effects.push({ kind: 'fail', code: DOWN_FAIL[out.state.reason] });
+    return resultOf(out.state, out.effects) ?? unchanged(state);
+}
+function resultOf(state, effects) {
+    const st = ownSnapshotTyped(state);
+    if (st === undefined)
+        return undefined;
+    const fx = [];
+    for (const e of effects) {
+        const c = ownSnapshotTyped(e);
+        if (c === undefined)
+            return undefined;
+        fx.push(c);
+    }
+    return Object.freeze({ state: st, effects: Object.freeze(fx) });
+}
+function unchanged(state) {
+    return resultOf(state, []) ?? Object.freeze({ state, effects: Object.freeze([]) });
+}
+export function engineSwapAnswerOutcomeOf(before, event, policy) {
+    try {
+        const b = stateOk(before) ? ownSnapshotTyped(before) : undefined;
+        if (b === undefined || !stateOk(b))
+            return 'nothing-pending';
+        const ev = eventOf(event);
+        if (ev === undefined || ev.kind !== 'answer')
+            return 'nothing-pending';
+        const r = answerRowOf(b, ev, policy);
+        if (r === null)
+            return 'nothing-pending';
+        if (r.row === 'B4')
+            return 'stale-card';
+        if (r.row === 'B3p')
+            return 'nothing-pending';
+        return 'started';
+    }
+    catch {
+        return 'nothing-pending';
+    }
+}