@adonis-agora/durable 0.50.0 → 0.51.0

package/dist/src/engine.js

@@ -24,7 +24,7 @@ import { loadFanMembers, loadRunDetail, } from './run-detail-summary.js';
 import { runFacetsOf } from './run-facets.js';
 import { scanRunValueFacets } from './run-value-facets.js';
 import { listSignalWaitersOfRuns } from './run-waiting.js';
-import { scheduleWindow } from './scheduler.js';
+import { resolveSchedule, scheduleWindow } from './scheduler.js';
 import { ScheduleClient } from './schedules.js';
 import { SINGLETON_RESERVED_TAGS, withoutAdmission, withSingletonTracked, } from './singleton-admission.js';
 import { SingletonGate } from './singleton-gate.js';
@@ -547,7 +547,7 @@ export class WorkflowEngine {
      * Called by `runTick`; idempotent.
      */
     adoptSchedules(schedules) {
-        this.#allSchedules = schedules;
+        this.#allSchedules = schedules.map(resolveSchedule);
     }
     /**
      * The runtime pause override for a schedule key: `true`/`false` when the console set one (wins
@@ -626,7 +626,7 @@ export class WorkflowEngine {
                 continue;
             }
             seen.add(schedule.key);
-            this.#discoveredSchedules.push(schedule);
+            this.#discoveredSchedules.push(resolveSchedule(schedule));
         }
     }
     /** Colocated schedules discovered from `static schedule`, for the worker loop to merge with config. */
@@ -1061,11 +1061,15 @@ export class WorkflowEngine {
                 : `workflow ${name}@${pinned} is not registered`);
         }
         // Validate the input up front — a bad payload is rejected before any run is created. The schema
-        // runs first and its OUTPUT (parsed/coerced) is what the run stores; `validateInput` then sees it.
-        if (registered.inputSchema) {
-            input = await validateStandard(registered.inputSchema, input, `workflow "${name}" input`);
-        }
-        await registered.validateInput?.(input);
+        // runs first and `validateInput` sees its OUTPUT (parsed/coerced), but the run stores the input
+        // AS SENT: the body gets the parsed value by re-parsing it before every turn (`turnInput`), so a
+        // value JSON can't carry (a `Date` from `z.coerce.date()`) reaches it the same way on every
+        // turn, whichever store holds the row. Everything else here — singleton and concurrency keys
+        // included — reads the stored input, the one value the singleton gate re-reads later.
+        const parsed = registered.inputSchema
+            ? await validateStandard(registered.inputSchema, input, `workflow "${name}" input`, 'invalid_input')
+            : input;
+        await registered.validateInput?.(parsed);
         // Idempotent by run id: a redelivered trigger (at-least-once queues) or a scheduler re-tick for
         // the same id is a no-op, returning the existing run's state instead of starting a duplicate.
         const prior = await this.store.getRun(runId);
@@ -3689,10 +3693,28 @@ export class WorkflowEngine {
             return this.settleRun(run, await this.followHandoff(run, handoff));
         }
         const history = await this.remoteHistory(run.id, checkpoints);
+        // The remote body gets the parsed input too, re-parsed here each turn like an inline one. It
+        // travels as JSON, so a value JSON can't carry arrives as its JSON form — but coercions and
+        // defaults do apply. Only the TASK carries it: `run` (and so the store) keeps the input as sent.
+        let turnRun;
+        try {
+            turnRun = registered.inputSchema
+                ? { ...run, input: await this.turnInput(run, registered) }
+                : run;
+        }
+        catch (err) {
+            return this.settleRun(run, {
+                kind: 'failed',
+                error: {
+                    message: err instanceof Error ? err.message : String(err),
+                    ...codeAndDetails(err),
+                },
+            });
+        }
         // Broker-backed executors: dispatch the turn and suspend on it. The decision is applied by
         // whichever replica consumes it (completeRemoteDecision), never awaited here.
         if (remote.executor.dispatch)
