@with-logic/elwood 0.1.0

package/dist/claude/transcript/cursor-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EACL,KAAK,UAAU,EACf,OAAO,EACP,QAAQ,EACR,KAAK,SAAS,EACd,SAAS,EACT,SAAS,EACT,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC;AAE5C,sFAAsF;AACtF,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAa9E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAOzF"}

package/dist/claude/transcript/cursor-io.js

@@ -0,0 +1,44 @@
+/**
+ * Bounded filesystem primitives for the Claude transcript cursor.
+ * Implements PRD §5.4 (C-CLAUDE-15). The forward primitives (stat, forward range
+ * read, the injectable byte seam) are shared with Codex via core/transcript/cursor-io;
+ * this file adds the Claude-only BACKWARD block read used by the baseline-tail scan,
+ * funneling through the SAME shared byte seam so a test still controls all reads.
+ */
+import { readBytes } from "../../core/transcript/cursor-io.js";
+import { completeUtf8Length } from "../../core/utf8.js";
+export { byteLen, fileSize, readBytes, readRange, resetByteReaderForTests, setByteReaderForTests, } from "../../core/transcript/cursor-io.js";
+// Max continuation bytes that can lead a code point split at a block seam (a
+// 4-byte code point has at most 3 continuation bytes).
+const maxLeadingContinuation = 3;
+// Reads the block `[start, end)` for a BACKWARD scan, decoding intact even when
+// `start` splits a multibyte code point at the block seam. When `start > 0` we
+// over-read up to 3 bytes before `start` so the split code point's lead byte is
+// present, then drop only the raw leading bytes that belong to the code point
+// straddling `start` — so no U+FFFD is ever produced at the seam (C-CLAUDE-15).
+// The returned `start` is the byte offset the decoded text actually begins at,
+// which the caller uses as the next step's `end` (no double-count, no gap).
+export function readBackwardBlock(path, start, end) {
+    const over = Math.min(start, maxLeadingContinuation);
+    const readStart = start - over;
+    const bytes = readBytes(path, readStart, end - readStart);
+    const skip = over === 0 ? 0 : leadingSkip(bytes, over);
+    const complete = completeUtf8Length(bytes.subarray(skip));
+    return { text: bytes.toString("utf8", skip, skip + complete), start: readStart + skip };
+}
+// Raw bytes to drop from the front of a backward block so decoding begins on a
+// COMPLETE code point at (or after) the original `start`. `over` extra bytes were
+// prepended so any code point straddling `start` is fully present. The original
+// `start` sits at buffer index `over`; if the byte there is a UTF-8 continuation
+// byte (0b10xxxxxx), the code point began earlier and straddles the seam, so skip
+// forward past every continuation byte to the next code-point boundary (which may
+// land after `over`). Otherwise `start` already begins a code point: drop the
+// `over` pre-bytes exactly.
+function leadingSkip(bytes, over) {
+    let skip = over;
+    while (skip < bytes.length && bytes[skip] >= 0x80 && bytes[skip] < 0xc0) {
+        skip++;
+    }
+    return skip;
+}
+//# sourceMappingURL=cursor-io.js.map

