@with-logic/elwood 0.1.0

package/dist/core/transcript/cursor-io.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bounded filesystem primitives shared by both adapters' transcript cursors.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a stat and a fixed-length forward range
+ * read that decode only to a complete UTF-8 boundary, so a cursor reads only NEW
+ * committed bytes and a full-file read never OOMs the host. Both adapters have
+ * identical forward-read semantics; Claude layers a backward baseline-tail scan on
+ * top of the same injectable byte seam (see claude/transcript/cursor-io.ts).
+ */
+export declare function byteLen(text: string): number;
+export declare function fileSize(path: string): number;
+export type RangeRead = {
+    readonly text: string;
+    readonly bytes: number;
+};
+/** The injectable read seam: returns the RAW bytes read at `[start, start+length)`. */
+export type ByteReader = (path: string, start: number, length: number) => Buffer;
+export declare const readBytes: ByteReader;
+export declare function readRange(path: string, start: number, length: number): RangeRead;
+export declare function setByteReaderForTests(reader: ByteReader): void;
+export declare function resetByteReaderForTests(): void;
+//# sourceMappingURL=cursor-io.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.d.ts","sourceRoot":"","sources":["../../../src/core/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW7C;AAED,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E,uFAAuF;AACvF,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AAiBjF,eAAO,MAAM,SAAS,EAAE,UAAgD,CAAC;AAMzE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAIhF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAE9D;AACD,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C"}

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