-            return this.dispatchRemoteTurn(run, registered, history);
+            return this.dispatchRemoteTurn(turnRun, registered, history);
         // INLINE advance (an executor that produces the decision in-process): await it under the lease.
         const advance = remote.executor.advance;
         if (!advance) {
@@ -3701,7 +3723,7 @@ export class WorkflowEngine {
         let decision;
         try {
             const silenceMs = this.remoteAdvanceSilenceMs;
-            const pending = advance.call(remote.executor, run, history);
+            const pending = advance.call(remote.executor, turnRun, history);
             decision =
                 silenceMs != null
                     ? await this.awaitTurnWithSilence(run.id, pending, silenceMs)
@@ -4642,6 +4664,19 @@ export class WorkflowEngine {
         return { runId: run.id, status: 'cancelled', error };
     }
     /** The run body, lease held + renewed by {@link execute}. */
+    /**
+     * The input a turn's body receives: the stored input parsed by the workflow's `inputSchema`, or the
+     * stored input itself without one. Re-parsed on every turn rather than stored parsed, because the
+     * store round-trips the row through JSON (on the SQL stores) or a structured clone (in memory): a
+     * stored parsed value would reach the body as a `Date` in tests and a string in production. A
+     * stored input that no longer parses — its schema changed without a version bump — throws the same
+     * `SchemaValidationError` (`invalid_input`, never retried) that fails the run.
+     */
+    async turnInput(run, registered) {
+        if (!registered?.inputSchema)
+            return run.input;
+        return validateStandard(registered.inputSchema, run.input, `workflow "${run.workflow}" input`, 'invalid_input');
+    }
     async runExecution(run, fn, registered) {
         // First execution of an enqueued run: mark it running and announce the start, BEFORE the singleton
         // gate, so an admitted run's body never starts while it still reads `pending`. A resumed run is
@@ -4689,7 +4724,8 @@ export class WorkflowEngine {
             // Establish the ambient ctx for the duration of this body turn so context-aware statics
             // (`BaseWorkflow.start`/`dispatch`) reachable from `fn` route through this run's `ctx.child`/
             // `ctx.startChild`. Re-set on every replay turn (each is its own async scope) — correct.
-            const output = await workflowAls.run(ctx, () => fn(ctx, run.input));
+            const input = await this.turnInput(run, registered);
+            const output = await workflowAls.run(ctx, () => fn(ctx, input));
             // A compensating cancel requested while this turn ran (or one whose resume replays straight to
             // `return`, with no suspension point left) still wins: undo + settle cancelled, never completed.
             if (await this.takeCancelIntent(run.id)) {
@@ -4918,7 +4954,7 @@ export class WorkflowEngine {
             throw new Error('dispatched compensation requires a Transport');
         const token = stepGroup(def, run.namespace);
         const validInput = def.input
-            ? await validateStandard(def.input, args, `step "${def.name}" input`)
+            ? await validateStandard(def.input, args, `step "${def.name}" input`, 'invalid_input')
             : args;
         const id = `${run.id}:compensate:${def.name}:${attempt}`;
         const name = `compensate:${def.name}`;
@@ -5087,7 +5123,7 @@ export class WorkflowEngine {
                         ?.searchAttributesSchema
                     : undefined;
                 if (schema) {
-                    validateStandardSync(schema, merged, `workflow "${run?.workflow}": ctx.upsertSearchAttributes`);
+                    validateStandardSync(schema, merged, `workflow "${run?.workflow}" ctx.upsertSearchAttributes`);
                 }
                 await this.store.updateRun(runId, {
                     searchAttributes: merged,
@@ -5418,7 +5454,7 @@ export class WorkflowEngine {
         // Optional runtime schema: validate only when the def carries one (a bare `@Step()` / string-name
         // call carries none — the engine passes the input through untouched then).
         const validInput = step.input
-            ? await validateStandard(step.input, input, `step "${step.name}" input`)
+            ? await validateStandard(step.input, input, `step "${step.name}" input`, 'invalid_input')
             : input;
         // Routing token: BY NAME (sanitized for brokers), optionally partition-suffixed. Computed once and
         // used at BOTH the checkpoint's workerGroup and the dispatched task's routing `group`, so the same
@@ -5567,7 +5603,9 @@ export class WorkflowEngine {
     async sendStepFan(runId, positions, step, inputs, batch, group, opts, runNamespace) {
         const token = stepGroup(step, runNamespace);
         await this.ensureRoutable(token, step.requires);
-        const input = (i) => step.input ? validateStandard(step.input, inputs[i], `step "${step.name}" input`) : inputs[i];
+        const input = (i) => step.input
+            ? validateStandard(step.input, inputs[i], `step "${step.name}" input`, 'invalid_input')
+            : inputs[i];
         const validInputs = new Map();
         for (const i of batch)
             validInputs.set(i, await input(i));
@@ -5999,7 +6037,7 @@ export class WorkflowEngine {
         if (this.pool.size === 0)
             throw new Error('remote steps require a Transport');
         const validInput = step.input
-            ? await validateStandard(step.input, input, `step "${step.name}" input`)
+            ? await validateStandard(step.input, input, `step "${step.name}" input`, 'invalid_input')
             : input;
         const token = stepGroup(step, runNamespace);
         // Capability/protocol guard (design §7.5) — same as the durable path, before the `step.started`
@@ -6118,7 +6156,7 @@ export class WorkflowEngine {
     /** Shared finalization for a remote resolution, however it arrived (live await or salvaged). */
     async settleRemoteAttempt(runId, seq, step, input, resolution, attempt, token, enqueuedAt) {
         const output = (step.output
-            ? await validateStandard(step.output, resolution.output, `step "${step.name}" output`)
+            ? await validateStandard(step.output, resolution.output, `step "${step.name}" output`, 'invalid_output')
             : resolution.output);
         // The worker reports when it actually picked the task up; fall back to dispatch time if a
         // transport doesn't carry it (queue-wait then reads as zero rather than going negative).