@exaudeus/workrail 0.8.6 → 0.9.0

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

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, lock) {
+        this.dataDir = dataDir;
+        this.fs = fs;
+        this.sha256 = sha256;
+        this.lock = lock;
+    }
+    append(sessionId, plan) {
+        return neverthrow_1.ResultAsync.fromPromise(this.appendImpl(sessionId, plan), (e) => {
+            if (e instanceof StoreFailure)
+                return e.storeError;
+            return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
+        });
+    }
+    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) };
+        });
+    }
+    async appendImpl(sessionId, plan) {
+        const lockHandle = await this.unwrap(this.lock.acquire(sessionId), mapLockError);
+        try {
+            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);
+            }
+        }
+        finally {
+            await this.lock.release(lockHandle).match(() => undefined, () => undefined);
+        }
+    }
+    async loadImpl(sessionId) {
+        const lockHandle = await this.unwrap(this.lock.acquire(sessionId), mapLockError);
+        try {
+            const sessionDir = this.dataDir.sessionDir(sessionId);
+            const manifestPath = this.dataDir.sessionManifestPath(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.unwrap(this.fs.readFileBytes(segmentPath), mapFsToStoreError);
+                const actual = this.sha256.sha256(bytes);
+                if (actual !== seg.sha256) {
+                    throw new StoreFailure({
+                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                        message: `Segment digest mismatch: ${seg.segmentRelPath}`,
+                    });
+                }
+                const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+                if (parsed.length === 0) {
+                    throw new StoreFailure({
+                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                        message: `Empty segment referenced by manifest: ${seg.segmentRelPath}`,
+                    });
+                }
+                if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
+                    throw new StoreFailure({
+                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                        message: `Segment bounds mismatch: ${seg.segmentRelPath}`,
+                    });
+                }
+                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',
+                            message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}`,
+                        });
+                    }
+                }
+                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',
+                        message: `Missing snapshot_pinned for introduced snapshotRef (pin-after-close violation): ${key}`,
+                    });
+                }
+            }
+            return { manifest, events };
+        }
+        finally {
+            await this.lock.release(lockHandle).match(() => undefined, () => undefined);
+        }
+    }
+    async 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));
+        });
+        if (raw.trim() === '')
+            return [];
+        return parseJsonlText(raw, index_js_1.ManifestRecordV1Schema);
+    }
+    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 };
+    }
+    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);
+    }
+    async unwrap(ra, map) {
+        return ra.match((v) => v, (e) => {
+            throw new StoreFailure(map(e));
+        });
+    }
+}
+exports.LocalSessionEventLogStoreV2 = LocalSessionEventLogStoreV2;
+function mapLockError(e) {
+    if (e.code === 'SESSION_LOCK_BUSY') {
+        return { code: 'SESSION_STORE_LOCK_BUSY', message: e.message, retry: e.retry };
+    }
+    return { code: 'SESSION_STORE_IO_ERROR', message: e.message };
+}
+function mapFsToStoreError(e) {
+    return { code: 'SESSION_STORE_IO_ERROR', message: e.message };
+}
+function nextManifestIndex(manifest) {
+    if (manifest.length === 0)
+        return 0;
+    return manifest[manifest.length - 1].manifestIndex + 1;
+}
+function nextEventIndexFromManifest(manifest) {
+    const segments = manifest.filter((m) => m.kind === 'segment_closed');
+    if (segments.length === 0)
+        return 0;
+    return segments[segments.length - 1].lastEventIndex + 1;
+}
+function validateManifestContiguityOrThrow(manifest) {
+    for (let i = 0; i < manifest.length; i++) {
+        const expected = i;
+        if (manifest[i].manifestIndex !== expected) {
+            throw new StoreFailure({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                message: `Non-contiguous manifestIndex at position ${i} (expected ${expected}, got ${manifest[i].manifestIndex})`,
+            });
+        }
+    }
+}
+function validateSegmentClosedContiguityOrThrow(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({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                message: `Non-contiguous segment_closed bounds (expected firstEventIndex=${prev.lastEventIndex + 1}, got ${cur.firstEventIndex})`,
+            });
+        }
+    }
+}
+function validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex) {
+    if (plan.events.length === 0) {
+        throw new StoreFailure({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: 'AppendPlan.events must be non-empty' });
+    }
+    const first = plan.events[0];
+    if (first.eventIndex !== expectedFirstEventIndex) {
+        throw new StoreFailure({
+            code: 'SESSION_STORE_INVARIANT_VIOLATION',
+            message: `AppendPlan.eventIndex must start at ${expectedFirstEventIndex} (got ${first.eventIndex})`,
+        });
+    }
+    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}` });
+        }
+        if (e.data.sessionId !== sessionId) {
+            throw new StoreFailure({
+                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({
+                code: 'SESSION_STORE_INVARIANT_VIOLATION',
+                message: `Non-contiguous eventIndex in AppendPlan at index ${i}`,
+            });
+        }
+    }
+    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({
+                code: 'SESSION_STORE_INVARIANT_VIOLATION',
+                message: `SnapshotPin.eventIndex must refer to an event in the appended segment`,
+            });
+        }
+    }
+}
+function sortedPins(pins) {
+    return [...pins].sort((a, b) => {
+        const sr = String(a.snapshotRef).localeCompare(String(b.snapshotRef));
+        if (sr !== 0)
+            return sr;
+        const ei = a.eventIndex - b.eventIndex;
+        if (ei !== 0)
+            return ei;
+        return a.createdByEventId.localeCompare(b.createdByEventId);
+    });
+}
+function segmentRelPathFor(firstEventIndex, lastEventIndex) {
+    const first = String(firstEventIndex).padStart(8, '0');
+    const last = String(lastEventIndex).padStart(8, '0');
+    return `events/${first}-${last}.jsonl`;
+}
+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 out = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        out.set(p, offset);
+        offset += p.length;
+    }
+    return out;
+}
+function parseJsonlText(text, schema) {
+    const lines = text.split('\n').filter((l) => l.trim() !== '');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new StoreFailure({ code: 'SESSION_STORE_CORRUPTION_DETECTED', message: `Invalid JSONL at line ${i}` });
+        }
+        const validated = schema.safeParse(parsed);
+        if (!validated.success) {
+            throw new StoreFailure({ code: 'SESSION_STORE_CORRUPTION_DETECTED', message: `Invalid record at line ${i}` });
+        }
+        out.push(validated.data);
+    }
+    return out;
+}
+function parseJsonlLines(bytes, schema) {
+    const text = new TextDecoder().decode(bytes);
+    return parseJsonlText(text, schema);
+}
+function extractSnapshotPinsFromEvents(events) {
+    const out = [];
+    for (const e of events) {
+        if (e.kind !== 'node_created')
+            continue;
+        const data = e.data;
+        if (typeof data !== 'object' || data === null)
+            continue;
+        const snap = data.snapshotRef;
+        if (typeof snap === 'string') {
+            out.push({ snapshotRef: snap, eventIndex: e.eventIndex, createdByEventId: e.eventId });
+        }
+    }
+    return out;
+}

