@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/session-persistence-sqlite/lib/invariant.js

@@ -9,8 +9,8 @@ const name = "session-persistence-sqlite-invariant";
 /** Service required before the companion can reserve package ownership. */
 const inject = ["invariants"];
 /**
-* No runtime invariant: persistence correctness requires backend round-trip and crash-tail tests;
-* this package exposes no continuously observable in-process relation.
+* No runtime invariant: physical packing is observable only by database
+* round-trip and row-count checks, not a continuous in-process relation.
 */
 const install = () => {};
 /**

package/dist/kernel/session-persistence-sqlite/lib/types/codec.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Schema-17 physical chunk-row codec. This package owns the durable tags,
+ * validation, and row-size limits independently from other persistence formats.
+ * @module @nomix-ai/nomix-session-persistence-sqlite/codec
+ */
+import type { StreamChunk } from '../../../llm/lib/index.js';
+import type { SessionEvent } from '../../../session/lib/index.js';
+interface RunDataBase {
+    readonly turn: number;
+    readonly step: number;
+    readonly index: number;
+    readonly dt: number[];
+}
+interface TextRunData extends RunDataBase {
+    readonly texts: string[];
+}
+interface ToolCallRunData extends RunDataBase {
+    readonly id: Extract<StreamChunk, {
+        type: 'tool-call-delta';
+    }>['id'];
+    readonly name?: string;
+    readonly args: string[];
+}
+/** One schema-17 packed physical record. */
+export type ChunkRow = {
+    readonly type: 'text-chunks';
+    readonly seq0: number;
+    readonly time0: number;
+    readonly data: TextRunData;
+} | {
+    readonly type: 'reasoning-chunks';
+    readonly seq0: number;
+    readonly time0: number;
+    readonly data: TextRunData;
+} | {
+    readonly type: 'tool-call-chunks';
+    readonly seq0: number;
+    readonly time0: number;
+    readonly data: ToolCallRunData;
+};
+/** One scalar event or schema-17 packed physical record. */
+export type StorageRecord = SessionEvent | ChunkRow;
+/** Minimum eligible members in a packed physical record. */
+export declare const MIN_PACKED_ROW_MEMBERS = 3;
+/** Maximum logical members represented by one packed physical record. */
+export declare const MAX_PACKED_ROW_MEMBERS = 1024;
+/** Maximum UTF-8 bytes in one packed physical record's data column. */
+export declare const MAX_PACKED_DATA_BYTES = 1048576;
+/**
+ * Pack eligible logical chunk runs into bounded schema-17 records.
+ * @param events - logical events in sequence order.
+ * @returns scalar and packed physical records in equivalent order.
+ */
+export declare function packChunkRuns(events: readonly SessionEvent[]): StorageRecord[];
+/**
+ * Decode one scalar or packed schema-17 record.
+ * @param value - parsed physical-record value.
+ * @returns the represented logical events.
+ */
+export declare function decodeStorageRecord(value: unknown): SessionEvent[];
+/**
+ * Decode one packed row from its exact uncompressed data value. The byte bound
+ * rejects oversized input before JSON parsing and avoids serializing it again.
+ * @param tag - validated packed physical type.
+ * @param seq0 - first represented logical sequence number.
+ * @param time0 - first represented logical timestamp.
+ * @param serializedData - decoded SQLite data-column text.
+ * @returns the represented logical events.
+ */
+export declare function decodeSerializedChunkRow(tag: ChunkRow['type'], seq0: number, time0: number, serializedData: string): SessionEvent[];
+export {};
+//# sourceMappingURL=codec.d.ts.map

package/dist/kernel/session-persistence-sqlite/lib/types/codec.js

