@exaudeus/workrail 1.1.0 → 1.2.0

package/dist/v2/durable-core/domain/validation-criteria-validator.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VALIDATION_CRITERIA_CONTRACT_REF = void 0;
 exports.getOutputRequirementStatusV1 = getOutputRequirementStatusV1;
+exports.getOutputRequirementStatusWithArtifactsV1 = getOutputRequirementStatusWithArtifactsV1;
+const artifact_contract_validator_js_1 = require("./artifact-contract-validator.js");
 exports.VALIDATION_CRITERIA_CONTRACT_REF = 'wr.validationCriteria';
 function getOutputRequirementStatusV1(args) {
     if (!args.validationCriteria)
@@ -14,3 +16,31 @@ function getOutputRequirementStatusV1(args) {
     }
     return { kind: 'not_required' };
 }
+function getOutputRequirementStatusWithArtifactsV1(args) {
+    if (args.outputContract) {
+        const result = (0, artifact_contract_validator_js_1.validateArtifactContract)(args.artifacts, args.outputContract);
+        if (!result.valid) {
+            const error = result.error;
+            if (error.code === 'MISSING_REQUIRED_ARTIFACT') {
+                return { kind: 'missing', contractRef: error.contractRef };
+            }
+            if (error.code === 'INVALID_ARTIFACT_SCHEMA') {
+                const validationResult = {
+                    valid: false,
+                    issues: error.issues.map(issue => issue),
+                    suggestions: ['Provide a valid artifact matching the contract schema'],
+                };
+                return { kind: 'invalid', contractRef: error.contractRef, validation: validationResult };
+            }
+            if (error.code === 'UNKNOWN_CONTRACT_REF') {
+                return { kind: 'missing', contractRef: error.contractRef };
+            }
+        }
+        return { kind: 'not_required' };
+    }
+    return getOutputRequirementStatusV1({
+        validationCriteria: args.validationCriteria,
+        notesMarkdown: args.notesMarkdown,
+        validation: args.validation,
+    });
+}

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

@@ -0,0 +1,26 @@
+import { type Result } from 'neverthrow';
+import type { ValidationResult } from '../../../types/validation.js';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
+export type ValidationEventError = {
+    readonly code: 'VALIDATION_EVENT_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'VALIDATION_EVENT_TEXT_TOO_LARGE';
+    readonly message: string;
+};
+export declare function buildValidationPerformedEvent(args: {
+    readonly sessionId: string;
+    readonly validationId: string;
+    readonly attemptId: string;
+    readonly contractRef: string;
+    readonly result: ValidationResult;
+    readonly scope: {
+        readonly runId: string;
+        readonly nodeId: string;
+    };
+    readonly minted: {
+        readonly eventId: string;
+    };
+}): Result<EventToAppendV1, ValidationEventError>;
+export {};

package/dist/v2/durable-core/domain/validation-event-builder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildValidationPerformedEvent = buildValidationPerformedEvent;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}
+function uniqueSorted(values) {
+    const sorted = [...values].filter((v) => v.length > 0).sort((a, b) => a.localeCompare(b, 'en-US'));
+    const out = [];
+    for (const v of sorted) {
+        if (out.length === 0 || out[out.length - 1] !== v)
+            out.push(v);
+    }
+    return out;
+}
+const VALIDATION_TRUNCATION_ITEM = '[TRUNCATED]';
+function truncateListToUtf8ByteBudget(args) {
+    if (args.maxBytes <= 0) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'maxBytes must be positive' });
+    }
+    const markerBytes = args.includeTruncationMarker ? utf8ByteLength(VALIDATION_TRUNCATION_ITEM) : 0;
+    if (args.includeTruncationMarker && markerBytes > args.maxBytes) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_TEXT_TOO_LARGE', message: 'validation truncation marker does not fit budget' });
+    }
+    const values = uniqueSorted(args.values);
+    const out = [];
+    let used = 0;
+    for (const v of values) {
+        const bytes = utf8ByteLength(v);
+        if (bytes > args.maxBytes) {
+            return (0, neverthrow_1.err)({
+                code: 'VALIDATION_EVENT_TEXT_TOO_LARGE',
+                message: 'validation item exceeds max bytes budget',
+            });
+        }
+        const remainingBudget = args.maxBytes - used;
+        const reserve = args.includeTruncationMarker ? markerBytes : 0;
+        const canFitWithReserve = bytes <= remainingBudget - reserve;
+        if (!canFitWithReserve) {
+            if (args.includeTruncationMarker) {
+                if (used + markerBytes <= args.maxBytes)
+                    out.push(VALIDATION_TRUNCATION_ITEM);
+            }
+            return (0, neverthrow_1.ok)(out);
+        }
+        out.push(v);
+        used += bytes;
+    }
+    return (0, neverthrow_1.ok)(out);
+}
+function buildValidationPerformedEvent(args) {
+    if (!args.sessionId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'sessionId is required' });
+    if (!args.validationId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'validationId is required' });
+    if (!args.attemptId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'attemptId is required' });
+    if (!args.contractRef)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'contractRef is required' });
+    if (!args.scope.runId || !args.scope.nodeId) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'scope.runId and scope.nodeId are required' });
+    }
+    if (!args.minted.eventId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'minted.eventId is required' });
+    const issuesRes = truncateListToUtf8ByteBudget({
+        values: args.result.issues ?? [],
+        maxBytes: constants_js_1.MAX_VALIDATION_ISSUES_BYTES,
+        includeTruncationMarker: true,
+    });
+    if (issuesRes.isErr())
+        return (0, neverthrow_1.err)(issuesRes.error);
+    const suggestionsRes = truncateListToUtf8ByteBudget({
+        values: args.result.suggestions ?? [],
+        maxBytes: constants_js_1.MAX_VALIDATION_SUGGESTIONS_BYTES,
+        includeTruncationMarker: true,
+    });
+    if (suggestionsRes.isErr())
+        return (0, neverthrow_1.err)(suggestionsRes.error);
+    const dedupeKey = `validation_performed:${args.sessionId}:${args.attemptId}`;
+    const event = {
+        v: 1,
+        eventId: args.minted.eventId,
+        kind: 'validation_performed',
+        dedupeKey: dedupeKey,
+        scope: { runId: args.scope.runId, nodeId: args.scope.nodeId },
+        data: {
+            validationId: args.validationId,
+            attemptId: args.attemptId,
+            contractRef: args.contractRef,
+            result: {
+                valid: args.result.valid,
+                issues: issuesRes.value,
+                suggestions: suggestionsRes.value,
+            },
+        },
+    };
+    return (0, neverthrow_1.ok)(event);
+}

