@exaudeus/workrail 1.2.0 → 1.3.0

package/dist/manifest.json

@@ -1081,6 +1081,22 @@
       "sha256": "f3c86be68aaa045c57c942459031a72df2b2d514e32a57905c1a57f8374e947f",
       "bytes": 1718
     },
+    "v2/durable-core/domain/bundle-builder.d.ts": {
+      "sha256": "4038983872901590c2aaaa6a27ad2af2f381e2816627f01f8d4276435c8c8a87",
+      "bytes": 1221
+    },
+    "v2/durable-core/domain/bundle-builder.js": {
+      "sha256": "f5422dda0c2a6591d7adc6460be49eb3967298658b51ebf0afd4f041a5395305",
+      "bytes": 3468
+    },
+    "v2/durable-core/domain/bundle-validator.d.ts": {
+      "sha256": "549df7b80ab5c2adcdb7c14e2ae7c668ca3531dfd53aab32bdd364180ef4cecd",
+      "bytes": 334
+    },
+    "v2/durable-core/domain/bundle-validator.js": {
+      "sha256": "b68d6fbbbe5bbb207d566118f9d7080ce39f51ba3eb8568a588861ef5639341c",
+      "bytes": 5925
+    },
     "v2/durable-core/domain/context-merge.d.ts": {
       "sha256": "e3068d49237d2ae351cf88c6829bf612dc7ced6f726b618e7f8aeb7462d34256",
       "bytes": 381
@@ -1840,6 +1856,22 @@
     "v2/usecases/execution-session-gate.js": {
       "sha256": "41a25f3046ed474c6c6223655ca1c21d0666aea171c024f51b85071619abfa52",
       "bytes": 7635
+    },
+    "v2/usecases/export-session.d.ts": {
+      "sha256": "037c6efb463c121feb41eff43d3b035e8443a12d25fcffb5387453ac5a49ae44",
+      "bytes": 2049
+    },
+    "v2/usecases/export-session.js": {
+      "sha256": "a91125866d50fe0a00bc8ef7d1a29bd43958b8e4eaff2e73a8247384e2d113db",
+      "bytes": 4092
+    },
+    "v2/usecases/import-session.d.ts": {
+      "sha256": "30c470707f5370f2b90d786f1d959a0a01bc4fecf3296a523a49518c626f99a8",
+      "bytes": 1514
+    },
+    "v2/usecases/import-session.js": {
+      "sha256": "9b9c8922cc2e6d6904f564c35ff0e402a2e755187f36ee7e54e76826f51bed5c",
+      "bytes": 2788
     }
   }
 }

package/dist/v2/durable-core/domain/bundle-builder.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../schemas/session/events.js';
+import type { ManifestRecordV1 } from '../schemas/session/index.js';
+import type { ExecutionSnapshotFileV1 } from '../schemas/execution-snapshot/index.js';
+import type { ExportBundleV1 } from '../schemas/export-bundle/index.js';
+import type { Sha256Digest } from '../ids/index.js';
+export interface BuildExportBundleArgs {
+    readonly bundleId: string;
+    readonly sessionId: string;
+    readonly events: readonly DomainEventV1[];
+    readonly manifest: readonly ManifestRecordV1[];
+    readonly snapshots: ReadonlyMap<string, ExecutionSnapshotFileV1>;
+    readonly pinnedWorkflows: ReadonlyMap<string, unknown>;
+    readonly producer: {
+        readonly appVersion: string;
+        readonly appliedConfigHash?: string;
+    };
+    readonly sha256: (bytes: Uint8Array) => Sha256Digest;
+}
+export type BundleBuilderError = {
+    readonly code: 'BUNDLE_BUILD_EMPTY_EVENTS';
+    readonly message: string;
+} | {
+    readonly code: 'BUNDLE_BUILD_CANONICALIZE_FAILED';
+    readonly message: string;
+};
+export declare function buildExportBundle(args: BuildExportBundleArgs): Result<ExportBundleV1, BundleBuilderError>;