package/dist/claude/transcript/cursor-io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.js","sourceRoot":"","sources":["../../../src/claude/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAEL,OAAO,EACP,QAAQ,EAER,SAAS,EACT,SAAS,EACT,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC;AAK5C,6EAA6E;AAC7E,uDAAuD;AACvD,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAEjC,gFAAgF;AAChF,+EAA+E;AAC/E,gFAAgF;AAChF,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,KAAa,EAAE,GAAW;IACxE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC;IACrD,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC;IAC/B,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1D,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,CAAC;AAC1F,CAAC;AAED,+EAA+E;AAC/E,kFAAkF;AAClF,gFAAgF;AAChF,iFAAiF;AACjF,kFAAkF;AAClF,kFAAkF;AAClF,8EAA8E;AAC9E,4BAA4B;AAC5B,SAAS,WAAW,CAAC,KAAa,EAAE,IAAY;IAC9C,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,OAAO,IAAI,GAAG,KAAK,CAAC,MAAM,IAAK,KAAK,CAAC,IAAI,CAAY,IAAI,IAAI,IAAK,KAAK,CAAC,IAAI,CAAY,GAAG,IAAI,EAAE,CAAC;QAChG,IAAI,EAAE,CAAC;IACT,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/claude/transcript/cursor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bounded, per-path incremental reader for a Claude transcript JSONL file.
+ * Implements PRD §5.4 (C-CLAUDE-15). The forward bounded-read core is shared with
+ * Codex (core/transcript/cursor); Claude extends it with a backward baseline-tail
+ * scan (recovering just the current turn already on disk) and an async `needsScan`.
+ */
+import { BoundedTranscriptCursor } from "../../core/transcript/cursor.ts";
+export type { ChunkRead, TakenLines } from "../../core/transcript/cursor.ts";
+export { resetByteReaderForTests, setByteReaderForTests } from "./cursor-io.ts";
+/**
+ * The forward bounded cursor plus Claude-only baseline-tail recovery. A new cursor
+ * starts at the file's CURRENT end (its history is NOT replayed); `baselineTail()`
+ * recovers just the current turn already-on-disk when the first hook to carry the
+ * path is a turn-boundary hook.
+ */
+export declare class TranscriptCursor extends BoundedTranscriptCursor {
+    baselineTail(): {
+        text: string;
+        truncated: boolean;
+        droppedBytes: number;
+    };
+    needsScan(): Promise<boolean>;
+}
+//# sourceMappingURL=cursor.d.ts.map

package/dist/claude/transcript/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/cursor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAI1E,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAEhF;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,uBAAuB;IAS3D,YAAY,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IAYpE,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAIpC"}

package/dist/claude/transcript/cursor.js

@@ -0,0 +1,43 @@
+/**
+ * Bounded, per-path incremental reader for a Claude transcript JSONL file.
+ * Implements PRD §5.4 (C-CLAUDE-15). The forward bounded-read core is shared with
+ * Codex (core/transcript/cursor); Claude extends it with a backward baseline-tail
+ * scan (recovering just the current turn already on disk) and an async `needsScan`.
+ */
+import { stat } from "node:fs/promises";
+import { BoundedTranscriptCursor } from "../../core/transcript/cursor.js";
+import { scanBaselineTail } from "./baseline.js";
+import { fileSize } from "./cursor-io.js";
+export { resetByteReaderForTests, setByteReaderForTests } from "./cursor-io.js";
+/**
+ * The forward bounded cursor plus Claude-only baseline-tail recovery. A new cursor
+ * starts at the file's CURRENT end (its history is NOT replayed); `baselineTail()`
+ * recovers just the current turn already-on-disk when the first hook to carry the
+ * path is a turn-boundary hook.
+ */
+export class TranscriptCursor extends BoundedTranscriptCursor {
+    // The current (final) turn already on disk (the Stop-first edge). Delegates to
+    // the bounded backward scan (`scanBaselineTail`): UTF-8-seam-safe, linear, and —
+    // when the turn is larger than the cap — recovering the in-window committed
+    // records rather than silently dropping the whole turn (§5.4, C-CLAUDE-15).
+    // Returns the joined tail text PLUS whether the scan hit its cap (`truncated`)
+    // and, if so, the bytes beyond the window that were NOT recovered — so the caller
+    // can surface that loss as a bounded, content-free drop instead of dropping it
+    // silently.
+    baselineTail() {
+        const size = fileSize(this.path);
+        const tail = scanBaselineTail(this.path, size);
+        return {
+            text: tail.lines.join("\n"),
+            truncated: tail.truncated,
+            droppedBytes: tail.unrecoveredBytes,
+        };
+    }
+    // True when the file changed size (grew OR truncated) since the last read, via
+    // an ASYNC stat so an idle poll does no sync fs work on the loop (§9.2).
+    async needsScan() {
+        const size = (await stat(this.path)).size;
+        return size !== this.offset;
+    }
+}
+//# sourceMappingURL=cursor.js.map