package/dist/v2/durable-core/domain/validation-loader.d.ts

@@ -0,0 +1,11 @@
+import { type Result } from 'neverthrow';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+export type ValidationLoadError = {
+    readonly code: 'VALIDATION_LOAD_INVARIANT_VIOLATION';
+    readonly message: string;
+};
+export type LoadedValidationV1 = {
+    readonly issues: readonly string[];
+    readonly suggestions: readonly string[];
+};
+export declare function loadValidationResultV1(events: readonly DomainEventV1[], validationId: string): Result<LoadedValidationV1 | null, ValidationLoadError>;

package/dist/v2/durable-core/domain/validation-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadValidationResultV1 = loadValidationResultV1;
+const neverthrow_1 = require("neverthrow");
+function loadValidationResultV1(events, validationId) {
+    if (!validationId) {
+        return (0, neverthrow_1.ok)(null);
+    }
+    let latest = null;
+    for (const e of events) {
+        if (e.kind !== 'validation_performed')
+            continue;
+        if (e.data.validationId !== validationId)
+            continue;
+        if (!latest || e.eventIndex > latest.eventIndex)
+            latest = e;
+    }
+    if (!latest)
+        return (0, neverthrow_1.ok)(null);
+    return (0, neverthrow_1.ok)({ issues: latest.data.result.issues, suggestions: latest.data.result.suggestions });
+}

package/dist/v2/durable-core/projections/snapshot-state.js

