@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/panelReduce.js

@@ -0,0 +1,1135 @@
+import { rowIdTail } from './workflow.js';
+import { isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess } from './terminalStatuses.js';
+import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, mergeCycle, } from './cycleOrder.js';
+export function isStaleEngineAgentPanelEnd(end, current) {
+    return cycleOrder(end, current) === 'before';
+}
+export function isNewEngineAgentPanelCycle(prev, next) {
+    const o = cycleOrder(prev, next);
+    return o === 'before' || o === 'after';
+}
+const TOMB = 0;
+class PMap {
+    base;
+    over;
+    size;
+    constructor(base, over, size) {
+        this.base = base;
+        this.over = over;
+        this.size = size;
+    }
+    static empty() {
+        return new PMap(new Map(), new Map(), 0);
+    }
+    get(k) {
+        const o = this.over.get(k);
+        if (o !== undefined)
+            return o === TOMB ? undefined : o.v;
+        return this.base.get(k);
+    }
+    has(k) {
+        return this.get(k) !== undefined;
+    }
+    *entries() {
+        for (const [k, v] of this.base) {
+            const o = this.over.get(k);
+            if (o === undefined)
+                yield [k, v];
+            else if (o !== TOMB && o.moved !== true)
+                yield [k, o.v];
+        }
+        for (const [k, o] of this.over) {
+            if (o === TOMB)
+                continue;
+            if (this.base.has(k) && o.moved !== true)
+                continue;
+            yield [k, o.v];
+        }
+    }
+    draft() {
+        return new PDraft(this);
+    }
+}
+class PDraft {
+    base;
+    over = null;
+    src;
+    size;
+    constructor(src) {
+        this.src = src;
+        this.base = src.base;
+        this.size = src.size;
+    }
+    w() {
+        if (this.over === null)
+            this.over = new Map(this.src.over);
+        return this.over;
+    }
+    ov() {
+        return this.over ?? this.src.over;
+    }
+    get(k) {
+        const o = this.ov().get(k);
+        if (o !== undefined)
+            return o === TOMB ? undefined : o.v;
+        return this.base.get(k);
+    }
+    has(k) {
+        return this.get(k) !== undefined;
+    }
+    set(k, v) {
+        const over = this.w();
+        const o = over.get(k);
+        if (o !== undefined && o !== TOMB) {
+            over.set(k, o.moved === true ? { v, moved: true } : { v });
+            return;
+        }
+        if (o === TOMB) {
+            over.delete(k);
+            over.set(k, { v, moved: true });
+            this.size++;
+            return;
+        }
+        if (!this.base.has(k))
+            this.size++;
+        over.set(k, { v });
+    }
+    delete(k) {
+        if (!this.has(k))
+            return;
+        const over = this.w();
+        if (this.base.has(k))
+            over.set(k, TOMB);
+        else
+            over.delete(k);
+        this.size--;
+    }
+    touch(k) {
+        const v = this.get(k);
+        if (v === undefined)
+            return;
+        const over = this.w();
+        over.delete(k);
+        over.set(k, this.base.has(k) ? { v, moved: true } : { v });
+    }
+    *entries() {
+        yield* new PMap(this.base, this.ov(), this.size).entries();
+    }
+    first(pred) {
+        for (const [k, v] of this.entries())
+            if (pred(k, v))
+                return k;
+        return undefined;
+    }
+    freeze() {
+        if (this.over === null)
+            return this.src;
+        if (this.over.size > Math.max(32, this.base.size >> 4)) {
+            return new PMap(new Map(new PMap(this.base, this.over, this.size).entries()), new Map(), this.size);
+        }
+        return new PMap(this.base, this.over, this.size);
+    }
+}
+export const ABSENT_SETTLE_MS = 30_000;
+const SETTLED_RETENTION_MS = ABSENT_SETTLE_MS * 4;
+export const MAX_HELD_WIRE_TICK_BEATS = 16;
+const MAX_HELD_WIRE_TICKS = 64;
+const MAX_ALIAS_PER_KIND = 2048;
+const MAX_WIRE_KEYS = 8192;
+const MAX_OWNED_TAILS = 8192;
+const MAX_RUNNING = 4096;
+const MAX_ENDED = 4096;
+const MAX_HELD_ROWS = 4096;
+const MAX_ROWS = 8192;
+export const PANEL_DELTA_OPS = Object.freeze(['upsert', 'usage_delta', 'terminal', 'remove']);
+export const PANEL_REDUCE_STATE_KEYS = Object.freeze(['__panelReduceState', 'records', 'alias', 'pending', 'sessions', 'overflowed', 'counts']);
+export function createPanelReduceState() {
+    const s = {
+        __panelReduceState: true,
+        records: PMap.empty(),
+        alias: PMap.empty(),
+        pending: PMap.empty(),
+        sessions: PMap.empty(),
+        overflowed: false,
+        counts: { alias: { t: 0, p: 0, w: 0 }, wire: 0, owned: 0, running: 0, ended: 0, held: 0, rows: 0 },
+    };
+    return Object.freeze(s);
+}
+function impl(s) {
+    return s;
+}
+class Step {
+    records;
+    alias;
+    pending;
+    sessionsDraft;
+    overflowed;
+    counts;
+    deltas = [];
+    facts = [];
+    constructor(s) {
+        this.records = s.records.draft();
+        this.alias = s.alias.draft();
+        this.pending = s.pending.draft();
+        this.sessionsDraft = s.sessions.draft();
+        this.overflowed = s.overflowed;
+        this.counts = { alias: { ...s.counts.alias }, wire: s.counts.wire, owned: s.counts.owned, running: s.counts.running, ended: s.counts.ended, held: s.counts.held, rows: s.counts.rows };
+    }
+    freeze() {
+        return Object.freeze({
+            __panelReduceState: true,
+            records: this.records.freeze(),
+            alias: this.alias.freeze(),
+            pending: this.pending.freeze(),
+            sessions: this.sessionsDraft.freeze(),
+            overflowed: this.overflowed,
+            counts: Object.freeze({ ...this.counts, alias: Object.freeze({ ...this.counts.alias }) }),
+        });
+    }
+    rec(key) {
+        return this.records.get(key);
+    }
+    put(key, patch) {
+        const old = this.records.get(key) ?? {};
+        const next = { ...old };
+        for (const [f, v] of Object.entries(patch)) {
+            if (v === undefined)
+                delete next[f];
+            else
+                next[f] = v;
+        }
+        const n = next;
+        this.counts.wire += (n.wire !== undefined ? 1 : 0) - (old.wire !== undefined ? 1 : 0);
+        this.counts.owned += (n.ownedBy !== undefined ? 1 : 0) - (old.ownedBy !== undefined ? 1 : 0);
+        this.counts.running += (n.running !== undefined ? 1 : 0) - (old.running !== undefined ? 1 : 0);
+        this.counts.ended += (n.ended !== undefined ? 1 : 0) - (old.ended !== undefined ? 1 : 0);
+        this.counts.held += (n.held !== undefined ? 1 : 0) - (old.held !== undefined ? 1 : 0);
+        this.counts.rows += (n.row !== undefined ? 1 : 0) - (old.row !== undefined ? 1 : 0);
+        if (Object.keys(next).length === 0)
+            this.records.delete(key);
+        else
+            this.records.set(key, n);
+        const from = old.ownedBy?.wireId;
+        const to = n.ownedBy?.wireId;
+        if (from !== to) {
+            if (from !== undefined)
+                this.linkOwned(from, key, false);
+            if (to !== undefined)
+                this.linkOwned(to, key, true);
+        }
+    }
+    linkOwned(owner, tail, add) {
+        const r = this.records.get(owner) ?? {};
+        const cur = r.owns ?? [];
+        if (cur.includes(tail) === add)
+            return;
+        const owns = add ? [...cur, tail] : cur.filter((t) => t !== tail);
+        const next = { ...r };
+        if (owns.length > 0)
+            next.owns = owns;
+        else
+            delete next.owns;
+        if (Object.keys(next).length === 0)
+            this.records.delete(owner);
+        else
+            this.records.set(owner, next);
+    }
+    ownedTails(owner) {
+        return this.records.get(owner)?.owns ?? [];
+    }
+    aliasGet(kind, key, touch) {
+        const k = `${kind}:${key}`;
+        const e = this.alias.get(k);
+        if (e !== undefined && touch)
+            this.alias.touch(k);
+        return e;
+    }
+    aliasHas(kind, key) {
+        return this.alias.has(`${kind}:${key}`);
+    }
+    aliasSet(kind, key, entry) {
+        const k = `${kind}:${key}`;
+        const had = this.alias.has(k);
+        if (had)
+            this.alias.delete(k);
+        else
+            this.counts.alias[kind]++;
+        this.alias.set(k, entry);
+        if (this.counts.alias[kind] > MAX_ALIAS_PER_KIND) {
+            const prefix = `${kind}:`;
+            const oldest = this.alias.first((key2) => key2.startsWith(prefix));
+            if (oldest !== undefined) {
+                this.alias.delete(oldest);
+                this.counts.alias[kind]--;
+            }
+        }
+    }
+    session(sessionKey) {
+        return (this.sessionsDraft.get(sessionKey) ?? PMap.empty()).draft();
+    }
+    putSession(sessionKey, d) {
+        if (d.size === 0)
+            this.sessionsDraft.delete(sessionKey);
+        else
+            this.sessionsDraft.set(sessionKey, d.freeze());
+    }
+    dropSessions(sessionKey) {
+        if (sessionKey !== undefined) {
+            this.sessionsDraft.delete(sessionKey);
+            return;
+        }
+        for (const [k] of [...this.sessionsDraft.entries()])
+            this.sessionsDraft.delete(k);
+    }
+}
+function boundFields(d) {
+    if (d.counts.wire > MAX_WIRE_KEYS) {
+        const k = d.records.first((_, r) => r.wire?.retired === true) ?? d.records.first((_, r) => r.wire !== undefined);
+        if (k !== undefined)
+            d.put(k, { wire: undefined });
+    }
+    if (d.counts.owned > MAX_OWNED_TAILS) {
+        const k = d.records.first((_, r) => r.ownedBy?.retired === true) ?? d.records.first((_, r) => r.ownedBy !== undefined);
+        if (k !== undefined)
+            d.put(k, { ownedBy: undefined });
+    }
+    if (d.counts.running > MAX_RUNNING) {
+        d.overflowed = true;
+        const k = d.records.first((_, r) => r.running === true);
+        if (k !== undefined)
+            d.put(k, { running: undefined });
+    }
+    if (d.counts.ended > MAX_ENDED) {
+        const k = d.records.first((_, r) => r.ended !== undefined);
+        if (k !== undefined)
+            d.put(k, { ended: undefined });
+    }
+    if (d.counts.held > MAX_HELD_ROWS) {
+        const k = d.records.first((_, r) => r.held !== undefined);
+        if (k !== undefined)
+            d.put(k, { held: undefined });
+    }
+    if (d.counts.rows > MAX_ROWS) {
+        const k = d.records.first((_, r) => r.row?.phase === 'ended') ?? d.records.first((_, r) => r.row !== undefined);
+        if (k !== undefined) {
+            const announced = d.rec(k)?.row?.announced === true;
+            d.put(k, { row: undefined });
+            if (announced)
+                d.deltas.push({ op: 'remove', canonicalId: k });
+        }
+    }
+}
+export function panelEndFact(taskId, isError, extra) {
+    return {
+        kind: 'end',
+        taskId,
+        isError,
+        ...(extra?.cycleSeq !== undefined ? { cycleSeq: extra.cycleSeq } : {}),
+        ...(extra?.startedAt !== undefined ? { startedAt: extra.startedAt } : {}),
+        ...(extra?.report !== undefined ? { report: extra.report } : {}),
+    };
+}
+function terminalDelta(key, isError, report, cause) {
+    return { op: 'terminal', canonicalId: key, isError, ...(report !== undefined ? { report } : {}), cause };
+}
+function mintTerminal(d, key, isError, report, cause) {
+    d.deltas.push(terminalDelta(key, isError, report, cause));
+}
+function tickFields(ev) {
+    return {
+        ...(ev.name !== undefined ? { name: ev.name } : {}),
+        ...(ev.description !== undefined ? { description: ev.description } : {}),
+        ...(ev.prompt !== undefined ? { prompt: ev.prompt } : {}),
+        ...(ev.currentAction !== undefined ? { currentAction: ev.currentAction } : {}),
+        ...(ev.spawnName !== undefined ? { spawnName: ev.spawnName } : {}),
+        ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
+        ...(ev.wireTaskId !== undefined ? { wireTaskId: ev.wireTaskId } : {}),
+        ...(ev.taskIdOrigin !== undefined ? { taskIdOrigin: ev.taskIdOrigin } : {}),
+    };
+}
+function fleetFields(ev) {
+    return {
+        ...(ev.name !== undefined ? { name: ev.name } : {}),
+        ...(ev.description !== undefined ? { description: ev.description } : {}),
+        ...(ev.currentTool !== undefined ? { currentTool: ev.currentTool } : {}),
+        ...(ev.transcriptId !== undefined ? { transcriptId: ev.transcriptId } : {}),
+        ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
+        ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}),
+        ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}),
+        ...(ev.wireTaskId !== undefined ? { wireTaskId: ev.wireTaskId } : {}),
+        ...(ev.taskIdOrigin !== undefined ? { taskIdOrigin: ev.taskIdOrigin } : {}),
+    };
+}
+function changedFields(row, next, onlyMissing) {
+    const out = {};
+    for (const [k, v] of Object.entries(next)) {
+        const cur = row[k];
+        if (onlyMissing.includes(k) && cur !== undefined)
+            continue;
+        if (JSON.stringify(cur) !== JSON.stringify(v))
+            out[k] = v;
+    }
+    return out;
+}
+const TICK_LATE_BIND = Object.freeze(['prompt', 'description', 'name']);
+function usageDelta(key, row, tokens, toolUses) {
+    const t = tokens !== undefined && tokens !== row?.totalTokens ? tokens : undefined;
+    const u = toolUses !== undefined && toolUses !== row?.toolUses ? toolUses : undefined;
+    if (t === undefined && u === undefined)
+        return undefined;
+    return { op: 'usage_delta', canonicalId: key, ...(t !== undefined ? { totalTokens: t } : {}), ...(u !== undefined ? { toolUses: u } : {}) };
+}
+function announce(d, key, row) {
+    d.deltas.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...row.fields } });
+    const u = usageDelta(key, undefined, row.totalTokens, row.toolUses);
+    if (u !== undefined)
+        d.deltas.push(u);
+    if (row.phase === 'ended')
+        mintTerminal(d, key, row.isError === true, row.report, 'end');
+    return { ...row, announced: true };
+}
+function foldTick(d, ev) {
+    const key = ev.taskId;
+    const row = d.rec(key)?.row;
+    if (row === undefined || !row.announced) {
+        const fresh = row !== undefined
+            ? { ...row, lane: 'tick', fields: { ...row.fields, ...tickFields(ev) }, totalTokens: ev.totalTokens, toolUses: ev.toolUses }
+            : { phase: 'running', lane: 'tick', announced: false, fields: tickFields(ev), totalTokens: ev.totalTokens, toolUses: ev.toolUses };
+        d.put(key, { row: announce(d, key, fresh) });
+        return;
+    }
+    if (row.phase !== 'running')
+        return;
+    const next = tickFields(ev);
+    const changed = changedFields(row.fields, next, TICK_LATE_BIND);
+    if (row.fields.absence)
+        changed.absence = null;
+    if (Object.keys(changed).length > 0)
+        d.deltas.push({ op: 'upsert', canonicalId: key, fields: changed });
+    const u = usageDelta(key, row, ev.totalTokens, ev.toolUses);
+    if (u !== undefined)
+        d.deltas.push(u);
+    const fields = { ...row.fields, ...changed };
+    if (changed.absence === null)
+        delete fields.absence;
+    d.put(key, { row: { ...row, lane: 'tick', fields, totalTokens: ev.totalTokens, toolUses: ev.toolUses } });
+}
+function foldFleetRow(d, ev, prior) {
+    const key = ev.taskId;
+    const row = d.rec(key)?.row;
+    const order = cycleOrder(prior, ev);
+    if (order === 'after')
+        return;
+    const endGen = row?.phase === 'ended' ? row.endCycle : undefined;
+    const newCycle = order === 'before' || (endGen !== undefined && cycleOrder(endGen, ev) === 'before');
+    if (row === undefined) {
+        const fresh = { phase: 'running', lane: 'fleet', announced: false, fields: fleetFields(ev), ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) };
+        d.put(key, { row: announce(d, key, fresh) });
+        return;
+    }
+    if (!row.announced) {
+        const merged = newCycle
+            ? { phase: 'running', lane: 'fleet', announced: false, fields: fleetFields(ev), ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) }
+            : { ...row, fields: { ...row.fields, ...fleetFields(ev) }, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) };
+        d.put(key, { row: announce(d, key, merged) });
+        return;
+    }
+    if (newCycle) {
+        const fields = fleetFields(ev);
+        d.deltas.push({ op: 'upsert', canonicalId: key, revived: true, fields: { ...fields, ...(row.fields.absence ? { absence: null } : {}) } });
+        const u = usageDelta(key, undefined, ev.totalTokens, ev.toolUses);
+        if (u !== undefined)
+            d.deltas.push(u);
+        const kept = { ...row.fields, ...fields };
+        delete kept.absence;
+        d.put(key, { row: { phase: 'running', lane: 'fleet', announced: true, fields: kept, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) } });
+        return;
+    }
+    if (row.phase !== 'running')
+        return;
+    if (row.lane === 'tick') {
+        if (row.fields.absence) {
+            d.deltas.push({ op: 'upsert', canonicalId: key, fields: { absence: null } });
+            const fields = { ...row.fields };
+            delete fields.absence;
+            d.put(key, { row: { ...row, fields } });
+        }
+        return;
+    }
+    const changed = changedFields(row.fields, fleetFields(ev), []);
+    if (row.fields.absence)
+        changed.absence = null;
+    if (Object.keys(changed).length > 0)
+        d.deltas.push({ op: 'upsert', canonicalId: key, fields: changed });
+    const u = usageDelta(key, row, ev.totalTokens, ev.toolUses);
+    if (u !== undefined)
+        d.deltas.push(u);
+    const fields = { ...row.fields, ...changed };
+    if (changed.absence === null)
+        delete fields.absence;
+    d.put(key, { row: { ...row, fields, ...(ev.totalTokens !== undefined ? { totalTokens: ev.totalTokens } : {}), ...(ev.toolUses !== undefined ? { toolUses: ev.toolUses } : {}) } });
+}
+function foldEnd(d, ev) {
+    const key = ev.taskId;
+    const rec = d.rec(key);
+    if (endOlderThanKnown(d, ev, key, rec?.cycle))
+        return;
+    const row = rec?.row;
+    if (row === undefined) {
+        d.put(key, { row: { phase: 'ended', lane: 'fleet', announced: false, isError: ev.isError, cause: 'end', ...(cycleEmpty(ev) ? {} : { endCycle: cycleOf(ev) }), ...(ev.report !== undefined ? { report: ev.report } : {}), fields: {} } });
+        return;
+    }
+    if (row.phase !== 'running')
+        return;
+    const fields = { ...row.fields };
+    delete fields.absence;
+    d.put(key, { row: { ...row, phase: 'ended', lane: 'fleet', isError: ev.isError, cause: 'end', ...(cycleEmpty(ev) ? {} : { endCycle: cycleOf(ev) }), ...(ev.report !== undefined ? { report: ev.report } : {}), fields } });
+    if (row.announced)
+        mintTerminal(d, key, ev.isError, ev.report, 'end');
+}
+function foldSweep(d) {
+    const hits = [];
+    for (const [key, r] of d.records.entries()) {
+        const row = r.row;
+        if (row === undefined || !row.announced || row.phase !== 'running')
+            continue;
+        if (row.fields.absence)
+            continue;
+        if (row.lane === 'fleet' || r.resident === true)
+            continue;
+        hits.push(key);
+    }
+    for (const key of hits) {
+        const row = d.rec(key)?.row;
+        if (row === undefined)
+            continue;
+        d.put(key, { row: { ...row, phase: 'ended', isError: false, cause: 'sweep' } });
+        mintTerminal(d, key, false, undefined, 'sweep');
+    }
+}
+function foldAbsence(d, a) {
+    const row = d.rec(a.taskId)?.row;
+    if (row === undefined || !row.announced || row.phase !== 'running')
+        return;
+    const absence = { lastSeenAtMs: a.lastSeenAtMs, absentForMs: a.absentForMs };
+    d.deltas.push({ op: 'upsert', canonicalId: a.taskId, fields: { absence } });
+    d.put(a.taskId, { row: { ...row, fields: { ...row.fields, absence } } });
+}
+function emit(d, ev, prior) {
+    d.facts.push({ ch: 'event', ev });
+    switch (ev.kind) {
+        case 'tick':
+            foldTick(d, ev);
+            break;
+        case 'fleet-row':
+            foldFleetRow(d, ev, prior);
+            break;
+        case 'end':
+            foldEnd(d, ev);
+            break;
+        default:
+            foldSweep(d);
+    }
+    boundFields(d);
+}
+function identityOf(a) {
+    return { taskId: a.to, origin: 'fleet-row', ...cycleOf(a.cycle) };
+}
+function resolve(d, wireTaskId, parentToolCallId, touch) {
+    const byT = d.aliasGet('t', wireTaskId, touch);
+    if (byT !== undefined)
+        return identityOf(byT);
+    const byP = parentToolCallId !== undefined ? d.aliasGet('p', parentToolCallId, touch) : undefined;
+    if (byP !== undefined)
+        return identityOf(byP);
+    return { taskId: wireTaskId, origin: 'wire' };
+}
+function rememberResolvedWire(d, wireTaskId, id) {
+    if (d.aliasHas('t', wireTaskId))
+        return;
+    const c = cycleOf(id);
+    d.aliasSet('t', wireTaskId, { to: id.taskId, ...(cycleEmpty(c) ? {} : { cycle: c }) });
+}
+function notePublishedWire(d, ev) {
+    d.put(ev.taskId, { wire: { retired: d.rec(ev.taskId)?.wire?.retired ?? false } });
+    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
+        d.aliasSet('w', ev.parentToolCallId, { to: ev.taskId });
+}
+function retireWire(d, wireId) {
+    const w = d.rec(wireId)?.wire;
+    if (w !== undefined)
+        d.put(wireId, { wire: { retired: true } });
+    const owned = d.ownedTails(wireId).filter((k) => d.rec(k)?.ownedBy?.retired === false);
+    for (const k of owned) {
+        const o = d.rec(k)?.ownedBy;
+        if (o !== undefined)
+            d.put(k, { ownedBy: { ...o, retired: true } });
+    }
+}
+function isPublishedWire(d, id) {
+    return d.rec(id)?.wire !== undefined;
+}
+function publishedWireFor(d, ev) {
+    if (ev.transcriptId !== undefined && isPublishedWire(d, ev.transcriptId))
+        return ev.transcriptId;
+    if (ev.parentToolCallId !== undefined) {
+        const u = d.aliasGet('w', ev.parentToolCallId, false)?.to;
+        if (u !== undefined && d.rec(u)?.wire?.retired === false)
+            return u;
+    }
+    return undefined;
+}
+function wireOwnerOf(d, fleetId, current, transcriptId) {
+    const o = d.rec(fleetId)?.ownedBy;
+    if (o === undefined)
+        return undefined;
+    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId);
+    if (newTranscript || (current !== undefined && isStaleEngineAgentPanelEnd(d.rec(o.wireId)?.cycle, current))) {
+        d.put(fleetId, { ownedBy: undefined });
+        retireWire(d, o.wireId);
+        return undefined;
+    }
+    return o.wireId;
+}
+function ageHeld(d, except) {
+    for (const [wireId, held] of [...d.pending.entries()]) {
+        if (wireId === except)
+            continue;
+        const beats = held.beats + 1;
+        if (beats >= MAX_HELD_WIRE_TICK_BEATS) {
+            d.pending.delete(wireId);
+            emit(d, asIsTick(d, held.ev));
+        }
+        else {
+            d.pending.set(wireId, { ev: held.ev, beats });
+        }
+    }
+}
+function migrateResidency(d, wireTaskId, fleetId) {
+    if (wireTaskId !== fleetId && d.rec(wireTaskId)?.resident === true) {
+        d.put(wireTaskId, { resident: undefined });
+        d.put(fleetId, { resident: true });
+    }
+}
+function stripCardBound(ev) {
+    const { cardBound: _cardBound, ...rest } = ev;
+    void _cardBound;
+    return rest;
+}
+function normalizedTick(d, ev, fleetId) {
+    migrateResidency(d, ev.taskId, fleetId);
+    return { ...stripCardBound(ev), taskId: fleetId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row' };
+}
+function asIsTick(d, ev) {
+    notePublishedWire(d, ev);
+    return { ...stripCardBound(ev), taskIdOrigin: 'wire' };
+}
+function staleWireTick(d, id) {
+    return isStaleEngineAgentPanelEnd(id, d.rec(id.taskId)?.cycle);
+}
+function flushHeld(d, wireTaskId) {
+    const held = d.pending.get(wireTaskId);
+    if (held === undefined)
+        return;
+    d.pending.delete(wireTaskId);
+    if (isPublishedWire(d, held.ev.taskId)) {
+        emit(d, asIsTick(d, held.ev));
+        return;
+    }
+    const id = resolve(d, held.ev.taskId, held.ev.parentToolCallId, true);
+    if (id.origin === 'fleet-row') {
+        if (staleWireTick(d, id))
+            return;
+        rememberResolvedWire(d, held.ev.taskId, id);
+        emit(d, normalizedTick(d, held.ev, id.taskId));
+        return;
+    }
+    emit(d, asIsTick(d, held.ev));
+}
+function notePanelRowRunning(d, taskId) {
+    if (d.rec(taskId)?.running === true)
+        return;
+    d.put(taskId, { running: true });
+}
+function panelRowUnknownToConsumer(d, taskId) {
+    const r = d.rec(taskId);
+    return !d.overflowed && r?.running !== true && r?.ended === undefined;
+}
+function notePanelRowEnded(d, taskId, cycle, older) {
+    const existing = d.rec(taskId)?.ended;
+    if (existing !== undefined && older)
+        return;
+    d.put(taskId, { ended: mergeCycle(cycleOf(cycle), existing) });
+}
+function settleRowHistory(d, taskId, cycle) {
+    d.put(taskId, { running: undefined });
+    notePanelRowEnded(d, taskId, cycle, isStaleEngineAgentPanelEnd(cycle, d.rec(taskId)?.ended));
+}
+function endOlderThanKnown(d, end, taskId, rowCycle) {
+    return isStaleEngineAgentPanelEnd(end, rowCycle) || isStaleEngineAgentPanelEnd(end, d.rec(taskId)?.ended);
+}
+function heldRowConsumerKey(d, tail, held) {
+    const owner = d.rec(tail)?.ownedBy;
+    if (owner !== undefined)
+        return owner.wireId;
+    return publishedWireFor(d, held) ?? tail;
+}
+function heldVerdict(d, taskId, endCycle) {
+    const held = d.rec(taskId)?.held;
+    if (held === undefined)
+        return 'none';
+    const o = cycleOrder(endCycle, held);
+    if (o === 'before')
+        return 'keep';
+    if (o === 'after')
+        return 'drop';
+    return 'release';
+}
+function heldRowReleasesOntoSameKey(d, tail, end) {
+    const held = d.rec(tail)?.held;
+    if (held === undefined)
+        return false;
+    const rowKey = heldRowConsumerKey(d, tail, held);
+    if (rowKey === end.taskId)
+        return true;
+    return rowKey === tail && held.transcriptId === end.taskId && !isPublishedWire(d, end.taskId);
+}
+function releaseHeld(d, taskId, endCycle) {
+    const verdict = heldVerdict(d, taskId, endCycle);
+    if (verdict === 'drop') {
+        d.put(taskId, { held: undefined });
+        return;
+    }
+    if (verdict !== 'release')
+        return;
+    const held = d.rec(taskId)?.held;
+    if (held === undefined)
+        return;
+    d.put(taskId, { held: undefined });
+    publish(d, held);
+}
+function publish(d, ev) {
+    if (ev.kind === 'end' || ev.kind === 'sweep')
+        ageHeld(d, ev.kind === 'sweep' ? undefined : ev.taskId);
+    switch (ev.kind) {
+        case 'fleet-row':
+            return publishFleetRow(d, ev);
+        case 'tick':
+            return publishTick(d, ev);
+        case 'end':
+            return publishEnd(d, ev);
+        default:
+            emit(d, ev);
+    }
+}
+function publishFleetRow(d, ev) {
+    const rowCycle = cycleOf(ev);
+    const published = wireOwnerOf(d, ev.taskId, rowCycle, ev.transcriptId) ?? publishedWireFor(d, ev);
+    if (published !== undefined && published !== ev.taskId) {
+        const prev = d.rec(ev.taskId)?.ownedBy;
+        const transcriptId = ev.transcriptId ?? prev?.transcriptId;
+        d.put(ev.taskId, { ownedBy: { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...(transcriptId !== undefined ? { transcriptId } : {}) } });
+        const tailAnchor = d.rec(ev.taskId)?.anchor;
+        if (tailAnchor !== undefined && tailAnchor === (transcriptId ?? published)) {
+            d.put(published, { anchor: tailAnchor });
+            d.put(ev.taskId, { anchor: undefined });
+        }
+        const prior = d.rec(published)?.cycle;
+        if (cycleOrder(rowCycle, prior) !== 'before')
+            d.put(published, { cycle: cycleEmpty(rowCycle) ? undefined : rowCycle });
+        emit(d, { ...ev, taskId: published, wireTaskId: ev.taskId, taskIdOrigin: 'wire' }, prior);
+        ageHeld(d, undefined);
+        return;
+    }
+    const prior = d.rec(ev.taskId)?.cycle;
+    if (!cycleEmpty(rowCycle) && cycleOrder(rowCycle, prior) !== 'before')
+        d.put(ev.taskId, { cycle: rowCycle });
+    const alias = { to: ev.taskId, ...(cycleEmpty(rowCycle) ? {} : { cycle: rowCycle }) };
+    if (ev.transcriptId !== undefined && ev.transcriptId.length > 0)
+        d.aliasSet('t', ev.transcriptId, alias);
+    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
+        d.aliasSet('p', ev.parentToolCallId, alias);
+    emit(d, ev, prior);
+    for (const [wireId, held] of [...d.pending.entries()]) {
+        if (wireId === ev.transcriptId || (held.ev.parentToolCallId !== undefined && held.ev.parentToolCallId === ev.parentToolCallId))
+            flushHeld(d, wireId);
+    }
+    ageHeld(d, undefined);
+}
+function publishTick(d, ev) {
+    if (isPublishedWire(d, ev.taskId)) {
+        d.pending.delete(ev.taskId);
+        emit(d, asIsTick(d, ev));
+        return;
+    }
+    const id = resolve(d, ev.taskId, ev.parentToolCallId, true);
+    if (id.origin === 'fleet-row') {
+        d.pending.delete(ev.taskId);
+        if (staleWireTick(d, id))
+            return;
+        rememberResolvedWire(d, ev.taskId, id);
+        emit(d, normalizedTick(d, ev, id.taskId));
+        return;
+    }
+    if (ev.cardBound === true) {
+        emit(d, asIsTick(d, ev));
+        return;
+    }
+    if (d.pending.has(ev.taskId)) {
+        d.pending.delete(ev.taskId);
+        emit(d, asIsTick(d, ev));
+        return;
+    }
+    if (d.pending.size >= MAX_HELD_WIRE_TICKS) {
+        const oldest = d.pending.first(() => true);
+        if (oldest !== undefined)
+            flushHeld(d, oldest);
+    }
+    d.pending.set(ev.taskId, { ev, beats: 0 });
+}
+function publishEnd(d, ev) {
+    releaseHeld(d, ev.taskId, ev);
+    {
+        const pre = resolve(d, ev.taskId, undefined, true);
+        if (pre.origin === 'fleet-row' && pre.taskId !== ev.taskId) {
+            releaseHeld(d, pre.taskId, mergeCycle(cycleOf(ev), cycleOf(pre)));
+        }
+        const owners = d.ownedTails(ev.taskId).filter((fleetId) => d.rec(fleetId)?.ownedBy?.retired === false);
+        for (const fleetId of owners)
+            releaseHeld(d, fleetId, ev);
+        const heldMatches = [];
+        if (d.counts.held > 0)
+            for (const [tail, r] of d.records.entries()) {
+                const held = r.held;
+                if (held === undefined || tail === ev.taskId)
+                    continue;
+                const byTranscript = typeof held.transcriptId === 'string' && held.transcriptId.length > 0 && held.transcriptId === ev.taskId;
+                const byParent = typeof held.parentToolCallId === 'string' && held.parentToolCallId.length > 0 &&
+                    d.aliasGet('w', held.parentToolCallId, false)?.to === ev.taskId &&
+                    d.rec(ev.taskId)?.wire?.retired === false;
+                if (byTranscript || byParent)
+                    heldMatches.push(tail);
+            }
+        const releasable = [];
+        for (const tail of heldMatches) {
+            const verdict = heldVerdict(d, tail, ev);
+            if (verdict === 'drop')
+                d.put(tail, { held: undefined });
+            else if (verdict === 'release' && heldRowReleasesOntoSameKey(d, tail, ev))
+                releasable.push(tail);
+        }
+        if (releasable.length === 1)
+            releaseHeld(d, releasable[0], ev);
+    }
+    const wireOwner = wireOwnerOf(d, ev.taskId, ev);
+    if (wireOwner !== undefined) {
+        const staleA = endOlderThanKnown(d, ev, ev.taskId, d.rec(wireOwner)?.cycle) || isStaleEngineAgentPanelEnd(ev, d.rec(wireOwner)?.ended);
+        emit(d, { ...ev, taskId: wireOwner, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
+        if (!staleA) {
+            retireWire(d, wireOwner);
+            settleRowHistory(d, ev.taskId, ev);
+            settleRowHistory(d, wireOwner, ev);
+        }
+        return;
+    }
+    if (isPublishedWire(d, ev.taskId)) {
+        flushHeld(d, ev.taskId);
+        const ownedFleetIds = d.ownedTails(ev.taskId).filter((fleetId) => !endOlderThanKnown(d, ev, fleetId, d.rec(ev.taskId)?.cycle));
+        const alias = d.aliasGet('t', ev.taskId, false);
+        if (alias !== undefined && !endOlderThanKnown(d, ev, alias.to, alias.cycle) && !ownedFleetIds.includes(alias.to))
+            ownedFleetIds.push(alias.to);
+        emit(d, ev);
+        retireWire(d, ev.taskId);
+        if (!isStaleEngineAgentPanelEnd(ev, d.rec(ev.taskId)?.ended))
+            settleRowHistory(d, ev.taskId, ev);
+        for (const fleetId of ownedFleetIds)
+            settleRowHistory(d, fleetId, ev);
+        return;
+    }
+    const id = resolve(d, ev.taskId, undefined, true);
+    if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
+        flushHeld(d, ev.taskId);
+        migrateResidency(d, ev.taskId, id.taskId);
+        const effectiveEnd = mergeCycle(cycleOf(ev), cycleOf(id));
+        const staleC = endOlderThanKnown(d, effectiveEnd, id.taskId, d.rec(id.taskId)?.cycle);
+        emit(d, { ...ev, taskId: id.taskId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row', ...effectiveEnd });
+        if (!staleC)
+            settleRowHistory(d, id.taskId, effectiveEnd);
+        return;
+    }
+    flushHeld(d, ev.taskId);
+    const staleD = endOlderThanKnown(d, ev, ev.taskId, d.rec(ev.taskId)?.cycle);
+    emit(d, ev);
+    retireWire(d, ev.taskId);
+    if (!staleD)
+        settleRowHistory(d, ev.taskId, ev);
+}
+function publishAbsence(d, a) {
+    const owner = wireOwnerOf(d, a.taskId);
+    const ev = owner !== undefined ? { ...a, taskId: owner, wireTaskId: a.taskId } : a;
+    d.facts.push({ ch: 'absence', absence: ev });
+    foldAbsence(d, ev);
+}
+function clearResidentByWire(d, wireTaskId, cycle) {
+    d.put(wireTaskId, { resident: undefined });
+    const owner = d.rec(wireTaskId)?.ownedBy;
+    if (owner !== undefined && !(cycle !== undefined && isStaleEngineAgentPanelEnd(cycle, d.rec(owner.wireId)?.cycle)))
+        d.put(owner.wireId, { resident: undefined });
+    const id = resolve(d, wireTaskId, undefined, true);
+    if (id.taskId === wireTaskId)
+        return;
+    if (isStaleEngineAgentPanelEnd(id, d.rec(id.taskId)?.cycle))
+        return;
+    d.put(id.taskId, { resident: undefined });
+}
+function currentToolKeyOf(ct) {
+    if (!ct || typeof ct.toolName !== 'string' || ct.toolName.length === 0)
+        return undefined;
+    return `${ct.toolName}\u0000${ct.target ?? ''}`;
+}
+function project(d, sessionKey, rows, nowMs) {
+    const seen = d.session(sessionKey);
+    const present = new Set();
+    for (const row of rows) {
+        if (!row?.id)
+            continue;
+        const taskId = rowIdTail(row.id);
+        if (!taskId)
+            continue;
+        present.add(taskId);
+        const status = row.status ?? 'running';
+        const tokens = typeof row.tokens === 'number' && Number.isInteger(row.tokens) && row.tokens >= 0 ? row.tokens : undefined;
+        const toolUses = typeof row.toolUses === 'number' ? row.toolUses : undefined;
+        const transcriptId = row.transcriptId || undefined;
+        const parentToolCallId = typeof row.parentToolCallId === 'string' && row.parentToolCallId.length > 0 ? row.parentToolCallId : undefined;
+        const frameCycle = cycleOf(row);
+        const currentTool = currentToolKeyOf(row.currentTool) !== undefined ? row.currentTool : undefined;
+        const currentToolKey = currentToolKeyOf(row.currentTool);
+        const prev = seen.get(taskId);
+        const prevCycle = prev !== undefined ? (d.rec(taskId)?.cycle ?? {}) : undefined;
+        const order = prev !== undefined ? cycleOrder(frameCycle, prevCycle) : 'unknown';
+        if (order === 'before')
+            continue;
+        const rowNewer = order === 'after';
+        const sameCycle = prev !== undefined && !prev.settled && (order === 'same' || order === 'unknown');
+        const knownTokens = tokens !== undefined ? tokens : sameCycle ? prev?.tokens : undefined;
+        const known = carryCycle(frameCycle, prevCycle, prev !== undefined && !rowNewer);
+        const knownFields = {
+            ...(known.startedAt !== undefined ? { startedAt: known.startedAt } : {}),
+            ...(known.cycleSeq !== undefined ? { cycleSeq: known.cycleSeq } : {}),
+        };
+        const base = {
+            kind: 'fleet-row',
+            taskId,
+            ...(row.name ? { name: row.name } : {}),
+            ...(row.description ? { description: row.description } : {}),
+            ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
+            ...(toolUses !== undefined ? { toolUses } : {}),
+            ...(transcriptId !== undefined ? { transcriptId } : {}),
+            ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+            ...knownFields,
+        };
+        if (isSdkFleetTaskTerminal(status)) {
+            const wireEnded = transcriptId !== undefined ? d.rec(transcriptId)?.ended : undefined;
+            const endedViaWire = wireEnded !== undefined && cycleOrder(wireEnded, frameCycle) !== 'before';
+            const newbornTerminal = prev === undefined && panelRowUnknownToConsumer(d, taskId) && !endedViaWire;
+            const settledThisCycle = prev?.settled === true && !rowNewer;
+            const endedRec = prev === undefined ? d.rec(taskId)?.ended : undefined;
+            if (endedRec !== undefined && cycleOrder(frameCycle, endedRec) === 'before')
+                continue;
+            const endedSameCycle = endedRec !== undefined && cycleOrder(endedRec, frameCycle) !== 'before';
+            if (newbornTerminal) {
+                d.put(taskId, { held: base });
+            }
+            else if (!settledThisCycle) {
+                if (rowNewer ||
+                    cycleKeysChanged(prevCycle, frameCycle) ||
+                    (tokens !== undefined && prev?.tokens !== tokens) ||
+                    (toolUses !== undefined && prev?.toolUses !== toolUses) ||
+                    (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
+                    (parentToolCallId !== undefined && prev?.parentToolCallId !== parentToolCallId)) {
+                    publish(d, base);
+                }
+                if (!endedSameCycle)
+                    publish(d, panelEndFact(taskId, isSdkFleetTaskTerminalNotSuccess(status), known));
+            }
+            d.put(taskId, { cycle: cycleEmpty(known) ? undefined : known });
+            seen.set(taskId, {
+                status,
+                tokens: knownTokens,
+                toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
+                transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
+                parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
+                currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
+                lastSeenAt: nowMs,
+                settled: true,
+                settledAtMs: prev?.settled ? prev.settledAtMs : nowMs,
+                absentReportedAtMs: undefined,
+            });
+            continue;
+        }
+        if (prev !== undefined && prev.settled && order === 'same' && d.rec(taskId)?.held !== undefined)
+            continue;
+        if (!prev ||
+            prev.settled ||
+            prev.absentReportedAtMs !== undefined ||
+            prev.status !== status ||
+            prev.tokens !== knownTokens ||
+            (toolUses !== undefined && prev.toolUses !== toolUses) ||
+            (transcriptId !== undefined && prev.transcriptId !== transcriptId) ||
+            (parentToolCallId !== undefined && prev.parentToolCallId !== parentToolCallId) ||
+            cycleKeysChanged(prevCycle, frameCycle) ||
+            (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
+            notePanelRowRunning(d, taskId);
+            d.put(taskId, { held: undefined });
+            publish(d, { ...base, ...(currentTool !== undefined ? { currentTool } : {}) });
+        }
+        d.put(taskId, { cycle: cycleEmpty(known) ? undefined : known });
+        seen.set(taskId, {
+            status,
+            tokens: knownTokens,
+            toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
+            transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
+            parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
+            currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
+            lastSeenAt: nowMs,
+            settled: false,
+            settledAtMs: undefined,
+            absentReportedAtMs: undefined,
+        });
+    }
+    for (const [taskId, s] of [...seen.entries()]) {
+        if (present.has(taskId) || s.settled || s.absentReportedAtMs !== undefined)
+            continue;
+        const absentForMs = nowMs - s.lastSeenAt;
+        if (absentForMs <= ABSENT_SETTLE_MS)
+            continue;
+        publishAbsence(d, { taskId, lastSeenAtMs: s.lastSeenAt, absentForMs });
+        seen.set(taskId, { ...s, absentReportedAtMs: nowMs });
+    }
+    for (const [taskId, s] of [...seen.entries()]) {
+        if (present.has(taskId))
+            continue;
+        if (s.settled) {
+            const settledAt = s.settledAtMs ?? s.lastSeenAt;
+            if (nowMs - settledAt > SETTLED_RETENTION_MS)
+                seen.delete(taskId);
+        }
+        else if (s.absentReportedAtMs !== undefined && nowMs - s.absentReportedAtMs > SETTLED_RETENTION_MS) {
+            seen.delete(taskId);
+        }
+    }
+    d.putSession(sessionKey, seen);
+}
+export function stepPanelFrame(state, frame) {
+    const d = new Step(impl(state));
+    switch (frame.kind) {
+        case 'tick':
+        case 'fleet-row':
+        case 'end':
+        case 'sweep':
+            publish(d, frame);
+            break;
+        case 'fleet-rows':
+            project(d, frame.sessionKey, frame.rows, frame.nowMs);
+            break;
+        case 'fleet-rows-reset':
+            d.dropSessions(frame.sessionKey);
+            if (frame.sessionKey === undefined) {
+                for (const [k, r] of [...d.records.entries()]) {
+                    if (r.running !== undefined || r.ended !== undefined || r.held !== undefined)
+                        d.put(k, { running: undefined, ended: undefined, held: undefined });
+                }
+                d.overflowed = false;
+            }
+            break;
+        case 'absence':
+            publishAbsence(d, frame.absence);
+            break;
+        case 'resident':
+            d.put(frame.taskId, { resident: frame.resident ? true : undefined });
+            break;
+        case 'resident-clear-wire':
+            clearResidentByWire(d, frame.taskId, frame.cycle);
+            break;
+        case 'anchor':
+            if (frame.taskId && frame.transcriptId)
+                d.put(anchorKeyOf(d, frame.taskId), { anchor: frame.transcriptId });
+            break;
+    }
+    boundFields(d);
+    return { state: d.freeze(), deltas: d.deltas, facts: d.facts };
+}
+export function reducePanelFrame(state, frame) {
+    const r = stepPanelFrame(state, frame);
+    return { state: r.state, deltas: r.deltas };
+}
+export function panelRowSnapshot(state) {
+    const out = [];
+    for (const [key, r] of impl(state).records.entries()) {
+        const row = r.row;
+        if (row === undefined || !row.announced)
+            continue;
+        out.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...row.fields } });
+        const u = usageDelta(key, undefined, row.totalTokens, row.toolUses);
+        if (u !== undefined)
+            out.push(u);
+        if (row.phase === 'ended')
+            out.push(terminalDelta(key, row.isError === true, row.report, row.cause ?? 'end'));
+    }
+    return out;
+}
+export function panelResolveTaskId(state, wireTaskId, parentToolCallId) {
+    const s = impl(state);
+    const byT = s.alias.get(`t:${wireTaskId}`);
+    if (byT !== undefined)
+        return identityOf(byT);
+    const byP = parentToolCallId !== undefined ? s.alias.get(`p:${parentToolCallId}`) : undefined;
+    if (byP !== undefined)
+        return identityOf(byP);
+    return { taskId: wireTaskId, origin: 'wire' };
+}
+export function panelIsResident(state, taskId) {
+    return impl(state).records.get(taskId)?.resident === true;
+}
+function anchorKeyOf(d, taskId) {
+    const o = d.rec(taskId)?.ownedBy;
+    return o !== undefined && !o.retired ? o.wireId : taskId;
+}
+export function panelAnchorOf(state, taskId) {
+    const recs = impl(state).records;
+    const own = recs.get(taskId);
+    if (own?.anchor !== undefined)
+        return own.anchor;
+    return own?.ownedBy !== undefined ? recs.get(own.ownedBy.wireId)?.anchor : undefined;
+}
+export function panelPresenceSize(state, sessionKey) {
+    return impl(state).sessions.get(sessionKey)?.size ?? 0;
+}
+export function panelClearIdentity(state) {
+    const d = new Step(impl(state));
+    for (const [k] of [...d.alias.entries()])
+        d.alias.delete(k);
+    d.counts.alias = { t: 0, p: 0, w: 0 };
+    for (const [k] of [...d.pending.entries()])
+        d.pending.delete(k);
+    for (const [k, r] of [...d.records.entries()]) {
+        if (r.cycle !== undefined || r.wire !== undefined || r.ownedBy !== undefined)
+            d.put(k, { cycle: undefined, wire: undefined, ownedBy: undefined });
+    }
+    return d.freeze();
+}
+export function panelClearAnchors(state) {
+    const d = new Step(impl(state));
+    for (const [k, r] of [...d.records.entries()])
+        if (r.anchor !== undefined)
+            d.put(k, { anchor: undefined });
+    return d.freeze();
+}
+export function panelClearRows(state) {
+    const d = new Step(impl(state));
+    for (const [k, r] of [...d.records.entries()])
+        if (r.row !== undefined)
+            d.put(k, { row: undefined });
+    return d.freeze();
+}