package/dist/claude/transcript/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../../src/claude/transcript/cursor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAEhF;;;;;GAKG;AACH,MAAM,OAAO,gBAAiB,SAAQ,uBAAuB;IAC3D,+EAA+E;IAC/E,iFAAiF;IACjF,4EAA4E;IAC5E,4EAA4E;IAC5E,+EAA+E;IAC/E,kFAAkF;IAClF,+EAA+E;IAC/E,YAAY;IACZ,YAAY;QACV,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,YAAY,EAAE,IAAI,CAAC,gBAAgB;SACpC,CAAC;IACJ,CAAC;IAED,+EAA+E;IAC/E,yEAAyE;IACzE,KAAK,CAAC,SAAS;QACb,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAC1C,OAAO,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC;IAC9B,CAAC;CACF"}

package/dist/claude/transcript/drain-context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Builds the collaborators a transcript drain needs (PRD §5.4, C-CLAUDE-15).
+ * Kept beside the watcher so the fs guard, line emitter, drop sink, and the
+ * test-injectable drain clock are assembled in exactly one place.
+ */
+import type { DrainContext } from "./drain.ts";
+import type { DropReporter } from "./drops.ts";
+import type { LineEmitter } from "./emit.ts";
+import type { TranscriptFsGuard } from "./fs-guard.ts";
+export type DrainCollaborators = {
+    readonly guard: TranscriptFsGuard;
+    readonly lines: LineEmitter;
+    readonly drops: DropReporter;
+    /** Undefined in production; drain.ts then uses `Date.now`. */
+    readonly now: (() => number) | undefined;
+};
+/**
+ * The guard's `read` is bound so the shared fs guard still contains a read
+ * failure mid-drain (the drain's `readFs` seam maps to it).
+ */
+export declare function buildDrainContext(parts: DrainCollaborators): DrainContext;
+//# sourceMappingURL=drain-context.d.ts.map

package/dist/claude/transcript/drain-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain-context.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/drain-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,GAAG,YAAY,CAOzE"}

package/dist/claude/transcript/drain-context.js

@@ -0,0 +1,18 @@
+/**
+ * Builds the collaborators a transcript drain needs (PRD §5.4, C-CLAUDE-15).
+ * Kept beside the watcher so the fs guard, line emitter, drop sink, and the
+ * test-injectable drain clock are assembled in exactly one place.
+ */
+/**
+ * The guard's `read` is bound so the shared fs guard still contains a read
+ * failure mid-drain (the drain's `readFs` seam maps to it).
+ */
+export function buildDrainContext(parts) {
+    return {
+        readFs: parts.guard.read.bind(parts.guard),
+        lines: parts.lines,
+        drops: parts.drops,
+        ...(parts.now === undefined ? {} : { now: parts.now }),
+    };
+}
+//# sourceMappingURL=drain-context.js.map

package/dist/claude/transcript/drain-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain-context.js","sourceRoot":"","sources":["../../../src/claude/transcript/drain-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAyB;IACzD,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;QAC1C,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC;KACvD,CAAC;AACJ,CAAC"}

