@exaudeus/workrail 1.5.0 → 1.5.1

package/dist/v2/infra/local/base32/index.js

@@ -16,29 +16,7 @@ class Base32AdapterV2 {
                 position: invalidMatch?.index,
             });
         }
-        try {
-            const bytes = (0, base32_lower_js_1.decodeBase32LowerNoPad)(encoded);
-            return (0, neverthrow_1.ok)(bytes);
-        }
-        catch (e) {
-            const message = e instanceof Error ? e.message : String(e);
-            if (/padding|non-canonical/i.test(message)) {
-                return (0, neverthrow_1.err)({
-                    code: 'BASE32_NON_CANONICAL',
-                    message: `Non-canonical base32 encoding: ${message}`,
-                });
-            }
-            if (/length/i.test(message)) {
-                return (0, neverthrow_1.err)({
-                    code: 'BASE32_INVALID_LENGTH',
-                    message: `Invalid base32 length: ${message}`,
-                });
-            }
-            return (0, neverthrow_1.err)({
-                code: 'BASE32_INVALID_CHARACTERS',
-                message: `Base32 decode failed: ${message}`,
-            });
-        }
+        return (0, base32_lower_js_1.decodeBase32LowerNoPad)(encoded);
     }
 }
 exports.Base32AdapterV2 = Base32AdapterV2;

package/dist/v2/infra/local/bech32m/index.js

