@exaudeus/workrail 0.11.0 → 0.12.0

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

@@ -4,12 +4,6 @@ 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");
-class StoreFailure extends Error {
-    constructor(storeError) {
-        super(storeError.message);
-        this.storeError = storeError;
-    }
-}
 class LocalSessionEventLogStoreV2 {
     constructor(dataDir, fs, sha256) {
         this.dataDir = dataDir;
@@ -23,286 +17,356 @@ class LocalSessionEventLogStoreV2 {
                 message: 'WithHealthySessionLock used after gate callback ended (witness misuse-after-release)',
             });
         }
-        return neverthrow_1.ResultAsync.fromPromise(this.appendImpl(lock.sessionId, plan), (e) => {
-            if (e instanceof StoreFailure)
-                return e.storeError;
-            return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
-        });
+        return this.appendImpl(lock.sessionId, plan);
     }
     load(sessionId) {
-        return neverthrow_1.ResultAsync.fromPromise(this.loadImpl(sessionId), (e) => {
-            if (e instanceof StoreFailure)
-                return e.storeError;
-            return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
-        });
+        return this.loadImpl(sessionId);
     }
     loadValidatedPrefix(sessionId) {
-        return neverthrow_1.ResultAsync.fromPromise(this.loadValidatedPrefixImpl(sessionId), (e) => {
-            if (e instanceof StoreFailure)
-                return e.storeError;
-            return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
-        });
+        return this.loadValidatedPrefixImpl(sessionId);
     }