package/dist/claude/transcript/drain.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bounded, self-yielding terminal drain for the transcript watcher (retire/finish).
+ * Implements PRD §5.4/§9.2 (C-CLAUDE-15): flushing a stopped subagent (retire) or
+ * the whole watcher at teardown (finish) shares ONE watcher-wide chunk budget
+ * across every cursor AND every call, so aggregate terminal work is watcher-
+ * bounded — a retire never gets a fresh full budget. Each call is bounded further
+ * by a small wall-clock slice, so no single call runs a hundreds-of-MiB synchronous
+ * loop that would stall the event loop. Any backlog still unread when the shared
+ * budget OR the per-call slice is spent is accounted as a content-free drop, never
+ * read in an unbounded synchronous loop, so the caller returns to the event loop
+ * promptly and termination/retirement always completes in bounded work.
+ */
+import type { TranscriptCursor } from "./cursor.ts";
+import type { DropReporter } from "./drops.ts";
+import type { LineEmitter } from "./emit.ts";
+/** A mutable chunk budget shared across every cursor drained across a watcher's life. */
+export type ChunkBudget = {
+    chunks: number;
+};
+/** One shared budget for a watcher's whole terminal-drain life (retire + finish). */
+export declare function newTerminalBudget(): ChunkBudget;
+/** The watcher collaborators a drain needs: the fs guard, emitter, and drop sink. */
+export type DrainContext = {
+    readFs<T>(path: string, read: () => T): T | undefined;
+    readonly lines: LineEmitter;
+    readonly drops: DropReporter;
+    /** Per-call wall-clock ms cap (defaults to `drainSliceMs`); tests may override. */
+    readonly sliceMs?: number;
+    /** Monotonic clock (injectable for tests); defaults to `Date.now`. */
+    readonly now?: () => number;
+};
+export declare function drainToBudget(context: DrainContext, cursors: readonly TranscriptCursor[], budget: ChunkBudget): void;
+//# sourceMappingURL=drain.d.ts.map

package/dist/claude/transcript/drain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,yFAAyF;AACzF,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAO7C,qFAAqF;AACrF,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C;AAED,qFAAqF;AACrF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B,CAAC;AAOF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,EAAE,WAAW,GAClB,IAAI,CAYN"}

package/dist/claude/transcript/drain.js

@@ -0,0 +1,56 @@
+/**
+ * Bounded, self-yielding terminal drain for the transcript watcher (retire/finish).
+ * Implements PRD §5.4/§9.2 (C-CLAUDE-15): flushing a stopped subagent (retire) or
+ * the whole watcher at teardown (finish) shares ONE watcher-wide chunk budget
+ * across every cursor AND every call, so aggregate terminal work is watcher-
+ * bounded — a retire never gets a fresh full budget. Each call is bounded further
+ * by a small wall-clock slice, so no single call runs a hundreds-of-MiB synchronous
+ * loop that would stall the event loop. Any backlog still unread when the shared
+ * budget OR the per-call slice is spent is accounted as a content-free drop, never
+ * read in an unbounded synchronous loop, so the caller returns to the event loop
+ * promptly and termination/retirement always completes in bounded work.
+ */
+/** Terminal-drain chunk budget, shared ONCE per watcher across every retire + finish. */
+const drainChunkBudget = 256;
+/** Wall-clock ms a single drain call may run before the leftover backlog is dropped. */
+const drainSliceMs = 50;
+/** One shared budget for a watcher's whole terminal-drain life (retire + finish). */
+export function newTerminalBudget() {
+    return { chunks: drainChunkBudget };
+}
+// Drain the given cursors to EOF, sharing ONE chunk budget so aggregate sync work
+// is watcher-bounded, and stopping at a per-call wall-clock deadline so no single
+// call blocks the loop for long. A cursor left with an unread backlog when the
+// budget OR the deadline is spent is accounted as a content-free drop (its size,
+// not content), and the final buffered partial is flushed once.
+export function drainToBudget(context, cursors, budget) {
+    const now = context.now ?? Date.now;
+    const deadline = now() + (context.sliceMs ?? drainSliceMs);
+    for (const cursor of cursors) {
+        const hasBacklog = drainCursor(context, cursor, budget, deadline, now);
+        // An unread teardown backlog is content-free data loss with its OWN cause
+        // ("unread_backlog"), never conflated with an unparseable record: it surfaces as
+        // ONE live drop warning under a truthful cause (C-CLAUDE-15, PRD §5.4).
+        if (hasBacklog)
+            context.drops.drop(cursor.path, "unread_backlog");
+        context.lines.emitLines(cursor.path, cursor.drainPending());
+    }
+    context.drops.flushPass(); // deliver this drain's coalesced drops (bounded fan-out)
+}
+// Read one cursor to EOF within the shared budget and the per-call deadline.
+// Returns whether bytes remained unread when the budget or the deadline was spent
+// (false when fully drained), for backlog accounting.
+function drainCursor(context, cursor, budget, deadline, now) {
+    while (budget.chunks > 0 && now() < deadline) {
+        budget.chunks -= 1;
+        const chunk = context.readFs(cursor.path, () => cursor.readChunk());
+        if (chunk === undefined)
+            return false; // contained FS failure; nothing to account
+        if (chunk.text.length > 0)
+            context.lines.emitLines(cursor.path, chunk.text, cursor);
+        if (!chunk.canContinueNow)
+            return false;
+    }
+    return (context.readFs(cursor.path, () => cursor.remainingBytes()) ?? 0) > 0;
+}
+//# sourceMappingURL=drain.js.map