@@ -0,0 +1,304 @@
+/**
+ * Schema-17 physical chunk-row codec. This package owns the durable tags,
+ * validation, and row-size limits independently from other persistence formats.
+ * @module @nomix-ai/nomix-session-persistence-sqlite/codec
+ */
+/** Minimum eligible members in a packed physical record. */
+export const MIN_PACKED_ROW_MEMBERS = 3;
+/** Maximum logical members represented by one packed physical record. */
+export const MAX_PACKED_ROW_MEMBERS = 1_024;
+/** Maximum UTF-8 bytes in one packed physical record's data column. */
+export const MAX_PACKED_DATA_BYTES = 1_048_576;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function hasExactKeys(value, keys) {
+    return Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+}
+function classify(event) {
+    if (event.type !== 'assistant/chunk')
+        return undefined;
+    if (!hasExactKeys(event, ['type', 'seq', 'time', 'data']))
+        return undefined;
+    if (!Number.isSafeInteger(event.seq) || event.seq < 0 || !Number.isSafeInteger(event.time))
+        return undefined;
+    const data = event.data;
+    if (!isRecord(data) || !hasExactKeys(data, ['turn', 'step', 'chunk']))
+        return undefined;
+    if (typeof data.turn !== 'number' || typeof data.step !== 'number')
+        return undefined;
+    const chunk = data.chunk;
+    if (!isRecord(chunk) || typeof chunk.index !== 'number')
+        return undefined;
+    switch (chunk.type) {
+        case 'text-delta':
+        case 'reasoning-delta':
+            return hasExactKeys(chunk, ['type', 'index', 'text']) && typeof chunk.text === 'string'
+                ? chunk.type
+                : undefined;
+        case 'tool-call-delta': {
+            const validKeys = hasExactKeys(chunk, ['type', 'index', 'id', 'argumentsDelta'])
+                || (hasExactKeys(chunk, ['type', 'index', 'id', 'name', 'argumentsDelta'])
+                    && typeof chunk.name === 'string');
+            return validKeys && typeof chunk.id === 'string' && typeof chunk.argumentsDelta === 'string'
+                ? chunk.type
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function toolCallOf(event) {
+    return event.data.chunk;
+}
+function indexOf(event) {
+    return event.data.chunk.index;
+}
+function continues(previous, next, kind) {
+    if (next.seq !== previous.seq + 1 || !Number.isSafeInteger(next.time - previous.time))
+        return false;
+    if (next.data.turn !== previous.data.turn || next.data.step !== previous.data.step)
+        return false;
+    if (indexOf(next) !== indexOf(previous))
+        return false;
+    if (kind !== 'tool-call-delta')
+        return true;
+    const left = toolCallOf(previous);
+    const right = toolCallOf(next);
+    return left.id === right.id
+        && Object.hasOwn(left, 'name') === Object.hasOwn(right, 'name')
+        && left.name === right.name;
+}
+function buildRow(kind, run) {
+    const first = run[0];
+    const base = {
+        turn: first.data.turn,
+        step: first.data.step,
+        index: indexOf(first),
+        dt: run.slice(1).map((event, index) => event.time - run[index].time),
+    };
+    const envelope = { seq0: first.seq, time0: first.time };
+    if (kind === 'tool-call-delta') {
+        const call = toolCallOf(first);
+        return {
+            type: 'tool-call-chunks',
+            ...envelope,
+            data: {
+                ...base,
+                id: call.id,
+                ...Object.hasOwn(call, 'name') ? { name: call.name } : {},
+                args: run.map(event => event.data.chunk.argumentsDelta),
+            },
+        };
+    }
+    const data = {
+        ...base,
+        texts: run.map(event => event.data.chunk.text),
+    };
+    return kind === 'text-delta'
+        ? { type: 'text-chunks', ...envelope, data }
+        : { type: 'reasoning-chunks', ...envelope, data };
+}
+function packedDataBytes(row) {
+    return Buffer.byteLength(JSON.stringify(row.data));
+}
+function emitBoundedRun(out, kind, completeRun) {
+    let offset = 0;
+    while (completeRun.length - offset >= MIN_PACKED_ROW_MEMBERS) {
+        let low = MIN_PACKED_ROW_MEMBERS;
+        let high = Math.min(completeRun.length - offset, MAX_PACKED_ROW_MEMBERS);
+        const largest = buildRow(kind, completeRun.slice(offset, offset + high));
+        if (packedDataBytes(largest) <= MAX_PACKED_DATA_BYTES) {
+            out.push(largest);
+            offset += high;
+            continue;
+        }
+        high -= 1;
+        let accepted = 0;
+        let acceptedRow;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const candidate = buildRow(kind, completeRun.slice(offset, offset + middle));
+            if (packedDataBytes(candidate) <= MAX_PACKED_DATA_BYTES) {
+                accepted = middle;
+                acceptedRow = candidate;
+                low = middle + 1;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        if (accepted === 0) {
+            out.push(completeRun[offset]);
+            offset += 1;
+            continue;
+        }
+        /* v8 ignore next -- accepted is set only with its same-branch candidate. */
+        out.push(acceptedRow ?? malformed(kind, 'bounded encoder lost its accepted row'));
+        offset += accepted;
+    }
+    out.push(...completeRun.slice(offset));
+}
+/**
+ * Pack eligible logical chunk runs into bounded schema-17 records.
+ * @param events - logical events in sequence order.
+ * @returns scalar and packed physical records in equivalent order.
+ */
+export function packChunkRuns(events) {
+    const out = [];
+    let kind;
+    let run = [];
+    const flush = () => {
+        if (kind === undefined)
+            out.push(...run);
+        else
+            emitBoundedRun(out, kind, run);
+        kind = undefined;
+        run = [];
+    };
+    for (const event of events) {
+        const nextKind = classify(event);
+        if (nextKind === undefined) {
+            flush();
+            out.push(event);
+            continue;
+        }
+        const delta = event;
+        const previous = run.at(-1);
+        if (nextKind === kind && previous !== undefined && continues(previous, delta, nextKind)) {
+            run.push(delta);
+            continue;
+        }
+        flush();
+        kind = nextKind;
+        run = [delta];
+    }
+    flush();
+    return out;
+}
+function malformed(tag, reason) {
+    throw new Error(`malformed ${tag} storage row: ${reason}`);
+}
+function validateRunData(tag, data, payloadKey, serializedBytes) {
+    if (typeof data.turn !== 'number' || typeof data.step !== 'number' || typeof data.index !== 'number') {
+        malformed(tag, 'turn/step/index must be numbers');
+    }
+    const payload = data[payloadKey];
+    if (!Array.isArray(payload)
+        || payload.length < MIN_PACKED_ROW_MEMBERS
+        || payload.length > MAX_PACKED_ROW_MEMBERS
+        || payload.some(member => typeof member !== 'string')) {
+        malformed(tag, `${payloadKey} must contain ${MIN_PACKED_ROW_MEMBERS}..${MAX_PACKED_ROW_MEMBERS} strings`);
+    }
+    const gaps = data.dt;
+    if (!Array.isArray(gaps) || gaps.some(gap => !Number.isSafeInteger(gap))) {
+        malformed(tag, 'dt must be an array of safe integers');
+    }
+    if (gaps.length !== payload.length - 1)
+        malformed(tag, 'dt length must match the member count');
+    if ((serializedBytes ?? Buffer.byteLength(JSON.stringify(data))) > MAX_PACKED_DATA_BYTES) {
+        malformed(tag, `data exceeds ${MAX_PACKED_DATA_BYTES} UTF-8 bytes`);
+    }
+    return payload;
+}
+function validateRow(value, tag, serializedBytes) {
+    if (!hasExactKeys(value, ['type', 'seq0', 'time0', 'data']))
+        malformed(tag, 'invalid envelope fields');
+    if (!Number.isSafeInteger(value.seq0) || value.seq0 < 0)
+        malformed(tag, 'seq0 must be non-negative');
+    if (!Number.isSafeInteger(value.time0))
+        malformed(tag, 'time0 must be a safe integer');
+    const data = value.data;
+    if (!isRecord(data))
+        malformed(tag, 'data must be an object');
+    let payload;
+    if (tag === 'tool-call-chunks') {
+        const withName = hasExactKeys(data, ['turn', 'step', 'index', 'id', 'name', 'dt', 'args']);
+        if (!withName && !hasExactKeys(data, ['turn', 'step', 'index', 'id', 'dt', 'args'])) {
+            malformed(tag, 'invalid tool-call data fields');
+        }
+        if (typeof data.id !== 'string' || (withName && typeof data.name !== 'string')) {
+            malformed(tag, 'id and optional name must be strings');
+        }
+        payload = validateRunData(tag, data, 'args', serializedBytes);
+    }
+    else {
+        if (!hasExactKeys(data, ['turn', 'step', 'index', 'dt', 'texts']))
+            malformed(tag, 'invalid text data fields');
+        payload = validateRunData(tag, data, 'texts', serializedBytes);
+    }
+    if (!Number.isSafeInteger(value.seq0 + payload.length - 1))
+        malformed(tag, 'member seqs exceed safe integers');
+    let time = value.time0;
+    for (const gap of data.dt) {
+        time += gap;
+        if (!Number.isSafeInteger(time))
+            malformed(tag, 'member times exceed safe integers');
+    }
+    return value;
+}
+function expandRow(row) {
+    const members = row.type === 'tool-call-chunks' ? row.data.args : row.data.texts;
+    const events = [];
+    let time = row.time0;
+    for (let index = 0; index < members.length; index += 1) {
+        if (index > 0)
+            time += row.data.dt[index - 1];
+        let chunk;
+        switch (row.type) {
+            case 'text-chunks':
+                chunk = { type: 'text-delta', index: row.data.index, text: members[index] };
+                break;
+            case 'reasoning-chunks':
+                chunk = { type: 'reasoning-delta', index: row.data.index, text: members[index] };
+                break;
+            case 'tool-call-chunks':
+                chunk = {
+                    type: 'tool-call-delta',
+                    index: row.data.index,
+                    id: row.data.id,
+                    ...Object.hasOwn(row.data, 'name') ? { name: row.data.name } : {},
+                    argumentsDelta: members[index],
+                };
+                break;
+        }
+        events.push({
+            type: 'assistant/chunk',
+            seq: row.seq0 + index,
+            time,
+            data: { turn: row.data.turn, step: row.data.step, chunk },
+        });
+    }
+    return events;
+}
+/**
+ * Decode one scalar or packed schema-17 record.
+ * @param value - parsed physical-record value.
+ * @returns the represented logical events.
+ */
+export function decodeStorageRecord(value) {
+    if (!isRecord(value))
+        return [value];
+    const tag = value.type;
+    if (tag !== 'text-chunks' && tag !== 'reasoning-chunks' && tag !== 'tool-call-chunks') {
+        return [value];
+    }
+    return expandRow(validateRow(value, tag));
+}
+/**
+ * Decode one packed row from its exact uncompressed data value. The byte bound
+ * rejects oversized input before JSON parsing and avoids serializing it again.
+ * @param tag - validated packed physical type.
+ * @param seq0 - first represented logical sequence number.
+ * @param time0 - first represented logical timestamp.
+ * @param serializedData - decoded SQLite data-column text.
+ * @returns the represented logical events.
+ */
+export function decodeSerializedChunkRow(tag, seq0, time0, serializedData) {
+    const bytes = Buffer.byteLength(serializedData);
+    if (bytes > MAX_PACKED_DATA_BYTES)
+        malformed(tag, `data exceeds ${MAX_PACKED_DATA_BYTES} UTF-8 bytes`);
+    return expandRow(validateRow({ type: tag, seq0, time0, data: JSON.parse(serializedData) }, tag, bytes));
+}
+/* jscpd:ignore-end */
+//# sourceMappingURL=codec.js.map

package/dist/kernel/session-persistence-sqlite/lib/types/compression.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Fixed physical-record compression for SQLite. Schema-owned functions
+ * encode logical events and decode tagged rows before persistence consumers
+ * observe them.
+ * @module @nomix-ai/nomix-session-persistence-sqlite/compression
+ */
+import type { SessionEvent } from '../../../session/lib/index.js';
+import { type StorageRecord } from './codec.ts';
+import type { EventRow } from './schema.ts';
+/** One physical row ready for SQLite parameter binding. */
+export interface BoundRecord {
+    readonly seq: number;
+    readonly type: string;
+    readonly time: number;
+    readonly data: string | Uint8Array;
+    readonly sourceEventSeqs: Uint8Array | null;
+    readonly surfaceOp: string | null;
+    readonly ignorable: number | null;
+}
+/** Small values stay as SQLite text to avoid per-frame CPU and byte overhead. */
+export declare const ZSTD_DATA_THRESHOLD_BYTES = 4096;
+/**
+ * Decode one physical SQLite row into its complete logical event span.
+ * @param row - detached SQLite event row.
+ * @returns every logical event represented by the row.
+ */
+export declare function decodeRow(row: EventRow): SessionEvent[];
+/**
+ * Convert a storage record to SQLite column values.
+ * @param record - scalar event or packed chunk record.
+ * @returns column values for one physical insert.
+ */
+export declare function bindRecord(record: StorageRecord): BoundRecord;
+/**
+ * Validate and flatten physical rows into their logical prefix. A malformed
+ * row or logical gap is committed corruption when a later valid turn end
+ * exists; otherwise it starts a removable physical tail.
+ * @param rows - physical rows ordered by their first logical sequence.
+ * @param base - logical sequence expected from the first selected row.
+ * @returns the contiguous logical prefix and optional physical deletion base.
+ */
+export declare function scanRows(rows: readonly EventRow[], base?: number): {
+    preserved: SessionEvent[];
+    tornFrom?: number;
+};
+//# sourceMappingURL=compression.d.ts.map

package/dist/kernel/session-persistence-sqlite/lib/types/compression.js

@@ -0,0 +1,234 @@
+/**
+ * Fixed physical-record compression for SQLite. Schema-owned functions
+ * encode logical events and decode tagged rows before persistence consumers
+ * observe them.
+ * @module @nomix-ai/nomix-session-persistence-sqlite/compression
+ */
+import { TextDecoder } from 'node:util';
+import { constants, zstdCompressSync, zstdDecompressSync } from 'node:zlib';
+import { decodeSerializedChunkRow, MAX_PACKED_DATA_BYTES, } from "./codec.js";
+/** Small values stay as SQLite text to avoid per-frame CPU and byte overhead. */
+export const ZSTD_DATA_THRESHOLD_BYTES = 4_096;
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MAX_ZIGZAG_INTEGER = MAX_SAFE_INTEGER * 2n;
+const UTF8_DECODER = new TextDecoder('utf-8', { fatal: true });
+const ZSTD_COMPRESSION_LEVEL = 3;
+const PACKED_ROW_SENTINEL = 0;
+const CHUNK_TAGS = ['text-chunks', 'reasoning-chunks', 'tool-call-chunks'];
+function isChunkTag(value) {
+    return CHUNK_TAGS.includes(value);
+}
+/**
+ * Decode one physical SQLite row into its complete logical event span.
+ * @param row - detached SQLite event row.
+ * @returns every logical event represented by the row.
+ */
+export function decodeRow(row) {
+    if (row.ignorable !== PACKED_ROW_SENTINEL)
+        return [decodeScalarRow(row)];
+    if (!isChunkTag(row.type)) {
+        throw new Error(`malformed ${row.type} storage row: packed discriminator requires a chunk tag`);
+    }
+    if (row.source_event_seqs !== null || row.surface_op !== null) {
+        throw new Error(`malformed ${row.type} storage row: packed surface fields must be null`);
+    }
+    return decodeSerializedChunkRow(row.type, row.seq, row.time, decodeData(row.data, MAX_PACKED_DATA_BYTES));
+}
+/**
+ * Convert a storage record to SQLite column values.
+ * @param record - scalar event or packed chunk record.
+ * @returns column values for one physical insert.
+ */
+export function bindRecord(record) {
+    if (isChunkRow(record)) {
+        return {
+            seq: record.seq0,
+            type: record.type,
+            time: record.time0,
+            data: encodeData(JSON.stringify(record.data)),
+            sourceEventSeqs: null,
+            surfaceOp: null,
+            ignorable: PACKED_ROW_SENTINEL,
+        };
+    }
+    const event = record;
+    const surface = event;
+    return {
+        seq: event.seq,
+        type: event.type,
+        time: event.time,
+        data: encodeData(JSON.stringify(event.data)),
+        sourceEventSeqs: surface.sourceEventSeqs === undefined
+            ? null
+            : encodeSourceEventSeqs(surface.sourceEventSeqs),
+        surfaceOp: surface.surfaceOp === undefined ? null : JSON.stringify(surface.surfaceOp),
+        ignorable: event.ignorable === true ? 1 : null,
+    };
+}
+function encodeData(serialized) {
+    const bytes = Buffer.from(serialized);
+    if (bytes.length < ZSTD_DATA_THRESHOLD_BYTES)
+        return serialized;
+    const compressed = zstdCompressSync(bytes, {
+        params: { [constants.ZSTD_c_compressionLevel]: ZSTD_COMPRESSION_LEVEL },
+    });
+    return compressed.length < bytes.length ? compressed : serialized;
+}
+function decodeData(value, maxOutputLength) {
+    if (typeof value === 'string')
+        return value;
+    const decoded = maxOutputLength === undefined
+        ? zstdDecompressSync(value)
+        : zstdDecompressSync(value, { maxOutputLength });
+    return UTF8_DECODER.decode(decoded);
+}
+function encodeSourceEventSeqs(values) {
+    const bytes = [];
+    let previous = 0n;
+    for (let index = 0; index < values.length; index += 1) {
+        const sourceSeq = values[index];
+        if (!Number.isSafeInteger(sourceSeq) || sourceSeq < 0) {
+            throw new TypeError('sourceEventSeqs must contain non-negative safe integers');
+        }
+        const value = BigInt(sourceSeq);
+        const encoded = index === 0
+            ? value
+            : value >= previous
+                ? (value - previous) * 2n
+                : ((previous - value) * 2n) - 1n;
+        appendVarint(bytes, encoded);
+        previous = value;
+    }
+    return Buffer.from(bytes);
+}
+function appendVarint(bytes, value) {
+    let remaining = value;
+    while (remaining >= 0x80n) {
+        bytes.push(Number(remaining & 0x7fn) | 0x80);
+        remaining >>= 7n;
+    }
+    bytes.push(Number(remaining));
+}
+function decodeSourceEventSeqs(bytes) {
+    const values = [];
+    let previous = 0n;
+    let offset = 0;
+    while (offset < bytes.length) {
+        const first = values.length === 0;
+        const decoded = readVarint(bytes, offset, first ? MAX_SAFE_INTEGER : MAX_ZIGZAG_INTEGER);
+        offset = decoded.offset;
+        const delta = first
+            ? decoded.value
+            : (decoded.value & 1n) === 0n
+                ? decoded.value / 2n
+                : -((decoded.value + 1n) / 2n);
+        const value = first ? delta : previous + delta;
+        if (value < 0n || value > MAX_SAFE_INTEGER) {
+            throw new Error('malformed source_event_seqs storage value: decoded seq is out of range');
+        }
+        values.push(Number(value));
+        previous = value;
+    }
+    return values;
+}
+function readVarint(bytes, offset, limit) {
+    let value = 0n;
+    let shift = 0n;
+    while (offset < bytes.length) {
+        const byte = bytes[offset];
+        offset += 1;
+        value |= BigInt(byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            if (shift > 0n && (byte & 0x7f) === 0) {
+                throw new Error('malformed source_event_seqs storage value: non-canonical varint');
+            }
+            if (value > limit) {
+                throw new Error('malformed source_event_seqs storage value: varint is out of range');
+            }
+            return { value, offset };
+        }
+        shift += 7n;
+        if (shift > 56n) {
+            throw new Error('malformed source_event_seqs storage value: varint is out of range');
+        }
+    }
+    throw new Error('malformed source_event_seqs storage value: truncated varint');
+}
+function isChunkRow(record) {
+    return isChunkTag(record.type) && 'seq0' in record && !('seq' in record);
+}
+function decodeScalarRow(row) {
+    const surfaceFields = {
+        ...row.source_event_seqs === null
+            ? {}
+            : { sourceEventSeqs: decodeSourceEventSeqs(row.source_event_seqs) },
+        ...row.surface_op === null
+            ? {}
+            : { surfaceOp: JSON.parse(row.surface_op) },
+    };
+    return {
+        type: row.type,
+        seq: row.seq,
+        time: row.time,
+        data: JSON.parse(decodeData(row.data)),
+        ...surfaceFields,
+        ...row.ignorable === 1 ? { ignorable: true } : {},
+    };
+}
+/**
+ * Validate and flatten physical rows into their logical prefix. A malformed
+ * row or logical gap is committed corruption when a later valid turn end
+ * exists; otherwise it starts a removable physical tail.
+ * @param rows - physical rows ordered by their first logical sequence.
+ * @param base - logical sequence expected from the first selected row.
+ * @returns the contiguous logical prefix and optional physical deletion base.
+ */
+export function scanRows(rows, base = 0) {
+    let lastTurnEndRow = -1;
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+        try {
+            if (decodeRow(rows[index]).some(event => event.type === 'turn/end')) {
+                lastTurnEndRow = index;
+                break;
+            }
+        }
+        catch {
+            // A malformed row cannot prove that an earlier physical prefix committed.
+        }
+    }
+    const preserved = [];
+    let expected = base;
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const physical = rows[rowIndex];
+        let logicalEvents;
+        try {
+            logicalEvents = decodeRow(physical);
+        }
+        catch {
+            // The committed-prefix rule below owns whether this invalid row is fatal or repairable.
+        }
+        if (logicalEvents === undefined) {
+            if (rowIndex <= lastTurnEndRow) {
+                throw new Error(`corrupt session log: invalid committed physical row at seq ${physical.seq}`);
+            }
+            return { preserved, tornFrom: physical.seq };
+        }
+        let contiguous = true;
+        for (const event of logicalEvents) {
+            if (event.seq !== expected) {
+                contiguous = false;
+                break;
+            }
+            expected += 1;
+        }
+        if (!contiguous) {
+            if (rowIndex <= lastTurnEndRow) {
+                throw new Error(`corrupt session log: invalid committed physical row at seq ${physical.seq}`);
+            }
+            return { preserved, tornFrom: physical.seq };
+        }
+        preserved.push(...logicalEvents);
+    }
+    return { preserved };
+}
+//# sourceMappingURL=compression.js.map