-    async appendImpl(sessionId, plan) {
+    appendImpl(sessionId, plan) {
         const sessionDir = this.dataDir.sessionDir(sessionId);
         const eventsDir = this.dataDir.sessionEventsDir(sessionId);
         const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-        await this.unwrap(this.fs.mkdirp(eventsDir), mapFsToStoreError);
-        const { manifest, events: existingEvents } = await this.loadTruthOrEmpty(sessionId);
-        validateManifestContiguityOrThrow(manifest);
-        const existingByDedupeKey = new Set(existingEvents.map((e) => e.dedupeKey));
-        const allExist = plan.events.every((e) => existingByDedupeKey.has(e.dedupeKey));
-        if (allExist) {
-            return;
-        }
-        const anyExist = plan.events.some((e) => existingByDedupeKey.has(e.dedupeKey));
-        if (anyExist && !allExist) {
-            throw new StoreFailure({
-                code: 'SESSION_STORE_INVARIANT_VIOLATION',
-                message: 'Partial dedupeKey collision detected (some events exist, some do not); this is an invariant violation',
-            });
-        }
-        const expectedFirstEventIndex = nextEventIndexFromManifest(manifest);
-        validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex);
-        const first = plan.events[0].eventIndex;
-        const last = plan.events[plan.events.length - 1].eventIndex;
-        const segmentRelPath = segmentRelPathFor(first, last);
-        const segmentPath = `${sessionDir}/${segmentRelPath}`;
-        const tmpPath = `${segmentPath}.tmp`;
-        const segmentBytes = concatJsonlRecords(plan.events);
-        const tmpHandle = await this.unwrap(this.fs.openWriteTruncate(tmpPath), mapFsToStoreError);
-        await this.unwrap(this.fs.writeAll(tmpHandle.fd, segmentBytes), mapFsToStoreError);
-        await this.unwrap(this.fs.fsyncFile(tmpHandle.fd), mapFsToStoreError);
-        await this.unwrap(this.fs.closeFile(tmpHandle.fd), mapFsToStoreError);
-        await this.unwrap(this.fs.rename(tmpPath, segmentPath), mapFsToStoreError);
-        await this.unwrap(this.fs.fsyncDir(eventsDir), mapFsToStoreError);
-        const digest = this.sha256.sha256(segmentBytes);
-        const segClosed = {
-            v: 1,
-            manifestIndex: nextManifestIndex(manifest),
-            sessionId,
-            kind: 'segment_closed',
-            firstEventIndex: first,
-            lastEventIndex: last,
-            segmentRelPath,
-            sha256: digest,
-            bytes: segmentBytes.length,
-        };
-        await this.appendManifestRecords(manifestPath, [segClosed]);
-        const pins = sortedPins(plan.snapshotPins);
-        if (pins.length > 0) {
-            const startIndex = segClosed.manifestIndex + 1;
-            const records = pins.map((p, i) => ({
-                v: 1,
-                manifestIndex: startIndex + i,
-                sessionId,
-                kind: 'snapshot_pinned',
-                eventIndex: p.eventIndex,
-                snapshotRef: p.snapshotRef,
-                createdByEventId: p.createdByEventId,
-            }));
-            await this.appendManifestRecords(manifestPath, records);
-        }
-    }
-    async loadImpl(sessionId) {
-        const sessionDir = this.dataDir.sessionDir(sessionId);
-        const manifest = await this.readManifestOrEmpty(sessionId);
-        validateManifestContiguityOrThrow(manifest);
-        validateSegmentClosedContiguityOrThrow(manifest);
-        const segments = manifest.filter((m) => m.kind === 'segment_closed');
-        const events = [];
-        for (const seg of segments) {
-            const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
-            const bytes = await this.fs.readFileBytes(segmentPath).match((v) => v, (e) => {
-                if (e.code === 'FS_NOT_FOUND') {
-                    throw new StoreFailure({
-                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        location: 'tail',
-                        reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` },
-                        message: `Missing attested segment: ${seg.segmentRelPath}`,
-                    });
-                }
-                throw new StoreFailure(mapFsToStoreError(e));
-            });
-            const actual = this.sha256.sha256(bytes);
-            if (actual !== seg.sha256) {
-                throw new StoreFailure({
-                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                    location: 'tail',
-                    reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` },
-                    message: `Segment digest mismatch: ${seg.segmentRelPath}`,
-                });
+        return this.fs.mkdirp(eventsDir)
+            .mapErr(mapFsToStoreError)
+            .andThen(() => this.loadTruthOrEmpty(sessionId))
+            .andThen(({ manifest, events: existingEvents }) => {
+            const contiguityRes = validateManifestContiguity(manifest);
+            if (contiguityRes.isErr())
+                return (0, neverthrow_1.errAsync)(contiguityRes.error);
+            const existingByDedupeKey = new Set(existingEvents.map((e) => e.dedupeKey));
+            const allExist = plan.events.every((e) => existingByDedupeKey.has(e.dedupeKey));
+            if (allExist) {
+                return (0, neverthrow_1.okAsync)(undefined);
             }
-            const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-            if (parsed.length === 0) {
-                throw new StoreFailure({
-                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                    location: 'tail',
-                    reason: { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${seg.segmentRelPath}` },
-                    message: `Empty segment referenced by manifest: ${seg.segmentRelPath}`,
+            const anyExist = plan.events.some((e) => existingByDedupeKey.has(e.dedupeKey));
+            if (anyExist && !allExist) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'SESSION_STORE_INVARIANT_VIOLATION',
+                    message: 'Partial dedupeKey collision detected (some events exist, some do not); this is an invariant violation',
                 });
             }
-            if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
-                throw new StoreFailure({
-                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                    location: 'tail',
-                    reason: { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${seg.segmentRelPath}` },
-                    message: `Segment bounds mismatch: ${seg.segmentRelPath}`,
+            const expectedFirstEventIndex = nextEventIndexFromManifest(manifest);
+            const planRes = validateAppendPlan(sessionId, plan, expectedFirstEventIndex);
+            if (planRes.isErr())
+                return (0, neverthrow_1.errAsync)(planRes.error);
+            const first = plan.events[0].eventIndex;
+            const last = plan.events[plan.events.length - 1].eventIndex;
+            const segmentRelPath = segmentRelPathFor(first, last);
+            const segmentPath = `${sessionDir}/${segmentRelPath}`;
+            const tmpPath = `${segmentPath}.tmp`;
+            const segmentBytesRes = concatJsonlRecords(plan.events);
+            if (segmentBytesRes.isErr())
+                return (0, neverthrow_1.errAsync)(segmentBytesRes.error);
+            const segmentBytes = segmentBytesRes.value;
+            return this.fs.openWriteTruncate(tmpPath)
+                .mapErr(mapFsToStoreError)
+                .andThen((tmpHandle) => this.fs.writeAll(tmpHandle.fd, segmentBytes).mapErr(mapFsToStoreError)
+                .andThen(() => this.fs.fsyncFile(tmpHandle.fd).mapErr(mapFsToStoreError))
+                .andThen(() => this.fs.closeFile(tmpHandle.fd).mapErr(mapFsToStoreError)))
+                .andThen(() => this.fs.rename(tmpPath, segmentPath).mapErr(mapFsToStoreError))
+                .andThen(() => this.fs.fsyncDir(eventsDir).mapErr(mapFsToStoreError))
+                .andThen(() => {
+                const digest = this.sha256.sha256(segmentBytes);
+                const segClosed = {
+                    v: 1,
+                    manifestIndex: nextManifestIndex(manifest),
+                    sessionId,
+                    kind: 'segment_closed',
+                    firstEventIndex: first,
+                    lastEventIndex: last,
+                    segmentRelPath,
+                    sha256: digest,
+                    bytes: segmentBytes.length,
+                };
+                return this.appendManifestRecords(manifestPath, [segClosed])
+                    .andThen(() => {
+                    const pins = sortedPins(plan.snapshotPins);
+                    if (pins.length === 0)
+                        return (0, neverthrow_1.okAsync)(undefined);
+                    const startIndex = segClosed.manifestIndex + 1;
+                    const records = pins.map((p, i) => ({
+                        v: 1,
+                        manifestIndex: startIndex + i,
+                        sessionId,
+                        kind: 'snapshot_pinned',
+                        eventIndex: p.eventIndex,
+                        snapshotRef: p.snapshotRef,
+                        createdByEventId: p.createdByEventId,
+                    }));
+                    return this.appendManifestRecords(manifestPath, records);
                 });
-            }
-            for (let i = 1; i < parsed.length; i++) {
-                if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
-                    throw new StoreFailure({
-                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        location: 'tail',
-                        reason: { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}` },
-                        message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}`,
-                    });
+            });
+        });
+    }
+    loadImpl(sessionId) {
+        const sessionDir = this.dataDir.sessionDir(sessionId);
+        return this.readManifestOrEmpty(sessionId)
+            .andThen((manifest) => {
+            const contRes = validateManifestContiguity(manifest);
+            if (contRes.isErr())
+                return (0, neverthrow_1.errAsync)(contRes.error);
+            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 = `${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 expectedPins = extractSnapshotPinsFromEvents(events);
+                const actualPins = new Set(manifest
+                    .filter((m) => m.kind === 'snapshot_pinned')
+                    .map((p) => `${p.eventIndex}:${p.createdByEventId}:${p.snapshotRef}`));
+                for (const ep of expectedPins) {
+                    const key = `${ep.eventIndex}:${ep.createdByEventId}:${ep.snapshotRef}`;
+                    if (!actualPins.has(key)) {
+                        return (0, neverthrow_1.errAsync)({
+                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                            location: 'tail',
+                            reason: { code: 'missing_attested_segment', message: `Missing snapshot_pinned for introduced snapshotRef: ${key}` },
+                            message: `Missing snapshot_pinned for introduced snapshotRef: ${key}`,
+                        });
+                    }
                 }
-            }
-            events.push(...parsed);
-        }
-        const expectedPins = extractSnapshotPinsFromEvents(events);
-        const actualPins = new Set(manifest
-            .filter((m) => m.kind === 'snapshot_pinned')
-            .map((p) => `${p.eventIndex}:${p.createdByEventId}:${p.snapshotRef}`));
-        for (const ep of expectedPins) {
-            const key = `${ep.eventIndex}:${ep.createdByEventId}:${ep.snapshotRef}`;
-            if (!actualPins.has(key)) {
-                throw new StoreFailure({
-                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                    location: 'tail',
-                    reason: { code: 'missing_attested_segment', message: `Missing snapshot_pinned for introduced snapshotRef: ${key}` },
-                    message: `Missing snapshot_pinned for introduced snapshotRef: ${key}`,
-                });
-            }
-        }
-        return { manifest, events };
+                return (0, neverthrow_1.okAsync)({ manifest, events });
+            });
+        });
     }
-    async readManifestOrEmpty(sessionId) {
+    readManifestOrEmpty(sessionId) {
         const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-        const raw = await this.fs.readFileUtf8(manifestPath).match((v) => v, (e) => {
-            if (e.code === 'FS_NOT_FOUND')
-                return '';
-            throw new StoreFailure(mapFsToStoreError(e));
+        return this.fs
+            .readFileUtf8(manifestPath)
+            .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)([]);
+            const parsed = parseJsonlText(raw, index_js_1.ManifestRecordV1Schema);
+            return parsed.isErr() ? (0, neverthrow_1.errAsync)(parsed.error) : (0, neverthrow_1.okAsync)(parsed.value);
         });
-        if (raw.trim() === '')
-            return [];
-        return parseJsonlText(raw, index_js_1.ManifestRecordV1Schema);
     }
-    async loadValidatedPrefixImpl(sessionId) {
+    loadValidatedPrefixImpl(sessionId) {
         const sessionDir = this.dataDir.sessionDir(sessionId);
         const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-        const raw = await this.fs.readFileUtf8(manifestPath).match((v) => v, (e) => {
-            if (e.code === 'FS_NOT_FOUND')
-                return '';
-            throw new StoreFailure(mapFsToStoreError(e));
-        });
-        if (raw.trim() === '')
-            return { truth: { manifest: [], events: [] }, isComplete: true, tailReason: null };
-        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);
+        return this.fs
+            .readFileUtf8(manifestPath)
+            .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 });
             }
-            catch {
-                isComplete = false;
-                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;
-                tailReason = { code: 'unknown_schema_version', message: 'Unknown manifest schema version (corrupt tail)' };
-                break;
-            }
-            if (validated.data.manifestIndex !== i) {
-                isComplete = false;
-                tailReason = { code: 'non_contiguous_indices', message: 'Non-contiguous manifestIndex in prefix (corrupt tail)' };
-                break;
-            }
-            manifest.push(validated.data);
-        }
-        if (manifest.length === 0) {
-            throw new StoreFailure({
-                code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                location: 'head',
-                reason: { code: 'non_contiguous_indices', message: 'No validated manifest prefix' },
-                message: 'No validated manifest prefix',
-            });
-        }
-        const segments = manifest.filter((m) => m.kind === 'segment_closed');
-        const events = [];
-        for (const seg of segments) {
-            const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
-            const bytes = await this.fs.readFileBytes(segmentPath).match((v) => v, (e) => {
-                if (e.code === 'FS_NOT_FOUND')
-                    return null;
-                throw new StoreFailure(mapFsToStoreError(e));
-            });
-            if (bytes === null) {
-                isComplete = false;
-                tailReason ?? (tailReason = { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` });
-                break;
-            }
-            const actual = this.sha256.sha256(bytes);
-            if (actual !== seg.sha256) {
-                isComplete = false;
-                tailReason ?? (tailReason = { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` });
-                break;
-            }
-            const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-            if (parsed.length === 0) {
-                isComplete = false;
-                tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${seg.segmentRelPath}` });
-                break;
-            }
-            if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
-                isComplete = false;
-                tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${seg.segmentRelPath}` });
-                break;
-            }
-            for (let i = 1; i < parsed.length; i++) {
-                if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
+            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;
+                    tailReason ?? (tailReason = { code: 'unknown_schema_version', message: 'Unknown manifest schema version (corrupt tail)' });
+                    break;
+                }
+                if (validated.data.manifestIndex !== i) {
                     isComplete = false;
-                    tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}` });
+                    tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: 'Non-contiguous manifestIndex in prefix (corrupt tail)' });
                     break;
                 }
+                manifest.push(validated.data);
             }