package/dist/claude/transcript/drain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain.js","sourceRoot":"","sources":["../../../src/claude/transcript/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,yFAAyF;AACzF,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAC7B,wFAAwF;AACxF,MAAM,YAAY,GAAG,EAAE,CAAC;AAExB,qFAAqF;AACrF,MAAM,UAAU,iBAAiB;IAC/B,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;AACtC,CAAC;AAaD,kFAAkF;AAClF,kFAAkF;AAClF,+EAA+E;AAC/E,iFAAiF;AACjF,gEAAgE;AAChE,MAAM,UAAU,aAAa,CAC3B,OAAqB,EACrB,OAAoC,EACpC,MAAmB;IAEnB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACpC,MAAM,QAAQ,GAAG,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,CAAC;IAC3D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QACvE,0EAA0E;QAC1E,iFAAiF;QACjF,wEAAwE;QACxE,IAAI,UAAU;YAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAClE,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,yDAAyD;AACtF,CAAC;AAED,6EAA6E;AAC7E,kFAAkF;AAClF,sDAAsD;AACtD,SAAS,WAAW,CAClB,OAAqB,EACrB,MAAwB,EACxB,MAAmB,EACnB,QAAgB,EAChB,GAAiB;IAEjB,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC7C,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;QACnB,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QACpE,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,CAAC,2CAA2C;QAClF,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACpF,IAAI,CAAC,KAAK,CAAC,cAAc;YAAE,OAAO,KAAK,CAAC;IAC1C,CAAC;IACD,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC/E,CAAC"}

package/dist/claude/transcript/drops.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Content-free, live-only reporting of Claude transcript observation problems.
+ * Identical to Codex's, so it re-exports the shared core reporters (DropReporter /
+ * ReadErrorReporter) and notice types under the adapter's names. Each problem emits
+ * one live, count-free warning; nothing is accumulated. Implements PRD §5.4
+ * (C-CLAUDE-15). See core/transcript/drops.
+ */
+export { type DropCause, DropReporter, ReadErrorReporter, type TranscriptDropNotice, type TranscriptReadErrorNotice, } from "../../core/transcript/drops.ts";
+//# sourceMappingURL=drops.d.ts.map

package/dist/claude/transcript/drops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drops.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,SAAS,EACd,YAAY,EACZ,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,GAC/B,MAAM,gCAAgC,CAAC"}

package/dist/claude/transcript/drops.js

@@ -0,0 +1,9 @@
+/**
+ * Content-free, live-only reporting of Claude transcript observation problems.
+ * Identical to Codex's, so it re-exports the shared core reporters (DropReporter /
+ * ReadErrorReporter) and notice types under the adapter's names. Each problem emits
+ * one live, count-free warning; nothing is accumulated. Implements PRD §5.4
+ * (C-CLAUDE-15). See core/transcript/drops.
+ */
+export { DropReporter, ReadErrorReporter, } from "../../core/transcript/drops.js";
+//# sourceMappingURL=drops.js.map

