@intentic/sandbox-contract 1.339.0 → 1.341.0

package/src/netd/generated/browser-wire.json

@@ -152,6 +152,19 @@
             "type"
           ],
           "type": "object"
+        },
+        {
+          "description": "Every binary message after this one is the pane's bytes deflated, for a browser that asked with `deflate=1` in\nthe socket's query: its unpacked length (4 bytes, big-endian), then raw deflate (RFC 1951) through a sync flush,\nall of one socket's messages one deflate stream. Sent first, before any pane bytes; a browser that never sees it\nreads binary messages as the raw bytes they always were, which is what an older netd sends whatever was asked.",
+          "properties": {
+            "type": {
+              "const": "deflate",
+              "type": "string"
+            }
+          },
+          "required": [
+            "type"
+          ],
+          "type": "object"
         }
       ],
       "title": "TerminalServerMessage"

package/src/netd/generated/browser-wire.ts

@@ -54,7 +54,7 @@ export type TerminalClientMessage = { "type": "input", data: string, } | { "type
 /**
  * What a terminal socket sends as JSON text; the pane's own bytes travel as binary messages.
  */
-export type TerminalServerMessage = { "type": "grid", cols: number, rows: number, } | { "type": "exit", code: number, reason?: string, } | { "type": "pong" };
+export type TerminalServerMessage = { "type": "grid", cols: number, rows: number, } | { "type": "exit", code: number, reason?: string, } | { "type": "pong" } | { "type": "deflate" };
 
 /**
  * Where netd's tunnel stands.

package/src/protocol/peer-dial.ts

@@ -42,8 +42,10 @@ const OPEN = 1;
 // Structural interface a browser's WebSocket, node's global one, and a test's fake all satisfy without a cast.
 export interface SocketLike {
     readonly readyState: number;
-/* `message` is here for the watchdog alone, which needs no more than the fact that one arrived. */
-    addEventListener(type: "open" | "close" | "error" | "message", listener: (event: { readonly code?: number }) => void): void;
+/* `message` is here for the watchdog alone, which needs no more than the fact that one arrived. Two signatures, so a
+   socket typing its listeners per event (ws's) satisfies it as well as one with a single listener type. */
+    addEventListener(type: "close", listener: (event: { readonly code?: number }) => void): void;
+    addEventListener(type: "open" | "error" | "message", listener: () => void): void;
     send(data: string): void;
     close(code?: number, reason?: string): void;
 }

package/src/schemas/ci.ts

@@ -164,12 +164,27 @@ export type MainFailureDecision = z.infer<typeof MainFailureDecisionSchema>;
 
 // A main-line branch while its CI fails, as the daemon's one fix agent on it sees it (ci/main-fixer.ts): from the first
 // job that failed until a later run of every workflow that failed on it passes, whatever else failed along the way.