@@ -0,0 +1,60 @@
+/**
+ * Bounded filesystem primitives shared by both adapters' transcript cursors.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a stat and a fixed-length forward range
+ * read that decode only to a complete UTF-8 boundary, so a cursor reads only NEW
+ * committed bytes and a full-file read never OOMs the host. Both adapters have
+ * identical forward-read semantics; Claude layers a backward baseline-tail scan on
+ * top of the same injectable byte seam (see claude/transcript/cursor-io.ts).
+ */
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { errnoCode } from "../errors.js";
+import { completeUtf8Length } from "../utf8.js";
+export function byteLen(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+export function fileSize(path) {
+    // One stat, no exists-then-stat TOCTOU window: ENOENT means "no file yet" (size
+    // 0); any other error propagates to the caller's fs guard. The errno is read via
+    // `errnoCode` (object-ness narrowed first) so a thrown null/non-Error is
+    // preserved and rethrown, never replaced by a secondary TypeError (C-ERR-01).
+    try {
+        return statSync(path).size;
+    }
+    catch (error) {
+        if (errnoCode(error) === "ENOENT")
+            return 0;
+        throw error;
+    }
+}
+function realReadBytes(path, start, length) {
+    const buffer = Buffer.allocUnsafe(length);
+    const fd = openSync(path, "r");
+    try {
+        const read = readSync(fd, buffer, 0, length, start);
+        return buffer.subarray(0, read);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+// Indirection so a test can force a read failure (proving the offset is committed
+// only AFTER a successful read) or count read amplification. All range reads,
+// forward and (in Claude) backward, funnel through this ONE seam.
+let readBytesImpl = realReadBytes;
+export const readBytes = (p, s, l) => readBytesImpl(p, s, l);
+// Reads `length` bytes at `start`, decoding only to the last COMPLETE UTF-8 code
+// point (a split multibyte char is left for the next read, not corrupted). `start`
+// is always an already-committed code-point boundary, so no leading-byte fixup is
+// needed (the forward-read invariant).
+export function readRange(path, start, length) {
+    const bytes = readBytes(path, start, length);
+    const complete = completeUtf8Length(bytes);
+    return { text: bytes.toString("utf8", 0, complete), bytes: complete };
+}
+export function setByteReaderForTests(reader) {
+    readBytesImpl = reader;
+}
+export function resetByteReaderForTests() {
+    readBytesImpl = realReadBytes;
+}
+//# sourceMappingURL=cursor-io.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-io.js","sourceRoot":"","sources":["../../../src/core/transcript/cursor-io.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,UAAU,OAAO,CAAC,IAAY;IAClC,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,gFAAgF;IAChF,iFAAiF;IACjF,yEAAyE;IACzE,8EAA8E;IAC9E,IAAI,CAAC;QACH,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;IAC7B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,QAAQ;YAAE,OAAO,CAAC,CAAC;QAC5C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAOD,SAAS,aAAa,CAAC,IAAY,EAAE,KAAa,EAAE,MAAc;IAChE,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC/B,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACpD,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAClC,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,8EAA8E;AAC9E,kEAAkE;AAClE,IAAI,aAAa,GAAe,aAAa,CAAC;AAC9C,MAAM,CAAC,MAAM,SAAS,GAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEzE,iFAAiF;AACjF,mFAAmF;AACnF,kFAAkF;AAClF,uCAAuC;AACvC,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,KAAa,EAAE,MAAc;IACnE,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC3C,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AACxE,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAAkB;IACtD,aAAa,GAAG,MAAM,CAAC;AACzB,CAAC;AACD,MAAM,UAAU,uBAAuB;IACrC,aAAa,GAAG,aAAa,CAAC;AAChC,CAAC"}

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

@@ -0,0 +1,49 @@
+/**
+ * Bounded incremental reader for one transcript JSONL file, shared by both adapters.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): reads only NEW committed records in
+ * fixed-size chunks, never the whole file — a real transcript can be hundreds of MB,
+ * so a full-delta read would OOM or block the loop. A single un-terminated record is
+ * buffered only up to a bounded ceiling; a record past it is discarded through its
+ * next newline so a no-newline giant line can't OOM or re-concatenate quadratically.
+ *
+ * Both adapters share these forward-read semantics verbatim. Claude extends the base
+ * with a backward baseline-tail scan and an async `needsScan`; Codex uses it as-is.
+ */
+/** Outcome of a bounded read: the decoded text plus whether an immediate next read
+ * can make progress (canContinueNow). An incomplete UTF-8 tail leaves unread bytes
+ * yet returns false: no progress is possible until the rest of the code point lands. */
+export type ChunkRead = {
+    readonly text: string;
+    readonly canContinueNow: boolean;
+};
+/**
+ * Complete lines from a chunk, plus whether this call BEGAN a new over-length
+ * discard (`startedOversizedDrop`). This is an EDGE trigger: it is true only on the
+ * call that starts losing a fresh oversized record, and false while an already-started
+ * discard continues (including when its terminating newline is finally consumed). The
+ * emitter surfaces exactly ONE live drop warning per oversized record off this edge —
+ * never a running count.
+ */
+export type TakenLines = {
+    readonly lines: readonly string[];
+    readonly startedOversizedDrop: boolean;
+};
+/**
+ * Tracks the read position for one transcript path and performs bounded reads.
+ * A new cursor starts at the file's CURRENT end (its history is NOT replayed), so
+ * an A→B→A path switch or a resume never replays committed activity.
+ */
+export declare class BoundedTranscriptCursor {
+    readonly path: string;
+    protected offset: number;
+    private pending;
+    private discarding;
+    constructor(path: string);
+    /** Read up to `maxChunkBytes` of new content, advancing the cursor by bytes consumed. */
+    readChunk(): ChunkRead;
+    takeLines(text: string): TakenLines;
+    /** The final buffered partial line (flushed once at teardown), then cleared. */
+    drainPending(): string;
+    remainingBytes(): number;
+}
+//# sourceMappingURL=cursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/core/transcript/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH;;wFAEwF;AACxF,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CACxC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,uBAAuB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,OAAO,CAAM;IAGrB,OAAO,CAAC,UAAU,CAAS;gBAEf,IAAI,EAAE,MAAM;IAKxB,yFAAyF;IACzF,SAAS,IAAI,SAAS;IAiCtB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAoBnC,gFAAgF;IAChF,YAAY,IAAI,MAAM;IAStB,cAAc,IAAI,MAAM;CAIzB"}

package/dist/core/transcript/cursor.js

@@ -0,0 +1,100 @@
+/**
+ * Bounded incremental reader for one transcript JSONL file, shared by both adapters.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): reads only NEW committed records in
+ * fixed-size chunks, never the whole file — a real transcript can be hundreds of MB,
+ * so a full-delta read would OOM or block the loop. A single un-terminated record is
+ * buffered only up to a bounded ceiling; a record past it is discarded through its
+ * next newline so a no-newline giant line can't OOM or re-concatenate quadratically.
+ *
+ * Both adapters share these forward-read semantics verbatim. Claude extends the base
+ * with a backward baseline-tail scan and an async `needsScan`; Codex uses it as-is.
+ */
+import { byteLen, fileSize, readRange } from "./cursor-io.js";
+const maxChunkBytes = 256 * 1024; // bytes read per scan pass (a large delta streams)
+// Max bytes a single un-terminated record may buffer before it is discarded through
+// its next newline (a no-newline giant line can't OOM or re-concat quadratically).
+const maxPendingBytes = 1024 * 1024;
+/**
+ * Tracks the read position for one transcript path and performs bounded reads.
+ * A new cursor starts at the file's CURRENT end (its history is NOT replayed), so
+ * an A→B→A path switch or a resume never replays committed activity.
+ */
+export class BoundedTranscriptCursor {
+    path;
+    offset;
+    pending = "";
+    // When the current un-terminated line overflowed, discard incoming bytes up to
+    // (and including) the next newline instead of buffering them.
+    discarding = false;
+    constructor(path) {
+        this.path = path;
+        this.offset = fileSize(path);
+    }
+    /** Read up to `maxChunkBytes` of new content, advancing the cursor by bytes consumed. */
+    readChunk() {
+        const size = fileSize(this.path);
+        // Truncation restarts from 0, but the offset is COMMITTED only after the read
+        // succeeds, so a truncate-then-read throw doesn't replay already-emitted data.
+        // The buffered partial line and any in-progress oversized discard belonged to
+        // the OLD file, so both reset with the cursor.
+        if (size < this.offset) {
+            this.pending = "";
+            this.discarding = false;
+        }
+        const from = size < this.offset ? 0 : this.offset;
+        if (size <= from) {
+            this.offset = from;
+            return { text: "", canContinueNow: false };
+        }
+        const want = Math.min(maxChunkBytes, size - from);
+        const { text, bytes } = readRange(this.path, from, want);
+        // Advance by bytes actually consumed (a split code point waits), no drift.
+        this.offset = from + bytes;
+        // A read that consumed ZERO bytes (the window is entirely an incomplete UTF-8
+        // sequence — a partial write at EOF) made no progress: report canContinueNow:false
+        // so the scan/drain loop stops this pass instead of spinning on the same bytes.
+        // The next tick re-reads once the rest of the code point is committed.
+        const advanced = bytes > 0;
+        return { text, canContinueNow: advanced && this.offset < size };
+    }
+    // Split buffered text into complete lines, retaining any trailing partial. A
+    // record past `maxPendingBytes` with no newline is discarded through its next
+    // newline so it can't OOM or re-concat quadratically. `startedOversizedDrop`
+    // reports whether THIS call BEGAN a fresh over-length discard, so the emitter
+    // surfaces exactly one live drop warning per over-length record (a continuation
+    // is not a new drop).
+    takeLines(text) {
+        let rest = text;
+        if (this.discarding) {
+            const nl = rest.indexOf("\n");
+            // Still no newline: the same over-length record continues (not a new drop).
+            if (nl === -1)
+                return { lines: [], startedOversizedDrop: false };
+            this.discarding = false;
+            rest = rest.slice(nl + 1);
+        }
+        const lines = `${this.pending}${rest}`.split(/\r?\n/);
+        // `split` always yields at least one element, so pop() is a string here.
+        this.pending = lines.pop();
+        const startedNew = byteLen(this.pending) > maxPendingBytes;
+        if (startedNew) {
+            this.pending = ""; // over-length un-terminated record: discard it
+            this.discarding = true;
+        }
+        return { lines, startedOversizedDrop: startedNew };
+    }
+    /** The final buffered partial line (flushed once at teardown), then cleared. */
+    drainPending() {
+        const rest = this.pending;
+        this.pending = "";
+        return rest;
+    }
+    // Unread bytes still on disk past the cursor (a truncation reads as 0). Used at
+    // teardown to size the backlog left unread when the drain budget is spent, so it
+    // is accounted as a content-free drop rather than read as hundreds of MiB.
+    remainingBytes() {
+        const size = fileSize(this.path);
+        return size > this.offset ? size - this.offset : 0;
+    }
+}
+//# sourceMappingURL=cursor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../../src/core/transcript/cursor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,63 @@
+/**
+ * Content-free, live-only reporting of transcript observation problems shared by
+ * both adapters: lost committed data (drops) and contained filesystem read errors.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a malformed record, an over-length record,
+ * an unread teardown backlog, or a transient fs error is surfaced as a live warning
+ * carrying only its path and a bounded cause/error-code — never raw content, never a
+ * running count. A human at the terminal sees each problem once, live; Elwood mirrors
+ * that (no persistence, no aggregate, no cross-resume continuation).
+ *
+ * Drop DELIVERY is bounded per scan pass: a chunk can hold millions of tiny malformed
+ * lines, so emitting one warning PER line would blow the reader's per-scan work budget
+ * with synchronous listener fan-outs (PRD §9.2). Instead a pass COALESCES drops to one
+ * live warning per (path, cause) — the incident is still surfaced, but delivery is
+ * bounded regardless of how many lines dropped. The reporter is neither reset nor
+ * counted across passes, so this is not a persisted aggregate.
+ */
+import type { DropCause } from "../warnings/reasons.ts";
+export type { DropCause };
+/** A bounded, content-free notice that committed transcript data was lost. */
+export type TranscriptDropNotice = {
+    readonly elwoodSessionId: string;
+    readonly path: string;
+    /** The cause of this loss (never content): unparseable / oversized / backlog. */
+    readonly cause: DropCause;
+};
+/** A bounded, content-free notice that a transcript filesystem read failed. */
+export type TranscriptReadErrorNotice = {
+    readonly elwoodSessionId: string;
+    readonly path: string;
+    /** The error's code (e.g. "ENOENT", "EISDIR"), for diagnosis (never content). */
+    readonly lastErrorCode: string;
+};
+/**
+ * Coalesces lost records into ONE live drop warning per (path, cause) per scan pass.
+ * A pass accumulates distinct (path, cause) incidents; `flushPass()` delivers each
+ * once and clears the pass, so a chunk of a million malformed lines yields a bounded
+ * number of warning fan-outs, not a million.
+ */
+export declare class DropReporter {
+    private readonly elwoodSessionId;
+    private readonly onDrop;
+    private readonly pending;
+    constructor(elwoodSessionId: string, onDrop: ((notice: TranscriptDropNotice) => void) | undefined);
+    /** Record one unparseable committed record (coalesced until the pass flushes). */
+    record(path: string): void;
+    /** Record one lost record/backlog under `cause` (coalesced until the pass flushes). */
+    drop(path: string, cause: DropCause): void;
+    /** Deliver each coalesced (path, cause) incident once, then clear the pass. */
+    flushPass(): void;
+    /**
+     * Discard this pass's coalesced incidents WITHOUT delivering — used when the watcher
+     * finished mid-poll, so nothing is emitted past the terminal:exit latch (§5.4).
+     */
+    discardPass(): void;
+}
+/** Emits ONE live read-error warning per contained fs error for one watcher. */
+export declare class ReadErrorReporter {
+    private readonly elwoodSessionId;
+    private readonly onError;
+    constructor(elwoodSessionId: string, onError: ((notice: TranscriptReadErrorNotice) => void) | undefined);
+    record(path: string, error: unknown): void;
+}
+//# sourceMappingURL=drops.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drops.d.ts","sourceRoot":"","sources":["../../../src/core/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuD;IAM9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;gBAG3D,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS;IAM9D,kFAAkF;IAClF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI1B,uFAAuF;IACvF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;IAO1C,+EAA+E;IAC/E,SAAS,IAAI,IAAI;IAWjB;;;OAGG;IACH,WAAW,IAAI,IAAI;CAGpB;AAED,gFAAgF;AAChF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4D;gBAGlF,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,yBAAyB,KAAK,IAAI,CAAC,GAAG,SAAS;IAMpE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;CAO3C"}

package/dist/core/transcript/drops.js

@@ -0,0 +1,86 @@
+/**
+ * Content-free, live-only reporting of transcript observation problems shared by
+ * both adapters: lost committed data (drops) and contained filesystem read errors.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a malformed record, an over-length record,
+ * an unread teardown backlog, or a transient fs error is surfaced as a live warning
+ * carrying only its path and a bounded cause/error-code — never raw content, never a
+ * running count. A human at the terminal sees each problem once, live; Elwood mirrors
+ * that (no persistence, no aggregate, no cross-resume continuation).
+ *
+ * Drop DELIVERY is bounded per scan pass: a chunk can hold millions of tiny malformed
+ * lines, so emitting one warning PER line would blow the reader's per-scan work budget
+ * with synchronous listener fan-outs (PRD §9.2). Instead a pass COALESCES drops to one
+ * live warning per (path, cause) — the incident is still surfaced, but delivery is
+ * bounded regardless of how many lines dropped. The reporter is neither reset nor
+ * counted across passes, so this is not a persisted aggregate.
+ */
+/**
+ * Coalesces lost records into ONE live drop warning per (path, cause) per scan pass.
+ * A pass accumulates distinct (path, cause) incidents; `flushPass()` delivers each
+ * once and clears the pass, so a chunk of a million malformed lines yields a bounded
+ * number of warning fan-outs, not a million.
+ */
+export class DropReporter {
+    elwoodSessionId;
+    onDrop;
+    // Per-path set of distinct causes seen in the CURRENT (un-flushed) pass. Indexed by
+    // the path string ITSELF (a Map key that already exists) rather than a composite
+    // `path|cause` string: a 4 MiB chunk of tiny malformed lines re-records the same
+    // (path, cause) millions of times, and rebuilding a composite key each time would
+    // churn path-length-proportional garbage. A small cause Set per path is free to re-hit.
+    pending = new Map();
+    constructor(elwoodSessionId, onDrop) {
+        this.elwoodSessionId = elwoodSessionId;
+        this.onDrop = onDrop;
+    }
+    /** Record one unparseable committed record (coalesced until the pass flushes). */
+    record(path) {
+        this.drop(path, "unparseable");
+    }
+    /** Record one lost record/backlog under `cause` (coalesced until the pass flushes). */
+    drop(path, cause) {
+        if (this.onDrop === undefined)
+            return;
+        const causes = this.pending.get(path);
+        if (causes === undefined)
+            this.pending.set(path, new Set([cause]));
+        else
+            causes.add(cause); // Set.add is a no-op if already surfacing this (path, cause)
+    }
+    /** Deliver each coalesced (path, cause) incident once, then clear the pass. */
+    flushPass() {
+        if (this.pending.size === 0)
+            return;
+        const pending = [...this.pending];
+        this.pending.clear(); // clear FIRST so a throwing listener cannot re-fire the batch
+        for (const [path, causes] of pending) {
+            for (const cause of causes) {
+                this.onDrop?.({ elwoodSessionId: this.elwoodSessionId, path, cause });
+            }
+        }
+    }
+    /**
+     * Discard this pass's coalesced incidents WITHOUT delivering — used when the watcher
+     * finished mid-poll, so nothing is emitted past the terminal:exit latch (§5.4).
+     */
+    discardPass() {
+        this.pending.clear();
+    }
+}
+/** Emits ONE live read-error warning per contained fs error for one watcher. */
+export class ReadErrorReporter {
+    elwoodSessionId;
+    onError;
+    constructor(elwoodSessionId, onError) {
+        this.elwoodSessionId = elwoodSessionId;
+        this.onError = onError;
+    }
+    record(path, error) {
+        // `code` is only a string on a real errno; a non-string (e.g. a numeric `code`)
+        // must NOT surface as `lastErrorCode`, whose public type is a string.
+        const code = error?.code;
+        const lastErrorCode = typeof code === "string" ? code : "UNKNOWN";
+        this.onError?.({ elwoodSessionId: this.elwoodSessionId, path, lastErrorCode });
+    }
+}
+//# sourceMappingURL=drops.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drops.js","sourceRoot":"","sources":["../../../src/core/transcript/drops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAsBH;;;;;GAKG;AACH,MAAM,OAAO,YAAY;IACN,eAAe,CAAS;IACxB,MAAM,CAAuD;IAC9E,oFAAoF;IACpF,iFAAiF;IACjF,iFAAiF;IACjF,kFAAkF;IAClF,wFAAwF;IACvE,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;IAE7D,YACE,eAAuB,EACvB,MAA4D;QAE5D,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,kFAAkF;IAClF,MAAM,CAAC,IAAY;QACjB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IACjC,CAAC;IAED,uFAAuF;IACvF,IAAI,CAAC,IAAY,EAAE,KAAgB;QACjC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;;YAC9D,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,6DAA6D;IACvF,CAAC;IAED,+EAA+E;IAC/E,SAAS;QACP,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,OAAO;QACpC,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,8DAA8D;QACpF,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACrC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;CACF;AAED,gFAAgF;AAChF,MAAM,OAAO,iBAAiB;IACX,eAAe,CAAS;IACxB,OAAO,CAA4D;IAEpF,YACE,eAAuB,EACvB,OAAkE;QAElE,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,MAAM,CAAC,IAAY,EAAE,KAAc;QACjC,gFAAgF;QAChF,sEAAsE;QACtE,MAAM,IAAI,GAAI,KAAmC,EAAE,IAAI,CAAC;QACxD,MAAM,aAAa,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QAClE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;IACjF,CAAC;CACF"}

package/dist/core/transcript/warning-router.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared live-only transcript-warning router for both adapters.
+ * Implements PRD §5.4/§5.7 (C-CLAUDE-15, C-CODEX-20): a transcript diagnostic
+ * (drop, contained fs error, poll-stop) observed BEFORE the session sink exists is
+ * BUFFERED and flushed once the sink resolves — never silently dropped. Delivery
+ * clears the pending buffer FIRST, so a warning is delivered exactly once: a throwing
+ * warning/activity listener is contained and the warning is dropped, not retried — a
+ * human's terminal does not re-show a banner. `pending` is bounded to the pre-sink
+ * startup window; it can never grow under a persistently-throwing listener.
+ */
+import type { ElwoodWarningEvent } from "../types.ts";
+/** The session-side sink that emits a batch as live `warning` + `activity` events. */
+export type TranscriptWarningSink = {
+    readonly emitWarnings: (warnings: readonly ElwoodWarningEvent[]) => void;
+};
+/** The router: route a live diagnostic and flush any pre-sink buffered diagnostics. */
+export type TranscriptWarningRouter = {
+    /** Buffer a diagnostic and attempt immediate delivery (contained). */
+    readonly route: (warning: ElwoodWarningEvent) => void;
+    /** Flush diagnostics buffered before the sink existed; call once it does. */
+    readonly flushPendingWarnings: () => void;
+};
+/**
+ * Builds the router. The sink is resolved lazily because the session object is
+ * constructed AFTER the watcher, so early diagnostics are held until it exists.
+ */
+export declare function createTranscriptWarningRouter(getSink: () => TranscriptWarningSink | undefined): TranscriptWarningRouter;
+//# sourceMappingURL=warning-router.d.ts.map

package/dist/core/transcript/warning-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warning-router.d.ts","sourceRoot":"","sources":["../../../src/core/transcript/warning-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,sFAAsF;AACtF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,KAAK,IAAI,CAAC;CAC1E,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,uBAAuB,GAAG;IACpC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACtD,6EAA6E;IAC7E,QAAQ,CAAC,oBAAoB,EAAE,MAAM,IAAI,CAAC;CAC3C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,qBAAqB,GAAG,SAAS,GAC/C,uBAAuB,CAmBzB"}

package/dist/core/transcript/warning-router.js

@@ -0,0 +1,37 @@
+/**
+ * Shared live-only transcript-warning router for both adapters.
+ * Implements PRD §5.4/§5.7 (C-CLAUDE-15, C-CODEX-20): a transcript diagnostic
+ * (drop, contained fs error, poll-stop) observed BEFORE the session sink exists is
+ * BUFFERED and flushed once the sink resolves — never silently dropped. Delivery
+ * clears the pending buffer FIRST, so a warning is delivered exactly once: a throwing
+ * warning/activity listener is contained and the warning is dropped, not retried — a
+ * human's terminal does not re-show a banner. `pending` is bounded to the pre-sink
+ * startup window; it can never grow under a persistently-throwing listener.
+ */
+/**
+ * Builds the router. The sink is resolved lazily because the session object is
+ * constructed AFTER the watcher, so early diagnostics are held until it exists.
+ */
+export function createTranscriptWarningRouter(getSink) {
+    const pending = [];
+    const flushPendingWarnings = () => {
+        const sink = getSink();
+        if (!sink || pending.length === 0)
+            return;
+        const batch = pending.splice(0); // clear FIRST — delivered once, never retried
+        sink.emitWarnings(batch);
+    };
+    const route = (warning) => {
+        pending.push(warning);
+        try {
+            flushPendingWarnings();
+        }
+        catch {
+            // Contained: a throwing warning listener must not stop the poll loop (§5.4).
+            // The warning was already removed from `pending`, so it is dropped, not
+            // retried — the watcher stays live.
+        }
+    };
+    return { route, flushPendingWarnings };
+}
+//# sourceMappingURL=warning-router.js.map

package/dist/core/transcript/warning-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warning-router.js","sourceRoot":"","sources":["../../../src/core/transcript/warning-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAiBH;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAAgD;IAEhD,MAAM,OAAO,GAAyB,EAAE,CAAC;IACzC,MAAM,oBAAoB,GAAG,GAAG,EAAE;QAChC,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,8CAA8C;QAC/E,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC,CAAC;IACF,MAAM,KAAK,GAAG,CAAC,OAA2B,EAAE,EAAE;QAC5C,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtB,IAAI,CAAC;YACH,oBAAoB,EAAE,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,6EAA6E;YAC7E,wEAAwE;YACxE,oCAAoC;QACtC,CAAC;IACH,CAAC,CAAC;IACF,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAC;AACzC,CAAC"}

package/dist/core/transcript/warnings.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared builders for the bounded, content-free transcript diagnostic warnings both
+ * adapters surface: `transcript_records_dropped` and `transcript_read_error`.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a dropped record or a contained fs read
+ * error becomes ONE live typed `warning` carrying only its cause or error code and
+ * path — never raw transcript content, never a running count. The two warnings are
+ * byte-identical across adapters except the `agent` tag, so they live here.
+ */
+import type { ElwoodAgentKind } from "../activity/index.ts";
+import type { ElwoodWarningEvent } from "../types.ts";
+import type { TranscriptDropNotice, TranscriptReadErrorNotice } from "./drops.ts";
+export declare function dropWarning(agent: ElwoodAgentKind, notice: TranscriptDropNotice): ElwoodWarningEvent;
+export declare function readErrorWarning(agent: ElwoodAgentKind, notice: TranscriptReadErrorNotice): ElwoodWarningEvent;
+//# sourceMappingURL=warnings.d.ts.map

package/dist/core/transcript/warnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnings.d.ts","sourceRoot":"","sources":["../../../src/core/transcript/warnings.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AASlF,wBAAgB,WAAW,CACzB,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,oBAAoB,GAC3B,kBAAkB,CAYpB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,yBAAyB,GAChC,kBAAkB,CAYpB"}

package/dist/core/transcript/warnings.js

@@ -0,0 +1,41 @@
+/**
+ * Shared builders for the bounded, content-free transcript diagnostic warnings both
+ * adapters surface: `transcript_records_dropped` and `transcript_read_error`.
+ * Implements PRD §5.4 (C-CLAUDE-15 / §7A): a dropped record or a contained fs read
+ * error becomes ONE live typed `warning` carrying only its cause or error code and
+ * path — never raw transcript content, never a running count. The two warnings are
+ * byte-identical across adapters except the `agent` tag, so they live here.
+ */
+/** Human-readable phrase for each bounded drop cause (no raw content). */
+const causePhrase = {
+    unparseable: "an unparseable transcript record",
+    oversized: "an over-length transcript record",
+    unread_backlog: "an unread transcript backlog",
+};
+export function dropWarning(agent, notice) {
+    return {
+        elwoodSessionId: notice.elwoodSessionId,
+        agent,
+        source: "terminal",
+        code: "transcript_records_dropped",
+        severity: "warning",
+        message: `Dropped ${causePhrase[notice.cause]}.`,
+        cause: notice.cause,
+        transcriptPath: notice.path,
+        raw: `transcript_records_dropped cause=${notice.cause}`,
+    };
+}
+export function readErrorWarning(agent, notice) {
+    return {
+        elwoodSessionId: notice.elwoodSessionId,
+        agent,
+        source: "terminal",
+        code: "transcript_read_error",
+        severity: "warning",
+        message: `Contained a transcript read error (${notice.lastErrorCode}).`,
+        lastErrorCode: notice.lastErrorCode,
+        transcriptPath: notice.path,
+        raw: `transcript_read_error code=${notice.lastErrorCode}`,
+    };
+}
+//# sourceMappingURL=warnings.js.map

package/dist/core/transcript/warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnings.js","sourceRoot":"","sources":["../../../src/core/transcript/warnings.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,0EAA0E;AAC1E,MAAM,WAAW,GAAkD;IACjE,WAAW,EAAE,kCAAkC;IAC/C,SAAS,EAAE,kCAAkC;IAC7C,cAAc,EAAE,8BAA8B;CAC/C,CAAC;AAEF,MAAM,UAAU,WAAW,CACzB,KAAsB,EACtB,MAA4B;IAE5B,OAAO;QACL,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,KAAK;QACL,MAAM,EAAE,UAAU;QAClB,IAAI,EAAE,4BAA4B;QAClC,QAAQ,EAAE,SAAS;QACnB,OAAO,EAAE,WAAW,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG;QAChD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,cAAc,EAAE,MAAM,CAAC,IAAI;QAC3B,GAAG,EAAE,oCAAoC,MAAM,CAAC,KAAK,EAAE;KACxD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,KAAsB,EACtB,MAAiC;IAEjC,OAAO;QACL,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,KAAK;QACL,MAAM,EAAE,UAAU;QAClB,IAAI,EAAE,uBAAuB;QAC7B,QAAQ,EAAE,SAAS;QACnB,OAAO,EAAE,sCAAsC,MAAM,CAAC,aAAa,IAAI;QACvE,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,cAAc,EAAE,MAAM,CAAC,IAAI;QAC3B,GAAG,EAAE,8BAA8B,MAAM,CAAC,aAAa,EAAE;KAC1D,CAAC;AACJ,CAAC"}

package/dist/core/trust/blocking.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared builder for the per-agent trust blocking screen-fact rules.
+ * Implements PRD §5.1/§5.5 (C-ATTN-03): a trust prompt that stays UNANSWERED
+ * under the policy classifies as a blocking prompt. Both adapters build these
+ * rules identically, so the construction — option-aware header recognition,
+ * stable semantic ids, base-table append — lives here once instead of diverging
+ * across `claude/screen-table.ts` and `codex/screen-table.ts`.
+ */
+import type { ElwoodAgentKind } from "../activity/index.ts";
+import type { ScreenFactTable } from "../screen-facts.ts";
+/**
+ * `base` plus one `blocking_prompt_visible` rule per trust prompt that stays
+ * unanswered under `autotrust`. Each rule recognizes the prompt only by its
+ * HEADER outside the option region (`trustHeaderMatches`, the same recognizer
+ * the responder uses; the non-option text is computed once per frame and cached
+ * across the rules), so an unrelated numbered/cursor option containing a trust
+ * phrase is NOT mistaken for a blocking trust prompt (PRD §5.1). Returns `base`
+ * unchanged when no trust prompt blocks (e.g. every allowlisted prompt is
+ * auto-answered).
+ */
+export declare function withTrustBlockingRules(base: ScreenFactTable, agent: ElwoodAgentKind, autotrust: boolean): ScreenFactTable;
+//# sourceMappingURL=blocking.d.ts.map

package/dist/core/trust/blocking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocking.d.ts","sourceRoot":"","sources":["../../../src/core/trust/blocking.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI1E;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,OAAO,GACjB,eAAe,CAgBjB"}

package/dist/core/trust/blocking.js

@@ -0,0 +1,38 @@
+/**
+ * Shared builder for the per-agent trust blocking screen-fact rules.
+ * Implements PRD §5.1/§5.5 (C-ATTN-03): a trust prompt that stays UNANSWERED
+ * under the policy classifies as a blocking prompt. Both adapters build these
+ * rules identically, so the construction — option-aware header recognition,
+ * stable semantic ids, base-table append — lives here once instead of diverging
+ * across `claude/screen-table.ts` and `codex/screen-table.ts`.
+ */
+import { nonOptionText } from "../terminal-options.js";
+import { blockingTrustSpecs, trustHeaderMatches } from "./prompts.js";
+/**
+ * `base` plus one `blocking_prompt_visible` rule per trust prompt that stays
+ * unanswered under `autotrust`. Each rule recognizes the prompt only by its
+ * HEADER outside the option region (`trustHeaderMatches`, the same recognizer
+ * the responder uses; the non-option text is computed once per frame and cached
+ * across the rules), so an unrelated numbered/cursor option containing a trust
+ * phrase is NOT mistaken for a blocking trust prompt (PRD §5.1). Returns `base`
+ * unchanged when no trust prompt blocks (e.g. every allowlisted prompt is
+ * auto-answered).
+ */
+export function withTrustBlockingRules(base, agent, autotrust) {
+    let cachedFrame;
+    let cachedHeader = "";
+    const headerFor = (text) => {
+        if (text !== cachedFrame) {
+            cachedFrame = text;
+            cachedHeader = nonOptionText(text);
+        }
+        return cachedHeader;
+    };
+    const rules = blockingTrustSpecs(agent, autotrust).map((spec) => ({
+        id: `${agent}-${spec.id}-prompt`,
+        fact: "blocking_prompt_visible",
+        match: (text) => trustHeaderMatches(headerFor(text), spec),
+    }));
+    return rules.length === 0 ? base : { ...base, rules: [...base.rules, ...rules] };
+}
+//# sourceMappingURL=blocking.js.map

package/dist/core/trust/blocking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocking.js","sourceRoot":"","sources":["../../../src/core/trust/blocking.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CACpC,IAAqB,EACrB,KAAsB,EACtB,SAAkB;IAElB,IAAI,WAA+B,CAAC;IACpC,IAAI,YAAY,GAAG,EAAE,CAAC;IACtB,MAAM,SAAS,GAAG,CAAC,IAAY,EAAE,EAAE;QACjC,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACzB,WAAW,GAAG,IAAI,CAAC;YACnB,YAAY,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC,CAAC;IACF,MAAM,KAAK,GAAqB,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAClF,EAAE,EAAE,GAAG,KAAK,IAAI,IAAI,CAAC,EAAE,SAAS;QAChC,IAAI,EAAE,yBAAyB;QAC/B,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;KAC3D,CAAC,CAAC,CAAC;IACJ,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;AACnF,CAAC"}