package/dist/claude/transcript/drops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drops.js","sourceRoot":"","sources":["../../../src/claude/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAEL,YAAY,EACZ,iBAAiB,GAGlB,MAAM,gCAAgC,CAAC"}

package/dist/claude/transcript/emit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parses committed transcript lines into activity events, surfacing drops live.
+ * Implements PRD §5.4 (C-CLAUDE-15): only committed, parseable records become
+ * activity; a malformed line or a discarded over-length record is surfaced as one
+ * live drop warning, never emitted as activity.
+ */
+import type { TranscriptCursor } from "./cursor.ts";
+import type { DropReporter } from "./drops.ts";
+import { type ClaudeTranscriptSummary } from "./summary.ts";
+export type ClaudeTranscriptEvent = {
+    readonly elwoodSessionId: string;
+    readonly path: string;
+    readonly item: unknown;
+    readonly summary: ClaudeTranscriptSummary;
+};
+/** Turns raw transcript text into parsed activity events for one watcher. */
+export declare class LineEmitter {
+    private readonly elwoodSessionId;
+    private readonly emit;
+    private readonly drops;
+    constructor(id: string, emit: (event: ClaudeTranscriptEvent) => void, drops: DropReporter);
+    /** Emit complete lines from `text`; a cursor retains any trailing partial line. */
+    emitLines(path: string, text: string, cursor?: TranscriptCursor): void;
+    private emitLine;
+}
+//# sourceMappingURL=emit.d.ts.map

package/dist/claude/transcript/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/emit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,cAAc,CAAC;AAEnF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;CAC3C,CAAC;AAEF,6EAA6E;AAC7E,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,EAAE,KAAK,EAAE,YAAY;IAMzF,mFAAmF;IACnF,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAatE,OAAO,CAAC,QAAQ;CAWjB"}

package/dist/claude/transcript/emit.js

@@ -0,0 +1,57 @@
+/**
+ * Parses committed transcript lines into activity events, surfacing drops live.
+ * Implements PRD §5.4 (C-CLAUDE-15): only committed, parseable records become
+ * activity; a malformed line or a discarded over-length record is surfaced as one
+ * live drop warning, never emitted as activity.
+ */
+import { summarizeClaudeRecord } from "./summary.js";
+/** Turns raw transcript text into parsed activity events for one watcher. */
+export class LineEmitter {
+    elwoodSessionId;
+    emit;
+    drops;
+    constructor(id, emit, drops) {
+        this.elwoodSessionId = id;
+        this.emit = emit;
+        this.drops = drops;
+    }
+    /** Emit complete lines from `text`; a cursor retains any trailing partial line. */
+    emitLines(path, text, cursor) {
+        if (text.length === 0)
+            return;
+        if (!cursor) {
+            for (const line of text.split(/\r?\n/))
+                this.emitLine(path, line);
+            return;
+        }
+        const { lines, startedOversizedDrop } = cursor.takeLines(text);
+        // An over-length un-terminated record was discarded, not emitted: surface one
+        // live drop warning so the truncation is visible rather than silent (§5.4).
+        if (startedOversizedDrop)
+            this.drops.drop(path, "oversized");
+        for (const line of lines)
+            this.emitLine(path, line);
+    }
+    emitLine(path, line) {
+        if (!line.trim())
+            return;
+        const item = parseLine(line);
+        if (item === undefined) {
+            this.drops.record(path);
+            return;
+        }
+        for (const summary of summarizeClaudeRecord(item)) {
+            this.emit({ elwoodSessionId: this.elwoodSessionId, path, item, summary });
+        }
+    }
+}
+/** Returns undefined for a malformed line so the caller can report the drop. */
+function parseLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=emit.js.map

