@exaudeus/workrail 1.5.0 → 1.5.2

package/dist/v2/durable-core/schemas/export-bundle/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManifestRecordV1Schema = exports.DomainEventV1Schema = exports.ExecutionSnapshotFileV1Schema = exports.BundleImportErrorSchema = exports.BundleImportErrorCodeSchema = exports.ExportBundleV1Schema = exports.SessionContentsV1Schema = exports.ProducerInfoV1Schema = exports.IntegrityManifestV1Schema = exports.IntegrityEntryV1Schema = void 0;
-exports.importCollisionPolicy = importCollisionPolicy;
-exports.importValidationOrder = importValidationOrder;
 const zod_1 = require("zod");
 const constants_js_1 = require("../../constants.js");
 const index_js_1 = require("../execution-snapshot/index.js");
@@ -68,12 +66,6 @@ exports.BundleImportErrorSchema = zod_1.z.object({
     retry: zod_1.z.enum(['yes', 'no']).describe('Whether caller should retry'),
     details: zod_1.z.record(zod_1.z.unknown()).optional().describe('Additional debugging context'),
 });
-function importCollisionPolicy(args) {
-    return 'import_as_new';
-}
-function importValidationOrder() {
-    return ['schema', 'integrity', 'ordering', 'references'];
-}
 var index_js_3 = require("../execution-snapshot/index.js");
 Object.defineProperty(exports, "ExecutionSnapshotFileV1Schema", { enumerable: true, get: function () { return index_js_3.ExecutionSnapshotFileV1Schema; } });
 var events_js_2 = require("../session/events.js");

package/dist/v2/durable-core/schemas/lib/dedupe-key.d.ts

@@ -1,8 +1,16 @@
 import { z } from 'zod';
+import type { Result } from 'neverthrow';
 import type { Brand } from '../../../../runtime/brand.js';
 export type DedupeKeyV1 = Brand<string, 'v2.DedupeKeyV1'>;
 export declare const DEDUPE_KEY_PATTERN: RegExp;
 export declare const MAX_DEDUPE_KEY_LENGTH = 256;
 export declare const DedupeKeyV1Schema: z.ZodString;
-export declare function buildDedupeKey(kind: string, parts: readonly string[]): DedupeKeyV1;
+export type DedupeKeyError = {
+    readonly code: 'DEDUPE_KEY_INVALID_PATTERN';
+    readonly message: string;
+} | {
+    readonly code: 'DEDUPE_KEY_TOO_LONG';
+    readonly message: string;
+};
+export declare function buildDedupeKey(kind: string, parts: readonly string[]): Result<DedupeKeyV1, DedupeKeyError>;
 export declare function isValidDedupeKey(value: string): value is DedupeKeyV1;

package/dist/v2/durable-core/schemas/lib/dedupe-key.js

@@ -4,6 +4,7 @@ exports.DedupeKeyV1Schema = exports.MAX_DEDUPE_KEY_LENGTH = exports.DEDUPE_KEY_P
 exports.buildDedupeKey = buildDedupeKey;
 exports.isValidDedupeKey = isValidDedupeKey;
 const zod_1 = require("zod");
+const neverthrow_1 = require("neverthrow");
 exports.DEDUPE_KEY_PATTERN = /^[a-z0-9_:>-]+$/;
 exports.MAX_DEDUPE_KEY_LENGTH = 256;
 exports.DedupeKeyV1Schema = zod_1.z
@@ -14,12 +15,12 @@ exports.DedupeKeyV1Schema = zod_1.z
 function buildDedupeKey(kind, parts) {
     const key = [kind, ...parts].join(':');
     if (!exports.DEDUPE_KEY_PATTERN.test(key)) {
-        throw new Error(`Invalid dedupeKey: "${key}" does not match pattern ${exports.DEDUPE_KEY_PATTERN}`);
+        return (0, neverthrow_1.err)({ code: 'DEDUPE_KEY_INVALID_PATTERN', message: `dedupeKey "${key}" does not match pattern ${exports.DEDUPE_KEY_PATTERN}` });
     }
     if (key.length > exports.MAX_DEDUPE_KEY_LENGTH) {
-        throw new Error(`Invalid dedupeKey: "${key}" exceeds max length ${exports.MAX_DEDUPE_KEY_LENGTH}`);
+        return (0, neverthrow_1.err)({ code: 'DEDUPE_KEY_TOO_LONG', message: `dedupeKey "${key}" exceeds max length ${exports.MAX_DEDUPE_KEY_LENGTH}` });
     }
-    return key;
+    return (0, neverthrow_1.ok)(key);
 }
 function isValidDedupeKey(value) {
     return (value.length > 0 &&

package/dist/v2/durable-core/schemas/lib/utf8-byte-length.d.ts

@@ -0,0 +1 @@
+export declare function utf8ByteLength(s: string): number;

package/dist/v2/durable-core/schemas/lib/utf8-byte-length.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8ByteLength = utf8ByteLength;
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}

package/dist/v2/durable-core/schemas/session/blockers.d.ts

@@ -0,0 +1,305 @@
+import { z } from 'zod';
+export declare const BlockerCodeSchema: z.ZodEnum<["USER_ONLY_DEPENDENCY", "MISSING_REQUIRED_OUTPUT", "INVALID_REQUIRED_OUTPUT", "REQUIRED_CAPABILITY_UNKNOWN", "REQUIRED_CAPABILITY_UNAVAILABLE", "INVARIANT_VIOLATION", "STORAGE_CORRUPTION_DETECTED"]>;
+export declare const BlockerPointerSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"context_key">;
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    kind: "context_key";
+}, {
+    key: string;
+    kind: "context_key";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"context_budget">;
+}, "strip", z.ZodTypeAny, {
+    kind: "context_budget";
+}, {
+    kind: "context_budget";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"output_contract">;
+    contractRef: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "output_contract";
+    contractRef: string;
+}, {
+    kind: "output_contract";
+    contractRef: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"capability">;
+    capability: z.ZodEnum<["delegation", "web_browsing"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "capability";
+    capability: "delegation" | "web_browsing";
+}, {
+    kind: "capability";
+    capability: "delegation" | "web_browsing";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"workflow_step">;
+    stepId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "workflow_step";
+    stepId: string;
+}, {
+    kind: "workflow_step";
+    stepId: string;
+}>]>;
+export declare const BlockerSchema: z.ZodObject<{
+    code: z.ZodEnum<["USER_ONLY_DEPENDENCY", "MISSING_REQUIRED_OUTPUT", "INVALID_REQUIRED_OUTPUT", "REQUIRED_CAPABILITY_UNKNOWN", "REQUIRED_CAPABILITY_UNAVAILABLE", "INVARIANT_VIOLATION", "STORAGE_CORRUPTION_DETECTED"]>;
+    pointer: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"context_key">;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        kind: "context_key";
+    }, {
+        key: string;
+        kind: "context_key";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"context_budget">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "context_budget";
+    }, {
+        kind: "context_budget";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"output_contract">;
+        contractRef: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "output_contract";
+        contractRef: string;
+    }, {
+        kind: "output_contract";
+        contractRef: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"capability">;
+        capability: z.ZodEnum<["delegation", "web_browsing"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "capability";
+        capability: "delegation" | "web_browsing";
+    }, {
+        kind: "capability";
+        capability: "delegation" | "web_browsing";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"workflow_step">;
+        stepId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "workflow_step";
+        stepId: string;
+    }, {
+        kind: "workflow_step";
+        stepId: string;
+    }>]>;
+    message: z.ZodEffects<z.ZodString, string, string>;
+    suggestedFix: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+    pointer: {
+        key: string;
+        kind: "context_key";
+    } | {
+        kind: "context_budget";
+    } | {
+        kind: "output_contract";
+        contractRef: string;
+    } | {
+        kind: "capability";
+        capability: "delegation" | "web_browsing";
+    } | {
+        kind: "workflow_step";
+        stepId: string;
+    };
+    suggestedFix?: string | undefined;
+}, {
+    message: string;
+    code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+    pointer: {
+        key: string;
+        kind: "context_key";
+    } | {
+        kind: "context_budget";
+    } | {
+        kind: "output_contract";
+        contractRef: string;
+    } | {
+        kind: "capability";
+        capability: "delegation" | "web_browsing";
+    } | {
+        kind: "workflow_step";
+        stepId: string;
+    };
+    suggestedFix?: string | undefined;
+}>;
+export declare const BlockerReportV1Schema: z.ZodEffects<z.ZodObject<{
+    blockers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<["USER_ONLY_DEPENDENCY", "MISSING_REQUIRED_OUTPUT", "INVALID_REQUIRED_OUTPUT", "REQUIRED_CAPABILITY_UNKNOWN", "REQUIRED_CAPABILITY_UNAVAILABLE", "INVARIANT_VIOLATION", "STORAGE_CORRUPTION_DETECTED"]>;
+        pointer: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"context_key">;
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            kind: "context_key";
+        }, {
+            key: string;
+            kind: "context_key";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"context_budget">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "context_budget";
+        }, {
+            kind: "context_budget";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"output_contract">;
+            contractRef: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "output_contract";
+            contractRef: string;
+        }, {
+            kind: "output_contract";
+            contractRef: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"capability">;
+            capability: z.ZodEnum<["delegation", "web_browsing"]>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        }, {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"workflow_step">;
+            stepId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "workflow_step";
+            stepId: string;
+        }, {
+            kind: "workflow_step";
+            stepId: string;
+        }>]>;
+        message: z.ZodEffects<z.ZodString, string, string>;
+        suggestedFix: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }, {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    blockers: readonly {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }[];
+}, {
+    blockers: readonly {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }[];
+}>, {
+    blockers: readonly {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }[];
+}, {
+    blockers: readonly {
+        message: string;
+        code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
+        pointer: {
+            key: string;
+            kind: "context_key";
+        } | {
+            kind: "context_budget";
+        } | {
+            kind: "output_contract";
+            contractRef: string;
+        } | {
+            kind: "capability";
+            capability: "delegation" | "web_browsing";
+        } | {
+            kind: "workflow_step";
+            stepId: string;
+        };
+        suggestedFix?: string | undefined;
+    }[];
+}>;
+export type BlockerV1 = z.infer<typeof BlockerSchema>;
+export type BlockerReportV1 = z.infer<typeof BlockerReportV1Schema>;

package/dist/v2/durable-core/schemas/session/blockers.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockerReportV1Schema = exports.BlockerSchema = exports.BlockerPointerSchema = exports.BlockerCodeSchema = void 0;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+const utf8_byte_length_js_1 = require("../lib/utf8-byte-length.js");
+exports.BlockerCodeSchema = zod_1.z.enum([
+    'USER_ONLY_DEPENDENCY',
+    'MISSING_REQUIRED_OUTPUT',
+    'INVALID_REQUIRED_OUTPUT',
+    'REQUIRED_CAPABILITY_UNKNOWN',
+    'REQUIRED_CAPABILITY_UNAVAILABLE',
+    'INVARIANT_VIOLATION',
+    'STORAGE_CORRUPTION_DETECTED',
+]);
+exports.BlockerPointerSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({ kind: zod_1.z.literal('context_key'), key: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'context_key must be delimiter-safe: [a-z0-9_-]+') }),
+    zod_1.z.object({ kind: zod_1.z.literal('context_budget') }),
+    zod_1.z.object({ kind: zod_1.z.literal('output_contract'), contractRef: zod_1.z.string().min(1) }),
+    zod_1.z.object({ kind: zod_1.z.literal('capability'), capability: zod_1.z.enum(['delegation', 'web_browsing']) }),
+    zod_1.z.object({ kind: zod_1.z.literal('workflow_step'), stepId: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+') }),
+]);
+exports.BlockerSchema = zod_1.z.object({
+    code: exports.BlockerCodeSchema,
+    pointer: exports.BlockerPointerSchema,
+    message: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => (0, utf8_byte_length_js_1.utf8ByteLength)(s) <= constants_js_1.MAX_BLOCKER_MESSAGE_BYTES, {
+        message: `Blocker message exceeds ${constants_js_1.MAX_BLOCKER_MESSAGE_BYTES} bytes (UTF-8)`,
+    }),
+    suggestedFix: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => (0, utf8_byte_length_js_1.utf8ByteLength)(s) <= constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES, {
+        message: `Blocker suggestedFix exceeds ${constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES} bytes (UTF-8)`,
+    })
+        .optional(),
+});
+exports.BlockerReportV1Schema = zod_1.z
+    .object({
+    blockers: zod_1.z.array(exports.BlockerSchema).min(1).max(constants_js_1.MAX_BLOCKERS).readonly(),
+})
+    .superRefine((v, ctx) => {
+    const keyFor = (b) => {
+        const p = b.pointer;
+        let ptrStable;
+        switch (p.kind) {
+            case 'context_key':
+                ptrStable = p.key;
+                break;
+            case 'output_contract':
+                ptrStable = p.contractRef;
+                break;
+            case 'capability':
+                ptrStable = p.capability;
+                break;
+            case 'workflow_step':
+                ptrStable = p.stepId;
+                break;
+            case 'context_budget':
+                ptrStable = '';
+                break;
+            default:
+                const _exhaustive = p;
+                ptrStable = _exhaustive;
+        }
+        return `${b.code}|${p.kind}|${String(ptrStable)}`;
+    };
+    for (let i = 1; i < v.blockers.length; i++) {
+        if (keyFor(v.blockers[i - 1]) > keyFor(v.blockers[i])) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: 'blockers must be deterministically sorted',
+                path: ['blockers'],
+            });
+            break;
+        }
+    }
+});