package/dist/v2/durable-core/domain/bundle-builder.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExportBundle = buildExportBundle;
+const neverthrow_1 = require("neverthrow");
+const jcs_js_1 = require("../canonical/jcs.js");
+function buildExportBundle(args) {
+    if (args.events.length === 0) {
+        return (0, neverthrow_1.err)({
+            code: 'BUNDLE_BUILD_EMPTY_EVENTS',
+            message: 'Cannot export a session with no events',
+        });
+    }
+    const snapshotsRecord = {};
+    for (const [ref, snapshot] of args.snapshots) {
+        snapshotsRecord[ref] = snapshot;
+    }
+    const pinnedWorkflowsRecord = {};
+    for (const [hash, compiled] of args.pinnedWorkflows) {
+        pinnedWorkflowsRecord[hash] = compiled;
+    }
+    const integrityResult = computeIntegrityEntries({
+        events: args.events,
+        manifest: args.manifest,
+        snapshots: snapshotsRecord,
+        pinnedWorkflows: pinnedWorkflowsRecord,
+        sha256: args.sha256,
+    });
+    if (integrityResult.isErr())
+        return (0, neverthrow_1.err)(integrityResult.error);
+    const bundle = {
+        bundleSchemaVersion: 1,
+        bundleId: args.bundleId,
+        exportedAt: new Date().toISOString(),
+        producer: {
+            appVersion: args.producer.appVersion,
+            ...(args.producer.appliedConfigHash != null
+                ? { appliedConfigHash: args.producer.appliedConfigHash }
+                : {}),
+        },
+        integrity: {
+            kind: 'sha256_manifest_v1',
+            entries: integrityResult.value,
+        },
+        session: {
+            sessionId: args.sessionId,
+            events: args.events,
+            manifest: args.manifest,
+            snapshots: snapshotsRecord,
+            pinnedWorkflows: pinnedWorkflowsRecord,
+        },
+    };
+    return (0, neverthrow_1.ok)(bundle);
+}
+function computeIntegrityEntries(args) {
+    const entries = [];
+    const eventsEntry = computeEntry('session/events', args.events, args.sha256);
+    if (eventsEntry.isErr())
+        return (0, neverthrow_1.err)(eventsEntry.error);
+    entries.push(eventsEntry.value);
+    const manifestEntry = computeEntry('session/manifest', args.manifest, args.sha256);
+    if (manifestEntry.isErr())
+        return (0, neverthrow_1.err)(manifestEntry.error);
+    entries.push(manifestEntry.value);
+    for (const [ref, snapshot] of Object.entries(args.snapshots)) {
+        const entry = computeEntry(`session/snapshots/${ref}`, snapshot, args.sha256);
+        if (entry.isErr())
+            return (0, neverthrow_1.err)(entry.error);
+        entries.push(entry.value);
+    }
+    for (const [hash, compiled] of Object.entries(args.pinnedWorkflows)) {
+        const entry = computeEntry(`session/pinnedWorkflows/${hash}`, compiled, args.sha256);
+        if (entry.isErr())
+            return (0, neverthrow_1.err)(entry.error);
+        entries.push(entry.value);
+    }
+    return (0, neverthrow_1.ok)(entries);
+}
+function computeEntry(path, value, sha256) {
+    const canonicalResult = (0, jcs_js_1.toCanonicalBytes)(value);
+    if (canonicalResult.isErr()) {
+        return (0, neverthrow_1.err)({
+            code: 'BUNDLE_BUILD_CANONICALIZE_FAILED',
+            message: `Failed to canonicalize ${path}: ${canonicalResult.error.message}`,
+        });
+    }
+    const bytes = canonicalResult.value;
+    const digest = sha256(bytes);
+    return (0, neverthrow_1.ok)({
+        path,
+        sha256: digest,
+        bytes: bytes.byteLength,
+    });
+}

package/dist/v2/durable-core/domain/bundle-validator.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from 'neverthrow';
+import { type ExportBundleV1, type BundleImportError } from '../schemas/export-bundle/index.js';
+import type { Sha256Digest } from '../ids/index.js';
+export declare function validateBundle(raw: unknown, sha256: (bytes: Uint8Array) => Sha256Digest): Result<ExportBundleV1, BundleImportError>;