package/dist/claude/transcript/emit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.js","sourceRoot":"","sources":["../../../src/claude/transcript/emit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAgC,qBAAqB,EAAE,MAAM,cAAc,CAAC;AASnF,6EAA6E;AAC7E,MAAM,OAAO,WAAW;IACL,eAAe,CAAS;IACxB,IAAI,CAAyC;IAC7C,KAAK,CAAe;IAErC,YAAY,EAAU,EAAE,IAA4C,EAAE,KAAmB;QACvF,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,mFAAmF;IACnF,SAAS,CAAC,IAAY,EAAE,IAAY,EAAE,MAAyB;QAC7D,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAC9B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;gBAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,oBAAoB,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC/D,8EAA8E;QAC9E,4EAA4E;QAC5E,IAAI,oBAAoB;YAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC7D,KAAK,MAAM,IAAI,IAAI,KAAK;YAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACtD,CAAC;IAEO,QAAQ,CAAC,IAAY,EAAE,IAAY;QACzC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO;QACzB,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACxB,OAAO;QACT,CAAC;QACD,KAAK,MAAM,OAAO,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;YAClD,IAAI,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5E,CAAC;IACH,CAAC;CACF;AAED,gFAAgF;AAChF,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/claude/transcript/fs-guard.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Contained filesystem access for the transcript watcher.
+ * Implements PRD §5.4 (C-CLAUDE-15): a transcript read that hits a
+ * rotation/removal/permission race is contained (never crashes the timer or hook
+ * dispatch) and recorded as a bounded, content-free diagnostic so a persistent
+ * fault stays visible rather than either aborting the host or being swallowed.
+ */
+import type { ReadErrorReporter } from "./drops.ts";
+/**
+ * Wraps a synchronous or async transcript read so a thrown/rejected fs error is
+ * contained and reported as one live, content-free `transcript_read_error` warning.
+ * `isFinished` gates async reporting: a stat kicked off before finish() can reject
+ * AFTER the watcher is terminal, and reporting it then would emit activity past
+ * `terminal:exit`, breaking the permanent latch (§5.4) — so a post-finish rejection
+ * is swallowed content-free instead.
+ */
+export declare class TranscriptFsGuard {
+    private readonly readErrors;
+    private readonly isFinished;
+    constructor(readErrors: ReadErrorReporter, isFinished: () => boolean);
+    read<T>(path: string, read: () => T): T | undefined;
+    readAsync(path: string, read: () => Promise<boolean>): Promise<boolean>;
+}
+//# sourceMappingURL=fs-guard.d.ts.map

package/dist/claude/transcript/fs-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-guard.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/fs-guard.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;gBAE/B,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,OAAO;IAOpE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS;IAY7C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;CAQ9E"}

package/dist/claude/transcript/fs-guard.js

