@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/runtime/index.d.ts

@@ -1,7 +1,8 @@
-import { W as WorkflowContext, h as DurableWorkflow, C as CancellationScope, O as Operation, R as RunOptions, l as LocalActivityOptions, j as Duration, n as SignalDefinition, o as SignalHandlerOptions, k as ExternalRunTarget, E as ExternalRunHandle, e as ChildTarget, d as ChildOptions, c as ChildHandle, f as ContinueAsNewOptions, b as CancellationScopeOptions } from '../workflow-DWTPHFbt.js';
-export { A as Activation, s as splitActivations } from '../activation-BnVQMv9y.js';
-import { W as WorkflowCommand, Z as RunEventRecord, aj as WorkflowTaskRequest, ak as WorkflowTaskResult, a as WorkflowTaskFailureCause, $ as RunTarget } from '../types-CnIOinoz.js';
-import { J as Json, a as JsonObject } from '../types-Bb2wRnJ5.js';
+import { k as WorkflowInterceptorsFactory } from '../interceptors-CNcr2dlk.js';
+import { W as WorkflowContext, v as DurableWorkflow, U as UpdateDefinition, K as UpdateHandlerOptions, t as DefaultUpdateHandlerOptions, Q as QueryDefinition, C as CancellationScope, O as Operation, R as RunOptions, e as ActivityDefinition, k as ActivityOptions, z as LocalActivityOptions, x as Duration, G as SignalDefinition, I as SignalHandlerOptions, y as ExternalRunTarget, E as ExternalRunHandle, q as ChildTarget, p as ChildOptions, o as ChildHandle, r as ContinueAsNewOptions, n as CancellationScopeOptions } from '../workflow-BGnv8SS6.js';
+export { A as Activation, s as splitActivations } from '../activation-xpx1oWuo.js';
+import { W as WorkflowCommand, R as RunEventRecord, az as WorkflowTaskRequest, aA as WorkflowTaskResult, a as WorkflowTaskFailureCause, ad as RunTarget, M as Headers } from '../types-DGx-b9eq.js';
+import { a as Json, J as JsonObject } from '../types-V7jEEUaL.js';
 
 /**
  * Determinism shims for workflow tasks (C-ABI, spec 04 §4).
@@ -51,10 +52,12 @@ declare function uuidFrom(random: () => number): string;
 
 /**
  * Replay matching (spec 04 §4): each command a replayed activation issues must
- * match the command event recorded at the same position. Activities match on
- * id and `nodeType + operation`, children on id and target, everything else on
- * type and id. A recorded patch marker that the code no longer issues is
- * skipped (the patch was deprecated and removed, spec 06 §4).
+ * match the command event recorded at the same position. Node activities
+ * match on id and `nodeType + operation`, user activities (Phase C) on id,
+ * `kind` and `activityName`, children on id and target, updates on id,
+ * everything else on type and id. A recorded patch marker that the code no
+ * longer issues is skipped (the patch was deprecated and removed, spec 06 §4).
+ * `REJECT_UPDATE` appends no event (11 §2.39), so it is not matched.
  */
 
 /** Why `command` does not match `event`, or undefined when it does. */
@@ -97,6 +100,14 @@ declare function isPatchMarkerId(markerId: string): boolean;
  * finishes it: a replayed activation must have issued exactly the commands it
  * recorded, and the open activation's commands are the task's result.
  *
+ * Updates (C-ABI-H, spec 04 §2): the updates of activation k are delivered
+ * after its input events. A replayed activation re-delivers the updates its
+ * task accepted (`UPDATE_ACCEPTED` in its command block) without running
+ * their validators; the open activation delivers the lease's pending updates
+ * (`request.updates`) with validation. `UPDATE_ADMITTED` is an input event and
+ * is validated like a live request. An update no handler takes by the end of
+ * its activation is rejected (`UpdateNotHandled`).
+ *
  * Pure JavaScript; it runs inside the isolate.
  */
 