package/dist/v2/infra/local/sha256/index.d.ts

@@ -0,0 +1,5 @@
+import type { Sha256PortV2 } from '../../../ports/sha256.port.js';
+import type { Sha256Digest } from '../../../durable-core/ids/index.js';
+export declare class NodeSha256V2 implements Sha256PortV2 {
+    sha256(bytes: Uint8Array): Sha256Digest;
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSha256V2 = void 0;
+const crypto_1 = require("crypto");
+const index_js_1 = require("../../../durable-core/ids/index.js");
+class NodeSha256V2 {
+    sha256(bytes) {
+        const hex = (0, crypto_1.createHash)('sha256').update(Buffer.from(bytes)).digest('hex');
+        return (0, index_js_1.asSha256Digest)(`sha256:${hex}`);
+    }
+}
+exports.NodeSha256V2 = NodeSha256V2;

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

@@ -0,0 +1,9 @@
+export interface DataDirPortV2 {
+    pinnedWorkflowsDir(): string;
+    pinnedWorkflowPath(workflowHash: string): string;
+    sessionsDir(): string;
+    sessionDir(sessionId: string): string;
+    sessionEventsDir(sessionId: string): string;
+    sessionManifestPath(sessionId: string): string;
+    sessionLockPath(sessionId: string): string;
+}

package/dist/v2/ports/data-dir.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/fs.port.d.ts

@@ -0,0 +1,41 @@
+import type { ResultAsync } from 'neverthrow';
+export type FsError = {
+    readonly code: 'FS_IO_ERROR';
+    readonly message: string;
+} | {
+    readonly code: 'FS_NOT_FOUND';
+    readonly message: string;
+} | {
+    readonly code: 'FS_ALREADY_EXISTS';
+    readonly message: string;
+} | {
+    readonly code: 'FS_PERMISSION_DENIED';
+    readonly message: string;
+} | {
+    readonly code: 'FS_UNSUPPORTED';
+    readonly message: string;
+};
+export interface FileSystemPortV2 {
+    mkdirp(dirPath: string): ResultAsync<void, FsError>;
+    readFileUtf8(filePath: string): ResultAsync<string, FsError>;
+    readFileBytes(filePath: string): ResultAsync<Uint8Array, FsError>;
+    writeFileBytes(filePath: string, bytes: Uint8Array): ResultAsync<void, FsError>;
+    openWriteTruncate(filePath: string): ResultAsync<{
+        readonly fd: number;
+    }, FsError>;
+    openAppend(filePath: string): ResultAsync<{
+        readonly fd: number;
+    }, FsError>;
+    writeAll(fd: number, bytes: Uint8Array): ResultAsync<void, FsError>;
+    openExclusive(filePath: string, bytes: Uint8Array): ResultAsync<{
+        readonly fd: number;
+    }, FsError>;
+    fsyncFile(fd: number): ResultAsync<void, FsError>;
+    fsyncDir(dirPath: string): ResultAsync<void, FsError>;
+    closeFile(fd: number): ResultAsync<void, FsError>;
+    rename(fromPath: string, toPath: string): ResultAsync<void, FsError>;
+    unlink(filePath: string): ResultAsync<void, FsError>;
+    stat(filePath: string): ResultAsync<{
+        readonly sizeBytes: number;
+    }, FsError>;
+}

package/dist/v2/ports/fs.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/pinned-workflow-store.port.d.ts

@@ -0,0 +1,11 @@
+import type { ResultAsync } from 'neverthrow';
+import type { WorkflowHash } from '../durable-core/ids/index.js';
+import type { CompiledWorkflowSnapshotV1 } from '../durable-core/schemas/compiled-workflow/index.js';
+export type PinnedWorkflowStoreError = {
+    readonly code: 'PINNED_WORKFLOW_IO_ERROR';
+    readonly message: string;
+};
+export interface PinnedWorkflowStorePortV2 {
+    get(workflowHash: WorkflowHash): ResultAsync<CompiledWorkflowSnapshotV1 | null, PinnedWorkflowStoreError>;
+    put(workflowHash: WorkflowHash, compiled: CompiledWorkflowSnapshotV1): ResultAsync<void, PinnedWorkflowStoreError>;
+}

package/dist/v2/ports/pinned-workflow-store.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/session-event-log-store.port.d.ts

@@ -0,0 +1,37 @@
+import type { ResultAsync } from 'neverthrow';
+import type { SessionId, SnapshotRef } from '../durable-core/ids/index.js';
+import type { DomainEventV1, ManifestRecordV1 } from '../durable-core/schemas/session/index.js';
+export interface SnapshotPinV2 {
+    readonly snapshotRef: SnapshotRef;
+    readonly eventIndex: number;
+    readonly createdByEventId: string;
+}
+export interface AppendPlanV2 {
+    readonly events: readonly DomainEventV1[];
+    readonly snapshotPins: readonly SnapshotPinV2[];
+}
+export type SessionEventLogStoreError = {
+    readonly code: 'SESSION_STORE_LOCK_BUSY';
+    readonly message: string;
+    readonly retry: {
+        readonly kind: 'retryable';
+        readonly afterMs: number;
+    };
+} | {
+    readonly code: 'SESSION_STORE_IO_ERROR';
+    readonly message: string;
+} | {
+    readonly code: 'SESSION_STORE_CORRUPTION_DETECTED';
+    readonly message: string;
+} | {
+    readonly code: 'SESSION_STORE_INVARIANT_VIOLATION';
+    readonly message: string;
+};
+export interface LoadedSessionTruthV2 {
+    readonly manifest: readonly ManifestRecordV1[];
+    readonly events: readonly DomainEventV1[];
+}
+export interface SessionEventLogStorePortV2 {
+    append(sessionId: SessionId, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
+}

package/dist/v2/ports/session-event-log-store.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/session-lock.port.d.ts

@@ -0,0 +1,23 @@
+import type { ResultAsync } from 'neverthrow';
+import type { SessionId } from '../durable-core/ids/index.js';
+export type SessionLockError = {
+    readonly code: 'SESSION_LOCK_BUSY';
+    readonly message: string;
+    readonly retry: {
+        readonly kind: 'retryable';
+        readonly afterMs: number;
+    };
+    readonly lockPath: string;
+} | {
+    readonly code: 'SESSION_LOCK_IO_ERROR';
+    readonly message: string;
+    readonly lockPath: string;
+};
+export interface SessionLockHandleV2 {
+    readonly kind: 'v2_session_lock_handle';
+    readonly sessionId: SessionId;
+}
+export interface SessionLockPortV2 {
+    acquire(sessionId: SessionId): ResultAsync<SessionLockHandleV2, SessionLockError>;
+    release(handle: SessionLockHandleV2): ResultAsync<void, SessionLockError>;
+}

package/dist/v2/ports/session-lock.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/ports/sha256.port.d.ts

@@ -0,0 +1,4 @@
+import type { Sha256Digest } from '../durable-core/ids/index.js';
+export interface Sha256PortV2 {
+    sha256(bytes: Uint8Array): Sha256Digest;
+}

package/dist/v2/ports/sha256.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/projections/advance-outcomes.d.ts

@@ -0,0 +1,23 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+type AdvanceRecordedEventV1 = Extract<DomainEventV1, {
+    kind: 'advance_recorded';
+}>;
+export interface NodeAdvanceOutcomeV2 {
+    readonly nodeId: string;
+    readonly latestAttemptId: string;
+    readonly outcome: AdvanceRecordedEventV1['data']['outcome'];
+    readonly recordedAtEventIndex: number;
+}
+export interface AdvanceOutcomesProjectionV2 {
+    readonly byNodeId: Readonly<Record<string, NodeAdvanceOutcomeV2>>;
+}
+export declare function projectAdvanceOutcomesV2(events: readonly DomainEventV1[]): Result<AdvanceOutcomesProjectionV2, ProjectionError>;
+export {};

package/dist/v2/projections/advance-outcomes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectAdvanceOutcomesV2 = projectAdvanceOutcomesV2;
+const neverthrow_1 = require("neverthrow");
+function projectAdvanceOutcomesV2(events) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({ code: 'PROJECTION_INVARIANT_VIOLATION', message: 'Events must be sorted by eventIndex ascending' });
+        }
+    }
+    const byNodeId = {};
+    for (const e of events) {
+        if (e.kind !== 'advance_recorded')
+            continue;
+        byNodeId[e.scope.nodeId] = {
+            nodeId: e.scope.nodeId,
+            latestAttemptId: e.data.attemptId,
+            outcome: e.data.outcome,
+            recordedAtEventIndex: e.eventIndex,
+        };
+    }
+    return (0, neverthrow_1.ok)({ byNodeId });
+}

