@agentshouse/mdruntime-adapter 0.1.0-cf9ab9b7cbbca → 0.1.0-cfd2dc1938a2c

package/dist/stream.js

@@ -1,117 +1,129 @@
-import { acceptedMessage } from './actions.js';
-import { sha256Hex } from './digest.js';
-import { binaryFileOf, headChange, identities } from './read.js';
-import { roomVersion } from './version.js';
-const HELD_FRAMES_MAX = 256;
+import { ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
+import { acceptedMessage, cursorPosition, houseHistory } from './history.js';
+import { keptSpaceSchemas, streamedModels } from './model.js';
+import { answered, answering, binaryFileOf, createdOf, folded, forgotten, headChange, revised, } from './read.js';
+import { classifyDoor } from './refusal.js';
+import { houseDoorRoute, } from './transport.js';
+import { DECIMAL, logPosition, presented, roomVersion } from './version.js';
 function turnOperation(frame) {
     const { type: _type, conversation_id: _conversation, turn_id: _turn, ...operation } = frame;
     return structuredClone(operation);
 }
+async function houseAgents(transport) {
+    const answer = await transport.door(houseDoorRoute('agents/list'), {});
+    if (classifyDoor(answer.status, answer.body, 'agents/list')?.kind === 'transport-uncertainty') {
+        throw new Error('agents/list reached no answer');
+    }
+    const agents = answer.status === 200 ? answer.body?.agents : null;
+    if (!Array.isArray(agents))
+        return null;
+    return agents.flatMap((one) => {
+        const { id, name, retired_at: retired } = (one ?? {});
+        return typeof id === 'string' && typeof name === 'string'
+            ? [{ agent: id, name, retired: retired !== null && retired !== undefined }]
+            : [];
+    });
+}
 function listedConversation(listed) {
     return {
         conversation: listed.conversation_id,
         agent: listed.agent_id,
+        agentName: listed.agent_name,
+        agentRetired: listed.agent_retired,
         name: listed.name,
         created: listed.created_at,
         finished: listed.finished_at,
         outcome: listed.outcome,
+        waiting: listed.waiting,
+        newest: listed.newest === null ? null : cursorPosition(listed.newest),
+        processEnded: listed.process_ended_at,
     };
 }
 function position(value) {
-    if (!/^(?:0|[1-9][0-9]*)$/.test(value))
+    if (!DECIMAL.test(value))
         return null;
     return BigInt(value);
 }
-function assembled(entries) {
-    const whole = [];
-    let open = null;
+function* changed(tracked, entries, version, schemas) {
+    const answer = answering();
     for (const entry of entries) {
-        if (entry.kind === 'piece') {
-            if (open === null || open.entry.path !== entry.path || entry.text === undefined)
-                return null;
-            open.texts.push(entry.text);
+        yield ROW_WEIGHT + (entry.text?.length ?? 0);
+        if (entry.kind === 'folder') {
+            folded(answer, entry.path, entry.removed === true);
+            continue;
         }
-        else {
-            if (open !== null)
-                return null;
-            if (entry.continued !== true) {
-                whole.push(entry);
-                continue;
-            }
-            if (entry.text === undefined)
-                return null;
-            open = { entry, texts: [entry.text] };
+        if (entry.path === tracked.schema)
+            schemas.set(entry.path, entry);
+        forgotten(answer, entry.path);
+        if (entry.space !== undefined) {
+            answer.removals.add(entry.path);
+            continue;
         }
-        if (entry.continued === true)
+        if (entry.kind === 'removed') {
+            answer.removals.add(entry.path);
             continue;
-        const { continued: _continued, ...head } = open.entry;
-        whole.push({ ...head, text: open.texts.join('') });
-        open = null;
-    }
-    return open === null ? whole : null;
-}
-async function verified(entries) {
-    try {
-        for (const entry of entries) {
-            if (entry.text === undefined || entry.sha256 === undefined)
-                continue;
-            if ((await sha256Hex(entry.text)) !== entry.sha256)
-                return false;
         }
-        return true;
-    }
-    catch {
-        return false;
+        const binary = binaryFileOf(entry);
+        if (binary === undefined)
+            answer.documents.set(entry.path, entry.text ?? '');
+        else if (binary !== null)
+            answer.binaryFiles.set(entry.path, binary);
+        if (binary === undefined && entry.facts !== undefined)
+            answer.facts.set(entry.path, entry.facts);
+        const revision = entry.revision ?? binary?.sha256;
+        if (revision !== undefined)
+            revised(answer, entry.path, revision);
+        const head = headChange(entry);
+        if (head)
+            answer.changes.set(entry.path, head);
+        const created = createdOf(entry);
+        if (created)
+            answer.created.set(entry.path, created);
     }
+    return { kind: 'net-advancement', roomVersion: version, ...(yield* answered(answer)) };
 }
-function resumed(kept, frame) {
-    const last = frame.entries.at(-1);
-    const point = { parts: frame.index + 1, from: frame.from, target: frame.target };
-    if (last?.continued !== true)
-        return { ...point, handled: frame.handled, piece: null };
-    const text = last.text?.length ?? 0;
-    if (last.kind !== 'piece') {
-        return last.sha256 === undefined
-            ? kept.resume
-            : { ...point, handled: frame.handled, piece: { sha256: last.sha256, offset: text } };
-    }
-    const piece = kept.resume?.piece ?? null;
-    if (piece === null)
-        return kept.resume;
-    const pieces = frame.entries.reduce((sum, entry) => sum + (entry.kind === 'piece' ? (entry.text?.length ?? 0) : 0), 0);
-    return {
-        ...point,
-        handled: frame.handled,
-        piece: { sha256: piece.sha256, offset: piece.offset + pieces },
-    };
+async function changePage(tracked, entries, version, mode, spaces, whole) {
+    const schemas = new Map();
+    const page = await stepped(changed(tracked, entries, version, schemas));
+    const models = await streamedModels(schemas, tracked, mode, spaces, whole);
+    return models === undefined ? page : { ...page, models };
 }
-export function houseNotifications(transport, mode) {
+export function houseNotifications(transport, mode, discovering, spaces) {
     const stream = transport.stream;
-    const lines = new Map();
-    const kept = new Map();
-    let receipts = null;
-    let loaded = Promise.resolve();
-    let acknowledging = null;
-    let receiving = Promise.resolve();
-    let verifying = 0;
-    const locators = new Map();
+    const staged = new Map();
+    let socket = null;
+    const tracking = new Map();
     const observers = new Set();
+    const replaying = new Map();
     const conversationObservers = new Set();
     const modeObservers = new Set();
     let replicated = [];
+    let listedCursor = null;
+    const unanswered = [];
+    const heldAtZero = new Set();
     const live = new Set();
     let opening = null;
+    let announced = null;
     const runtime = crypto.randomUUID();
     function emit(event) {
-        for (const observer of observers)
-            observer(event);
+        for (const observer of observers) {
+            const held = replaying.get(observer);
+            if (held === undefined)
+                observer(event);
+            else
+                held.push(event);
+        }
     }
     function emitConversation(event) {
         if (event.kind === 'turn' ||
             event.kind === 'questions' ||
             event.kind === 'process' ||
             event.kind === 'commands' ||
-            event.kind === 'options') {
+            event.kind === 'options' ||
+            event.kind === 'starting' ||
+            event.kind === 'subagents' ||
+            event.kind === 'link' ||
+            event.kind === 'deliveries') {
             live.add(event.conversation);
         }
         for (const observer of conversationObservers)
@@ -119,12 +131,33 @@ export function houseNotifications(transport, mode) {
     }
     function reopened(next) {
         opening = next;
-        acknowledging = next;
+        announced = null;
+        socket = next;
+        staged.clear();
+        unanswered.length = 0;
+        heldAtZero.clear();
         const gapped = new Set([...replicated, ...live]);
         live.clear();
         for (const conversation of gapped)
             emitConversation({ kind: 'gap', conversation });
         emit({ kind: 'opened' });
+        if (mode === 'site')
+            announce(next, null);
+    }
+    function announce(via, frame) {
+        void discovering.opened(frame).then((discovery) => {
+            if (socket !== via)
+                return;
+            if (discovery === null) {
+                via.close();
+                return;
+            }
+            announced = { kind: 'discovered', discovery };
+            emit(announced);
+        }, () => {
+            if (socket === via)
+                via.close();
+        });
     }
     function converse(frame) {
         const conversation = frame.conversation_id;
@@ -143,6 +176,7 @@ export function houseNotifications(transport, mode) {
                 return;
             emitConversation({ kind: 'commands', conversation, commands: [] });
             emitConversation({ kind: 'options', conversation, options: [] });
+            emitConversation({ kind: 'subagents', conversation, subagents: [] });
             return;
         }
         if (frame.type === 'commands') {
@@ -157,6 +191,26 @@ export function houseNotifications(transport, mode) {
             emitConversation({ kind: 'options', conversation, options: structuredClone(frame.options) });
             return;
         }
+        if (frame.type === 'starting') {
+            emitConversation({ kind: 'starting', conversation, step: frame.step });
+            return;
+        }
+        if (frame.type === 'subagents') {
+            emitConversation({
+                kind: 'subagents',
+                conversation,
+                subagents: structuredClone(frame.subagents),
+            });
+            return;
+        }
+        if (frame.type === 'link') {
+            emitConversation({ kind: 'link', conversation, connected: frame.connected });
+            return;
+        }
+        if (frame.type === 'deliveries') {
+            emitConversation({ kind: 'deliveries', conversation, unknown: [...frame.unknown] });
+            return;
+        }
         if (frame.type === 'interactions') {
             emitConversation({
                 kind: 'questions',
@@ -170,171 +224,31 @@ export function houseNotifications(transport, mode) {
             return;
         emitConversation({ kind: 'accepted-message', conversation, message });
     }
-    function announce(authority, at) {
-        const version = roomVersion(at);
-        for (const locator of locators.get(authority) ?? []) {
-            emit({ kind: 'room-version', locator, roomVersion: version });
-        }
-    }
-    function interrupt(authority) {
-        const line = lines.get(authority);
-        if (line !== undefined)
-            lines.set(authority, { ...line, frames: [] });
-    }
-    async function forget(carries) {
-        const held = carries.filter((carry) => kept.delete(carry));
-        if (held.length > 0)
-            await receipts?.drop(held).catch(() => { });
-    }
-    async function lost(authority, carry) {
-        interrupt(authority);
-        await forget([carry]);
-    }
-    async function stage(frame, via) {
-        await loaded;
-        const port = receipts;
-        if (port === null)
-            return;
-        const held = kept.get(frame.carry);
-        if (held === undefined && frame.index !== 0) {
-            interrupt(frame.authority);
-            return;
-        }
-        if (held !== undefined &&
-            (held.fenced !== null || frame.index > held.parts || frame.index < (held.resume?.parts ?? 0))) {
-            await lost(frame.authority, frame.carry);
+    function stage(frame, via) {
+        const held = staged.get(frame.carry);
+        if (frame.index !== (held?.parts ?? 0)) {
+            staged.delete(frame.carry);
             return;
         }
         if (held === undefined) {
-            await forget([...kept.values()]
-                .filter((other) => other.authority === frame.authority && other.fenced === null)
-                .map((other) => other.carry));
-        }
-        const start = held ?? {
-            authority: frame.authority,
-            carry: frame.carry,
-            logEpoch: lines.get(frame.authority)?.logEpoch ?? null,
-            after: frame.after,
-            parts: 0,
-            resume: null,
-            fenced: null,
-        };
-        const next = { ...start, parts: frame.index + 1, resume: resumed(start, frame) };
-        const part = { entries: frame.entries };
-        try {
-            await port.keep(frame.carry, next, { index: frame.index, value: part });
-        }
-        catch {
-            await lost(frame.authority, frame.carry);
-            return;
+            for (const [carry, other] of staged) {
+                if (other.authority === frame.authority)
+                    staged.delete(carry);
+            }
         }
-        kept.set(frame.carry, next);
+        const next = held ?? { authority: frame.authority, parts: 0, entries: [] };
+        keptSpaceSchemas(frame.entries, spaces);
+        next.entries.push(...frame.entries);
+        next.parts += 1;
+        staged.set(frame.carry, next);
         via?.received(frame.authority, frame.carry, frame.index);
     }
-    async function keptEntries(carry, parts) {
-        if (parts === 0)
-            return [];
-        if (receipts === null)
-            return null;
-        const read = (await receipts.parts(carry, parts));
-        if (read.length !== parts)
-            return null;
-        const entries = assembled(read.flatMap((part) => part.entries));
-        return entries !== null && (await verified(entries)) ? entries : null;
-    }
-    async function carried(frame) {
-        await loaded;
-        const held = kept.get(frame.carry);
-        if (frame.parts > 0 && held?.parts !== frame.parts) {
-            await lost(frame.authority, frame.carry);
-            return;
-        }
-        const entries = await keptEntries(frame.carry, frame.parts).catch(() => null);
-        if (entries === null) {
-            await lost(frame.authority, frame.carry);
-            return;
-        }
-        const fenced = {
-            ...(held ?? {
-                authority: frame.authority,
-                carry: frame.carry,
-                logEpoch: frame.log_epoch,
-                after: frame.after,
-                parts: 0,
-                resume: null,
-            }),
-            after: frame.after,
-            fenced: { position: frame.position, logEpoch: frame.log_epoch },
-        };
-        try {
-            await receipts?.keep(frame.carry, fenced);
-        }
-        catch {
-            await lost(frame.authority, frame.carry);
+    function carried(frame) {
+        const held = staged.get(frame.carry);
+        staged.delete(frame.carry);
+        if ((held?.parts ?? 0) !== frame.parts)
             return;
-        }
-        kept.set(frame.carry, fenced);
-        publish(frame, entries);
-    }
-    async function load(port) {
-        try {
-            for (const { key, head } of await port.heads())
-                kept.set(key, head);
-        }
-        catch {
-            kept.clear();
-        }
-    }
-    async function restored(room) {
-        const line = lines.get(room.authority);
-        let at = room.position;
-        const chain = [];
-        for (;;) {
-            const next = [...kept.values()].find((carry) => carry.authority === room.authority &&
-                carry.after === at &&
-                carry.fenced?.logEpoch === room.log_epoch);
-            if (next?.fenced == null)
-                break;
-            const entries = await keptEntries(next.carry, next.parts).catch(() => null);
-            if (entries === null)
-                break;
-            chain.push({ carry: next, entries });
-            at = next.fenced.position;
-        }
-        const partial = [...kept.values()].find((carry) => carry.authority === room.authority &&
-            carry.fenced === null &&
-            carry.logEpoch === room.log_epoch &&
-            carry.after === at &&
-            carry.resume !== null &&
-            carry.resume.parts > 0);
-        const stale = [...kept.values()].filter((carry) => carry.authority === room.authority &&
-            carry !== partial &&
-            !chain.some((link) => link.carry === carry));
-        await forget(stale.map((carry) => carry.carry));
-        if (line !== undefined && line.logEpoch === room.log_epoch && chain.length > 0) {
-            const frames = chain.map(({ carry, entries }) => ({
-                after: BigInt(carry.after),
-                position: BigInt(carry.fenced.position),
-                entries,
-            }));
-            lines.set(room.authority, { ...line, frames: [...line.frames, ...frames] });
-        }
-        return {
-            ...room,
-            position: at,
-            ...(partial?.resume == null
-                ? {}
-                : {
-                    carry: {
-                        id: partial.carry,
-                        parts: partial.resume.parts,
-                        from: partial.resume.from,
-                        target: partial.resume.target,
-                        handled: partial.resume.handled,
-                        ...(partial.resume.piece === null ? {} : { piece: partial.resume.piece }),
-                    },
-                }),
-        };
+        publish(frame, held?.entries ?? []);
     }
     function handle(frame, via) {
         if (frame.type === 'signal') {
@@ -346,14 +260,35 @@ export function houseNotifications(transport, mode) {
             return;
         }
         if (frame.type === 'opening') {
+            if (via !== null && mode === 'credential')
+                announce(via, frame);
+            return;
+        }
+        if (frame.type === 'caught_up') {
+            discovering.expired?.(frame.expired);
             emit({
-                kind: 'opening',
-                expired: frame.expired.flatMap((authority) => locators.get(authority) ?? []),
+                kind: 'caught-up',
+                expired: [
+                    ...frame.expired.flatMap((authority) => (tracking.get(authority) ?? []).map((tracked) => tracked.locator)),
+                    ...(unanswered.shift() ?? []),
+                ],
             });
             return;
         }
+        if (frame.type === 'authority_changed') {
+            const change = discovering.changed(frame);
+            if (change !== null)
+                emit(change);
+            return;
+        }
         if (frame.type === 'conversations') {
-            emitConversation({ kind: 'list', entries: frame.conversations.map(listedConversation) });
+            emitConversation({
+                kind: 'list',
+                entries: frame.conversations.map(listedConversation),
+                whole: frame.whole,
+                more: frame.more,
+                cursor: frame.cursor,
+            });
             return;
         }
         if (frame.type === 'conversation') {
@@ -368,63 +303,49 @@ export function houseNotifications(transport, mode) {
             frame.type === 'process' ||
             frame.type === 'commands' ||
             frame.type === 'options' ||
+            frame.type === 'starting' ||
+            frame.type === 'subagents' ||
+            frame.type === 'link' ||
+            frame.type === 'deliveries' ||
             frame.type === 'interactions' ||
             frame.type === 'message') {
             converse(frame);
             return;
         }
         if (frame.type === 'part')
-            return stage(frame, via);
-        if (frame.type === 'carried')
-            return carried(frame);
+            stage(frame, via);
+        else if (frame.type === 'carried')
+            carried(frame);
     }
     function publish(frame, entries) {
         const at = position(frame.position);
         const after = position(frame.after);
-        if (at === null || after === null || after >= at) {
-            interrupt(frame.authority);
+        if (at === null || after === null || after >= at)
             return;
-        }
-        const line = lines.get(frame.authority);
-        if (line?.logEpoch === frame.log_epoch) {
-            if (line.held !== null && at <= line.held)
-                return;
-            const last = line.frames.at(-1);
-            if (last !== undefined && at <= last.position)
-                return;
-            const held = { after, position: at, entries };
-            const next = last !== undefined && after <= last.position ? [...line.frames, held] : [held];
-            lines.set(frame.authority, { ...line, frames: next.length > HELD_FRAMES_MAX ? [] : next });
-        }
-        else {
-            interrupt(frame.authority);
-        }
-        announce(frame.authority, { position: frame.position, logEpoch: frame.log_epoch });
-    }
-    stream.observe((frame) => {
-        const via = acknowledging;
-        if (verifying === 0) {
-            const handled = handle(frame, via);
-            if (handled === undefined)
-                return;
-            verifying += 1;
-            receiving = handled.finally(() => {
-                verifying -= 1;
+        const from = after === 0n && !heldAtZero.has(frame.authority)
+            ? null
+            : roomVersion({ position: frame.after, logEpoch: frame.log_epoch });
+        const version = roomVersion({ position: frame.position, logEpoch: frame.log_epoch });
+        for (const tracked of tracking.get(frame.authority) ?? []) {
+            emit({
+                kind: 'room-change',
+                locator: tracked.locator,
+                from,
+                roomVersion: version,
+                read: () => changePage(tracked, entries, version, mode, spaces, from === null),
             });
-            return;
         }
-        verifying += 1;
-        receiving = receiving
-            .then(() => handle(frame, via))
-            .finally(() => {
-            verifying -= 1;
-        });
-    });
+    }
+    stream.observe((frame) => handle(frame, socket));
     stream.opened(reopened);
-    stream.closed(({ revoked, lost }) => {
+    stream.closed(({ revoked, lost, authorityChanged }) => {
         opening = null;
-        acknowledging = null;
-        emit({ kind: 'closed', revoked, lost });
+        announced = null;
+        socket = null;
+        staged.clear();
+        unanswered.length = 0;
+        heldAtZero.clear();
+        emit({ kind: 'closed', revoked, lost, authorityChanged });
     });
     return {
         runtime,
@@ -440,175 +361,94 @@ export function houseNotifications(transport, mode) {
             replicate(next) {
                 replicated = [...next];
             },
+            hold(cursor) {
+                listedCursor = cursor;
+            },
             observe(notify) {
                 conversationObservers.add(notify);
                 return () => {
                     conversationObservers.delete(notify);
                 };
             },
+            ...(mode === 'credential'
+                ? {
+                    agents: () => houseAgents(transport),
+                    history: (request) => houseHistory(transport, request),
+                }
+                : {}),
         },
-        observe(notify, port) {
+        observe(notify) {
             observers.add(notify);
-            if (receipts === null) {
-                receipts = port;
-                loaded = load(port);
-            }
             if (opening !== null) {
+                const replayed = [{ kind: 'opened' }];
+                if (announced !== null)
+                    replayed.push(announced);
+                replaying.set(notify, replayed);
                 queueMicrotask(() => {
-                    if (observers.has(notify))
-                        notify({ kind: 'opened' });
+                    replaying.delete(notify);
+                    for (const event of replayed)
+                        if (observers.has(notify))
+                            notify(event);
                 });
             }
             return () => {
                 observers.delete(notify);
             };
         },
-        send(rooms, demand) {
-            for (const room of rooms) {
-                const line = lines.get(room.authority);
-                const held = position(room.position);
-                if (line === undefined || held === null || line.logEpoch !== room.log_epoch)
-                    continue;
-                lines.set(room.authority, { ...line, frames: [], held });
-            }
-            const current = opening;
+        send(rooms) {
             opening = null;
-            if (current === null)
+            announced = null;
+            if (socket === null)
                 return;
-            void loaded
-                .then(() => Promise.all(rooms.map(restored)))
-                .then((presented) => {
-                current.hold(presented, runtime, demand);
-                for (const [index, room] of presented.entries()) {
-                    if (room.position === rooms[index].position)
-                        continue;
-                    announce(room.authority, { position: room.position, logEpoch: room.log_epoch });
-                }
+            const entries = new Map([...tracking.values()].flat().map((tracked) => [tracked.locator, tracked]));
+            const named = rooms.flatMap((room) => {
+                const entry = entries.get(room.locator);
+                const at = room.roomVersion === null ? null : logPosition(room.roomVersion);
+                return entry === undefined || at === null ? [] : [{ entry, at }];
             });
-        },
-        published(locator, at) {
-            const authority = [...locators].find(([, held]) => held.includes(locator))?.[0];
-            const reached = position(at.position);
-            if (authority === undefined || reached === null)
+            const unheld = rooms.flatMap((room) => {
+                const entry = entries.get(room.locator);
+                return entry === undefined || room.roomVersion !== null ? [] : [entry];
+            });
+            for (const { entry, at } of named) {
+                if (at.position === '0')
+                    heldAtZero.add(entry.authority);
+                else
+                    heldAtZero.delete(entry.authority);
+            }
+            for (const entry of unheld)
+                heldAtZero.delete(entry.authority);
+            const site = mode === 'site';
+            unanswered.push(site ? unheld.map((entry) => entry.locator) : []);
+            socket.hold([
+                ...named.map(({ entry, at }) => presented(entry.authority, at)),
+                ...(site ? [] : unheld).map((entry) => presented(entry.authority, { position: '0', logEpoch: entry.logEpoch })),
+            ], runtime, listedCursor);
+            if (site)
                 return;
-            void forget([...kept.values()]
-                .filter((carry) => carry.authority === authority &&
-                carry.fenced !== null &&
-                carry.fenced.logEpoch === at.logEpoch &&
-                BigInt(carry.fenced.position) <= reached)
-                .map((carry) => carry.carry));
-        },
-        reopen() {
-            const current = opening;
-            opening = null;
-            current?.close();
+            const made = unheld.filter((entry) => entry.position === '0');
+            queueMicrotask(() => {
+                for (const entry of made) {
+                    const version = roomVersion(entry);
+                    emit({
+                        kind: 'room-change',
+                        locator: entry.locator,
+                        from: null,
+                        roomVersion: version,
+                        read: () => changePage(entry, [], version, mode, spaces, true),
+                    });
+                }
+            });
         },
         track(entries) {
-            locators.clear();
+            tracking.clear();
             for (const entry of entries) {
-                locators.set(entry.authority, [...(locators.get(entry.authority) ?? []), entry.locator]);
-                if (lines.get(entry.authority)?.logEpoch !== entry.logEpoch) {
-                    lines.set(entry.authority, { logEpoch: entry.logEpoch, frames: [], held: null });
-                }
+                tracking.set(entry.authority, [...(tracking.get(entry.authority) ?? []), entry]);
             }
-            for (const authority of lines.keys()) {
-                if (!locators.has(authority))
-                    lines.delete(authority);
-            }
-            void loaded.then(() => forget([...kept.values()]
-                .filter((carry) => !locators.has(carry.authority))
-                .map((carry) => carry.carry)));
-        },
-        reach(authority, at) {
-            const line = lines.get(authority);
-            const held = position(at.position);
-            if (line === undefined || held === null || line.logEpoch !== at.logEpoch)
-                return;
-            if (line.held !== null && held <= line.held)
-                return;
-            lines.set(authority, {
-                ...line,
-                frames: line.frames.filter((frame) => frame.position > held),
-                held,
-            });
-        },
-        advance(tracked, from, holds) {
-            const line = lines.get(tracked.authority);
-            const start = position(from.position);
-            if (line === undefined || start === null || line.logEpoch !== from.logEpoch)
-                return null;
-            const pending = line.frames.filter((frame) => frame.position > start);
-            const first = pending[0];
-            if (first === undefined || first.after > start)
-                return null;
-            const documents = {};
-            const revisions = {};
-            const changes = {};
-            const binaryFiles = {};
-            const removals = [];
-            const applied = [];
-            const schemas = new Map();
-            const forget = (path) => {
-                delete documents[path];
-                delete revisions[path];
-                delete changes[path];
-                delete binaryFiles[path];
-                const removed = removals.indexOf(path);
-                if (removed !== -1)
-                    removals.splice(removed, 1);
-            };
-            for (const frame of pending) {
-                for (const entry of frame.entries) {
-                    if (entry.kind === 'edited' &&
-                        entry.revision !== undefined &&
-                        holds?.(entry.path, entry.revision) === true) {
-                        forget(entry.path);
-                        continue;
-                    }
-                    applied.push(entry);
-                    if (tracked.schemas.includes(entry.path))
-                        schemas.set(entry.path, entry);
-                    if (entry.kind === 'removed') {
-                        forget(entry.path);
-                        removals.push(entry.path);
-                        continue;
-                    }
-                    const binary = binaryFileOf(entry);
-                    if (binary === null || (binary === undefined && entry.text === undefined))
-                        return null;
-                    if (mode === 'credential' && entry.revision === undefined)
-                        return null;
-                    const head = headChange(entry);
-                    if (head === null)
-                        return null;
-                    forget(entry.path);
-                    if (binary === undefined)
-                        documents[entry.path] = entry.text;
-                    else
-                        binaryFiles[entry.path] = binary;
-                    const revision = entry.revision ?? binary?.sha256;
-                    if (revision !== undefined)
-                        revisions[entry.path] = revision;
-                    if (head !== undefined)
-                        changes[entry.path] = head;
-                }
+            for (const [carry, held] of staged) {
+                if (!tracking.has(held.authority))
+                    staged.delete(carry);
             }
-            const last = pending.at(-1);
-            lines.set(tracked.authority, { ...line, frames: pending, held: last.position });
-            return {
-                page: {
-                    kind: 'net-advancement',
-                    roomVersion: roomVersion({ position: last.position.toString(), logEpoch: line.logEpoch }),
-                    documents,
-                    revisions,
-                    ...identities(revisions),
-                    changes,
-                    binaryFiles,
-                    removals: removals.sort(),
-                },
-                entries: applied,
-                schemas,
-            };
         },
     };
 }