@@ -106,7 +117,8 @@ declare const SDK_NAME = "@fluidgrids/workflows";
 declare class ContinueAsNewRequest {
     readonly input: Json;
     readonly options: JsonObject;
-    constructor(input: Json, options: JsonObject);
+    readonly headers: Headers;
+    constructor(input: Json, options: JsonObject, headers?: Headers);
 }
 declare class Scope implements CancellationScope {
     readonly parent: Scope | undefined;
@@ -133,6 +145,8 @@ interface ExecutionInput {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     request: WorkflowTaskRequest;
     sdkVersion: string;
+    /** The bundle's workflow interceptors (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** One workflow task in progress. */
 declare class WorkflowExecution {
@@ -145,7 +159,7 @@ declare class WorkflowExecution {
     private activationOpen;
     private replaying;
     private clock;
-    private readonly random;
+    private readonly randomSource;
     private readonly ids;
     private commands;
     private newCommands;
@@ -190,6 +204,24 @@ declare class WorkflowExecution {
     /** Running asynchronous handlers by name, for the drain warning (11 §2.18). */
     private readonly running;
     private unfinished;
+    /** Updates delivered so far, by id (an update is delivered at most once per task). */
+    private readonly deliveredUpdates;
+    /** Updates delivered in the current activation without a handler yet. */
+    private bufferedUpdates;
+    private readonly updateHandlers;
+    private defaultUpdateHandler;
+    private readonly queryHandlers;
+    private defaultQueryHandler;
+    /** Set while a query handler or an update validator runs: commands and sinks throw. */
+    private readOnly;
+    /** The first state-changing call a read-only handler made, even when it caught the error. */
+    private readOnlyViolation;
+    private searchAttributes;
+    private readonly startHeaders;
+    private readonly inbound;
+    private readonly outbound;
+    private sinkCalls;
+    private sinkCallsDropped;
     private readonly recordedLocalActivities;
     private readonly localActivityResults;
     private readonly localActivities;
@@ -202,8 +234,21 @@ declare class WorkflowExecution {
     private continueAsNewSuggested;
     /** The workflow clock. */
     now(): number;
-    /** The next deterministic random number. */
+    /** The next deterministic random number (`Math.random()` and `crypto.getRandomValues()`). */
     nextRandom(): number;
+    /** `ctx.random()`: advances the run's random source, so read-only handlers may not call it. */
+    private random;
+    /**
+     * Throw `QueryHandlerSideEffect` when a query handler or an update validator
+     * calls something that changes the run's deterministic state (the random
+     * source, the command id counters, patches, details). Validators are not run
+     * again on replay, and a worker that keeps a run's state between tasks keeps
+     * whatever a query handler changed, so either would make the next replay
+     * diverge. The violation is remembered, so catching the error does not hide it.
+     */
+    private assertWritable;
+    /** The next command id of a kind; refused in read-only handlers (it advances a counter). */
+    private nextId;
     /** Begin or finish an activation; `done` when there is nothing left to do. */
     step(): 'more' | 'done';
     /** The task's result. Call after `step()` returned `done` and jobs were drained. */
@@ -217,6 +262,14 @@ declare class WorkflowExecution {
     /** Fail the task (the runtime's own failures and code errors). */
     failTask(cause: WorkflowTaskFailureCause, message: string, stackTrace?: string, seq?: number, errorType?: string): void;
     private beginActivation;
+    /**
+     * The updates an activation delivers after its inputs (C-ABI-H): a replayed
+     * activation re-delivers the updates its task accepted (validators
+     * skipped); the open activation of a workflow task delivers the lease's
+     * pending updates. Updates history admitted (`UPDATE_ADMITTED`) arrive as
+     * inputs instead.
+     */
+    private updatesOf;
     private finishActivation;
     /**
      * A local activity issued on a replayed activation without a recorded
@@ -230,9 +283,38 @@ declare class WorkflowExecution {
     private expectIssued;
     private settleActivity;
     private settleChild;
+    /** Run a signal handler through the inbound `handleSignal` interceptors. */
+    private signalCall;
     private dispatchSignal;
     private takeBuffered;
     private runHandler;
+    /** Count a running asynchronous handler (drain check, `allHandlersFinished`); returns its end. */
+    private trackHandler;
+    private deliverUpdate;
+    private updateHandlerFor;
+    /**
+     * Run `fn` with commands, sinks and every other change to the run's
+     * deterministic state refused (query handlers, update validators). A
+     * refused call fails the whole call with `QueryHandlerSideEffect`, even
+     * when the code caught the error it threw.
+     */
+    private readOnlyCall;
+    /**
+     * Validate, accept and run one update. A validator error rejects it
+     * (`REJECT_UPDATE`, no history); otherwise `ACCEPT_UPDATE` is issued and
+     * the handler's result or failure completes it (`COMPLETE_UPDATE`). A
+     * handler that throws something other than a failure class fails the task,
+     * as a signal handler does.
+     */
+    private runUpdate;
+    private completeUpdate;
+    /** Reject the updates of this activation that no handler took (`UpdateNotHandled`). */
+    private rejectUnhandledUpdates;
+    handleUpdate(update: UpdateDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown, options?: UpdateHandlerOptions<unknown>): void;
+    setDefaultUpdateHandler(first: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions, second?: ((name: string, args: unknown) => unknown) | DefaultUpdateHandlerOptions): void;
+    private dispatchBufferedUpdates;
+    handleQuery(query: QueryDefinition<unknown, unknown> | string, handler: (args: unknown) => unknown): void;
+    setDefaultQueryHandler(handler: (name: string, args: unknown) => unknown): void;
     /**
      * The drain check of 11 §2.18 when the workflow finishes: handlers still
      * running with policy `WARN_AND_ABANDON` give one warning line and
@@ -257,6 +339,15 @@ declare class WorkflowExecution {
     private stack;
     private never;
     scheduleActivity<In, Out>(scope: Scope, operation: Operation<In, Out>, options: RunOptions<In>): Promise<Out>;
+    /**
+     * `ctx.activity` (Phase C): a user activity on a self-hosted task queue
+     * (`SCHEDULE_ACTIVITY` of kind `user`). The queue is the option, else the
+     * declaration's, else the run's own.
+     */
+    userActivity<In, Out>(scope: Scope, activity: ActivityDefinition<In, Out> | string, options: ActivityOptions<In>): Promise<Out>;
+    /** Run the outbound `scheduleActivity` interceptors, then issue the command. */
+    private issueActivity;
+    private pushActivity;
     /**
      * `ctx.localActivity` (11 §2.12). A replayed activation returns the outcome
      * its history recorded; the open activation takes the outcome the worker
@@ -282,34 +373,64 @@ declare class WorkflowExecution {
     runHandle(target: ExternalRunTarget): ExternalRunHandle;
     private childTarget;
     private childCommand;
+    /**
+     * Run the outbound `startChild` interceptors around a child start. `go`
+     * starts the child with the options the interceptors leave (input and
+     * headers).
+     */
+    private interceptChild;
     private startChildRun;
     /** What cancelling the scope of a child's awaitable does (see `ChildOptions.cancellationType`). */
     private onChildCancel;
     child<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<Out>;
     private childResult;
     startChild<Out>(scope: Scope, target: ChildTarget<Out>, options: ChildOptions): Promise<ChildHandle<Out>>;
+    private startChildHandle;
     signalExternal(target: RunTarget, name: string, payload: unknown): Promise<void>;
+    private pushSignal;
     cancelExternal(target: RunTarget): Promise<void>;
+    private pushCancel;
     sideEffect<T extends Json>(fn: () => T): T;
+    private recordSideEffect;
     patched(patchId: string, deprecated: boolean): boolean;
     setCurrentDetails(markdown: string): void;
     upsertContext(entries: JsonObject): void;
+    /** `ctx.upsertSearchAttributes` (Phase C): a null value removes an attribute. */
+    upsertSearchAttributes(attributes: JsonObject): void;
+    /** A `ctx.sinks.<sink>.<fn>(...args)` call: recorded once, never on replay (11 §2.31). */
+    private callSink;
+    private sinksProxy;
+    /** `ctx.continueAsNew`: a rejection with the request, after the outbound interceptors. */
+    continueAsNewCall(input: unknown, options: ContinueAsNewOptions): Promise<never>;
     /** The request a `ctx.continueAsNew` call throws; the run ends with `CONTINUE_AS_NEW`. */
     continueAsNew(input: unknown, options: ContinueAsNewOptions): ContinueAsNewRequest;
     cancellationScope<T>(parent: Scope, fn: (ctx: WorkflowContext) => Promise<T>, options: CancellationScopeOptions): Promise<T>;
     /** Waits for the signal handlers regardless of cancellation, as Temporal does. */
     allHandlersFinished(): Promise<void>;
     private pendingStacks;
+    /**
+     * Answer a custom query (Phase C): the handler registered for the name, else
+     * the default handler, run read-only through the inbound `handleQuery`
+     * interceptors. No handler gives `rejected`.
+     */
+    private answerCustomQuery;
     private answerQueries;
     private contextFor;
 }
 
 /** The global a tier-2 bundle defines. */
 declare const RUNTIME_GLOBAL = "__fluidgridsRuntime";
-/** The runtime ABI, protocol 1. */
+/**
+ * The runtime ABI, protocol 1. `capabilities` (C-ABI-H, from C-R1) lists what
+ * the runtime answers beyond Phase B: `updates`, `queries` (custom and default
+ * handlers) and `dynamic` (dynamic workflows and default handlers). A bundle
+ * built before C-R1 has none, and the service refuses updates and custom
+ * queries for its runs (DC4).
+ */
 interface FluidgridsRuntimeAbi {
     readonly protocol: 1;
     readonly sdkVersion: string;
+    readonly capabilities?: readonly string[];
     start(requestJson: string): void;
     step(): 'more' | 'done';
     complete(): string;
@@ -320,6 +441,12 @@ interface WorkflowRegistry {
     exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
     /** Export names declared by more than one module; starting one fails the task. */
     ambiguous: ReadonlySet<string>;
+    /** The bundle's dynamic workflow (Phase C), which serves names no export has. */
+    dynamic?: DurableWorkflow<never, unknown>;
+    /** True when more than one dynamic workflow is exported; a dynamic start fails the task. */
+    dynamicAmbiguous?: boolean;
+    /** Workflow interceptor factories (`interceptors` exports), in module order. */
+    interceptors?: readonly WorkflowInterceptorsFactory[];
 }
 /** Build the registry from the bundle's modules (`[path, namespace]` pairs). */
 declare function buildWorkflowRegistry(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): WorkflowRegistry;

package/dist/runtime/index.js

@@ -1,9 +1,9 @@
-export { CommandIds, RUNTIME_GLOBAL, SDK_NAME, WorkflowExecution, buildWorkflowRegistry, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId } from '../chunk-MJ5TGYVG.js';
-import '../chunk-KXJDRQ6G.js';
+export { CommandIds, RUNTIME_GLOBAL, SDK_NAME, WorkflowExecution, buildWorkflowRegistry, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId } from '../chunk-2D3MYIIF.js';
+import '../chunk-6A2FGSUS.js';
 import '../chunk-M272AHEX.js';
 export { SHIM_HOOK, SHIM_VIOLATION, TASK_PRELUDE, createRandom, seedOf, uuidFrom } from '../chunk-4LYSEANA.js';
-import '../chunk-7ILGCUI6.js';
+import '../chunk-C4F5KJTI.js';
 import '../chunk-LNUQE6D6.js';
-export { splitActivations } from '../chunk-FWBRQWRX.js';
-import '../chunk-2DDULZFM.js';
-import '../chunk-PWIUEWC3.js';
+export { splitActivations } from '../chunk-AE5Q6ZAJ.js';
+import '../chunk-AC6ZEXVR.js';
+import '../chunk-5HIVIV53.js';