package/dist/v2/durable-core/domain/bundle-validator.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBundle = validateBundle;
+const neverthrow_1 = require("neverthrow");
+const index_js_1 = require("../schemas/export-bundle/index.js");
+const jcs_js_1 = require("../canonical/jcs.js");
+function validateBundle(raw, sha256) {
+    const schemaResult = validateSchema(raw);
+    if (schemaResult.isErr())
+        return schemaResult;
+    const bundle = schemaResult.value;
+    const integrityResult = validateIntegrity(bundle, sha256);
+    if (integrityResult.isErr())
+        return (0, neverthrow_1.err)(integrityResult.error);
+    const orderingResult = validateOrdering(bundle);
+    if (orderingResult.isErr())
+        return (0, neverthrow_1.err)(orderingResult.error);
+    const referencesResult = validateReferences(bundle);
+    if (referencesResult.isErr())
+        return (0, neverthrow_1.err)(referencesResult.error);
+    return (0, neverthrow_1.ok)(bundle);
+}
+function validateSchema(raw) {
+    if (typeof raw === 'object' &&
+        raw !== null &&
+        'bundleSchemaVersion' in raw &&
+        raw.bundleSchemaVersion !== 1) {
+        return (0, neverthrow_1.err)(importError('BUNDLE_UNSUPPORTED_VERSION', `Unsupported bundle schema version: ${String(raw.bundleSchemaVersion)}. Expected 1.`));
+    }
+    const parsed = index_js_1.ExportBundleV1Schema.safeParse(raw);
+    if (!parsed.success) {
+        return (0, neverthrow_1.err)(importError('BUNDLE_INVALID_FORMAT', `Bundle schema validation failed: ${parsed.error.issues.map(i => i.message).join('; ')}`));
+    }
+    return (0, neverthrow_1.ok)(parsed.data);
+}
+function validateIntegrity(bundle, sha256) {
+    for (const entry of bundle.integrity.entries) {
+        const value = resolveIntegrityPath(bundle, entry.path);
+        if (value === undefined) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_INTEGRITY_FAILED', `Integrity path not found in bundle: ${entry.path}`));
+        }
+        const canonicalResult = (0, jcs_js_1.toCanonicalBytes)(value);
+        if (canonicalResult.isErr()) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_INTEGRITY_FAILED', `Failed to canonicalize ${entry.path}: ${canonicalResult.error.message}`));
+        }
+        const bytes = canonicalResult.value;
+        const computedDigest = sha256(bytes);
+        if (computedDigest !== entry.sha256) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_INTEGRITY_FAILED', `Integrity mismatch for ${entry.path}: expected ${entry.sha256}, got ${computedDigest}`));
+        }
+        if (bytes.byteLength !== entry.bytes) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_INTEGRITY_FAILED', `Byte length mismatch for ${entry.path}: expected ${String(entry.bytes)}, got ${String(bytes.byteLength)}`));
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+function resolveIntegrityPath(bundle, path) {
+    if (path === 'session/events')
+        return bundle.session.events;
+    if (path === 'session/manifest')
+        return bundle.session.manifest;
+    const snapshotPrefix = 'session/snapshots/';
+    if (path.startsWith(snapshotPrefix)) {
+        const ref = path.slice(snapshotPrefix.length);
+        return bundle.session.snapshots[ref];
+    }
+    const workflowPrefix = 'session/pinnedWorkflows/';
+    if (path.startsWith(workflowPrefix)) {
+        const hash = path.slice(workflowPrefix.length);
+        return bundle.session.pinnedWorkflows[hash];
+    }
+    return undefined;
+}
+function validateOrdering(bundle) {
+    const events = bundle.session.events;
+    for (let i = 1; i < events.length; i++) {
+        const prev = events[i - 1].eventIndex;
+        const curr = events[i].eventIndex;
+        if (curr <= prev) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_EVENT_ORDER_INVALID', `Events not in ascending eventIndex order: index ${String(i)} has eventIndex ${String(curr)} ≤ previous ${String(prev)}`));
+        }
+    }
+    const manifest = bundle.session.manifest;
+    for (let i = 1; i < manifest.length; i++) {
+        const prev = manifest[i - 1].manifestIndex;
+        const curr = manifest[i].manifestIndex;
+        if (curr <= prev) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_MANIFEST_ORDER_INVALID', `Manifest records not in ascending manifestIndex order: index ${String(i)} has manifestIndex ${String(curr)} ≤ previous ${String(prev)}`));
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+function validateReferences(bundle) {
+    const referencedSnapshots = new Set();
+    const referencedWorkflows = new Set();
+    for (const event of bundle.session.events) {
+        const evt = event;
+        if (evt.kind === 'node_created') {
+            if (typeof evt.data.snapshotRef === 'string') {
+                referencedSnapshots.add(evt.data.snapshotRef);
+            }
+            if (typeof evt.data.workflowHash === 'string') {
+                referencedWorkflows.add(evt.data.workflowHash);
+            }
+        }
+        if (evt.kind === 'run_started' && typeof evt.data.workflowHash === 'string') {
+            referencedWorkflows.add(evt.data.workflowHash);
+        }
+    }
+    for (const ref of referencedSnapshots) {
+        if (!(ref in bundle.session.snapshots)) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_MISSING_SNAPSHOT', `Referenced snapshotRef not found in bundle: ${ref}`, { missingRef: ref }));
+        }
+    }
+    for (const hash of referencedWorkflows) {
+        if (!(hash in bundle.session.pinnedWorkflows)) {
+            return (0, neverthrow_1.err)(importError('BUNDLE_MISSING_PINNED_WORKFLOW', `Referenced workflowHash not found in bundle: ${hash}`, { missingHash: hash }));
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+function importError(code, message, details) {
+    return {
+        code,
+        message,
+        retry: 'no',
+        ...(details != null ? { details } : {}),
+    };
+}

package/dist/v2/usecases/export-session.d.ts

@@ -0,0 +1,47 @@
+import type { ResultAsync } from 'neverthrow';
+import type { SessionId, Sha256Digest } from '../durable-core/ids/index.js';
+import type { SessionEventLogReadonlyStorePortV2, SessionEventLogStoreError } from '../ports/session-event-log-store.port.js';
+import type { SnapshotStorePortV2, SnapshotStoreError } from '../ports/snapshot-store.port.js';
+import type { PinnedWorkflowStorePortV2, PinnedWorkflowStoreError } from '../ports/pinned-workflow-store.port.js';
+import type { ExportBundleV1 } from '../durable-core/schemas/export-bundle/index.js';
+import { type BundleBuilderError } from '../durable-core/domain/bundle-builder.js';
+export interface ExportSessionPorts {
+    readonly sessionStore: SessionEventLogReadonlyStorePortV2;
+    readonly snapshotStore: SnapshotStorePortV2;
+    readonly pinnedWorkflowStore: PinnedWorkflowStorePortV2;
+    readonly sha256: (bytes: Uint8Array) => Sha256Digest;
+}
+export interface ExportSessionArgs {
+    readonly sessionId: SessionId;
+    readonly bundleId: string;
+    readonly producer: {
+        readonly appVersion: string;
+        readonly appliedConfigHash?: string;
+    };
+}
+export type ExportSessionError = {
+    readonly code: 'EXPORT_SESSION_STORE_ERROR';
+    readonly message: string;
+    readonly cause: SessionEventLogStoreError;
+} | {
+    readonly code: 'EXPORT_SNAPSHOT_STORE_ERROR';
+    readonly message: string;
+    readonly cause: SnapshotStoreError;
+} | {
+    readonly code: 'EXPORT_PINNED_WORKFLOW_STORE_ERROR';
+    readonly message: string;
+    readonly cause: PinnedWorkflowStoreError;
+} | {
+    readonly code: 'EXPORT_MISSING_SNAPSHOT';
+    readonly message: string;
+    readonly snapshotRef: string;
+} | {
+    readonly code: 'EXPORT_MISSING_PINNED_WORKFLOW';
+    readonly message: string;
+    readonly workflowHash: string;
+} | {
+    readonly code: 'EXPORT_BUILD_FAILED';
+    readonly message: string;
+    readonly cause: BundleBuilderError;
+};
+export declare function exportSession(args: ExportSessionArgs, ports: ExportSessionPorts): ResultAsync<ExportBundleV1, ExportSessionError>;

package/dist/v2/usecases/export-session.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportSession = exportSession;
+const neverthrow_1 = require("neverthrow");
+const bundle_builder_js_1 = require("../durable-core/domain/bundle-builder.js");
+function exportSession(args, ports) {
+    return ports.sessionStore
+        .load(args.sessionId)
+        .mapErr((cause) => ({
+        code: 'EXPORT_SESSION_STORE_ERROR',
+        message: `Failed to load session ${args.sessionId}: ${cause.message}`,
+        cause,
+    }))
+        .andThen((truth) => {
+        const snapshotRefs = new Set();
+        const workflowHashes = new Set();
+        for (const event of truth.events) {
+            const evt = event;
+            if (evt.kind === 'node_created') {
+                if (typeof evt.data.snapshotRef === 'string')
+                    snapshotRefs.add(evt.data.snapshotRef);
+                if (typeof evt.data.workflowHash === 'string')
+                    workflowHashes.add(evt.data.workflowHash);
+            }
+            if (evt.kind === 'run_started' && typeof evt.data.workflowHash === 'string') {
+                workflowHashes.add(evt.data.workflowHash);
+            }
+        }
+        const snapshotEntries = [...snapshotRefs].map((ref) => ports.snapshotStore
+            .getExecutionSnapshotV1(ref)
+            .mapErr((cause) => ({
+            code: 'EXPORT_SNAPSHOT_STORE_ERROR',
+            message: `Failed to load snapshot ${ref}: ${cause.message}`,
+            cause,
+        }))
+            .andThen((snapshot) => {
+            if (snapshot === null) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'EXPORT_MISSING_SNAPSHOT',
+                    message: `Snapshot not found: ${ref}`,
+                    snapshotRef: ref,
+                });
+            }
+            return (0, neverthrow_1.okAsync)([ref, snapshot]);
+        }));
+        const workflowEntries = [...workflowHashes].map((hash) => ports.pinnedWorkflowStore
+            .get(hash)
+            .mapErr((cause) => ({
+            code: 'EXPORT_PINNED_WORKFLOW_STORE_ERROR',
+            message: `Failed to load pinned workflow ${hash}: ${cause.message}`,
+            cause,
+        }))
+            .andThen((compiled) => {
+            if (compiled === null) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'EXPORT_MISSING_PINNED_WORKFLOW',
+                    message: `Pinned workflow not found: ${hash}`,
+                    workflowHash: hash,
+                });
+            }
+            return (0, neverthrow_1.okAsync)([hash, compiled]);
+        }));
+        const allSnapshots = snapshotEntries.length > 0
+            ? snapshotEntries.reduce((acc, next) => acc.andThen((list) => next.map((entry) => [...list, entry])), (0, neverthrow_1.okAsync)([]))
+            : (0, neverthrow_1.okAsync)([]);
+        const allWorkflows = workflowEntries.length > 0
+            ? workflowEntries.reduce((acc, next) => acc.andThen((list) => next.map((entry) => [...list, entry])), (0, neverthrow_1.okAsync)([]))
+            : (0, neverthrow_1.okAsync)([]);
+        return allSnapshots.andThen((snapshotPairs) => allWorkflows.andThen((workflowPairs) => {
+            const snapshots = new Map(snapshotPairs);
+            const pinnedWorkflows = new Map(workflowPairs);
+            const buildResult = (0, bundle_builder_js_1.buildExportBundle)({
+                bundleId: args.bundleId,
+                sessionId: args.sessionId,
+                events: truth.events,
+                manifest: truth.manifest,
+                snapshots,
+                pinnedWorkflows,
+                producer: args.producer,
+                sha256: ports.sha256,
+            });
+            if (buildResult.isErr()) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'EXPORT_BUILD_FAILED',
+                    message: `Bundle build failed: ${buildResult.error.message}`,
+                    cause: buildResult.error,
+                });
+            }
+            return (0, neverthrow_1.okAsync)(buildResult.value);
+        }));
+    });
+}

