@meridianlabs/log-viewer 0.3.249 → 0.3.250

package/lib/src/log_data/chunked/chunkedSample.d.ts

@@ -0,0 +1,30 @@
+import { ChatMessage } from '@tsmono/inspect-common';
+import { SequenceReader, EntryByteSource } from './chunkStore';
+import { SkeletonIndex } from './skeletonIndex';
+import { ChunkedEvent, ChunkedSampleShell, EventChunkStats, SampleSkeleton } from './types';
+export interface ChunkedSample {
+    shell: ChunkedSampleShell;
+    skeleton: SampleSkeleton;
+    skel: SkeletonIndex;
+    stats: EventChunkStats[];
+    events: SequenceReader<ChunkedEvent>;
+    messages: SequenceReader<ChatMessage>;
+    calls: SequenceReader<unknown>;
+    attachments: SequenceReader<string>;
+    /**
+     * Resolve an event uuid to its ordinal via `events/uuids.json` (fetched
+     * lazily, once). Undefined for unknown uuids — including every uuid on a
+     * log converted before the sidecar existed.
+     */
+    uuidToOrdinal: (uuid: string) => Promise<number | undefined>;
+    /** Fetch `metadata.json` (undefined when the sample has no metadata). */
+    readMetadata?: () => Promise<Record<string, unknown>>;
+}
+/**
+ * Open a chunked sample. `entryNames` is the log's central-directory name
+ * set — the persisted chunk layout (per-sequence starts) plus optional
+ * metadata detection; the three parsed artifacts — shell, skeleton,
+ * stats — are fetched in parallel.
+ */
+export declare const openChunkedSample: (source: EntryByteSource, entryNames: ReadonlySet<string>, id: string | number, epoch: number, byteBudget?: number) => Promise<ChunkedSample>;
+//# sourceMappingURL=chunkedSample.d.ts.map

package/lib/src/log_data/chunked/chunkedSample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedSample.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/chunkedSample.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EAEL,cAAc,EACd,KAAK,eAAe,EACrB,MAAM,cAAc,CAAC;AAWtB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,eAAe,EAEf,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,MAAM,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;IACrC,QAAQ,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;IACtC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAC/B,WAAW,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACpC;;;;OAIG;IACH,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7D,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD;AAoBD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,eAAe,EACvB,YAAY,WAAW,CAAC,MAAM,CAAC,EAC/B,IAAI,MAAM,GAAG,MAAM,EACnB,OAAO,MAAM,EACb,aAAa,MAAM,KAClB,OAAO,CAAC,aAAa,CA4EvB,CAAC"}

package/lib/src/log_data/chunked/cursor.d.ts

@@ -0,0 +1,35 @@
+import { SequenceReader } from './chunkStore';
+import { ChunkedEvent, EventChunkStats } from './types';
+export interface OrdinalEvent {
+    ordinal: number;
+    ev: ChunkedEvent;
+}
+export declare class FilteredCursor {
+    private store;
+    private stats;
+    /**
+     * Survival predicate over event type; span_begin/span_end are the
+     * caller's job to force-include (structure drives the walk).
+     */
+    private survives;
+    private buffer;
+    private from;
+    private exhausted;
+    constructor(store: SequenceReader<ChunkedEvent>, stats: readonly EventChunkStats[], start: number, 
+    /**
+     * Survival predicate over event type; span_begin/span_end are the
+     * caller's job to force-include (structure drives the walk).
+     */
+    survives: (type: string) => boolean);
+    get done(): boolean;
+    private chunkSurvivorCount;
+    statsFor(chunkIdx: number): EventChunkStats | undefined;
+    chunkIndexOf(ordinal: number): number;
+    chunkBounds(chunkIdx: number): [number, number];
+    private refill;
+    peek(): Promise<OrdinalEvent | null>;
+    next(): Promise<OrdinalEvent | null>;
+    /** Jump to `ordinal`: advance in-buffer if already buffered, else drop and refetch. */
+    seek(ordinal: number): void;
+}
+//# sourceMappingURL=cursor.d.ts.map