-            events.push(...parsed);
-        }
-        return { truth: { manifest, events }, isComplete, tailReason };
-    }
-    async loadTruthOrEmpty(sessionId) {
-        const manifest = await this.readManifestOrEmpty(sessionId);
-        if (manifest.length === 0)
-            return { manifest: [], events: [] };
-        const segments = manifest.filter((m) => m.kind === 'segment_closed');
-        const sessionDir = this.dataDir.sessionDir(sessionId);
-        const events = [];
-        for (const seg of segments) {
-            const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
-            const bytes = await this.unwrap(this.fs.readFileBytes(segmentPath), mapFsToStoreError);
-            const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-            events.push(...parsed);
-        }
-        return { manifest, events };
+            if (manifest.length === 0) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'head',
+                    reason: { code: 'non_contiguous_indices', message: 'No validated manifest prefix' },
+                    message: 'No validated manifest prefix',
+                });
+            }
+            const segments = manifest.filter((m) => m.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 = `${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,
+            }));
+        });
     }
-    async appendManifestRecords(manifestPath, records) {
-        const handle = await this.unwrap(this.fs.openAppend(manifestPath), mapFsToStoreError);
-        const bytes = concatJsonlRecords(records);
-        await this.unwrap(this.fs.writeAll(handle.fd, bytes), mapFsToStoreError);
-        await this.unwrap(this.fs.fsyncFile(handle.fd), mapFsToStoreError);
-        await this.unwrap(this.fs.closeFile(handle.fd), mapFsToStoreError);
+    loadTruthOrEmpty(sessionId) {
+        return this.readManifestOrEmpty(sessionId)
+            .andThen((manifest) => {
+            if (manifest.length === 0)
+                return (0, neverthrow_1.okAsync)({ manifest: [], events: [] });
+            const segments = manifest.filter((m) => m.kind === 'segment_closed');
+            const sessionDir = this.dataDir.sessionDir(sessionId);
+            const loadSegments = (segs) => {
+                if (segs.length === 0)
+                    return (0, neverthrow_1.okAsync)([]);
+                const [head, ...tail] = segs;
+                const segmentPath = `${sessionDir}/${head.segmentRelPath}`;
+                return this.fs.readFileBytes(segmentPath)
+                    .mapErr(mapFsToStoreError)
+                    .andThen((bytes) => {
+                    const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+                    if (parsedRes.isErr())
+                        return (0, neverthrow_1.errAsync)(parsedRes.error);
+                    return (0, neverthrow_1.okAsync)(parsedRes.value);
+                })
+                    .andThen((events) => loadSegments(tail).map((rest) => [...events, ...rest]));
+            };
+            return loadSegments(segments).map((events) => ({ manifest, events }));
+        });
     }
-    async unwrap(ra, map) {
-        return ra.match((v) => v, (e) => {
-            throw new StoreFailure(map(e));
+    appendManifestRecords(manifestPath, records) {
+        return this.fs.openAppend(manifestPath)
+            .mapErr(mapFsToStoreError)
+            .andThen((handle) => {
+            const bytesRes = concatJsonlRecords(records);
+            if (bytesRes.isErr())
+                return (0, neverthrow_1.errAsync)(bytesRes.error);
+            const bytes = bytesRes.value;
+            return this.fs.writeAll(handle.fd, bytes).mapErr(mapFsToStoreError)
+                .andThen(() => this.fs.fsyncFile(handle.fd).mapErr(mapFsToStoreError))
+                .andThen(() => this.fs.closeFile(handle.fd).mapErr(mapFsToStoreError));
         });
     }
 }
@@ -321,11 +385,11 @@ function nextEventIndexFromManifest(manifest) {
         return 0;
     return segments[segments.length - 1].lastEventIndex + 1;
 }
-function validateManifestContiguityOrThrow(manifest) {
+function validateManifestContiguity(manifest) {
     for (let i = 0; i < manifest.length; i++) {
         const expected = i;
         if (manifest[i].manifestIndex !== expected) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
                 location: i === 0 ? 'head' : 'tail',
                 reason: {
@@ -336,14 +400,15 @@ function validateManifestContiguityOrThrow(manifest) {
             });
         }
     }
+    return (0, neverthrow_1.ok)(undefined);
 }
-function validateSegmentClosedContiguityOrThrow(manifest) {
+function validateSegmentClosedContiguity(manifest) {
     const segments = manifest.filter((m) => m.kind === 'segment_closed');
     for (let i = 1; i < segments.length; i++) {
         const prev = segments[i - 1];
         const cur = segments[i];
         if (cur.firstEventIndex !== prev.lastEventIndex + 1) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
                 location: 'tail',
                 reason: {
@@ -354,14 +419,15 @@ function validateSegmentClosedContiguityOrThrow(manifest) {
             });
         }
     }
+    return (0, neverthrow_1.ok)(undefined);
 }
-function validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex) {
+function validateAppendPlan(sessionId, plan, expectedFirstEventIndex) {
     if (plan.events.length === 0) {
-        throw new StoreFailure({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: 'AppendPlan.events must be non-empty' });
+        return (0, neverthrow_1.err)({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: 'AppendPlan.events must be non-empty' });
     }
     const first = plan.events[0];
     if (first.eventIndex !== expectedFirstEventIndex) {
-        throw new StoreFailure({
+        return (0, neverthrow_1.err)({
             code: 'SESSION_STORE_INVARIANT_VIOLATION',
             message: `AppendPlan.eventIndex must start at ${expectedFirstEventIndex} (got ${first.eventIndex})`,
         });
@@ -369,16 +435,16 @@ function validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex) {
     for (let i = 0; i < plan.events.length; i++) {
         const e = index_js_1.DomainEventV1Schema.safeParse(plan.events[i]);
         if (!e.success) {
-            throw new StoreFailure({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: `Invalid domain event at index ${i}` });
+            return (0, neverthrow_1.err)({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: `Invalid domain event at index ${i}` });
         }
         if (e.data.sessionId !== sessionId) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: `Domain event sessionId mismatch at index ${i}`,
             });
         }
         if (i > 0 && plan.events[i].eventIndex !== plan.events[i - 1].eventIndex + 1) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: `Non-contiguous eventIndex in AppendPlan at index ${i}`,
             });
@@ -387,12 +453,13 @@ function validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex) {
     const pins = sortedPins(plan.snapshotPins);
     for (const p of pins) {
         if (p.eventIndex < first.eventIndex || p.eventIndex > plan.events[plan.events.length - 1].eventIndex) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: `SnapshotPin.eventIndex must refer to an event in the appended segment`,
             });
         }
     }
+    return (0, neverthrow_1.ok)(undefined);
 }
 function sortedPins(pins) {
     return [...pins].sort((a, b) => {
@@ -414,11 +481,12 @@ function concatJsonlRecords(records) {
     const parts = [];
     let total = 0;
     for (const r of records) {
-        const encoded = (0, jsonl_js_1.toJsonlLineBytes)(r).match((v) => v, (e) => {
-            throw new StoreFailure({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: e.message });
-        });
-        parts.push(encoded);
-        total += encoded.length;
+        const encoded = (0, jsonl_js_1.toJsonlLineBytes)(r);
+        if (encoded.isErr())
+            return (0, neverthrow_1.err)({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: encoded.error.message });
+        const val = encoded.value;
+        parts.push(val);
+        total += val.length;
     }
     const out = new Uint8Array(total);
     let offset = 0;
@@ -426,7 +494,7 @@ function concatJsonlRecords(records) {
         out.set(p, offset);
         offset += p.length;
     }
-    return out;
+    return (0, neverthrow_1.ok)(out);
 }
 function parseJsonlText(text, schema) {
     const lines = text.split('\n').filter((l) => l.trim() !== '');
@@ -438,7 +506,7 @@ function parseJsonlText(text, schema) {
             parsed = JSON.parse(raw);
         }
         catch {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
                 location: i === 0 ? 'head' : 'tail',
                 reason: { code: 'non_contiguous_indices', message: `Invalid JSONL at line ${i}` },
@@ -447,7 +515,7 @@ function parseJsonlText(text, schema) {
         }
         const validated = schema.safeParse(parsed);
         if (!validated.success) {
-            throw new StoreFailure({
+            return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
                 location: i === 0 ? 'head' : 'tail',
                 reason: { code: 'unknown_schema_version', message: `Invalid record at line ${i}` },
@@ -456,7 +524,7 @@ function parseJsonlText(text, schema) {
         }
         out.push(validated.data);
     }
-    return out;
+    return (0, neverthrow_1.ok)(out);
 }
 function parseJsonlLines(bytes, schema) {
     const text = new TextDecoder().decode(bytes);