package/dist/v2/usecases/import-session.d.ts

@@ -0,0 +1,34 @@
+import type { ResultAsync } from 'neverthrow';
+import type { Sha256Digest } from '../durable-core/ids/index.js';
+import type { SnapshotStorePortV2, SnapshotStoreError } from '../ports/snapshot-store.port.js';
+import type { PinnedWorkflowStorePortV2, PinnedWorkflowStoreError } from '../ports/pinned-workflow-store.port.js';
+import type { BundleImportError, ExportBundleV1 } from '../durable-core/schemas/export-bundle/index.js';
+export interface ImportSessionPorts {
+    readonly snapshotStore: SnapshotStorePortV2;
+    readonly pinnedWorkflowStore: PinnedWorkflowStorePortV2;
+    readonly generateSessionId: () => string;
+    readonly sha256: (bytes: Uint8Array) => Sha256Digest;
+}
+export interface ImportResult {
+    readonly sessionId: string;
+    readonly eventCount: number;
+    readonly snapshotCount: number;
+    readonly pinnedWorkflowCount: number;
+    readonly validatedBundle: ExportBundleV1;
+}
+export type ImportSessionError = BundleImportError | {
+    readonly code: 'IMPORT_SNAPSHOT_STORE_ERROR';
+    readonly message: string;
+    readonly retry: 'no';
+    readonly cause: SnapshotStoreError;
+} | {
+    readonly code: 'IMPORT_PINNED_WORKFLOW_STORE_ERROR';
+    readonly message: string;
+    readonly retry: 'no';
+    readonly cause: PinnedWorkflowStoreError;
+} | {
+    readonly code: 'IMPORT_SNAPSHOT_PARSE_ERROR';
+    readonly message: string;
+    readonly retry: 'no';
+};
+export declare function importSession(raw: unknown, ports: ImportSessionPorts): ResultAsync<ImportResult, ImportSessionError>;

