@exaudeus/workrail 3.14.0 → 3.16.0

package/dist/runtime/adapters/noop-process-signals.js

@@ -4,5 +4,7 @@ exports.NoopProcessSignals = void 0;
 class NoopProcessSignals {
     on(_signal, _handler) {
     }
+    once(_signal, _handler) {
+    }
 }
 exports.NoopProcessSignals = NoopProcessSignals;

package/dist/runtime/ports/process-signals.d.ts

@@ -1,4 +1,5 @@
 export type ProcessSignal = NodeJS.Signals | 'exit';
 export interface ProcessSignals {
     on(signal: ProcessSignal, handler: () => void | Promise<void>): void;
+    once(signal: ProcessSignal, handler: () => void | Promise<void>): void;
 }

package/dist/types/workflow-definition.d.ts

@@ -23,8 +23,7 @@ export interface AssessmentDefinition {
     readonly dimensions: readonly AssessmentDimensionDefinition[];
 }
 export interface AssessmentConsequenceTriggerDefinition {
-    readonly dimensionId: string;
-    readonly equalsLevel: string;
+    readonly anyEqualsLevel: string;
 }
 export interface AssessmentFollowupRequiredEffectDefinition {
     readonly kind: 'require_followup';
@@ -135,6 +134,8 @@ export interface WorkflowDefinition {
     readonly extensionPoints?: readonly ExtensionPoint[];
     readonly references?: readonly WorkflowReference[];
     readonly validatedAgainstSpecVersion?: number;
+    readonly about?: string;
+    readonly examples?: readonly string[];
 }
 export declare function isLoopStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is LoopStepDefinition;
 export declare function isWorkflowStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is WorkflowStepDefinition;

package/dist/types/workflow.d.ts

@@ -3,6 +3,9 @@ import { WorkflowSource } from './workflow-source';
 export interface Workflow {
     readonly definition: WorkflowDefinition;
     readonly source: WorkflowSource;
+    readonly stepById: ReadonlyMap<string, WorkflowStepDefinition | LoopStepDefinition>;
+    readonly parentLoopByStepId: ReadonlyMap<string, LoopStepDefinition>;
+    readonly loopById: ReadonlyMap<string, LoopStepDefinition>;
 }
 export interface WorkflowSummary {
     readonly id: string;

package/dist/types/workflow.js

@@ -9,10 +9,35 @@ exports.getAllStepIds = getAllStepIds;
 exports.isWorkflow = isWorkflow;
 exports.isWorkflowDefinition = isWorkflowDefinition;
 const workflow_source_1 = require("./workflow-source");
+function buildWorkflowIndices(definition) {
+    const stepById = new Map();
+    const parentLoopByStepId = new Map();
+    const loopById = new Map();
+    function indexSteps(steps, parentLoop) {
+        for (const step of steps) {
+            stepById.set(step.id, step);
+            if (parentLoop !== null) {
+                parentLoopByStepId.set(step.id, parentLoop);
+            }
+            if ('type' in step && step.type === 'loop') {
+                loopById.set(step.id, step);
+                if (Array.isArray(step.body)) {
+                    indexSteps(step.body, step);
+                }
+            }
+        }
+    }
+    indexSteps(definition.steps ?? [], null);
+    return { stepById, parentLoopByStepId, loopById };
+}
 function createWorkflow(definition, source) {
+    const { stepById, parentLoopByStepId, loopById } = buildWorkflowIndices(definition);
     return Object.freeze({
         definition,
-        source
+        source,
+        stepById,
+        parentLoopByStepId,
+        loopById,
     });
 }
 function toWorkflowSummary(workflow) {
@@ -31,32 +56,10 @@ function toWorkflowSourceInfo(source) {
     });
 }
 function getStepById(workflow, stepId) {
-    const steps = workflow.definition.steps;
-    for (const step of steps) {
-        if (step.id === stepId) {
-            return step;
-        }
-        if ('type' in step && step.type === 'loop' && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                if (bodyStep.id === stepId) {
-                    return bodyStep;
-                }
-            }
-        }
-    }
-    return null;
+    return workflow.stepById.get(stepId) ?? null;
 }
 function getAllStepIds(workflow) {
-    const ids = [];
-    for (const step of workflow.definition.steps) {
-        ids.push(step.id);
-        if ('type' in step && step.type === 'loop' && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                ids.push(bodyStep.id);
-            }
-        }
-    }
-    return Object.freeze(ids);
+    return Object.freeze([...workflow.stepById.keys()]);
 }
 function isWorkflow(obj) {
     if (!obj || typeof obj !== 'object')
@@ -64,10 +67,16 @@ function isWorkflow(obj) {
     const candidate = obj;
     return ('definition' in candidate &&
         'source' in candidate &&
+        'stepById' in candidate &&
+        'parentLoopByStepId' in candidate &&
+        'loopById' in candidate &&
         candidate['definition'] !== null &&
         typeof candidate['definition'] === 'object' &&
         candidate['source'] !== null &&
-        typeof candidate['source'] === 'object');
+        typeof candidate['source'] === 'object' &&
+        candidate['stepById'] instanceof Map &&
+        candidate['parentLoopByStepId'] instanceof Map &&
+        candidate['loopById'] instanceof Map);
 }
 function isWorkflowDefinition(obj) {
     if (!obj || typeof obj !== 'object')

package/dist/v2/durable-core/domain/context-template-resolver.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTEXT_TOKEN_PATTERN = void 0;
 exports.resolveContextTemplates = resolveContextTemplates;
 exports.CONTEXT_TOKEN_PATTERN = /\{\{(?!wr\.)([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\}\}/;
-const CONTEXT_TOKEN_RE_G = new RegExp(exports.CONTEXT_TOKEN_PATTERN.source, 'g');
 function resolveDotPath(base, path) {
     let current = base;
     for (const segment of path) {
@@ -16,7 +15,8 @@ function resolveDotPath(base, path) {
 function resolveContextTemplates(template, context) {
     if (!template.includes('{{'))
         return template;
-    return template.replace(CONTEXT_TOKEN_RE_G, (_match, dotPath) => {
+    const re = new RegExp(exports.CONTEXT_TOKEN_PATTERN.source, 'g');
+    return template.replace(re, (_match, dotPath) => {
         const value = resolveDotPath(context, dotPath.split('.'));
         if (value === undefined || value === null) {
             return `[unset: ${dotPath}]`;

package/dist/v2/durable-core/domain/function-definition-expander.js

@@ -3,23 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandFunctionDefinitions = expandFunctionDefinitions;
 exports.formatFunctionDef = formatFunctionDef;
 const neverthrow_1 = require("neverthrow");
-const workflow_js_1 = require("../../../types/workflow.js");
 function findLoopById(workflow, loopId) {
-    function searchSteps(steps) {
-        for (const step of steps) {
-            if (!(0, workflow_js_1.isLoopStepDefinition)(step))
-                continue;
-            if (step.id === loopId)
-                return step;
-            if (Array.isArray(step.body)) {
-                const found = searchSteps(step.body);
-                if (found)
-                    return found;
-            }
-        }
-        return null;
-    }
-    return searchSteps(workflow.definition.steps);
+    return workflow.loopById.get(loopId) ?? null;
 }
 function getWorkflowScopeDefs(workflow) {
     return workflow.definition.functionDefinitions?.filter(f => !f.scope || f.scope === 'workflow') ?? [];
@@ -31,7 +16,7 @@ function getLoopScopeDefs(args) {
     });
 }
 function getStepScopeDefs(args) {
-    const step = args.workflow.definition.steps.find(s => s.id === args.stepId);
+    const step = args.workflow.stepById.get(args.stepId);
     return step?.functionDefinitions?.filter(f => !f.scope || f.scope === 'step') ?? [];
 }
 function expandFunctionDefinitions(args) {

package/dist/v2/durable-core/domain/prompt-renderer.d.ts

@@ -24,4 +24,5 @@ export declare function renderPendingPrompt(args: {
     readonly runId: RunId;
     readonly nodeId: NodeId;
     readonly rehydrateOnly: boolean;
+    readonly precomputedIndex?: import('../session-index.js').SessionIndex;
 }): Result<StepMetadata, PromptRenderError>;

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -13,9 +13,11 @@ const constants_js_1 = require("../constants.js");
 const validation_requirements_extractor_js_1 = require("./validation-requirements-extractor.js");
 const index_js_2 = require("../schemas/artifacts/index.js");
 const run_context_js_1 = require("../../projections/run-context.js");
+const sorted_event_log_js_1 = require("../sorted-event-log.js");
 const condition_evaluator_js_1 = require("../../../utils/condition-evaluator.js");
 const context_template_resolver_js_1 = require("./context-template-resolver.js");
 const retrieval_contract_js_1 = require("./retrieval-contract.js");
+const env_flags_js_1 = require("../../../env-flags.js");
 function buildNonTipSegments(args) {
     const segments = [];
     const childSummary = (0, recap_recovery_js_1.buildChildSummary)({ nodeId: args.nodeId, dag: args.run });
@@ -86,15 +88,7 @@ function buildRecoverySegments(args) {
     ];
 }
 function resolveParentLoopStep(workflow, stepId) {
-    for (const step of workflow.definition.steps) {
-        if ((0, workflow_js_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                if (bodyStep.id === stepId)
-                    return step;
-            }
-        }
-    }
-    return undefined;
+    return workflow.parentLoopByStepId.get(stepId);
 }
 function buildLoopRenderContext(loopStep, iteration, sessionContext) {
     const iterationVar = loopStep.loop.iterationVar || 'currentIteration';
@@ -238,11 +232,13 @@ function renderPendingPrompt(args) {
     const isExitStep = outputContract?.contractRef === index_js_2.LOOP_CONTROL_CONTRACT_REF;
     const loopStep = resolveParentLoopStep(args.workflow, args.stepId);
     const maxIterations = loopStep?.loop.maxIterations;
-    const sessionContext = (0, run_context_js_1.projectRunContextV2)(args.truth.events).match((ok) => (ok.byRunId[String(args.runId)]?.context ?? {}), (e) => {
-        console.warn(`[prompt-renderer] Context projection failed for step '${args.stepId}' — ` +
-            `{{varName}} tokens will render as [unset:...]: ${e.message}`);
-        return {};
-    });
+    const sessionContext = args.precomputedIndex
+        ? (args.precomputedIndex.runContextByRunId.get(String(args.runId)) ?? {})
+        : (0, sorted_event_log_js_1.asSortedEventLog)(args.truth.events).andThen((sorted) => (0, run_context_js_1.projectRunContextV2)(sorted)).match((ok) => (ok.byRunId[String(args.runId)]?.context ?? {}), (e) => {
+            console.warn(`[prompt-renderer] Context projection failed for step '${args.stepId}' — ` +
+                `{{varName}} tokens will render as [unset:...]: ${e.message}`);
+            return {};
+        });
     const loopIterationFrame = args.loopPath.at(-1);
     const loopRenderContext = loopStep && loopIterationFrame
         ? buildLoopRenderContext(loopStep, loopIterationFrame.iteration, sessionContext)
@@ -250,7 +246,7 @@ function renderPendingPrompt(args) {
     const renderContext = { ...sessionContext, ...loopRenderContext };
     const basePrompt = (0, context_template_resolver_js_1.resolveContextTemplates)(step.prompt ?? '', renderContext);
     const baseTitle = (0, context_template_resolver_js_1.resolveContextTemplates)(step.title, renderContext);
-    const cleanResponseFormat = process.env.WORKRAIL_CLEAN_RESPONSE_FORMAT === 'true';
+    const cleanResponseFormat = env_flags_js_1.CLEAN_RESPONSE_FORMAT;
     const loopBanner = buildLoopContextBanner({ loopPath: args.loopPath, isExitStep, maxIterations, cleanFormat: cleanResponseFormat });
     const validationCriteria = step.validationCriteria;
     const requirements = (0, validation_requirements_extractor_js_1.extractValidationRequirements)(validationCriteria);
@@ -279,7 +275,9 @@ function renderPendingPrompt(args) {
         if (cleanResponseFormat) {
             return '';
         }
-        const hasPriorNotes = hasPriorNotesInRun({ truth: args.truth, runId: args.runId });
+        const hasPriorNotes = args.precomputedIndex
+            ? args.precomputedIndex.hasPriorNotesByRunId.has(String(args.runId))
+            : hasPriorNotesInRun({ truth: args.truth, runId: args.runId });
         if (hasPriorNotes && !args.rehydrateOnly) {
             return '\n\n**NOTES REQUIRED (System):** Include `output.notesMarkdown` when advancing.\n\n' +
                 'Scope: this step only — WorkRail concatenates notes automatically.\n' +
@@ -321,8 +319,15 @@ function renderPendingPrompt(args) {
     const fragmentSuffix = promptFragments && promptFragments.length > 0
         ? assembleFragmentedPrompt(promptFragments, renderContext)
         : '';
-    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + assessmentSection + notesSection
-        + (fragmentSuffix ? '\n\n' + fragmentSuffix : '');
+    const enhancedPrompt = [
+        loopBanner,
+        basePrompt,
+        requirementsSection,
+        contractSection,
+        assessmentSection,
+        notesSection,
+        fragmentSuffix ? '\n\n' + fragmentSuffix : '',
+    ].join('');
     if (!args.rehydrateOnly) {
         return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: enhancedPrompt, agentRole, requireConfirmation });
     }

package/dist/v2/durable-core/domain/recap-recovery.js

@@ -6,18 +6,21 @@ exports.buildChildSummary = buildChildSummary;
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../constants.js");
 function collectAncestryRecap(args) {
-    const buildChain = (cur, visited) => {
-        if (!cur || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildChain(parent, newVisited)];
+    const buildChain = (start) => {
+        const result = [];
+        const visited = new Set();
+        let cur = start;
+        while (cur !== null && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
     const startNode = args.includeCurrentNode
         ? String(args.nodeId)
         : args.dag.nodesById[String(args.nodeId)]?.parentNodeId ?? null;
-    const chain = buildChain(startNode, new Set());
+    const chain = buildChain(startNode);
     const recaps = chain.flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)
@@ -35,15 +38,19 @@ function collectAncestryRecap(args) {
     return (0, neverthrow_1.ok)([...recaps].reverse());
 }
 function collectDownstreamRecap(args) {
-    const buildPathBackward = (cur, visited) => {
-        if (!cur || cur === String(args.fromNodeId) || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildPathBackward(parent, newVisited)];
+    const buildPathBackward = (start) => {
+        const result = [];
+        const visited = new Set();
+        const fromId = String(args.fromNodeId);
+        let cur = start;
+        while (cur !== null && cur !== fromId && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
-    const pathBackward = buildPathBackward(String(args.toNodeId), new Set());
+    const pathBackward = buildPathBackward(String(args.toNodeId));
     const recaps = [...pathBackward].reverse().flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)

package/dist/v2/durable-core/domain/retrieval-contract.js

@@ -63,17 +63,21 @@ exports.RESUME_PREVIEW_CONTRACT = {
 };
 const encoder = new TextEncoder();
 const decoder = new TextDecoder('utf-8');
+const TIER_PRIORITY = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const TIER_RETENTION = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.retention]));
+const RESUME_PREVIEW_TIER_PRIORITY = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const RESUME_PREVIEW_TIER_MAX_BYTES = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.maxBytes]));
 function getTierPriority(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getTierRetention(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.retention ?? 'tail';
+    return TIER_RETENTION[tier] ?? 'tail';
 }
 function getResumePreviewTierPriority(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return RESUME_PREVIEW_TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getResumePreviewTierMaxBytes(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.maxBytes ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
+    return RESUME_PREVIEW_TIER_MAX_BYTES[tier] ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
 }
 function compareAscii(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
@@ -283,7 +287,8 @@ function renderBudgetedRehydrateRecovery(args) {
     const initiallyIncludedTiers = tiersInOrder.filter((tier) => (sectionsByTier.get(tier) ?? []).length > 0);
     let includedTiers = initiallyIncludedTiers;
     let recoveryText = renderFromTiers(includedTiers);
-    while (encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES) {
+    let recoveryBytes = encoder.encode(recoveryText).length;
+    while (recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES) {
         const droppableTierIndex = [...includedTiers]
             .reverse()
             .findIndex((tier) => getTierRetention(tier) === 'tail');
@@ -293,9 +298,10 @@ function renderBudgetedRehydrateRecovery(args) {
         const actualIndex = includedTiers.length - 1 - droppableTierIndex;
         includedTiers = includedTiers.filter((_, index) => index !== actualIndex);
         recoveryText = renderFromTiers(includedTiers);
+        recoveryBytes = encoder.encode(recoveryText).length;
     }
     const omittedTierCount = initiallyIncludedTiers.length - includedTiers.length;
-    const needsSuffix = omittedTierCount > 0 || encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
+    const needsSuffix = omittedTierCount > 0 || recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
     const finalText = recoveryText.length === 0
         ? trimFinalRecoveryText(args.header, initiallyIncludedTiers.length)
         : !needsSuffix
@@ -305,6 +311,6 @@ function renderBudgetedRehydrateRecovery(args) {
         text: finalText,
         includedTiers,
         omittedTierCount,
-        truncatedWithinTier: encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
+        truncatedWithinTier: recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
     };
 }

package/dist/v2/durable-core/session-index.d.ts

@@ -0,0 +1,22 @@
+import type { Brand } from '../../runtime/brand.js';
+import type { SortedEventLog } from './sorted-event-log.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { JsonObject } from './canonical/json-types.js';
+export interface SessionIndexData {
+    readonly sortedEvents: SortedEventLog;
+    readonly runStartedByRunId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'run_started';
+    }>>;
+    readonly nodeCreatedByNodeId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'node_created';
+    }>>;
+    readonly hasChildEdgeByFromNodeId: ReadonlySet<string>;
+    readonly advanceRecordedByDedupeKey: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'advance_recorded';
+    }>>;
+    readonly nextEventIndex: number;
+    readonly hasPriorNotesByRunId: ReadonlySet<string>;
+    readonly runContextByRunId: ReadonlyMap<string, JsonObject>;
+}
+export type SessionIndex = Brand<SessionIndexData, 'v2.SessionIndex'>;
+export declare function buildSessionIndex(events: SortedEventLog): SessionIndex;

package/dist/v2/durable-core/session-index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionIndex = buildSessionIndex;
+const constants_js_1 = require("./constants.js");
+function buildSessionIndex(events) {
+    const runStartedByRunId = new Map();
+    const nodeCreatedByNodeId = new Map();
+    const hasChildEdgeByFromNodeId = new Set();
+    const advanceRecordedByDedupeKey = new Map();
+    const hasPriorNotesByRunId = new Set();
+    const runContextByRunId = new Map();
+    for (const event of events) {
+        switch (event.kind) {
+            case 'run_started':
+                runStartedByRunId.set(event.scope.runId, event);
+                break;
+            case 'node_created':
+                nodeCreatedByNodeId.set(event.scope.nodeId, event);
+                break;
+            case 'edge_created':
+                hasChildEdgeByFromNodeId.add(event.data.fromNodeId);
+                break;
+            case 'advance_recorded':
+                advanceRecordedByDedupeKey.set(event.dedupeKey, event);
+                break;
+            case 'node_output_appended': {
+                const outputEvt = event;
+                if (outputEvt.data.outputChannel === constants_js_1.OUTPUT_CHANNEL.RECAP &&
+                    outputEvt.data.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES) {
+                    hasPriorNotesByRunId.add(event.scope.runId);
+                }
+                break;
+            }
+            case 'context_set': {
+                const ctx = event.data.context;
+                if (ctx && typeof ctx === 'object' && !Array.isArray(ctx)) {
+                    runContextByRunId.set(event.scope.runId, ctx);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const lastEvent = events[events.length - 1];
+    const nextEventIndex = lastEvent !== undefined ? lastEvent.eventIndex + 1 : 0;
+    const data = {
+        sortedEvents: events,
+        runStartedByRunId,
+        nodeCreatedByNodeId,
+        hasChildEdgeByFromNodeId,
+        advanceRecordedByDedupeKey,
+        nextEventIndex,
+        hasPriorNotesByRunId,
+        runContextByRunId,
+    };
+    return data;
+}

package/dist/v2/durable-core/sorted-event-log.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from 'neverthrow';
+import type { Brand } from '../../runtime/brand.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { ProjectionError } from '../projections/projection-error.js';
+export type SortedEventLog = Brand<readonly DomainEventV1[], 'v2.SortedEventLog'>;
+export declare function asSortedEventLog(events: readonly DomainEventV1[]): Result<SortedEventLog, ProjectionError>;

package/dist/v2/durable-core/sorted-event-log.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asSortedEventLog = asSortedEventLog;
+const neverthrow_1 = require("neverthrow");
+function asSortedEventLog(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 strictly ascending (no duplicates)',
+            });
+        }
+    }
+    return (0, neverthrow_1.ok)(events);
+}

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

@@ -166,18 +166,18 @@ class NodeFileSystemV2 {
     readdirWithMtime(dirPath) {
         return neverthrow_1.ResultAsync.fromPromise((async () => {
             const entries = await fs.readdir(dirPath);
+            const results = await Promise.allSettled(entries.map((name) => fs.stat(path.join(dirPath, name)).then((s) => ({ name, mtimeMs: s.mtimeMs }))));
             const withMtime = [];
             let skipped = 0;
-            for (const name of entries) {
-                try {
-                    const stats = await fs.stat(path.join(dirPath, name));
-                    withMtime.push({ name, mtimeMs: stats.mtimeMs });
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                if (result.status === 'fulfilled') {
+                    withMtime.push(result.value);
                 }
-                catch (e) {
-                    const code = nodeErrorCode(e);
+                else {
+                    const code = nodeErrorCode(result.reason);
                     skipped++;
-                    console.error(`[workrail:session-enum] Skipping ${name}: stat failed (${code ?? 'unknown'}: ${e instanceof Error ? e.message : String(e)})`);
-                    continue;
+                    console.error(`[workrail:session-enum] Skipping ${entries[i]}: stat failed (${code ?? 'unknown'}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)})`);
                 }
             }
             if (skipped > 0) {

package/dist/v2/infra/local/session-store/index.d.ts

@@ -10,7 +10,7 @@ export declare class LocalSessionEventLogStoreV2 implements SessionEventLogReado
     private readonly fs;
     private readonly sha256;
     constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, sha256: Sha256PortV2);
-    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2, preloadedTruth?: LoadedSessionTruthV2): ResultAsync<void, SessionEventLogStoreError>;
     load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
     loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
     private appendImpl;