@@ -6,7 +6,7 @@ function deriveIsComplete(state) {
     return state.kind === 'complete';
 }
 function derivePendingStep(state) {
-    if (state.kind !== 'running')
+    if (state.kind !== 'running' && state.kind !== 'blocked')
         return null;
     if (state.pending.kind !== 'some')
         return null;

package/dist/v2/durable-core/schemas/artifacts/index.d.ts

@@ -0,0 +1,4 @@
+export { LOOP_CONTROL_CONTRACT_REF, LoopControlDecisionSchema, LoopControlMetadataV1Schema, LoopControlArtifactV1Schema, isLoopControlArtifact, parseLoopControlArtifact, findLoopControlArtifact, type LoopControlDecision, type LoopControlMetadataV1, type LoopControlArtifactV1, } from './loop-control.js';
+export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.loop_control"];
+export type ArtifactContractRef = (typeof ARTIFACT_CONTRACT_REFS)[number];
+export declare function isValidContractRef(ref: string): ref is ArtifactContractRef;

package/dist/v2/durable-core/schemas/artifacts/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_CONTRACT_REFS = exports.findLoopControlArtifact = exports.parseLoopControlArtifact = exports.isLoopControlArtifact = exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = void 0;
+exports.isValidContractRef = isValidContractRef;
+var loop_control_js_1 = require("./loop-control.js");
+Object.defineProperty(exports, "LOOP_CONTROL_CONTRACT_REF", { enumerable: true, get: function () { return loop_control_js_1.LOOP_CONTROL_CONTRACT_REF; } });
+Object.defineProperty(exports, "LoopControlDecisionSchema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlDecisionSchema; } });
+Object.defineProperty(exports, "LoopControlMetadataV1Schema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlMetadataV1Schema; } });
+Object.defineProperty(exports, "LoopControlArtifactV1Schema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlArtifactV1Schema; } });
+Object.defineProperty(exports, "isLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.isLoopControlArtifact; } });
+Object.defineProperty(exports, "parseLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.parseLoopControlArtifact; } });
+Object.defineProperty(exports, "findLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.findLoopControlArtifact; } });
+exports.ARTIFACT_CONTRACT_REFS = [
+    'wr.contracts.loop_control',
+];
+function isValidContractRef(ref) {
+    return exports.ARTIFACT_CONTRACT_REFS.includes(ref);
+}

package/dist/v2/durable-core/schemas/artifacts/loop-control.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const LOOP_CONTROL_CONTRACT_REF: "wr.contracts.loop_control";
+export declare const LoopControlDecisionSchema: z.ZodEnum<["continue", "stop"]>;
+export type LoopControlDecision = z.infer<typeof LoopControlDecisionSchema>;
+export declare const LoopControlMetadataV1Schema: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    issuesFound: z.ZodOptional<z.ZodNumber>;
+    iterationIndex: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    issuesFound?: number | undefined;
+    iterationIndex?: number | undefined;
+}, {
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    issuesFound?: number | undefined;
+    iterationIndex?: number | undefined;
+}>>;
+export type LoopControlMetadataV1 = z.infer<typeof LoopControlMetadataV1Schema>;
+export declare const LoopControlArtifactV1Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wr.loop_control">;
+    loopId: z.ZodString;
+    decision: z.ZodEnum<["continue", "stop"]>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodOptional<z.ZodString>;
+        issuesFound: z.ZodOptional<z.ZodNumber>;
+        iterationIndex: z.ZodOptional<z.ZodNumber>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    }, {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    kind: "wr.loop_control";
+    loopId: string;
+    decision: "continue" | "stop";
+    metadata?: {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    } | undefined;
+}, {
+    kind: "wr.loop_control";
+    loopId: string;
+    decision: "continue" | "stop";
+    metadata?: {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    } | undefined;
+}>;
+export type LoopControlArtifactV1 = z.infer<typeof LoopControlArtifactV1Schema>;
+export declare function isLoopControlArtifact(artifact: unknown): artifact is LoopControlArtifactV1;
+export declare function parseLoopControlArtifact(artifact: unknown): LoopControlArtifactV1 | null;
+export declare function findLoopControlArtifact(artifacts: readonly unknown[], loopId: string): LoopControlArtifactV1 | null;

package/dist/v2/durable-core/schemas/artifacts/loop-control.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = void 0;
+exports.isLoopControlArtifact = isLoopControlArtifact;
+exports.parseLoopControlArtifact = parseLoopControlArtifact;
+exports.findLoopControlArtifact = findLoopControlArtifact;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+exports.LOOP_CONTROL_CONTRACT_REF = 'wr.contracts.loop_control';
+exports.LoopControlDecisionSchema = zod_1.z.enum(['continue', 'stop']);
+exports.LoopControlMetadataV1Schema = zod_1.z
+    .object({
+    reason: zod_1.z.string().max(1024).optional(),
+    issuesFound: zod_1.z.number().int().nonnegative().optional(),
+    iterationIndex: zod_1.z.number().int().nonnegative().optional(),
+    confidence: zod_1.z.number().int().min(0).max(100).optional(),
+})
+    .strict()
+    .optional();
+exports.LoopControlArtifactV1Schema = zod_1.z
+    .object({
+    kind: zod_1.z.literal('wr.loop_control'),
+    loopId: zod_1.z.string().min(1).max(64).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'loopId must be delimiter-safe: [a-z0-9_-]+'),
+    decision: exports.LoopControlDecisionSchema,
+    metadata: exports.LoopControlMetadataV1Schema,
+})
+    .strict();
+function isLoopControlArtifact(artifact) {
+    if (typeof artifact !== 'object' || artifact === null)
+        return false;
+    return artifact.kind === 'wr.loop_control';
+}
+function parseLoopControlArtifact(artifact) {
+    const result = exports.LoopControlArtifactV1Schema.safeParse(artifact);
+    return result.success ? result.data : null;
+}
+function findLoopControlArtifact(artifacts, loopId) {
+    for (const artifact of artifacts) {
+        if (!isLoopControlArtifact(artifact))
+            continue;
+        const parsed = parseLoopControlArtifact(artifact);
+        if (parsed && parsed.loopId === loopId) {
+            return parsed;
+        }
+    }
+    return null;
+}