package/dist/v2/usecases/import-session.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSession = importSession;
+const neverthrow_1 = require("neverthrow");
+const index_js_1 = require("../durable-core/ids/index.js");
+const index_js_2 = require("../durable-core/schemas/execution-snapshot/index.js");
+const bundle_validator_js_1 = require("../durable-core/domain/bundle-validator.js");
+function importSession(raw, ports) {
+    const validationResult = (0, bundle_validator_js_1.validateBundle)(raw, ports.sha256);
+    if (validationResult.isErr()) {
+        return (0, neverthrow_1.errAsync)(validationResult.error);
+    }
+    const bundle = validationResult.value;
+    const newSessionId = ports.generateSessionId();
+    const workflowKeys = Object.keys(bundle.session.pinnedWorkflows);
+    const storeWorkflows = workflowKeys.length > 0
+        ? workflowKeys.reduce((chain, hash) => chain.andThen(() => ports.pinnedWorkflowStore
+            .put((0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(hash)), bundle.session.pinnedWorkflows[hash])
+            .mapErr((cause) => ({
+            code: 'IMPORT_PINNED_WORKFLOW_STORE_ERROR',
+            message: `Failed to store pinned workflow ${hash}: ${cause.message}`,
+            retry: 'no',
+            cause,
+        }))), (0, neverthrow_1.okAsync)(undefined))
+        : (0, neverthrow_1.okAsync)(undefined);
+    const snapshotKeys = Object.keys(bundle.session.snapshots);
+    const storeSnapshots = snapshotKeys.length > 0
+        ? snapshotKeys.reduce((chain, ref) => chain.andThen(() => {
+            const rawSnapshot = bundle.session.snapshots[ref];
+            const parsed = index_js_2.ExecutionSnapshotFileV1Schema.safeParse(rawSnapshot);
+            if (!parsed.success) {
+                return (0, neverthrow_1.errAsync)({
+                    code: 'IMPORT_SNAPSHOT_PARSE_ERROR',
+                    message: `Snapshot ${ref} failed schema validation: ${parsed.error.issues.map(i => i.message).join('; ')}`,
+                    retry: 'no',
+                });
+            }
+            return ports.snapshotStore
+                .putExecutionSnapshotV1(parsed.data)
+                .mapErr((cause) => ({
+                code: 'IMPORT_SNAPSHOT_STORE_ERROR',
+                message: `Failed to store snapshot ${ref}: ${cause.message}`,
+                retry: 'no',
+                cause,
+            }));
+        }), (0, neverthrow_1.okAsync)(undefined))
+        : (0, neverthrow_1.okAsync)(undefined);
+    return storeWorkflows
+        .andThen(() => storeSnapshots)
+        .map(() => ({
+        sessionId: newSessionId,
+        eventCount: bundle.session.events.length,
+        snapshotCount: snapshotKeys.length,
+        pinnedWorkflowCount: workflowKeys.length,
+        validatedBundle: bundle,
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {