@exaudeus/workrail 0.11.0 → 0.13.0

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

@@ -0,0 +1,82 @@
+"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");
+const events_js_1 = require("../session/events.js");
+const index_js_2 = require("../session/index.js");
+const Sha256DigestSchema = zod_1.z
+    .string()
+    .regex(constants_js_1.SHA256_DIGEST_PATTERN, 'Expected sha256:<64 hex chars>')
+    .describe('SHA-256 digest in format sha256:<64 lowercase hex>');
+exports.IntegrityEntryV1Schema = zod_1.z.object({
+    path: zod_1.z.string().min(1).describe('Location within bundle (e.g., "session/events")'),
+    sha256: Sha256DigestSchema.describe('JCS canonical JSON + SHA-256'),
+    bytes: zod_1.z.number().int().nonnegative().describe('Byte length of JCS canonical UTF-8'),
+});
+exports.IntegrityManifestV1Schema = zod_1.z.object({
+    kind: zod_1.z.literal('sha256_manifest_v1').describe('Integrity scheme identifier'),
+    entries: zod_1.z
+        .array(exports.IntegrityEntryV1Schema)
+        .min(1)
+        .describe('Integrity entries for each major artifact path'),
+});
+exports.ProducerInfoV1Schema = zod_1.z.object({
+    appVersion: zod_1.z.string().min(1).describe('Application version that produced the bundle'),
+    appliedConfigHash: Sha256DigestSchema.optional().describe('Optional: hash of applied config'),
+});
+const SnapshotsMapV1Schema = zod_1.z
+    .record(zod_1.z.string().min(1).describe('SnapshotRef (sha256:<digest>)'), index_js_1.ExecutionSnapshotFileV1Schema)
+    .describe('Content-addressed snapshot storage');
+const PinnedWorkflowsMapV1Schema = zod_1.z
+    .record(zod_1.z.string().min(1).describe('WorkflowHash (sha256:<digest>)'), zod_1.z.unknown().describe('CompiledWorkflowV1 or equivalent snapshot'))
+    .describe('Pinned workflow definitions by hash');
+exports.SessionContentsV1Schema = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1).describe('Stable session identifier'),
+    events: zod_1.z
+        .array(events_js_1.DomainEventV1Schema)
+        .describe('Ordered session events by ascending eventIndex'),
+    manifest: zod_1.z
+        .array(index_js_2.ManifestRecordV1Schema)
+        .describe('Ordered manifest records by ascending manifestIndex'),
+    snapshots: SnapshotsMapV1Schema.describe('Content-addressed snapshot CAS'),
+    pinnedWorkflows: PinnedWorkflowsMapV1Schema.describe('Pinned workflow definitions'),
+});
+exports.ExportBundleV1Schema = zod_1.z.object({
+    bundleSchemaVersion: zod_1.z.literal(1).describe('Bundle format version (1)'),
+    bundleId: zod_1.z.string().min(1).describe('Stable bundle identifier'),
+    exportedAt: zod_1.z.string().datetime().describe('ISO 8601 timestamp (informational only)'),
+    producer: exports.ProducerInfoV1Schema.describe('Informational producer metadata'),
+    integrity: exports.IntegrityManifestV1Schema.describe('Corruption detection manifest'),
+    session: exports.SessionContentsV1Schema.describe('Session durable truth'),
+});
+exports.BundleImportErrorCodeSchema = zod_1.z.enum([
+    'BUNDLE_INVALID_FORMAT',
+    'BUNDLE_UNSUPPORTED_VERSION',
+    'BUNDLE_INTEGRITY_FAILED',
+    'BUNDLE_MISSING_SNAPSHOT',
+    'BUNDLE_MISSING_PINNED_WORKFLOW',
+    'BUNDLE_EVENT_ORDER_INVALID',
+    'BUNDLE_MANIFEST_ORDER_INVALID',
+]);
+exports.BundleImportErrorSchema = zod_1.z.object({
+    code: exports.BundleImportErrorCodeSchema,
+    message: zod_1.z.string().min(1).describe('Human-readable error message'),
+    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");
+Object.defineProperty(exports, "DomainEventV1Schema", { enumerable: true, get: function () { return events_js_2.DomainEventV1Schema; } });
+var index_js_4 = require("../session/index.js");
+Object.defineProperty(exports, "ManifestRecordV1Schema", { enumerable: true, get: function () { return index_js_4.ManifestRecordV1Schema; } });

package/dist/v2/durable-core/schemas/lib/decision-trace-ref.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const DecisionTraceRefKindSchema: z.ZodEnum<["step_id", "loop_id", "condition_id", "iteration"]>;
+export type DecisionTraceRefKind = z.infer<typeof DecisionTraceRefKindSchema>;
+export declare const DecisionTraceRefV1Schema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"step_id">;
+    stepId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "step_id";
+    stepId: string;
+}, {
+    kind: "step_id";
+    stepId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop_id">;
+    loopId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "loop_id";
+    loopId: string;
+}, {
+    kind: "loop_id";
+    loopId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"condition_id">;
+    conditionId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "condition_id";
+    conditionId: string;
+}, {
+    kind: "condition_id";
+    conditionId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"iteration">;
+    value: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    value: number;
+    kind: "iteration";
+}, {
+    value: number;
+    kind: "iteration";
+}>]>;
+export type DecisionTraceRefV1 = z.infer<typeof DecisionTraceRefV1Schema>;
+export declare const MAX_DECISION_TRACE_REFS_PER_ENTRY = 10;
+export declare const DecisionTraceRefsV1Schema: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"step_id">;
+    stepId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "step_id";
+    stepId: string;
+}, {
+    kind: "step_id";
+    stepId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop_id">;
+    loopId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "loop_id";
+    loopId: string;
+}, {
+    kind: "loop_id";
+    loopId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"condition_id">;
+    conditionId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "condition_id";
+    conditionId: string;
+}, {
+    kind: "condition_id";
+    conditionId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"iteration">;
+    value: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    value: number;
+    kind: "iteration";
+}, {
+    value: number;
+    kind: "iteration";
+}>]>, "many">>;
+export type DecisionTraceRefsV1 = z.infer<typeof DecisionTraceRefsV1Schema>;