@@ -0,0 +1,48 @@
+/**
+ * Contained filesystem access for the transcript watcher.
+ * Implements PRD §5.4 (C-CLAUDE-15): a transcript read that hits a
+ * rotation/removal/permission race is contained (never crashes the timer or hook
+ * dispatch) and recorded as a bounded, content-free diagnostic so a persistent
+ * fault stays visible rather than either aborting the host or being swallowed.
+ */
+/**
+ * Wraps a synchronous or async transcript read so a thrown/rejected fs error is
+ * contained and reported as one live, content-free `transcript_read_error` warning.
+ * `isFinished` gates async reporting: a stat kicked off before finish() can reject
+ * AFTER the watcher is terminal, and reporting it then would emit activity past
+ * `terminal:exit`, breaking the permanent latch (§5.4) — so a post-finish rejection
+ * is swallowed content-free instead.
+ */
+export class TranscriptFsGuard {
+    readErrors;
+    isFinished;
+    constructor(readErrors, isFinished) {
+        this.readErrors = readErrors;
+        this.isFinished = isFinished;
+    }
+    // Contains a sync read failure (never crashes the timer/hook dispatch) and
+    // records a bounded diagnostic so a persistent fault stays visible (§5.4).
+    read(path, read) {
+        try {
+            return read();
+        }
+        catch (error) {
+            this.readErrors.record(path, error);
+            return undefined;
+        }
+    }
+    // Async twin of read: contains a rejected stat during polling. Recorded only
+    // while `!isFinished()` so a post-finish rejection cannot emit past the latch;
+    // poll()'s own post-await check still bails on the terminal case (§5.4).
+    async readAsync(path, read) {
+        try {
+            return await read();
+        }
+        catch (error) {
+            if (!this.isFinished())
+                this.readErrors.record(path, error);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=fs-guard.js.map

package/dist/claude/transcript/fs-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-guard.js","sourceRoot":"","sources":["../../../src/claude/transcript/fs-guard.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;GAOG;AACH,MAAM,OAAO,iBAAiB;IACX,UAAU,CAAoB;IAC9B,UAAU,CAAgB;IAE3C,YAAY,UAA6B,EAAE,UAAyB;QAClE,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,IAAI,CAAI,IAAY,EAAE,IAAa;QACjC,IAAI,CAAC;YACH,OAAO,IAAI,EAAE,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACpC,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,+EAA+E;IAC/E,yEAAyE;IACzE,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,IAA4B;QACxD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,EAAE,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC5D,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;CACF"}

package/dist/claude/transcript/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Best-effort live observation of Claude transcript JSONL files.
+ * Implements PRD §5.4 (C-CLAUDE-15): committed assistant text, tool calls, and
+ * tool results are sourced from the transcript(s) the CLI writes (no ghost-text);
+ * reads are bounded, per-path, no replay.
+ */
+import { type TranscriptDropNotice, type TranscriptReadErrorNotice } from "./drops.ts";
+import { type ClaudeTranscriptEvent } from "./emit.ts";
+import type { TranscriptNoticeHandlers } from "./watcher-config.ts";
+export type { TranscriptNoticeHandlers } from "./watcher-config.ts";
+export type { ClaudeTranscriptEvent, TranscriptDropNotice, TranscriptReadErrorNotice };
+export declare class ClaudeTranscriptWatcher {
+    private readonly cursors;
+    private interval;
+    private polling;
+    private finished;
+    private readonly terminalBudget;
+    private readonly drops;
+    private readonly guard;
+    private readonly onPollError;
+    private readonly pollIntervalMs;
+    private readonly lines;
+    private readonly drain;
+    private afterScanForTests;
+    setAfterScanForTests(hook: () => void): void;
+    constructor(elwoodSessionId: string, emit: (event: ClaudeTranscriptEvent) => void, notices?: TranscriptNoticeHandlers);
+    observe(path: string, recoverTail?: boolean): void;
+    scan(): void;
+    retire(path: string): void;
+    pollOnceForTests(): Promise<void>;
+    private poll;
+    finish(): void;
+    stop(): void;
+    private ensurePolling;
+    private recoverFromPollError;
+    private scanCursor;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/claude/transcript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/claude/transcript/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,qBAAqB,EAAe,MAAM,WAAW,CAAC;AAEpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,CAAC;AAMvF,qBAAa,uBAAuB;IAElC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAA6C;IAC7D,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoC;IACnE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IAGrC,OAAO,CAAC,iBAAiB,CAA2B;IAEpD,oBAAoB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;gBAK1C,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,EAC5C,OAAO,GAAE,wBAA6B;IAmBxC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,UAAQ,GAAG,IAAI;IAgBhD,IAAI,IAAI,IAAI;IAaZ,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO1B,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;YAMnB,IAAI;IA6BlB,MAAM,IAAI,IAAI;IAUd,IAAI,IAAI,IAAI;IAKZ,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,oBAAoB;IAa5B,OAAO,CAAC,UAAU;CASnB"}