package/lib/src/log_data/chunked/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,YAAY,CAAC;CAClB;AAKD,qBAAa,cAAc;IAMvB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,KAAK;IAEb;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAZlB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,SAAS,CAAS;gBAGhB,KAAK,EAAE,cAAc,CAAC,YAAY,CAAC,EACnC,KAAK,EAAE,SAAS,eAAe,EAAE,EACzC,KAAK,EAAE,MAAM;IACb;;;OAGG;IACK,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;IAK7C,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,OAAO,CAAC,kBAAkB;IAW1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIvD,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIrC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;YAIjC,MAAM;IAuBd,IAAI,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAOpC,IAAI,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAQ1C,uFAAuF;IACvF,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAc5B"}

package/lib/src/log_data/chunked/decode.d.ts

@@ -0,0 +1,55 @@
+import { SequenceReader } from './chunkStore';
+import { SkeletonIndex } from './skeletonIndex';
+import { ChunkedEvent, EventChunkStats, SkeletonSpan } from './types';
+export type ViewRow = {
+    kind: "span";
+    ordinal: number;
+    depth: number;
+    spanIdx: number;
+    span: SkeletonSpan;
+    collapsed: boolean;
+} | {
+    kind: "event";
+    ordinal: number;
+    depth: number;
+    ev: ChunkedEvent;
+} | {
+    kind: "run";
+    ordinal: number;
+    depth: number;
+    runType: string;
+    count: number;
+    extent: [number, number];
+    sample: ChunkedEvent;
+};
+/**
+ * Event types whose consecutive same-span occurrences merge into one row.
+ * Binding constraint (spec): run membership must be decidable from type +
+ * span facts available in chunk stats — never from event payload contents.
+ */
+export declare const RUN_TYPES: ReadonlySet<string>;
+/**
+ * Structural marker types: span begin/end pairs and legacy step begin/end
+ * pairs (the skeleton folds steps into span-table entries — one contract,
+ * no legacy carve-out). Structure drives the walk and is only conditionally
+ * a row, never subject to the user's filter.
+ */
+export declare const STRUCTURAL_TYPES: ReadonlySet<string>;
+export interface DecodeCtx {
+    events: SequenceReader<ChunkedEvent>;
+    stats: readonly EventChunkStats[];
+    skel: SkeletonIndex;
+    isCollapsed: (spanId: string) => boolean;
+    /** User event-type filter (structure types are force-included separately). */
+    visible: (type: string) => boolean;
+}
+/**
+ * Decode view rows for ordinals `[startOrd, endOrd)`. Rows whose decode
+ * unit starts in-range are emitted even if (via seeks or runs) they extend
+ * past `endOrd`. `headRunContinues` — the caller detected (from the
+ * previous chunk's stats) that `startOrd` begins mid-run; leading run
+ * events are consumed rowless (the row belongs to the chunk where the run
+ * starts).
+ */
+export declare function decodeRange(ctx: DecodeCtx, startOrd: number, endOrd: number, headRunContinues: boolean): Promise<ViewRow[]>;
+//# sourceMappingURL=decode.d.ts.map

package/lib/src/log_data/chunked/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/decode.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE3E,MAAM,MAAM,OAAO,GACf;IACE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB,GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,YAAY,CAAA;CAAE,GACnE;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEN;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,MAAM,CAAwB,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAI/C,CAAC;AAQH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;IACrC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;IAClC,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,8EAA8E;IAC9E,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,OAAO,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA+EpB"}

package/lib/src/log_data/chunked/format.d.ts

@@ -0,0 +1,39 @@
+import { SequenceName } from './types';
+export declare const SHELL_JSON = "sample.json";
+export declare const METADATA_JSON = "metadata.json";
+export declare const SKELETON_JSON = "skeleton.json";
+export declare const STATS_JSON = "stats.json";
+export declare const UUIDS_JSON = "uuids.json";
+/** `samples/{id}_epoch_{epoch}` — the per-sample prefix (no trailing slash). */
+export declare const samplePrefix: (id: string | number, epoch: number) => string;
+/** Today's monolith sample entry name (`samples/{id}_epoch_{epoch}.json`). */
+export declare const monolithEntryName: (id: string | number, epoch: number) => string;
+export declare const shellEntryName: (id: string | number, epoch: number) => string;
+export declare const metadataEntryName: (id: string | number, epoch: number) => string;
+export declare const skeletonEntryName: (id: string | number, epoch: number) => string;
+export declare const statsEntryName: (id: string | number, epoch: number) => string;
+/** Event uuids in ordinal order (position = ordinal), lazily fetched. */
+export declare const uuidsEntryName: (id: string | number, epoch: number) => string;
+/** `{prefix}/{sequence}/{start}.json` — chunk holding items from `start`. */
+export declare const chunkEntryName: (id: string | number, epoch: number, sequence: SequenceName, start: number) => string;
+export type SampleShape = "monolith" | "chunked";
+/**
+ * Classify a sample's on-disk shape from zip entry names (the central
+ * directory). Structural per-sample dispatch: one log may mix shapes.
+ * Returns undefined when the sample has no entries at all.
+ */
+export declare const classifySampleShape: (entryNames: ReadonlySet<string>, id: string | number, epoch: number) => SampleShape | undefined;
+/**
+ * Chunk start indexes for a sequence, recovered from central-directory
+ * entry names. Ascending; empty sequences have no chunk entries at all.
+ * Non-numeric stems are skipped (`events/` also holds `stats.json`).
+ */
+export declare const sequenceChunkStarts: (entryNames: ReadonlySet<string>, id: string | number, epoch: number, sequence: SequenceName) => number[];
+/** Bounds-checked index (an out-of-range index is a coding error). */
+export declare const at: <T>(items: readonly T[], i: number) => T;
+/**
+ * Index of the chunk holding item `i`: greatest start ≤ i (binary search
+ * over ascending starts). Callers must ensure `0 ≤ i <` the sequence count.
+ */
+export declare const chunkIndexOf: (starts: readonly number[], i: number) => number;
+//# sourceMappingURL=format.d.ts.map

package/lib/src/log_data/chunked/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C,eAAO,MAAM,UAAU,gBAAgB,CAAC;AACxC,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAC7C,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAC7C,eAAO,MAAM,UAAU,eAAe,CAAC;AACvC,eAAO,MAAM,UAAU,eAAe,CAAC;AAEvC,gFAAgF;AAChF,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MAC3B,CAAC;AAExC,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACpC,CAAC;AAEpC,eAAO,MAAM,cAAc,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACxB,CAAC;AAE7C,eAAO,MAAM,iBAAiB,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACxB,CAAC;AAEhD,eAAO,MAAM,iBAAiB,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACxB,CAAC;AAEhD,eAAO,MAAM,cAAc,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACjB,CAAC;AAEpD,yEAAyE;AACzE,eAAO,MAAM,cAAc,GAAI,IAAI,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACjB,CAAC;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GACzB,IAAI,MAAM,GAAG,MAAM,EACnB,OAAO,MAAM,EACb,UAAU,YAAY,EACtB,OAAO,MAAM,KACZ,MAAgE,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,WAAW,CAAC,MAAM,CAAC,EAC/B,IAAI,MAAM,GAAG,MAAM,EACnB,OAAO,MAAM,KACZ,WAAW,GAAG,SAKA,CAAC;AAElB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,WAAW,CAAC,MAAM,CAAC,EAC/B,IAAI,MAAM,GAAG,MAAM,EACnB,OAAO,MAAM,EACb,UAAU,YAAY,KACrB,MAAM,EAYR,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,OAAO,SAAS,CAAC,EAAE,EAAE,GAAG,MAAM,KAAG,CAMtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,SAAS,MAAM,EAAE,EAAE,GAAG,MAAM,KAAG,MASnE,CAAC"}

package/lib/src/log_data/chunked/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Headless data layer for chunked-format samples
+ * (design/large-samples.md in the inspect_ai repo). Framework-free: no
+ * React, no react-query — the viewer integration layers those on top.
+ */
+export { openChunkedSample, type ChunkedSample } from './chunkedSample';
+export { ChunkByteStore, SequenceReader, type EntryByteSource, } from './chunkStore';
+export { FilteredCursor, type OrdinalEvent } from './cursor';
+export { RUN_TYPES, STRUCTURAL_TYPES, decodeRange, type DecodeCtx, type ViewRow, } from './decode';
+export { classifySampleShape, monolithEntryName, samplePrefix, shellEntryName, type SampleShape, } from './format';
+export { sampleSkeleton, type SkeletonEvent, type SkeletonPolicy, } from './skeleton';
+export { candidateOutlineRows, defaultCollapsedSpanIds, type CollapseState, type OutlineRow, } from './outlineRows';
+export { SkeletonIndex } from './skeletonIndex';
+export { syntheticEventsFromSkeleton, type SyntheticStream, } from './syntheticEvents';
+export { RowSpace, type RowSlot } from './rowSpace';
+export type { ChunkedEvent, ChunkedSampleShell, EventChunkStats, EventStats, SampleSkeleton, SequenceName, SkeletonNotable, SkeletonSpan, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/src/log_data/chunked/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,cAAc,EACd,cAAc,EACd,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,WAAW,EACX,KAAK,SAAS,EACd,KAAK,OAAO,GACb,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,KAAK,WAAW,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,cAAc,EACd,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,UAAU,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EACL,2BAA2B,EAC3B,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,cAAc,EACd,YAAY,EACZ,eAAe,EACf,YAAY,GACb,MAAM,SAAS,CAAC"}

package/lib/src/log_data/chunked/log.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Unconditional console logging for the chunked read path: every member
+ * fetch/cache-hit/eviction, chunk parse, sidecar read, attachment
+ * resolution, and row materialization, for confirming windowed-read
+ * behavior while browsing. Deliberately NOT the gated `createLogger` —
+ * the chunked path is dev-phase (only the hidden converter produces
+ * chunked logs), and the point is to see the reads in any build. Dial
+ * back to `createLogger("chunked")` before the format ships by default.
+ */
+export declare const log: {
+    info: (message: string) => void;
+    debug: (message: string) => void;
+};
+//# sourceMappingURL=log.d.ts.map

package/lib/src/log_data/chunked/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/log.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG;oBACE,MAAM,KAAG,IAAI;qBAGZ,MAAM,KAAG,IAAI;CAG/B,CAAC"}

package/lib/src/log_data/chunked/outlineRows.d.ts

@@ -0,0 +1,33 @@
+import { SampleSkeleton } from './types';
+/** One outline row (the Python `OutlineRow` NamedTuple, plus `spanId`). */
+export interface OutlineRow {
+    kind: "span" | "turns" | "scoring" | "event";
+    depth: number;
+    name?: string;
+    type?: string;
+    /**
+     * Sequence index of the row's anchor event (absent only for synthetic
+     * rows whose subtree holds no indexed events).
+     */
+    anchor?: number;
+    /** Merged item count (turns / scoring rows). */
+    total?: number;
+    /**
+     * The skeleton span's id (span rows only) — keys collapse state. Absent
+     * on the synthetic sample_init wrapper row, which has no skeleton span.
+     */
+    spanId?: string;
+}
+/**
+ * Collapse state: a preset, or a set of span identities (span ids; legacy
+ * steps use the skeleton convention `step-<begin index>`).
+ */
+export type CollapseState = "default" | "expanded" | "collapsed" | ReadonlySet<string>;
+/**
+ * Span ids the default-collapse policy collapses — for seeding transcript
+ * collapse state to match `candidateOutlineRows(skeleton, "default")`.
+ */
+export declare const defaultCollapsedSpanIds: (skeleton: SampleSkeleton) => Set<string>;
+/** Outline rows derived from the skeleton alone. */
+export declare const candidateOutlineRows: (skeleton: SampleSkeleton, collapse?: CollapseState) => OutlineRow[];
+//# sourceMappingURL=outlineRows.d.ts.map

package/lib/src/log_data/chunked/outlineRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlineRows.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/outlineRows.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAiC,MAAM,SAAS,CAAC;AAK7E,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GACvB,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAkN7D;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAU,cAAc,KACvB,GAAG,CAAC,MAAM,CAC4D,CAAC;AAE1E,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,GAC/B,UAAU,cAAc,EACxB,WAAU,aAAyB,KAClC,UAAU,EAkIZ,CAAC"}

package/lib/src/log_data/chunked/pyTimestamp.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Timestamp twin of the Python skeleton producer's datetime handling.
+ *
+ * `Event.timestamp` is a `UtcDatetime`: every parsed timestamp is coerced to
+ * UTC (offset-less strings are treated as UTC), and the producer emits
+ * `datetime.isoformat()` of the UTC datetime — no fraction when microseconds
+ * are zero, otherwise six digits, offset always `+00:00`. The producer also
+ * compares timestamps at microsecond precision, beyond JS `Date`, so we
+ * carry a microsecond epoch.
+ */
+export interface PyTimestamp {
+    /** Microseconds since the Unix epoch (instant, for comparisons). */
+    epochUs: number;
+    /** Python `datetime.isoformat()` rendering of the UTC datetime. */
+    iso: string;
+}
+/** Parse an ISO-8601 timestamp; offset-less values are treated as UTC. */
+export declare const parsePyTimestamp: (value: string) => PyTimestamp;
+/** Python `datetime.isoformat()` of a UTC microsecond epoch. */
+export declare const formatPyTimestamp: (epochUs: number) => string;
+/** Later of two timestamps (Python `max` — ties keep the first argument). */
+export declare const maxPyTimestamp: (a: PyTimestamp, b: PyTimestamp) => PyTimestamp;
+//# sourceMappingURL=pyTimestamp.d.ts.map

package/lib/src/log_data/chunked/pyTimestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyTimestamp.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/pyTimestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,WAAW;IAC1B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;CACb;AAKD,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,WAwBhD,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,MAUnD,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GAAI,GAAG,WAAW,EAAE,GAAG,WAAW,KAAG,WACjC,CAAC"}

package/lib/src/log_data/chunked/rowSpace.d.ts

@@ -0,0 +1,53 @@
+import { SequenceReader } from './chunkStore';
+import { DecodeCtx, ViewRow } from './decode';
+import { SkeletonIndex } from './skeletonIndex';
+import { ChunkedEvent, EventChunkStats } from './types';
+export type RowSlot = {
+    kind: "row";
+    row: ViewRow;
+    globalIndex: number;
+} | {
+    kind: "placeholder";
+    chunkIdx: number;
+    estOrdinal: number;
+    globalIndex: number;
+};
+export declare class RowSpace {
+    private events;
+    private stats;
+    private skel;
+    private visible;
+    readonly chunkRows: number[];
+    readonly exact: boolean[];
+    private materializedRows;
+    private inflight;
+    private prefix;
+    version: number;
+    private listeners;
+    /** Merged elided ordinal ranges `[lo, hi]` (collapsed span interiors). */
+    private elision;
+    constructor(events: SequenceReader<ChunkedEvent>, stats: readonly EventChunkStats[], skel: SkeletonIndex, collapsed: ReadonlySet<string>, visible: (type: string) => boolean);
+    onChange(fn: () => void): () => void;
+    get total(): number;
+    private chunkBounds;
+    private elidedOverlap;
+    private fullyElided;
+    private estimateChunk;
+    private recompute;
+    slotAt(globalIndex: number): RowSlot;
+    /**
+     * The ordinal anchor: map an event ordinal to its global row index.
+     *
+     * Two accepted one-row inaccuracies on materialized chunks: an ordinal
+     * covered by a run row that STARTS in the previous chunk anchors one row
+     * late (the containing run row lives in that chunk), and an ordinal past
+     * the chunk's last row (e.g. a trailing span_end) clamps backward to it.
+     */
+    rowIndexForOrdinal(ordinal: number): number;
+    isMaterialized(chunkIdx: number): boolean;
+    /** Decode a chunk's window and correct its row count; idempotent. */
+    materialize(chunkIdx: number, ctx: DecodeCtx): Promise<void>;
+    private doMaterialize;
+    get materializedCount(): number;
+}
+//# sourceMappingURL=rowSpace.d.ts.map

package/lib/src/log_data/chunked/rowSpace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowSpace.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/rowSpace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,OAAO,EACb,MAAM,UAAU,CAAC;AAGlB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK7D,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAClD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEN,qBAAa,QAAQ;IAiBjB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,IAAI;IAEZ,OAAO,CAAC,OAAO;IApBjB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC;IAK1B,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,SAAK;IACZ,OAAO,CAAC,SAAS,CAAyB;IAE1C,0EAA0E;IAC1E,OAAO,CAAC,OAAO,CAA0B;gBAG/B,MAAM,EAAE,cAAc,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,IAAI,EAAE,aAAa,EAC3B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,EACtB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;IA8B5C,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAOpC,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,SAAS;IASjB,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IA0BpC;;;;;;;OAOG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAgB3C,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIzC,qEAAqE;IACrE,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;YAc9C,aAAa;IAiC3B,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF"}

package/lib/src/log_data/chunked/skeleton.d.ts

@@ -0,0 +1,49 @@
+import { SampleSkeleton } from './types';
+export declare const DEFAULT_NOTABLE_CAP = 1000;
+export declare const DEFAULT_ESCAPE_HATCH_EVENTS = 1000;
+/**
+ * Event types persisted as notables (ratified, not a policy knob): a
+ * model-event notable would break the per-span accounting invariant
+ * `sum(gap_models) + sum(child span models) == models`.
+ */
+export declare const NOTABLE_TYPES: ReadonlySet<string>;
+/**
+ * Writer-policy knobs for skeleton production. Policy, not contract: knobs
+ * change which spans/notables are persisted, never the schema.
+ */
+export interface SkeletonPolicy {
+    /** Per-type first-N cap on persisted notables. */
+    notable_cap?: number;
+    /**
+     * A leaf tool span with at least this many descendant events is included
+     * despite the leaf-tool exclusion (fetch elision + outline presence for
+     * monster tool spans).
+     */
+    escape_hatch_events?: number;
+}
+/**
+ * The event fields the producer reads. `Event` union members satisfy this
+ * structurally; fixture events parsed from JSON do too.
+ */
+export interface SkeletonEvent {
+    event: string;
+    span_id?: string | null;
+    timestamp: string;
+    working_start: number;
+    /** Span id (span begin/end events). */
+    id?: string | null;
+    parent_id?: string | null;
+    name?: string | null;
+    type?: string | null;
+    /** Step action (legacy step events). */
+    action?: string | null;
+    checkpoint_id?: number | null;
+}
+/**
+ * Produce the structural skeleton for an event sequence. Pure and
+ * deterministic: the same events (and policy) always yield the same
+ * skeleton. Legacy step begin/end pairs map to span-table entries — one
+ * skeleton contract, no legacy carve-out.
+ */
+export declare const sampleSkeleton: (events: readonly SkeletonEvent[], policy?: SkeletonPolicy) => SampleSkeleton;
+//# sourceMappingURL=skeleton.d.ts.map

package/lib/src/log_data/chunked/skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/skeleton.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,cAAc,EAAiC,MAAM,SAAS,CAAC;AAE7E,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,CAG5C,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AA6BD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,SAAS,aAAa,EAAE,EAChC,SAAQ,cAAmB,KAC1B,cA4DF,CAAC"}

package/lib/src/log_data/chunked/skeletonIndex.d.ts

@@ -0,0 +1,23 @@
+import { SampleSkeleton, SkeletonSpan } from './types';
+export declare class SkeletonIndex {
+    readonly skeleton: SampleSkeleton;
+    readonly spans: SkeletonSpan[];
+    readonly childrenOf: number[][];
+    readonly roots: number[];
+    readonly spanIds: ReadonlySet<string>;
+    private byBegin;
+    constructor(skeleton: SampleSkeleton);
+    /** Span whose begin event sits at `ordinal` (undefined: dissolved span). */
+    spanAtBegin(ordinal: number): number | undefined;
+    /**
+     * Structural ancestor stack (outermost first) containing `ordinal` —
+     * answered entirely from extents; the span_begin events need never be
+     * fetched. Interleaved-span extent overlap: first containing child wins
+     * (tolerated per spec; correctness comes from span_id on fetched events).
+     */
+    spanStackAt(ordinal: number): number[];
+    depthAt(ordinal: number): number;
+    /** Does an expanded span have anything to show under the current filter? */
+    hasVisibleContents(spanIdx: number, visibleTypes: (type: string) => boolean): boolean;
+}
+//# sourceMappingURL=skeletonIndex.d.ts.map

package/lib/src/log_data/chunked/skeletonIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonIndex.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/skeletonIndex.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5D,qBAAa,aAAa;IAOZ,QAAQ,CAAC,QAAQ,EAAE,cAAc;IAN7C,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,OAAO,CAAC,OAAO,CAA6B;gBAEvB,QAAQ,EAAE,cAAc;IAe7C,4EAA4E;IAC5E,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhD;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAgBtC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIhC,4EAA4E;IAC5E,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACtC,OAAO;CAcX"}

package/lib/src/log_data/chunked/syntheticEvents.d.ts

@@ -0,0 +1,9 @@
+import { Event } from '@tsmono/inspect-common/types';
+import { SampleSkeleton } from './types';
+export interface SyntheticStream {
+    events: Event[];
+    /** Synthetic event uuid -> ordinal in the real event sequence. */
+    ordinals: ReadonlyMap<string, number>;
+}
+export declare const syntheticEventsFromSkeleton: (skel: SampleSkeleton) => SyntheticStream;
+//# sourceMappingURL=syntheticEvents.d.ts.map

package/lib/src/log_data/chunked/syntheticEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntheticEvents.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/syntheticEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAG1D,OAAO,KAAK,EAAE,cAAc,EAAiC,MAAM,SAAS,CAAC;AAE7E,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,kEAAkE;IAClE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAaD,eAAO,MAAM,2BAA2B,GACtC,MAAM,cAAc,KACnB,eAkTF,CAAC"}

package/lib/src/log_data/chunked/types.d.ts

@@ -0,0 +1,104 @@
+import { Event, Timeline } from '@tsmono/inspect-common';
+export type SequenceName = "messages" | "events" | "calls" | "attachments";
+export declare const SEQUENCE_NAMES: readonly SequenceName[];
+/**
+ * The sample shell (`sample.json`): every EvalSample field except the
+ * token-linear sequences and metadata, plus `message_refs`. Sequence items
+ * are fetched separately by range — the chunk layout is never persisted
+ * here; it's recovered from central-directory entry names (`format.ts`).
+ * The shell is cheap by construction.
+ */
+export interface ChunkedSampleShell {
+    id: string | number;
+    epoch: number;
+    /** Final conversation as half-open ranges into the messages sequence. */
+    message_refs: [number, number][];
+    /** Producer-authored timelines (EvalSample.timelines, carried verbatim). */
+    timelines?: Timeline[];
+    /** Remaining EvalSample shell fields (input, target, scores, store, ...). */
+    [key: string]: unknown;
+}
+export interface SkeletonCounts {
+    events: number;
+    models: number;
+}
+/** One structural span (span begin/end pair or legacy step pair). */
+export interface SkeletonSpan {
+    /** Span id (legacy steps: synthesized as `step-<begin index>`). */
+    id: string;
+    /** Index of parent span in the spans array (absent at root). */
+    parent?: number;
+    name: string;
+    /** Span type (solver | agent | subtask | scorer | tool | ...). */
+    type?: string;
+    /** Sequence index of the span begin event. */
+    begin: number;
+    /** [first, last] descendant event index (parallel spans may overlap). */
+    extent: [number, number];
+    /** [start, end] ISO timestamps. */
+    t: [string, string];
+    /** [start, end] working time. */
+    working: [number, number];
+    /** Descendant event count (incl. nested spans and begin/end markers). */
+    events: number;
+    /** Descendant model-event count. */
+    models: number;
+    /**
+     * Model events strictly between consecutive items, where items are
+     * direct-child structural spans + persisted notables merged in sequence
+     * order (`length == items + 1`). Additive: suppressing an item row means
+     * summing its adjacent gaps.
+     */
+    gap_models: number[];
+    /**
+     * Direct-child event-type counts, sparse. Includes events of excluded
+     * (dissolved) leaf tool spans; excludes structural markers of structural
+     * children.
+     */
+    children: Record<string, number>;
+}
+/** A persisted notable event. */
+export interface SkeletonNotable {
+    /** Sequence index of the event. */
+    i: number;
+    /** Index of the directly containing span row (absent at root level). */
+    span?: number;
+    type: string;
+    /** Checkpoint id (checkpoint events only). */
+    checkpoint_id?: number;
+}
+/** Span-proportional structural skeleton of a sample's event sequence. */
+export interface SampleSkeleton {
+    version: number;
+    counts: SkeletonCounts;
+    spans: SkeletonSpan[];
+    notables: SkeletonNotable[];
+    /** Per-type count of notables omitted past the cap, sparse. */
+    overflow: Record<string, number>;
+}
+/** First/last event of a chunk (`span_id` absent at root level). */
+export interface ChunkEdgeEvent {
+    type: string;
+    span_id?: string;
+}
+/** Per-chunk entry in the events stats sidecar. */
+export interface EventChunkStats {
+    /** Chunk start index (== the chunk entry name). */
+    start: number;
+    /** Sparse per-chunk event-type counts. */
+    type_counts: Record<string, number>;
+    first: ChunkEdgeEvent;
+    last: ChunkEdgeEvent;
+}
+/** The events stats sidecar (`events/stats.json`). */
+export interface EventStats {
+    version: number;
+    chunks: EventChunkStats[];
+}
+/**
+ * An event as parsed from a chunk. Chunk JSON is the serialized `Event`
+ * union; ModelEvents additionally carry range-encoded `input_refs` /
+ * `call.call_refs` in place of inline copies.
+ */
+export type ChunkedEvent = Event;
+//# sourceMappingURL=types.d.ts.map

package/lib/src/log_data/chunked/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/log_data/chunked/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,CAAC;AAE3E,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAKjD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACjC,4EAA4E;IAC5E,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,6EAA6E;IAC7E,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,mCAAmC;IACnC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpB,iCAAiC;IACjC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,iCAAiC;AACjC,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,CAAC,EAAE,MAAM,CAAC;IACV,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,cAAc,CAAC;CACtB;AAED,sDAAsD;AACtD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC"}

package/lib/src/log_data/chunkedAttachments.d.ts

@@ -0,0 +1,20 @@
+import { SequenceReader, ChunkedEvent, ChunkedSample } from './chunked';
+/**
+ * Substitute every attachment ref in `items` from the sample's attachments
+ * sequence (fetches dedup through the shared chunk-byte store). `label`
+ * names the batch in the read log.
+ */
+export declare const withAttachmentsResolved: <T>(items: T[], chunked: ChunkedSample, label: string) => Promise<T[]>;
+/**
+ * Warm the attachment chunks `items` reference without resolving (the
+ * parsed-chunk and byte caches make the later `withAttachmentsResolved`
+ * pass a cache hit). Lets callers overlap attachment downloads with
+ * whatever else they're still fetching.
+ */
+export declare const prefetchAttachments: <T>(items: T[], chunked: ChunkedSample) => Promise<void>;
+/**
+ * The sample's events reader with attachment refs resolved per chunk.
+ * Chunk-level caching means each chunk resolves once.
+ */
+export declare const resolvedEventsReader: (chunked: ChunkedSample) => SequenceReader<ChunkedEvent>;
+//# sourceMappingURL=chunkedAttachments.d.ts.map

package/lib/src/log_data/chunkedAttachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedAttachments.d.ts","sourceRoot":"","sources":["../../../src/log_data/chunkedAttachments.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,EACnB,MAAM,WAAW,CAAC;AAoCnB;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAU,CAAC,EAC7C,OAAO,CAAC,EAAE,EACV,SAAS,aAAa,EACtB,OAAO,MAAM,KACZ,OAAO,CAAC,CAAC,EAAE,CAmBb,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAU,CAAC,EACzC,OAAO,CAAC,EAAE,EACV,SAAS,aAAa,KACrB,OAAO,CAAC,IAAI,CAMd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,aAAa,KACrB,cAAc,CAAC,YAAY,CAG3B,CAAC"}

package/lib/src/log_data/chunkedHydrate.d.ts

@@ -0,0 +1,25 @@
+import { EvalSample } from '@tsmono/inspect-common/types';
+import { LogZipAccess } from '../client/remote/remoteLogFile';
+import { ChunkedSample } from './chunked';
+/**
+ * Full-download size gate for timeline'd chunked samples
+ * (`TIMELINE_HYDRATION_BYTES` in the spec's named-constants table).
+ */
+export declare const TIMELINE_HYDRATION_BYTES: number;
+/**
+ * Whether the sample needs legacy-pipeline fidelity (producer timelines or
+ * branch/anchor events) and is small enough to download whole. Both checks
+ * are free: shell + stats are already parsed, sizes come from the central
+ * directory.
+ */
+export declare const shouldFullyHydrate: (chunked: ChunkedSample, zip: LogZipAccess) => boolean;
+/**
+ * Download all four sequences and reassemble the monolith `EvalSample`
+ * shape: the message sequence doubles as the `events_data` pool (indices
+ * preserved by the converter), `message_refs` rebuild the final
+ * conversation, and attachments become an index-keyed map. `resolveSample`
+ * then expands pool refs and resolves `attachment://<index>` refs exactly
+ * as it does for monolith samples.
+ */
+export declare const hydrateFullSample: (chunked: ChunkedSample) => Promise<EvalSample>;
+//# sourceMappingURL=chunkedHydrate.d.ts.map

package/lib/src/log_data/chunkedHydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedHydrate.d.ts","sourceRoot":"","sources":["../../../src/log_data/chunkedHydrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAEnE,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAG7D;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAmB,CAAC;AAmBzD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,aAAa,EACtB,KAAK,YAAY,KAChB,OAgBF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,aAAa,KACrB,OAAO,CAAC,UAAU,CAwBpB,CAAC"}