package/dist/v2/durable-core/schemas/lib/decision-trace-ref.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionTraceRefsV1Schema = exports.MAX_DECISION_TRACE_REFS_PER_ENTRY = exports.DecisionTraceRefV1Schema = exports.DecisionTraceRefKindSchema = void 0;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+exports.DecisionTraceRefKindSchema = zod_1.z.enum([
+    'step_id',
+    'loop_id',
+    'condition_id',
+    'iteration',
+]);
+const StepIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('step_id'),
+    stepId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const LoopIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('loop_id'),
+    loopId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'loopId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const ConditionIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('condition_id'),
+    conditionId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'conditionId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const IterationRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('iteration'),
+    value: zod_1.z.number().int().nonnegative(),
+}).strict();
+exports.DecisionTraceRefV1Schema = zod_1.z.discriminatedUnion('kind', [
+    StepIdRefSchema,
+    LoopIdRefSchema,
+    ConditionIdRefSchema,
+    IterationRefSchema,
+]);
+exports.MAX_DECISION_TRACE_REFS_PER_ENTRY = 10;
+exports.DecisionTraceRefsV1Schema = zod_1.z
+    .array(exports.DecisionTraceRefV1Schema)
+    .max(exports.MAX_DECISION_TRACE_REFS_PER_ENTRY)
+    .optional();

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+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 declare function isValidDedupeKey(value: string): value is DedupeKeyV1;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedupeKeyV1Schema = exports.MAX_DEDUPE_KEY_LENGTH = exports.DEDUPE_KEY_PATTERN = void 0;
+exports.buildDedupeKey = buildDedupeKey;
+exports.isValidDedupeKey = isValidDedupeKey;
+const zod_1 = require("zod");
+exports.DEDUPE_KEY_PATTERN = /^[a-z0-9_:>-]+$/;
+exports.MAX_DEDUPE_KEY_LENGTH = 256;
+exports.DedupeKeyV1Schema = zod_1.z
+    .string()
+    .min(1)
+    .max(exports.MAX_DEDUPE_KEY_LENGTH)
+    .regex(exports.DEDUPE_KEY_PATTERN, 'dedupeKey must be ASCII-safe: [a-z0-9_:->]+');
+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}`);
+    }
+    if (key.length > exports.MAX_DEDUPE_KEY_LENGTH) {
+        throw new Error(`Invalid dedupeKey: "${key}" exceeds max length ${exports.MAX_DEDUPE_KEY_LENGTH}`);
+    }
+    return key;
+}
+function isValidDedupeKey(value) {
+    return (value.length > 0 &&
+        value.length <= exports.MAX_DEDUPE_KEY_LENGTH &&
+        exports.DEDUPE_KEY_PATTERN.test(value));
+}

package/dist/v2/durable-core/schemas/lib/utf8-bounded-string.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare function utf8BoundedString(opts: {
+    readonly maxBytes: number;
+    readonly label: string;
+    readonly minLength?: number;
+}): z.ZodEffects<z.ZodString, string, string>;

package/dist/v2/durable-core/schemas/lib/utf8-bounded-string.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8BoundedString = utf8BoundedString;
+const zod_1 = require("zod");
+function utf8BoundedString(opts) {
+    const encoder = new TextEncoder();
+    let schema = zod_1.z.string();
+    if (opts.minLength !== undefined && opts.minLength > 0) {
+        schema = schema.min(opts.minLength);
+    }
+    return schema.refine((s) => encoder.encode(s).length <= opts.maxBytes, { message: `${opts.label} exceeds ${opts.maxBytes} UTF-8 bytes` });
+}