package/dist/v2/durable-core/schemas/session/dag-topology.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+export declare const NodeKindSchema: z.ZodEnum<["step", "checkpoint", "blocked_attempt"]>;
+export declare const NodeCreatedDataV1Schema: z.ZodObject<{
+    nodeKind: z.ZodEnum<["step", "checkpoint", "blocked_attempt"]>;
+    parentNodeId: z.ZodNullable<z.ZodString>;
+    workflowHash: z.ZodEffects<z.ZodString, never, string>;
+    snapshotRef: z.ZodEffects<z.ZodString, never, string>;
+}, "strip", z.ZodTypeAny, {
+    snapshotRef: never;
+    nodeKind: "checkpoint" | "step" | "blocked_attempt";
+    parentNodeId: string | null;
+    workflowHash: never;
+}, {
+    snapshotRef: string;
+    nodeKind: "checkpoint" | "step" | "blocked_attempt";
+    parentNodeId: string | null;
+    workflowHash: string;
+}>;
+export declare const EdgeKindSchema: z.ZodEnum<["acked_step", "checkpoint"]>;
+export declare const EdgeCauseKindSchema: z.ZodEnum<["idempotent_replay", "intentional_fork", "non_tip_advance", "checkpoint_created"]>;
+export declare const EdgeCauseSchema: z.ZodObject<{
+    kind: z.ZodEnum<["idempotent_replay", "intentional_fork", "non_tip_advance", "checkpoint_created"]>;
+    eventId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+    eventId: string;
+}, {
+    kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+    eventId: string;
+}>;
+export declare const EdgeCreatedDataV1Schema: z.ZodEffects<z.ZodObject<{
+    edgeKind: z.ZodEnum<["acked_step", "checkpoint"]>;
+    fromNodeId: z.ZodString;
+    toNodeId: z.ZodString;
+    cause: z.ZodObject<{
+        kind: z.ZodEnum<["idempotent_replay", "intentional_fork", "non_tip_advance", "checkpoint_created"]>;
+        eventId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    }, {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    cause: {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    };
+    edgeKind: "acked_step" | "checkpoint";
+    fromNodeId: string;
+    toNodeId: string;
+}, {
+    cause: {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    };
+    edgeKind: "acked_step" | "checkpoint";
+    fromNodeId: string;
+    toNodeId: string;
+}>, {
+    cause: {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    };
+    edgeKind: "acked_step" | "checkpoint";
+    fromNodeId: string;
+    toNodeId: string;
+}, {
+    cause: {
+        kind: "intentional_fork" | "non_tip_advance" | "idempotent_replay" | "checkpoint_created";
+        eventId: string;
+    };
+    edgeKind: "acked_step" | "checkpoint";
+    fromNodeId: string;
+    toNodeId: string;
+}>;

package/dist/v2/durable-core/schemas/session/dag-topology.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeCreatedDataV1Schema = exports.EdgeCauseSchema = exports.EdgeCauseKindSchema = exports.EdgeKindSchema = exports.NodeCreatedDataV1Schema = exports.NodeKindSchema = void 0;
+const zod_1 = require("zod");
+const index_js_1 = require("../../ids/index.js");
+const constants_js_1 = require("../../constants.js");
+const sha256DigestSchema = zod_1.z
+    .string()
+    .regex(constants_js_1.SHA256_DIGEST_PATTERN, 'Expected sha256:<64 hex chars>')
+    .describe('sha256 digest in WorkRail v2 format');
+const workflowHashSchema = sha256DigestSchema
+    .transform((v) => (0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(v)))
+    .describe('WorkflowHash (sha256 digest of workflow definition)');
+const snapshotRefSchema = sha256DigestSchema
+    .transform((v) => (0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(v)))
+    .describe('SnapshotRef (content-addressed sha256 ref)');
+exports.NodeKindSchema = zod_1.z.enum(['step', 'checkpoint', 'blocked_attempt']);
+exports.NodeCreatedDataV1Schema = zod_1.z.object({
+    nodeKind: exports.NodeKindSchema,
+    parentNodeId: zod_1.z.string().min(1).nullable(),
+    workflowHash: workflowHashSchema,
+    snapshotRef: snapshotRefSchema,
+});
+exports.EdgeKindSchema = zod_1.z.enum(['acked_step', 'checkpoint']);
+exports.EdgeCauseKindSchema = zod_1.z.enum(['idempotent_replay', 'intentional_fork', 'non_tip_advance', 'checkpoint_created']);
+exports.EdgeCauseSchema = zod_1.z.object({
+    kind: exports.EdgeCauseKindSchema,
+    eventId: zod_1.z.string().min(1),
+});
+exports.EdgeCreatedDataV1Schema = zod_1.z
+    .object({
+    edgeKind: exports.EdgeKindSchema,
+    fromNodeId: zod_1.z.string().min(1),
+    toNodeId: zod_1.z.string().min(1),
+    cause: exports.EdgeCauseSchema,
+})
+    .superRefine((v, ctx) => {
+    if (v.edgeKind === 'checkpoint' && v.cause.kind !== 'checkpoint_created') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'edgeKind=checkpoint requires cause.kind=checkpoint_created',
+            path: ['cause', 'kind'],
+        });
+    }
+});