@@ -22,7 +22,7 @@ class Bech32mAdapterV2 {
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            if (/checksum/i.test(msg) || /invalid/i.test(msg)) {
+            if (/checksum/i.test(msg)) {
                 return (0, neverthrow_1.err)({
                     code: 'BECH32M_CHECKSUM_FAILED',
                     message: `Bech32m checksum validation failed (likely corruption): ${msg}`,

package/dist/v2/infra/local/data-dir/index.d.ts

@@ -1,18 +1,19 @@
 import type { DataDirPortV2 } from '../../../ports/data-dir.port.js';
+import type { SessionId, WorkflowHash, SnapshotRef } from '../../../durable-core/ids/index.js';
 export declare class LocalDataDirV2 implements DataDirPortV2 {
     private readonly env;
     constructor(env: Record<string, string | undefined>);
     private safeFileSegment;
     private root;
     snapshotsDir(): string;
-    snapshotPath(snapshotRef: string): string;
+    snapshotPath(snapshotRef: SnapshotRef): string;
     keysDir(): string;
     keyringPath(): string;
     pinnedWorkflowsDir(): string;
-    pinnedWorkflowPath(workflowHash: string): string;
+    pinnedWorkflowPath(workflowHash: WorkflowHash): string;
     sessionsDir(): string;
-    sessionDir(sessionId: string): string;
-    sessionEventsDir(sessionId: string): string;
-    sessionManifestPath(sessionId: string): string;
-    sessionLockPath(sessionId: string): string;
+    sessionDir(sessionId: SessionId): string;
+    sessionEventsDir(sessionId: SessionId): string;
+    sessionManifestPath(sessionId: SessionId): string;
+    sessionLockPath(sessionId: SessionId): string;
 }

package/dist/v2/infra/local/data-dir/index.js

@@ -51,7 +51,7 @@ class LocalDataDirV2 {
         return path.join(this.root(), 'snapshots');
     }
     snapshotPath(snapshotRef) {
-        return path.join(this.snapshotsDir(), `${this.safeFileSegment(snapshotRef)}.json`);
+        return path.join(this.snapshotsDir(), `${this.safeFileSegment(String(snapshotRef))}.json`);
     }
     keysDir() {
         return path.join(this.root(), 'keys');
@@ -63,13 +63,13 @@ class LocalDataDirV2 {
         return path.join(this.root(), 'workflows', 'pinned');
     }
     pinnedWorkflowPath(workflowHash) {
-        return path.join(this.pinnedWorkflowsDir(), `${this.safeFileSegment(workflowHash)}.json`);
+        return path.join(this.pinnedWorkflowsDir(), `${this.safeFileSegment(String(workflowHash))}.json`);
     }
     sessionsDir() {
         return path.join(this.root(), 'sessions');
     }
     sessionDir(sessionId) {
-        return path.join(this.sessionsDir(), sessionId);
+        return path.join(this.sessionsDir(), String(sessionId));
     }
     sessionEventsDir(sessionId) {
         return path.join(this.sessionDir(sessionId), 'events');

package/dist/v2/infra/local/directory-listing/index.d.ts

@@ -1,8 +1,8 @@
 import type { ResultAsync } from 'neverthrow';
-import type { FsError, FileSystemPortV2 } from '../../../ports/fs.port.js';
+import type { FsError, DirectoryListingOpsPortV2 } from '../../../ports/fs.port.js';
 import type { DirectoryListingPortV2 } from '../../../ports/directory-listing.port.js';
 export declare class LocalDirectoryListingV2 implements DirectoryListingPortV2 {
     private readonly fs;
-    constructor(fs: FileSystemPortV2);
+    constructor(fs: DirectoryListingOpsPortV2);
     readdir(dirPath: string): ResultAsync<readonly string[], FsError>;
 }

package/dist/v2/infra/local/session-store/index.js

@@ -37,6 +37,7 @@ exports.LocalSessionEventLogStoreV2 = void 0;
 const neverthrow_1 = require("neverthrow");
 const jsonl_js_1 = require("../../../durable-core/canonical/jsonl.js");
 const index_js_1 = require("../../../durable-core/schemas/session/index.js");
+const constants_js_1 = require("../../../durable-core/constants.js");
 const path = __importStar(require("path"));
 class LocalSessionEventLogStoreV2 {
     constructor(dataDir, fs, sha256) {
@@ -108,7 +109,7 @@ class LocalSessionEventLogStoreV2 {
                     v: 1,
                     manifestIndex: nextManifestIndex(manifest),
                     sessionId,
-                    kind: 'segment_closed',
+                    kind: constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED,
                     firstEventIndex: first,
                     lastEventIndex: last,
                     segmentRelPath,
@@ -125,7 +126,7 @@ class LocalSessionEventLogStoreV2 {
                         v: 1,
                         manifestIndex: startIndex + i,
                         sessionId,
-                        kind: 'snapshot_pinned',
+                        kind: constants_js_1.MANIFEST_KIND.SNAPSHOT_PINNED,
                         eventIndex: p.eventIndex,
                         snapshotRef: p.snapshotRef,
                         createdByEventId: p.createdByEventId,
@@ -145,72 +146,16 @@ class LocalSessionEventLogStoreV2 {
             const segRes = validateSegmentClosedContiguity(manifest);
             if (segRes.isErr())
                 return (0, neverthrow_1.errAsync)(segRes.error);
-            const segments = manifest.filter((m) => m.kind === 'segment_closed');
-            const loadSegments = (segs) => {
-                if (segs.length === 0)
-                    return (0, neverthrow_1.okAsync)([]);
-                const [head, ...tail] = segs;
-                const segmentPath = path.join(sessionDir, head.segmentRelPath);
-                return this.fs.readFileBytes(segmentPath)
-                    .mapErr((e) => {
-                    if (e.code === 'FS_NOT_FOUND') {
-                        return {
-                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                            location: 'tail',
-                            reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${head.segmentRelPath}` },
-                            message: `Missing attested segment: ${head.segmentRelPath}`,
-                        };
-                    }
-                    return mapFsToStoreError(e);
-                })
-                    .andThen((bytes) => {
-                    const actual = this.sha256.sha256(bytes);
-                    if (actual !== head.sha256) {
-                        return (0, neverthrow_1.errAsync)({
-                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                            location: 'tail',
-                            reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${head.segmentRelPath}` },
-                            message: `Segment digest mismatch: ${head.segmentRelPath}`,
-                        });
-                    }
-                    const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-                    if (parsedRes.isErr())
-                        return (0, neverthrow_1.errAsync)(parsedRes.error);
-                    const parsed = parsedRes.value;
-                    if (parsed.length === 0) {
-                        return (0, neverthrow_1.errAsync)({
-                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                            location: 'tail',
-                            reason: { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${head.segmentRelPath}` },
-                            message: `Empty segment referenced by manifest: ${head.segmentRelPath}`,
-                        });
-                    }
-                    if (parsed[0].eventIndex !== head.firstEventIndex || parsed[parsed.length - 1].eventIndex !== head.lastEventIndex) {
-                        return (0, neverthrow_1.errAsync)({
-                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                            location: 'tail',
-                            reason: { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${head.segmentRelPath}` },
-                            message: `Segment bounds mismatch: ${head.segmentRelPath}`,
-                        });
-                    }
-                    for (let i = 1; i < parsed.length; i++) {
-                        if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
-                            return (0, neverthrow_1.errAsync)({
-                                code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                                location: 'tail',
-                                reason: { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${head.segmentRelPath}` },
-                                message: `Non-contiguous eventIndex inside segment: ${head.segmentRelPath}`,
-                            });
-                        }
-                    }
-                    return (0, neverthrow_1.okAsync)(parsed);
-                })
-                    .andThen((events) => loadSegments(tail).map((rest) => [...events, ...rest]));
-            };
-            return loadSegments(segments).andThen((events) => {
+            const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
+            return loadSegmentsRecursive({
+                segments,
+                sessionDir,
+                sha256: this.sha256,
+                fs: this.fs,
+            }).andThen((events) => {
                 const expectedPins = extractSnapshotPinsFromEvents(events);
                 const actualPins = new Set(manifest
-                    .filter((m) => m.kind === 'snapshot_pinned')
+                    .filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SNAPSHOT_PINNED)
                     .map((p) => `${p.eventIndex}:${p.createdByEventId}:${p.snapshotRef}`));
                 for (const ep of expectedPins) {
                     const key = `${ep.eventIndex}:${ep.createdByEventId}:${ep.snapshotRef}`;
@@ -247,44 +192,10 @@ class LocalSessionEventLogStoreV2 {
             .orElse((e) => (e.code === 'FS_NOT_FOUND' ? (0, neverthrow_1.okAsync)('') : (0, neverthrow_1.errAsync)(mapFsToStoreError(e))))
             .andThen((raw) => {
             if (raw.trim() === '') {
-                return (0, neverthrow_1.okAsync)({ truth: { manifest: [], events: [] }, isComplete: true, tailReason: null });
+                return (0, neverthrow_1.okAsync)({ kind: 'complete', truth: { manifest: [], events: [] } });
             }
             const lines = raw.split('\n').filter((l) => l.trim() !== '');
-            const manifest = [];
-            let isComplete = true;
-            let tailReason = null;
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                let parsed;
-                try {
-                    parsed = JSON.parse(line);
-                }
-                catch {
-                    isComplete = false;
-                    tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: 'Invalid JSON in manifest (corrupt tail)' });
-                    break;
-                }
-                const validated = index_js_1.ManifestRecordV1Schema.safeParse(parsed);
-                if (!validated.success) {
-                    isComplete = false;
-                    const rawVersion = (typeof parsed === 'object' && parsed !== null && 'v' in parsed)
-                        ? parsed.v
-                        : undefined;
-                    if (rawVersion !== 1) {
-                        tailReason ?? (tailReason = { code: 'unknown_schema_version', message: `Expected v=1, got v=${rawVersion}` });
-                    }
-                    else {
-                        tailReason ?? (tailReason = { code: 'schema_validation_failed', message: 'Manifest record schema validation failed (corrupt tail)' });
-                    }
-                    break;
-                }
-                if (validated.data.manifestIndex !== i) {
-                    isComplete = false;
-                    tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: 'Non-contiguous manifestIndex in prefix (corrupt tail)' });
-                    break;
-                }
-                manifest.push(validated.data);
-            }
+            const { manifest, isComplete, tailReason } = parseManifestPrefix(lines);
             if (manifest.length === 0) {
                 return (0, neverthrow_1.errAsync)({
                     code: 'SESSION_STORE_CORRUPTION_DETECTED',
@@ -293,84 +204,29 @@ class LocalSessionEventLogStoreV2 {
                     message: 'No validated manifest prefix',
                 });
             }
-            const segments = manifest.filter((m) => m.kind === 'segment_closed');
+            const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
             const initial = { events: [], isComplete, tailReason, done: false };
-            const processSegment = (seg, state) => {
-                if (state.done)
-                    return (0, neverthrow_1.okAsync)(state);
-                const segmentPath = path.join(sessionDir, seg.segmentRelPath);
-                return this.fs
-                    .readFileBytes(segmentPath)
-                    .map((bytes) => ({ kind: 'present', bytes }))
-                    .orElse((e) => (e.code === 'FS_NOT_FOUND' ? (0, neverthrow_1.okAsync)({ kind: 'missing' }) : (0, neverthrow_1.errAsync)(mapFsToStoreError(e))))
-                    .andThen((res) => {
-                    if (res.kind === 'missing') {
-                        return (0, neverthrow_1.okAsync)({
-                            ...state,
-                            isComplete: false,
-                            tailReason: state.tailReason ?? { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` },
-                            done: true,
-                        });
-                    }
-                    const bytes = res.bytes;
-                    const actual = this.sha256.sha256(bytes);
-                    if (actual !== seg.sha256) {
-                        return (0, neverthrow_1.okAsync)({
-                            ...state,
-                            isComplete: false,
-                            tailReason: state.tailReason ?? { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` },
-                            done: true,
-                        });
-                    }
-                    const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-                    if (parsedRes.isErr()) {
-                        return (0, neverthrow_1.okAsync)({
-                            ...state,
-                            isComplete: false,
-                            tailReason: state.tailReason ?? { code: 'non_contiguous_indices', message: `Invalid JSONL inside segment: ${seg.segmentRelPath}` },
-                            done: true,
-                        });
-                    }
-                    const parsed = parsedRes.value;
-                    if (parsed.length === 0) {
-                        return (0, neverthrow_1.okAsync)({
-                            ...state,
-                            isComplete: false,
-                            tailReason: state.tailReason ?? { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${seg.segmentRelPath}` },
-                            done: true,
-                        });
-                    }
-                    if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
-                        return (0, neverthrow_1.okAsync)({
-                            ...state,
-                            isComplete: false,
-                            tailReason: state.tailReason ?? { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${seg.segmentRelPath}` },
-                            done: true,
-                        });
-                    }
-                    for (let i = 1; i < parsed.length; i++) {
-                        if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
-                            return (0, neverthrow_1.okAsync)({
-                                ...state,
-                                isComplete: false,
-                                tailReason: state.tailReason ?? { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}` },
-                                done: true,
-                            });
-                        }
-                    }
-                    return (0, neverthrow_1.okAsync)({
-                        ...state,
-                        events: [...state.events, ...parsed],
-                    });
-                });
-            };
             return segments
-                .reduce((acc, seg) => acc.andThen((s) => processSegment(seg, s)), (0, neverthrow_1.okAsync)(initial))
-                .map((final) => ({
-                truth: { manifest, events: final.events },
-                isComplete: final.isComplete,
-                tailReason: final.tailReason,
-            }));
+                .reduce((acc, seg) => acc.andThen((s) => processSegmentForSalvage({
+                segment: seg,
+                sessionDir,
+                sha256: this.sha256,
+                fs: this.fs,
+                state: s,
+            })), (0, neverthrow_1.okAsync)(initial))
+                .map((final) => {
+                if (final.isComplete) {
+                    return { kind: 'complete', truth: { manifest, events: final.events } };
+                }
+                return {
+                    kind: 'truncated',
+                    truth: { manifest, events: final.events },
+                    tailReason: final.tailReason ?? {
+                        code: 'non_contiguous_indices',
+                        message: 'Unknown truncation reason',
+                    },
+                };
+            });
         });
     }
     loadTruthOrEmpty(sessionId) {
@@ -378,7 +234,7 @@ class LocalSessionEventLogStoreV2 {
             .andThen((manifest) => {
             if (manifest.length === 0)
                 return (0, neverthrow_1.okAsync)({ manifest: [], events: [] });
-            const segments = manifest.filter((m) => m.kind === 'segment_closed');
+            const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
             const sessionDir = this.dataDir.sessionDir(sessionId);
             const loadSegments = (segs) => {
                 if (segs.length === 0)
@@ -425,7 +281,7 @@ function nextManifestIndex(manifest) {
     return manifest[manifest.length - 1].manifestIndex + 1;
 }
 function nextEventIndexFromManifest(manifest) {
-    const segments = manifest.filter((m) => m.kind === 'segment_closed');
+    const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
     if (segments.length === 0)
         return 0;
     return segments[segments.length - 1].lastEventIndex + 1;
@@ -448,7 +304,7 @@ function validateManifestContiguity(manifest) {
     return (0, neverthrow_1.ok)(undefined);
 }
 function validateSegmentClosedContiguity(manifest) {
-    const segments = manifest.filter((m) => m.kind === 'segment_closed');
+    const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
     for (let i = 1; i < segments.length; i++) {
         const prev = segments[i - 1];
         const cur = segments[i];
@@ -589,9 +445,169 @@ function parseJsonlLines(bytes, schema) {
 function extractSnapshotPinsFromEvents(events) {
     const out = [];
     for (const e of events) {
-        if (e.kind !== 'node_created')
+        if (e.kind !== constants_js_1.EVENT_KIND.NODE_CREATED)
             continue;
         out.push({ snapshotRef: e.data.snapshotRef, eventIndex: e.eventIndex, createdByEventId: e.eventId });
     }
     return out;
 }
+function validateSegmentBounds(parsed, segment) {
+    if (parsed.length === 0) {
+        return (0, neverthrow_1.err)({
+            code: 'SESSION_STORE_CORRUPTION_DETECTED',
+            location: 'tail',
+            reason: { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${segment.segmentRelPath}` },
+            message: `Empty segment referenced by manifest: ${segment.segmentRelPath}`,
+        });
+    }
+    if (parsed[0].eventIndex !== segment.firstEventIndex || parsed[parsed.length - 1].eventIndex !== segment.lastEventIndex) {
+        return (0, neverthrow_1.err)({
+            code: 'SESSION_STORE_CORRUPTION_DETECTED',
+            location: 'tail',
+            reason: { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${segment.segmentRelPath}` },
+            message: `Segment bounds mismatch: ${segment.segmentRelPath}`,
+        });
+    }
+    for (let i = 1; i < parsed.length; i++) {
+        if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
+            return (0, neverthrow_1.err)({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: 'tail',
+                reason: { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${segment.segmentRelPath}` },
+                message: `Non-contiguous eventIndex inside segment: ${segment.segmentRelPath}`,
+            });
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+function parseManifestPrefix(lines) {
+    const manifest = [];
+    let isComplete = true;
+    let tailReason = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            isComplete = false;
+            tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: 'Invalid JSON in manifest (corrupt tail)' });
+            break;
+        }
+        const validated = index_js_1.ManifestRecordV1Schema.safeParse(parsed);
+        if (!validated.success) {
+            isComplete = false;
+            const rawVersion = (typeof parsed === 'object' && parsed !== null && 'v' in parsed)
+                ? parsed.v
+                : undefined;
+            if (rawVersion !== 1) {
+                tailReason ?? (tailReason = { code: 'unknown_schema_version', message: `Expected v=1, got v=${rawVersion}` });
+            }
+            else {
+                tailReason ?? (tailReason = { code: 'schema_validation_failed', message: 'Manifest record schema validation failed (corrupt tail)' });
+            }
+            break;
+        }
+        if (validated.data.manifestIndex !== i) {
+            isComplete = false;
+            tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: 'Non-contiguous manifestIndex in prefix (corrupt tail)' });
+            break;
+        }
+        manifest.push(validated.data);
+    }
+    return { manifest, isComplete, tailReason };
+}
+function processSegmentForSalvage(args) {
+    if (args.state.done)
+        return (0, neverthrow_1.okAsync)(args.state);
+    const segmentPath = path.join(args.sessionDir, args.segment.segmentRelPath);
+    return args.fs
+        .readFileBytes(segmentPath)
+        .map((bytes) => ({ kind: 'present', bytes }))
+        .orElse((e) => (e.code === 'FS_NOT_FOUND' ? (0, neverthrow_1.okAsync)({ kind: 'missing' }) : (0, neverthrow_1.errAsync)(mapFsToStoreError(e))))
+        .andThen((res) => {
+        if (res.kind === 'missing') {
+            return (0, neverthrow_1.okAsync)({
+                ...args.state,
+                isComplete: false,
+                tailReason: args.state.tailReason ?? { code: 'missing_attested_segment', message: `Missing attested segment: ${args.segment.segmentRelPath}` },
+                done: true,
+            });
+        }
+        const bytes = res.bytes;
+        const actual = args.sha256.sha256(bytes);
+        if (actual !== args.segment.sha256) {
+            return (0, neverthrow_1.okAsync)({
+                ...args.state,
+                isComplete: false,
+                tailReason: args.state.tailReason ?? { code: 'digest_mismatch', message: `Segment digest mismatch: ${args.segment.segmentRelPath}` },
+                done: true,
+            });
+        }
+        const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+        if (parsedRes.isErr()) {
+            return (0, neverthrow_1.okAsync)({
+                ...args.state,
+                isComplete: false,
+                tailReason: args.state.tailReason ?? { code: 'non_contiguous_indices', message: `Invalid JSONL inside segment: ${args.segment.segmentRelPath}` },
+                done: true,
+            });
+        }
+        const parsed = parsedRes.value;
+        const boundsResult = validateSegmentBounds(parsed, args.segment);
+        if (boundsResult.isErr()) {
+            const reason = boundsResult.error.code === 'SESSION_STORE_CORRUPTION_DETECTED'
+                ? boundsResult.error.reason
+                : { code: 'non_contiguous_indices', message: boundsResult.error.message };
+            return (0, neverthrow_1.okAsync)({
+                ...args.state,
+                isComplete: false,
+                tailReason: args.state.tailReason ?? reason,
+                done: true,
+            });
+        }
+        return (0, neverthrow_1.okAsync)({
+            ...args.state,
+            events: [...args.state.events, ...parsed],
+        });
+    });
+}
+function loadSegmentsRecursive(args) {
+    if (args.segments.length === 0)
+        return (0, neverthrow_1.okAsync)([]);
+    const [head, ...tail] = args.segments;
+    const segmentPath = path.join(args.sessionDir, head.segmentRelPath);
+    return args.fs.readFileBytes(segmentPath)
+        .mapErr((e) => {
+        if (e.code === 'FS_NOT_FOUND') {
+            return {
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: 'tail',
+                reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${head.segmentRelPath}` },
+                message: `Missing attested segment: ${head.segmentRelPath}`,
+            };
+        }
+        return mapFsToStoreError(e);
+    })
+        .andThen((bytes) => {
+        const actual = args.sha256.sha256(bytes);
+        if (actual !== head.sha256) {
+            return (0, neverthrow_1.errAsync)({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: 'tail',
+                reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${head.segmentRelPath}` },
+                message: `Segment digest mismatch: ${head.segmentRelPath}`,
+            });
+        }
+        const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+        if (parsedRes.isErr())
+            return (0, neverthrow_1.errAsync)(parsedRes.error);
+        const parsed = parsedRes.value;
+        const boundsResult = validateSegmentBounds(parsed, head);
+        if (boundsResult.isErr())
+            return (0, neverthrow_1.errAsync)(boundsResult.error);
+        return (0, neverthrow_1.okAsync)(parsed);
+    })
+        .andThen((events) => loadSegmentsRecursive({ ...args, segments: tail }).map((rest) => [...events, ...rest]));
+}

package/dist/v2/infra/local/session-summary-provider/index.js

@@ -7,6 +7,7 @@ const enumerate_sessions_js_1 = require("../../../usecases/enumerate-sessions.js
 const session_health_js_1 = require("../../../projections/session-health.js");
 const run_dag_js_1 = require("../../../projections/run-dag.js");
 const node_outputs_js_1 = require("../../../projections/node-outputs.js");
+const constants_js_1 = require("../../../durable-core/constants.js");
 const MAX_SESSIONS_TO_SCAN = 50;
 class LocalSessionSummaryProviderV2 {
     constructor(ports) {
@@ -107,7 +108,7 @@ function extractObservations(events) {
     let gitBranch = null;
     let repoRootHash = null;
     for (const event of events) {
-        if (event.kind !== 'observation_recorded')
+        if (event.kind !== constants_js_1.EVENT_KIND.OBSERVATION_RECORDED)
             continue;
         const data = event.data;
         switch (data.key) {
@@ -120,13 +121,15 @@ function extractObservations(events) {
             case 'repo_root_hash':
                 repoRootHash = data.value.value;
                 break;
+            default:
+                break;
         }
     }
     return { gitHeadSha, gitBranch, repoRootHash };
 }
 function extractWorkflowIdentity(events, runId) {
     for (const event of events) {
-        if (event.kind !== 'run_started')
+        if (event.kind !== constants_js_1.EVENT_KIND.RUN_STARTED)
             continue;
         const scope = event.scope;
         if (scope?.runId !== runId)

package/dist/v2/infra/local/snapshot-store/index.js

@@ -20,7 +20,7 @@ class LocalSnapshotStoreV2 {
             return (0, neverthrow_1.errAsync)(canonical.error);
         const ref = (0, index_js_1.asSnapshotRef)(this.crypto.sha256(canonical.value));
         const dir = this.dataDir.snapshotsDir();
-        const filePath = this.dataDir.snapshotPath(String(ref));
+        const filePath = this.dataDir.snapshotPath(ref);
         const tmpPath = `${filePath}.tmp`;
         return this.fs
             .mkdirp(dir)
@@ -35,7 +35,7 @@ class LocalSnapshotStoreV2 {
             .mapErr((e) => ({ code: 'SNAPSHOT_STORE_IO_ERROR', message: e.message }));
     }
     getExecutionSnapshotV1(snapshotRef) {
-        const filePath = this.dataDir.snapshotPath(String(snapshotRef));
+        const filePath = this.dataDir.snapshotPath(snapshotRef);
         return this.fs
             .readFileBytes(filePath)
             .andThen((bytes) => {

package/dist/v2/ports/data-dir.port.d.ts

@@ -1,13 +1,14 @@
+import type { SessionId, WorkflowHash, SnapshotRef } from '../durable-core/ids/index.js';
 export interface DataDirPortV2 {
     pinnedWorkflowsDir(): string;
-    pinnedWorkflowPath(workflowHash: string): string;
+    pinnedWorkflowPath(workflowHash: WorkflowHash): string;
     snapshotsDir(): string;
-    snapshotPath(snapshotRef: string): string;
+    snapshotPath(snapshotRef: SnapshotRef): string;
     keysDir(): string;
     keyringPath(): string;
     sessionsDir(): string;
-    sessionDir(sessionId: string): string;
-    sessionEventsDir(sessionId: string): string;
-    sessionManifestPath(sessionId: string): string;
-    sessionLockPath(sessionId: string): string;
+    sessionDir(sessionId: SessionId): string;
+    sessionEventsDir(sessionId: SessionId): string;
+    sessionManifestPath(sessionId: SessionId): string;
+    sessionLockPath(sessionId: SessionId): string;
 }