package/dist/v2/projections/capabilities.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+export type CapabilityV2 = 'delegation' | 'web_browsing';
+export type CapabilityStatusV2 = 'unknown' | 'available' | 'unavailable';
+type CapabilityObservedEventV1 = Extract<DomainEventV1, {
+    kind: 'capability_observed';
+}>;
+export interface CapabilityObservationV2 {
+    readonly status: CapabilityStatusV2;
+    readonly provenance: CapabilityObservedEventV1['data']['provenance'];
+    readonly observedAtEventIndex: number;
+}
+export interface NodeCapabilitiesViewV2 {
+    readonly byCapability: Readonly<Record<CapabilityV2, CapabilityObservationV2 | null>>;
+}
+export interface CapabilitiesProjectionV2 {
+    readonly nodesById: Readonly<Record<string, NodeCapabilitiesViewV2>>;
+}
+export declare function projectCapabilitiesV2(events: readonly DomainEventV1[]): Result<CapabilitiesProjectionV2, ProjectionError>;
+export {};

package/dist/v2/projections/capabilities.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectCapabilitiesV2 = projectCapabilitiesV2;
+const neverthrow_1 = require("neverthrow");
+function projectCapabilitiesV2(events) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({ code: 'PROJECTION_INVARIANT_VIOLATION', message: 'Events must be sorted by eventIndex ascending' });
+        }
+    }
+    const nodes = {};
+    const ensure = (nodeId) => {
+        const existing = nodes[nodeId];
+        if (existing)
+            return existing;
+        const created = { byCapability: { delegation: null, web_browsing: null } };
+        nodes[nodeId] = created;
+        return created;
+    };
+    for (const e of events) {
+        if (e.kind !== 'capability_observed')
+            continue;
+        const nodeId = e.scope.nodeId;
+        const cap = e.data.capability;
+        const observation = {
+            status: e.data.status,
+            provenance: e.data.provenance,
+            observedAtEventIndex: e.eventIndex,
+        };
+        ensure(nodeId).byCapability[cap] = observation;
+    }
+    return (0, neverthrow_1.ok)({ nodesById: nodes });
+}