+// One workflow failing on a main-line branch, where a push starts several (GitHub): a later run of it passing takes it
+// off the failure, so a pass of any other says nothing of it. A scheduled one (a nightly) is the case that needs
+// spelling out: a push does not run it, and the board's own runs may all pass while it still fails.
+export const CiMainFailureWorkflowSchema = z.object({
+    name: z.string().describe("The workflow, by the name the forge gives it. `ci` on a forge that runs one pipeline per commit."),
+    runId: z.number().describe("Its newest run that failed."),
+    jobs: z.array(z.string()).describe("Its jobs failing now, by name."),
+});
+export type CiMainFailureWorkflow = z.infer<typeof CiMainFailureWorkflowSchema>;
 export const CiMainFailureSchema = z.object({
     repo: z.string().describe("Which workspace repository."),
     branch: z.string().describe("Which main-line branch."),
     since: z.number().describe("When its first job failed, in milliseconds."),
     runId: z.number().describe("The newest run that failed on it."),
     jobs: z.array(z.string()).describe("The jobs failing on it now, by name: the newest failed run's failures, and any that failed since."),
+    workflows: z
+        .array(CiMainFailureWorkflowSchema)
+        .optional()
+        .describe(
+            "Each workflow failing on it, in the order they began failing, with its newest failed run and its jobs: the branch passes again only once a later run of every one of them passes. Absent from a daemon from before workflows were told apart.",
+        ),
     fixer: z
         .string()
         .optional()

package/src/schemas/git/index-run.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { CommandRunSchema } from "../ci.js";
+import { RepoParamSchema } from "../shared.js";
+import { CommitResultSchema, GitTargetSchema } from "./git.js";
+
+// Stage-all and commit-all as runs the daemon keeps, not requests held open: over a tree of tens of thousands of
+// untracked files `git add -A` alone outlives the browser's header deadline (seconds), and a request that dies there
+// leaves git running with nobody told how it ended. Modelled on the push run (PushRunSchema): started and answered at
+// once, polled for progress and verdict, one per repository, a second start of the same thing joining the first.
+
+// The guardrail's line, past which a run stops before staging and asks: a stage that size is almost always a dependency
+// or build tree nobody meant to commit. Either one trips it.
+export const INDEX_RUN_FILE_LIMIT = 2_000;
+export const INDEX_RUN_BYTE_LIMIT = 100 * 1024 * 1024;
+
+export const IndexRunOpSchema = z.enum(["stage", "commit"]);
+export type IndexRunOp = z.infer<typeof IndexRunOpSchema>;
+
+// Where a running run is, in the order it passes them; a plain commit skips counting and staging.
+// waiting: queued behind another write on the same repository (an agent's land, another commit).
+// counting: reading what the stage would take, for the guardrail.
+// staging / committing: git is running.
+// reading: re-reading the repository the commit just wrote, for the answer.
+export const IndexRunPhaseSchema = z.enum(["waiting", "counting", "staging", "committing", "reading"]);
+
+export const IndexRunDirSchema = z.object({
+    dir: z.string().describe("A top-level directory of the repository, or an empty string for the files directly at its root."),
+    files: z.number().describe("How many of the files the stage would take sit under it."),
+    bytes: z.number().optional().describe("Their combined size on disk. Absent when the run did not measure sizes, which it skips once the file count alone is over the line."),
+});
+export type IndexRunDir = z.infer<typeof IndexRunDirSchema>;
+
+// What a held run found, so the question names the directories rather than only a number.
+export const IndexRunHoldSchema = z.object({
+    files: z.number().describe("How many files the stage would take."),
+    bytes: z.number().optional().describe("Their combined size on disk, when measured."),
+    dirs: z.array(IndexRunDirSchema).describe("The largest top-level directories among them, biggest first, at most a handful."),
+});
+export type IndexRunHold = z.infer<typeof IndexRunHoldSchema>;
+
+// Flat rather than a union on `op`: the route's path parameter merges into the input, which a discriminated union cannot
+// take, and the one cross-field rule (a commit needs a message) is a refine.
+export const IndexRunStartSchema = RepoParamSchema.extend({
+    op: IndexRunOpSchema.describe("Stage, or commit (staging `target` first when given)."),
+    target: GitTargetSchema.optional().describe(
+        "What to stage. For a stage, leave it out for the whole repository. For a commit, leave it out to record the index exactly as it stands, or give an empty object to stage everything first.",
+    ),
+    message: z.string().min(1).optional().describe("The commit message. Required for a commit, refused for a stage."),
+    confirmed: z
+        .boolean()
+        .optional()
+        .describe(
+            `Go ahead past the guardrail. Without it, a stage that would take more than ${String(INDEX_RUN_FILE_LIMIT)} files or ${String(INDEX_RUN_BYTE_LIMIT / 1024 / 1024)} MB stops before touching the index and settles holding what it found, for a person to confirm.`,
+        ),
+})
+    .refine((start) => start.target === undefined || start.target.paths === undefined || start.target.scope === undefined, {
+        message: "name paths or a scope, not both",
+    })
+    .refine((start) => (start.op === "commit") === (start.message !== undefined), { message: "a commit takes a message and a stage does not" });
+export type IndexRunStart = z.infer<typeof IndexRunStartSchema>;
+
+export const IndexRunSchema = CommandRunSchema.extend({
+    id: z.string().describe("This run's own id, new on every start that did not join one already going. Empty when idle."),
+    repo: z.string().describe("The repository this run is about, the same id the routes take."),
+    op: IndexRunOpSchema.optional().describe("What was started. Absent when idle."),
+    phase: IndexRunPhaseSchema.optional().describe("Where a running run is. Absent once it settles."),
+    files: z
+        .object({
+            total: z.number().optional().describe("How many files the stage takes, once counted."),
+            done: z.number().optional().describe("How many of them are staged so far. git stages a whole repository in one go, so this jumps from 0 to the total."),
+        })
+        .optional()
+        .describe("Progress in files, where known."),
+    reason: z.string().optional().describe("Why it did not go, in git's own words where git said something."),
+    held: IndexRunHoldSchema.optional().describe(
+        "Present when the run stopped at the guardrail before touching anything (status `error`): what it would have staged. Start again with `confirmed` to go ahead.",
+    ),
+    result: CommitResultSchema.optional().describe("A commit's answer, the same one the commit call gives, once it passes."),
+});
+export type IndexRun = z.infer<typeof IndexRunSchema>;

package/src/schemas/providers/plan-limits.ts

@@ -148,6 +148,14 @@ export const ProviderRefusalSchema = z.object({
         .describe(
             "When the provider said to try again, in epoch seconds, for a spent allowance where it named one. Until then the refusal stands whatever a reading says; after it, it is over.",
         ),
+    // Codex's "To get more access now, send a request to your admin": a team's credit, which no usage endpoint reads,
+    // so a weekly pool at 57% says nothing about it (2026-10-17).
+    unmetered: z
+        .literal(true)
+        .optional()
+        .describe(
+            "Set on a spent allowance no usage reading measures, such as a credit an organisation's admin grants. No reading answers it: it stands until the provider's own reset, or until a turn is answered.",
+        ),
 });
 export type ProviderRefusal = z.infer<typeof ProviderRefusalSchema>;
 export const ProviderRefusalsSchema = z.object({

package/src/schemas/settings.ts

@@ -452,6 +452,10 @@ export const SandboxSettingsSchema = z.object({
     outagePolicy: RetryPolicySchema.default("wait").describe(
         "What happens to a turn the model provider's own failure killed. `wait` holds it for a press. `retry` re-runs it on the shared per-provider breaker, backing off between attempts. The sandbox-wide default; any one conversation can say otherwise. Worth `retry` for a sandbox whose work mostly happens with nobody in the room.",
     ),
+    // A vendor loop's hard cap on one turn; half an hour ended two Gemini children mid-work as failures (2026-10-17).
+    turnCapMinutes: z.number().int().min(5).max(1440).default(30).describe(
+        "The longest one turn may run on a loop the sandbox drives itself (OpenCode, an ACP agent, Pi, Muse) before it is ended, in minutes, however busy it keeps. A subagent's turn that reaches it is carried on in a fresh turn of the same session rather than ended as a failure. The Claude Code and Codex loops have no such cap.",
+    ),
     // The posture that used to live only in a browser tab; moving it here is what lets it fire with nothing open.
     stopPolicy: RetryPolicySchema.default("wait").describe(
         "What happens to a turn that stopped short with nothing to repair — a hung runtime, a crashed harness. `wait` holds it for a press. `retry` re-runs the held turn on a short ladder, standing down after three tries that got nowhere rather than looping forever.",

package/src/schemas/voice.ts

@@ -159,7 +159,13 @@ export const VoiceServerMessageSchema = z.discriminatedUnion("type", [
         type: z.literal("audio"),
         id: z.number(),
         sampleRate: z.number(),
-        samples: z.number().describe("How many mono s16le samples the binary frame right after this one holds."),
+        samples: z.number().describe("How many mono samples the binary frame right after this one holds, as s16le or once decoded."),
+        codec: z
+            .literal("opus")
+            .optional()
+            .describe(
+                "Absent: the frame is s16le PCM. `opus`, only for a socket opened with `codec=opus`: the frame is the chunk's Opus packets, each a big-endian 16-bit length then the packet (opusPackets), one Opus stream per utterance and sample rate.",
+            ),
     }),
     z.object({ type: z.literal("done"), id: z.number() }),
     z.object({
@@ -170,3 +176,36 @@ export const VoiceServerMessageSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("error"), id: z.number().optional(), message: z.string() }),
 ]);
 export type VoiceServerMessage = z.infer<typeof VoiceServerMessageSchema>;
+
+// Opus on the voice sockets, for a client that asks with `codec=opus` where the daemon's /events hello names it among
+// `voiceCodecs`: about a tenth of PCM's bytes (24 kbit/s for 16 kHz speech against 256, 33 for 24 kHz against 384).
+// `/speech/stream` takes one 20 ms packet per binary frame; `/speech/say` sends each chunk's packets in one frame, framed
+// by these two. A client that asks nothing is sent PCM, and an older daemon that ignores the ask sends PCM too.
+
+/** Packets as one frame: each a big-endian 16-bit length, then the packet. */
+export const framedOpus = (packets: readonly Uint8Array[]): Uint8Array<ArrayBuffer> => {
+    const frame = new Uint8Array(packets.reduce((total, packet) => total + 2 + packet.byteLength, 0));
+    const view = new DataView(frame.buffer);
+    let at = 0;
+    for (const packet of packets) {
+        view.setUint16(at, packet.byteLength);
+        frame.set(packet, at + 2);
+        at += 2 + packet.byteLength;
+    }
+    return frame;
+};
+
+/** The packets of a frame framedOpus made; a frame cut short ends at its last whole packet. */
+export const opusPackets = (frame: Uint8Array): Uint8Array[] => {
+    const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+    const packets: Uint8Array[] = [];
+    for (let at = 0; at + 2 <= frame.byteLength;) {
+        const length = view.getUint16(at);
+        if (at + 2 + length > frame.byteLength) {
+            break;
+        }
+        packets.push(frame.subarray(at + 2, at + 2 + length));
+        at += 2 + length;
+    }
+    return packets;
+};

package/src/text/packed-formats.ts

@@ -0,0 +1,17 @@
+// File formats whose bytes are already compressed (images, audio, video, archives, office documents, fonts): encoding
+// them again spends CPU and saves next to nothing. The daemon stores them as they are in a ZIP it streams, and the
+// browser sends them plain where it gzips the rest of an upload, so both read the one list here.
+
+const PACKED = new Set(
+    (
+        "7z aac apk avif br bz2 cab deb docx dmg epub flac gif gz heic heif ico jar jpeg jpg jxl lz lz4 lzma m4a m4v mkv mov mp3 mp4 mpeg mpg " +
+        "odg odp ods odt ogg ogv opus pdf png pptx rar rpm tbz tgz txz webm webp whl woff woff2 xlsx xz zip zst"
+    ).split(" "),
+);
+
+/** Whether a file of this name holds bytes that are already compressed, by its extension. */
+export const isPackedName = (name: string): boolean => {
+    const base = name.slice(name.lastIndexOf("/") + 1);
+    const dot = base.lastIndexOf(".");
+    return dot > 0 && PACKED.has(base.slice(dot + 1).toLowerCase());
+};

package/src/text/transcript-fold.ts

@@ -1,6 +1,6 @@
 import { cancelledRequests, settledRequests } from "../policy/request-status.js";
 import type { AgentEvent } from "../events/agent-events.js";
-import type { Page } from "../events/requests.js";
+import { drawInline, type InlineEvent, supersedeEarlier } from "./transcript-inline.js";
 import {
     REQUEST_FIELDS,
     holdsRequest,
@@ -16,6 +16,7 @@ import { keptWarmLine, keptWarmNotice } from "../schemas/keep-warm.js";
 import { handedOffLine, handedOffNotice } from "../schemas/providers/handoff.js";
 import { isLandConflict } from "../events/land-conflict.js";
 import { turnedAwayCode } from "../policy/turned-away.js";
+import { undeliveredRow } from "../events/undelivered.js";
 import { mentionedPathTokens } from "./mentions.js";
 import { unspokenPromptRow } from "../events/agent-words.js";
 import { needRowText } from "../events/need-wake.js";
@@ -197,15 +198,6 @@ const landedRow = (event: Extract<AgentEvent, { kind: "landed" }>): TranscriptRo
 const failureOf = (event: Extract<AgentEvent, { kind: "error" }>): { message: string; error?: string } =>
     event.code === undefined ? { message: event.message } : { message: event.message, error: event.code };
 
-// The clause after a refusal that ran nothing. A turn somebody typed is held in its conversation's queue for another
-// press; a turn that started itself — an automation, a loop, a watch wake — has no typed message and nobody watching,
-// so promising a resend there names a composer the reader is not looking at. Neither version promises a retry: whether
-// one comes is the scheduler's decision, not this row's to state.
-const undelivered = (unattended: boolean): string =>
-    unattended
-        ? `Nothing ran, and nothing is held: this run started on its own, so there is no message waiting to be sent again.`
-        : `Your message was not delivered: it is held for you to send again.`;
-
 // The press a memory hold offers: the raise rides along only when the hold carried a ceiling to size it by, since a
 // stall names none and raising one would not clear it.
 const memoryPress = (event: Extract<AgentEvent, { kind: "error" }>): "sendAnyway" | "sandboxMemory" =>
@@ -230,11 +222,7 @@ const heldRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow =
         };
     }
     if (!memory || unattended) {
-        return {
-            role: "notice",
-            text: `${event.message} ${undelivered(unattended)}`,
-            noticeCode: noticeCode({ code: "undelivered", params: { ...said, unattended: unattended || undefined } }),
-        };
+        return undeliveredRow(said, unattended);
     }
     return {
         role: "notice",
@@ -462,12 +450,9 @@ export class TranscriptFold {
                 return this.steered(event);
             case "checkpoint":
                 // Anchors the pre-turn snapshot id and this turn's transcript position on its user row, for rewind.
-                return this.stampOpener((row) => {
-                    row.checkpointId = event.id;
-                    if (event.index !== undefined) {
-                        row.rewindIndex = event.index;
-                    }
-                });
+                return this.stampOpener((row) =>
+                    Object.assign(row, { checkpointId: event.id }, event.index === undefined ? {} : { rewindIndex: event.index }),
+                );
             case "preamble":
                 // Collapses the daemon's preamble notes onto the user row; an empty note list is not a disclosure.
                 return event.notes.length === 0 ? [] : this.stampOpener((row) => (row.notes = [...event.notes]));
@@ -484,7 +469,7 @@ export class TranscriptFold {
             case "handoff":
                 return this.pushRow({ role: "notice", text: handedOffLine(event), noticeCode: noticeCode(handedOffNotice(event)) });
             case "worktree":
-                return event.sync === undefined ? [] : this.synced(event.sync);
+                return this.synced(event.sync);
             case "landed":
                 return this.pushRow(landedRow(event));
             case "compact":
@@ -553,7 +538,8 @@ export class TranscriptFold {
             case "credential_offer":
                 return this.park(event.requestId, { credentialOffer: { requestId: event.requestId, offer: event.offer, status: "pending" } });
             case "page":
-                return this.showPage(event.page);
+            case "review":
+                return this.showInline(event);
             case "page_ask":
                 return this.park(event.requestId, { pageAsk: { requestId: event.requestId, page: event.page, status: "pending" } });
             case "need":
@@ -608,20 +594,16 @@ export class TranscriptFold {
     }
 
     /**
-     * A page drawn on the bubble whose call showed it, which it then closes, as a card does: the prose after it is the
-     * next row. A redraw of a page already shown folds the earlier row to a line rather than drawing two copies.
+     * Drawn on the bubble whose call showed it (a page, a review's findings), which it then closes, as a card does: the
+     * prose after it is the next row. A redraw of one already shown folds the earlier row to a line rather than drawing
+     * two copies (transcript-inline.ts).
      */
-    private showPage(page: Page): TranscriptPatch[] {
-        const patches: TranscriptPatch[] = [];
-        const earlier = this.rows.findLastIndex((row) => row.page !== undefined && row.page.id === page.id && row.page.superseded !== true);
-        if (earlier !== -1) {
-            this.rows[earlier]!.page = { ...this.rows[earlier]!.page!, superseded: true };
-            patches.push(this.replace(earlier));
-        }
+    private showInline(event: InlineEvent): TranscriptPatch[] {
+        const earlier = supersedeEarlier(this.rows, event);
         const [index, opened] = this.open();
-        this.rows[index]!.page = page;
+        drawInline(this.rows[index]!, event);
         this.bubble = undefined;
-        return [...patches, ...opened, this.replace(index)];
+        return [...(earlier === undefined ? [] : [this.replace(earlier)]), ...opened, this.replace(index)];
     }
 
     /** A message pushed into a running turn; only a person's own message is a rewind anchor. */
@@ -910,7 +892,10 @@ export class TranscriptFold {
 
     // The rebase notice, less what a resolve turn was sent to fix: that turn opens because the branch couldn't rebase, so
     // saying so again one row under its own errand only repeats it. What did move is still told.
-    private synced(sync: { commits: number; blocked: readonly string[] }): TranscriptPatch[] {
+    private synced(sync: { commits: number; blocked: readonly string[] } | undefined): TranscriptPatch[] {
+        if (sync === undefined) {
+            return [];
+        }
         const opener = this.opener === undefined ? undefined : this.rows[this.opener];
         const told = opener !== undefined && isLandConflict(opener.text) ? { ...sync, blocked: [] } : sync;
         const text = syncLine(told);

package/src/text/transcript-inline.test.ts

@@ -0,0 +1,43 @@
+import type { AgentEvent } from "../events/agent-events.js";
+import type { Page } from "../events/requests.js";
+import type { ReviewFindings } from "../events/review.js";
+import { foldTurn, userRow } from "./transcript-fold.js";
+
+// path-literals: content, a page's stored path and a finding's file as transcript rows carry them
+const PAGE: Page = { id: "p1", title: "Q3 revenue", path: ".intentic/records/artifacts/pages/c1/p1.r0.html" };
+const REVIEW: ReviewFindings = {
+    id: "review-1",
+    source: "claude",
+    level: "high",
+    findings: [{ file: "src/parse.ts", line: 12, summary: "Off-by-one drops the last token.", verdict: "CONFIRMED" }],
+};
+
+const fold = (events: readonly AgentEvent[]) => foldTurn([userRow("/code-review high", 1, [])], events).slice(1);
+
+describe("a review in the fold", () => {
+    it("draws the findings on the bubble that reported them, and starts the next words below", () => {
+        const rows = fold([
+            { kind: "tool_call", id: "t1", name: "ReportFindings", category: "other", status: "in_progress" },
+            { kind: "review", review: REVIEW },
+            { kind: "delta", text: "One finding." },
+        ]);
+        expect(rows).toHaveLength(2);
+        expect(rows[0]?.review).toEqual(REVIEW);
+        expect(rows[1]).toEqual({ role: "assistant", text: "One finding." });
+    });
+
+    // The skill re-reports the same findings once it has fixed them: the card is redrawn, not drawn twice.
+    it("folds the earlier card away when the same review is re-reported with its outcomes", () => {
+        const fixed: ReviewFindings = { ...REVIEW, findings: REVIEW.findings.map((finding) => ({ ...finding, outcome: "fixed" as const })) };
+        const rows = fold([{ kind: "review", review: REVIEW }, { kind: "delta", text: "Fixing." }, { kind: "text_end" }, { kind: "review", review: fixed }]);
+        expect(rows[0]?.review?.superseded).toBe(true);
+        expect(rows.at(-1)?.review).toEqual(fixed);
+    });
+
+    // A page and a review share the redraw rule by id, never each other's rows.
+    it("keeps a page and a review that share an id apart", () => {
+        const rows = fold([{ kind: "page", page: PAGE }, { kind: "review", review: { ...REVIEW, id: PAGE.id } }]);
+        expect(rows[0]?.page?.superseded).toBeUndefined();
+        expect(rows[1]?.review?.id).toBe(PAGE.id);
+    });
+});

package/src/text/transcript-inline.ts

@@ -0,0 +1,38 @@
+import type { AgentEvent } from "../events/agent-events.js";
+import type { TranscriptRow } from "../events/transcript.js";
+
+// What the chat draws inline, on the bubble that showed it, rather than as a card that waits for an answer: a page the
+// agent showed (show_page) and a code review's findings. Each has an id, and one shown again under its id is a redraw
+// (a page redrawn, a review re-reported with its fixes applied), so the earlier row folds to a line.
+
+export type InlineEvent = Extract<AgentEvent, { kind: "page" | "review" }>;
+
+const drawnOf = (row: TranscriptRow, kind: InlineEvent["kind"]): { readonly id: string; readonly superseded?: boolean | undefined } | undefined =>
+    kind === "page" ? row.page : row.review;
+
+// The latest row still drawing this one in full, folded now that its redraw stands below; undefined when none does.
+export const supersedeEarlier = (rows: TranscriptRow[], event: InlineEvent): number | undefined => {
+    const id = event.kind === "page" ? event.page.id : event.review.id;
+    const index = rows.findLastIndex((row) => {
+        const drawn = drawnOf(row, event.kind);
+        return drawn !== undefined && drawn.id === id && drawn.superseded !== true;
+    });
+    const row = rows[index];
+    if (row === undefined) {
+        return undefined;
+    }
+    if (event.kind === "page" && row.page !== undefined) {
+        row.page = { ...row.page, superseded: true };
+    } else if (event.kind === "review" && row.review !== undefined) {
+        row.review = { ...row.review, superseded: true };
+    }
+    return index;
+};
+
+export const drawInline = (row: TranscriptRow, event: InlineEvent): void => {
+    if (event.kind === "page") {
+        row.page = event.page;
+    } else {
+        row.review = event.review;
+    }
+};