@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/runtime/index.d.cts

@@ -0,0 +1,297 @@
+import { W as WorkflowContext, h as DurableWorkflow, C as CancellationScope, O as Operation, R as RunOptions, j as Duration, l as SignalDefinition, e as ChildTarget, d as ChildOptions, c as ChildHandle, f as ContinueAsNewOptions, b as CancellationScopeOptions } from '../workflow-J-yYixny.cjs';
+export { A as Activation, s as splitActivations } from '../activation-BBh1p82z.cjs';
+import { W as WorkflowCommand, U as RunEventRecord, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, a as WorkflowTaskFailureCause, X as RunTarget } from '../types-CpBBjaGX.cjs';
+import { a as Json, J as JsonObject } from '../types-BGoPzgcl.cjs';
+
+/**
+ * Determinism shims for workflow tasks (C-ABI, spec 04 §4).
+ *
+ * `TASK_PRELUDE` runs in the isolate before the bundle, in place of the
+ * lowering prelude (`DETERMINISM_PRELUDE`, which refuses the clock outright).
+ * Inside a workflow task the clock and the random source resolve through the
+ * runtime: `Date.now()`, `new Date()` and `Date()` read the workflow clock,
+ * `Math.random()` and `crypto.getRandomValues()` read the per-run seeded
+ * generator.
+ *
+ * The prelude also gives every engine and host the same built-ins: local time
+ * is UTC (the `Date` local getters, setters, constructor, `Date.parse` of
+ * strings without an offset and `toString` ignore the host's TZ), the
+ * `toLocale*` and `localeCompare` methods are locale-independent (fixed en-US
+ * shapes without ICU), `Intl` is absent, and `WeakRef` and
+ * `FinalizationRegistry` throw, because garbage collection is observable and
+ * not deterministic. QuickJS and `vm` otherwise differ on all of these. Outside a task (module top level) they throw
+ * `DeterminismViolation`, as do the timer functions and network entry points,
+ * which have no deterministic meaning in workflow code.
+ *
+ * The prelude leaves one hook, `globalThis.__fluidgridsShims`, which the
+ * runtime takes (and deletes) when the bundle installs it. This is not a
+ * security boundary (the isolate is); it only keeps workflow code honest.
+ */
+/** The `name` of the error the shims throw. */
+declare const SHIM_VIOLATION = "DeterminismViolation";
+/** Global the prelude leaves for the runtime. */
+declare const SHIM_HOOK = "__fluidgridsShims";
+declare const TASK_PRELUDE: string;
+/** What the runtime gives the shims while a task runs. */
+interface ShimHooks {
+    now(): number;
+    random(): number;
+}
+/** The control the prelude leaves behind. */
+interface ShimControl {
+    attach(hooks: ShimHooks): void;
+    detach(): void;
+}
+/** A 32-bit FNV-1a hash of a string: the seed of a run's random generator. */
+declare function seedOf(text: string): number;
+/** mulberry32: a small, fast, deterministic generator of numbers in [0, 1). */
+declare function createRandom(seed: number): () => number;
+/** A version-4 UUID from a random source. */
+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).
+ */
+
+/** Why `command` does not match `event`, or undefined when it does. */
+declare function mismatch(command: WorkflowCommand, event: RunEventRecord): string | undefined;
+/**
+ * Match the commands of a replayed activation against what it recorded.
+ * Returns the first mismatch and the seq it concerns, or undefined.
+ */
+declare function matchActivation(commands: readonly WorkflowCommand[], recorded: readonly RunEventRecord[]): {
+    message: string;
+    seq?: number;
+} | undefined;
+
+/**
+ * Command ids (C-HIST): one counter per kind, in issue order, so a replay that
+ * issues the same commands in the same order derives the same ids, and a
+ * reordered await is caught as a mismatch. Patch markers use `patch:<id>`.
+ */
+type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm';
+declare class CommandIds {
+    private readonly counters;
+    /** The next id of a kind: `a1`, `a2`, ... */
+    next(kind: CommandIdKind): string;
+}
+/** The marker id of a patch. */
+declare function patchMarkerId(patchId: string): string;
+/** True for a patch marker id. */
+declare function isPatchMarkerId(markerId: string): boolean;
+
+/**
+ * The deterministic scheduler of one workflow task (spec 04 §4-5): it runs a
+ * tier-2 function through the activations of its history, resolving awaitables
+ * in history order, and turns what the code does into commands.
+ *
+ * The host drives it with the runtime ABI: `start()`, then `step()` until it
+ * returns `done`, draining promise jobs between calls, then `complete()`. One
+ * `step()` either begins the next activation (delivers its inputs) or, once
+ * the jobs of the current one have settled and no `condition` fires any more,
+ * finishes it: a replayed activation must have issued exactly the commands it
+ * recorded, and the open activation's commands are the task's result.
+ *
+ * Pure JavaScript; it runs inside the isolate.
+ */
+
+/** The SDK name reported by `__enhanced_stack_trace`. */
+declare const SDK_NAME = "@fluidgrids/workflows";
+/** A thrown value that ends the run with `CONTINUE_AS_NEW`. */
+declare class ContinueAsNewRequest {
+    readonly input: Json;
+    readonly options: JsonObject;
+    constructor(input: Json, options: JsonObject);
+}
+declare class Scope implements CancellationScope {
+    readonly parent: Scope | undefined;
+    readonly nonCancellable: boolean;
+    consideredCancelled: boolean;
+    readonly cancelRequested: Promise<never>;
+    private rejectRequested;
+    private readonly handlers;
+    private readonly children;
+    constructor(parent: Scope | undefined, nonCancellable: boolean);
+    /** Register a reaction to cancellation; returns its removal. */
+    onCancel(handler: () => void): () => void;
+    /**
+     * Cancel the scope and its children. Every handler and child runs even when
+     * one throws; the first error is rethrown once the fan-out is complete.
+     */
+    cancel(): void;
+    detach(): void;
+}
+/** Everything one workflow task needs to run. */
+interface ExecutionInput {
+    definition: DurableWorkflow<never, unknown>;
+    /** Export names of the bundle's tier-2 functions, to name `ctx.child` targets. */
+    exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
+    request: WorkflowTaskRequest;
+    sdkVersion: string;
+}
+/** One workflow task in progress. */
+declare class WorkflowExecution {
+    readonly request: WorkflowTaskRequest;
+    private readonly definition;
+    private readonly exportNames;
+    private readonly sdkVersion;
+    private readonly activations;
+    private index;
+    private activationOpen;
+    private replaying;
+    private clock;
+    private readonly random;
+    private readonly ids;
+    private commands;
+    private newCommands;
+    private readonly logs;
+    private failure;
+    private closed;
+    private readonly captureStacks;
+    /** History length and inline bytes the current activation reports (see `Activation.historyLength`). */
+    private historyLength;
+    private historyBytes;
+    /** `bytesUpTo[n]`: UTF-8 bytes of the payloads of events 1..n. */
+    private readonly bytesUpTo;
+    private readonly limitEvents;
+    private readonly limitBytes;
+    private readonly root;
+    /**
+     * Scopes whose function is running synchronously right now, innermost
+     * last. The outer `ctx` uses the innermost one, else the root: a scope is
+     * ambient only during the synchronous part of its function, never across
+     * an await, so concurrent branches never see each other's scopes.
+     */
+    private readonly syncScopes;
+    /** A scope that is never cancelled, for waits that ignore cancellation. */
+    private readonly detachedScope;
+    private cancelRequested;
+    private readonly activities;
+    private readonly timers;
+    private readonly children;
+    private readonly externals;
+    private readonly issued;
+    private readonly recordedSideEffects;
+    private readonly recordedMarkers;
+    private readonly patches;
+    private readonly signalBuffers;
+    private readonly signalOrder;
+    private readonly signalHandlers;
+    private readonly signalWaiters;
+    private defaultSignalHandler;
+    private runningHandlers;
+    private conditions;
+    private currentDetails;
+    readonly context: WorkflowContext;
+    private readonly info;
+    constructor(input: ExecutionInput);
+    private continueAsNewSuggested;
+    /** The workflow clock. */
+    now(): number;
+    /** The next deterministic random number. */
+    nextRandom(): number;
+    /** 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. */
+    complete(): WorkflowTaskResult;
+    /** 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;
+    private finishActivation;
+    private deliver;
+    private expectIssued;
+    private settleActivity;
+    private settleChild;
+    private dispatchSignal;
+    private takeBuffered;
+    private runHandler;
+    private startFunction;
+    private onReturn;
+    private isFailureType;
+    /** What an error thrown out of workflow code does (11 §2.25, §2.37). */
+    onWorkflowError(error: unknown): void;
+    private currentScope;
+    /**
+     * Throw `HistoryLimitExceeded` from 95 % of the cap. It runs on replay too:
+     * the history length is the activation's cutoff and the command count is
+     * the activation's own, so replay sees what the first execution saw.
+     */
+    private checkLimit;
+    /** Issue a command; false when the run is already closed (the command is dropped). */
+    private push;
+    private pushTerminal;
+    private stack;
+    private never;
+    scheduleActivity<In, Out>(scope: Scope, operation: Operation<In, Out>, options: RunOptions<In>): Promise<Out>;
+    startTimer(scope: Scope, durationMs: number, summary: string | undefined): Promise<void>;
+    /** Start a durable timer; `timerId` is undefined when no timer was needed or issued. */
+    private timer;
+    /** Cancel a pending timer the runtime started for itself (condition and scope timeouts). */
+    private cancelOwnTimer;
+    condition(scope: Scope, predicate: () => boolean, timeout: Duration | undefined): Promise<boolean>;
+    /** Resolve conditions whose predicate now holds; true when any did. */
+    private checkConditions;
+    signalReceived<P>(scope: Scope, signal: SignalDefinition<P> | string): Promise<P>;
+    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown): void;
+    setDefaultSignalHandler(handler: (name: string, payload: unknown) => unknown): void;
+    private childTarget;
+    private childCommand;
+    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>>;
+    signalExternal(target: RunTarget, name: string, payload: unknown): Promise<void>;
+    cancelExternal(target: RunTarget): Promise<void>;
+    sideEffect<T extends Json>(fn: () => T): T;
+    patched(patchId: string, deprecated: boolean): boolean;
+    setCurrentDetails(markdown: string): void;
+    upsertContext(entries: JsonObject): void;
+    /** 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;
+    private answerQueries;
+    private contextFor;
+}
+
+/** The global a tier-2 bundle defines. */
+declare const RUNTIME_GLOBAL = "__fluidgridsRuntime";
+/** The runtime ABI, protocol 1. */
+interface FluidgridsRuntimeAbi {
+    readonly protocol: 1;
+    readonly sdkVersion: string;
+    start(requestJson: string): void;
+    step(): 'more' | 'done';
+    complete(): string;
+}
+/** The tier-2 functions of a bundle, by export name. */
+interface WorkflowRegistry {
+    byName: ReadonlyMap<string, DurableWorkflow<never, unknown>>;
+    exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
+    /** Export names declared by more than one module; starting one fails the task. */
+    ambiguous: ReadonlySet<string>;
+}
+/** Build the registry from the bundle's modules (`[path, namespace]` pairs). */
+declare function buildWorkflowRegistry(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): WorkflowRegistry;
+/**
+ * Create the ABI over a registry. `shims` connects the isolate's clock and
+ * random source to the running task (absent in-process).
+ */
+declare function createWorkflowRuntime(registry: WorkflowRegistry, shims?: ShimControl | undefined): FluidgridsRuntimeAbi;
+/**
+ * Define `globalThis.__fluidgridsRuntime` for a bundle's modules. Called by
+ * the generated bundle entry; harmless when the bundle is only lowered.
+ */
+declare function installWorkflowRuntime(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): void;
+/** True when `value` looks like the runtime ABI (it crossed a realm or an isolate boundary). */
+declare function isRuntimeAbi(value: unknown): value is FluidgridsRuntimeAbi;
+
+export { CommandIds, type FluidgridsRuntimeAbi, RUNTIME_GLOBAL, SDK_NAME, SHIM_HOOK, SHIM_VIOLATION, TASK_PRELUDE, WorkflowExecution, type WorkflowRegistry, buildWorkflowRegistry, createRandom, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId, seedOf, uuidFrom };

package/dist/runtime/index.d.ts

@@ -0,0 +1,297 @@
+import { W as WorkflowContext, h as DurableWorkflow, C as CancellationScope, O as Operation, R as RunOptions, j as Duration, l as SignalDefinition, e as ChildTarget, d as ChildOptions, c as ChildHandle, f as ContinueAsNewOptions, b as CancellationScopeOptions } from '../workflow-C2a05WUJ.js';
+export { A as Activation, s as splitActivations } from '../activation-DnhG7SmF.js';
+import { W as WorkflowCommand, U as RunEventRecord, a7 as WorkflowTaskRequest, a8 as WorkflowTaskResult, a as WorkflowTaskFailureCause, X as RunTarget } from '../types-DV-HX_Gt.js';
+import { a as Json, J as JsonObject } from '../types-BGoPzgcl.js';
+
+/**
+ * Determinism shims for workflow tasks (C-ABI, spec 04 §4).
+ *
+ * `TASK_PRELUDE` runs in the isolate before the bundle, in place of the
+ * lowering prelude (`DETERMINISM_PRELUDE`, which refuses the clock outright).
+ * Inside a workflow task the clock and the random source resolve through the
+ * runtime: `Date.now()`, `new Date()` and `Date()` read the workflow clock,
+ * `Math.random()` and `crypto.getRandomValues()` read the per-run seeded
+ * generator.
+ *
+ * The prelude also gives every engine and host the same built-ins: local time
+ * is UTC (the `Date` local getters, setters, constructor, `Date.parse` of
+ * strings without an offset and `toString` ignore the host's TZ), the
+ * `toLocale*` and `localeCompare` methods are locale-independent (fixed en-US
+ * shapes without ICU), `Intl` is absent, and `WeakRef` and
+ * `FinalizationRegistry` throw, because garbage collection is observable and
+ * not deterministic. QuickJS and `vm` otherwise differ on all of these. Outside a task (module top level) they throw
+ * `DeterminismViolation`, as do the timer functions and network entry points,
+ * which have no deterministic meaning in workflow code.
+ *
+ * The prelude leaves one hook, `globalThis.__fluidgridsShims`, which the
+ * runtime takes (and deletes) when the bundle installs it. This is not a
+ * security boundary (the isolate is); it only keeps workflow code honest.
+ */
+/** The `name` of the error the shims throw. */
+declare const SHIM_VIOLATION = "DeterminismViolation";
+/** Global the prelude leaves for the runtime. */
+declare const SHIM_HOOK = "__fluidgridsShims";
+declare const TASK_PRELUDE: string;
+/** What the runtime gives the shims while a task runs. */
+interface ShimHooks {
+    now(): number;
+    random(): number;
+}
+/** The control the prelude leaves behind. */
+interface ShimControl {
+    attach(hooks: ShimHooks): void;
+    detach(): void;
+}
+/** A 32-bit FNV-1a hash of a string: the seed of a run's random generator. */
+declare function seedOf(text: string): number;
+/** mulberry32: a small, fast, deterministic generator of numbers in [0, 1). */
+declare function createRandom(seed: number): () => number;
+/** A version-4 UUID from a random source. */
+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).
+ */
+
+/** Why `command` does not match `event`, or undefined when it does. */
+declare function mismatch(command: WorkflowCommand, event: RunEventRecord): string | undefined;
+/**
+ * Match the commands of a replayed activation against what it recorded.
+ * Returns the first mismatch and the seq it concerns, or undefined.
+ */
+declare function matchActivation(commands: readonly WorkflowCommand[], recorded: readonly RunEventRecord[]): {
+    message: string;
+    seq?: number;
+} | undefined;
+
+/**
+ * Command ids (C-HIST): one counter per kind, in issue order, so a replay that
+ * issues the same commands in the same order derives the same ids, and a
+ * reordered await is caught as a mismatch. Patch markers use `patch:<id>`.
+ */
+type CommandIdKind = 'a' | 't' | 'c' | 's' | 'x' | 'm';
+declare class CommandIds {
+    private readonly counters;
+    /** The next id of a kind: `a1`, `a2`, ... */
+    next(kind: CommandIdKind): string;
+}
+/** The marker id of a patch. */
+declare function patchMarkerId(patchId: string): string;
+/** True for a patch marker id. */
+declare function isPatchMarkerId(markerId: string): boolean;
+
+/**
+ * The deterministic scheduler of one workflow task (spec 04 §4-5): it runs a
+ * tier-2 function through the activations of its history, resolving awaitables
+ * in history order, and turns what the code does into commands.
+ *
+ * The host drives it with the runtime ABI: `start()`, then `step()` until it
+ * returns `done`, draining promise jobs between calls, then `complete()`. One
+ * `step()` either begins the next activation (delivers its inputs) or, once
+ * the jobs of the current one have settled and no `condition` fires any more,
+ * finishes it: a replayed activation must have issued exactly the commands it
+ * recorded, and the open activation's commands are the task's result.
+ *
+ * Pure JavaScript; it runs inside the isolate.
+ */
+
+/** The SDK name reported by `__enhanced_stack_trace`. */
+declare const SDK_NAME = "@fluidgrids/workflows";
+/** A thrown value that ends the run with `CONTINUE_AS_NEW`. */
+declare class ContinueAsNewRequest {
+    readonly input: Json;
+    readonly options: JsonObject;
+    constructor(input: Json, options: JsonObject);
+}
+declare class Scope implements CancellationScope {
+    readonly parent: Scope | undefined;
+    readonly nonCancellable: boolean;
+    consideredCancelled: boolean;
+    readonly cancelRequested: Promise<never>;
+    private rejectRequested;
+    private readonly handlers;
+    private readonly children;
+    constructor(parent: Scope | undefined, nonCancellable: boolean);
+    /** Register a reaction to cancellation; returns its removal. */
+    onCancel(handler: () => void): () => void;
+    /**
+     * Cancel the scope and its children. Every handler and child runs even when
+     * one throws; the first error is rethrown once the fan-out is complete.
+     */
+    cancel(): void;
+    detach(): void;
+}
+/** Everything one workflow task needs to run. */
+interface ExecutionInput {
+    definition: DurableWorkflow<never, unknown>;
+    /** Export names of the bundle's tier-2 functions, to name `ctx.child` targets. */
+    exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
+    request: WorkflowTaskRequest;
+    sdkVersion: string;
+}
+/** One workflow task in progress. */
+declare class WorkflowExecution {
+    readonly request: WorkflowTaskRequest;
+    private readonly definition;
+    private readonly exportNames;
+    private readonly sdkVersion;
+    private readonly activations;
+    private index;
+    private activationOpen;
+    private replaying;
+    private clock;
+    private readonly random;
+    private readonly ids;
+    private commands;
+    private newCommands;
+    private readonly logs;
+    private failure;
+    private closed;
+    private readonly captureStacks;
+    /** History length and inline bytes the current activation reports (see `Activation.historyLength`). */
+    private historyLength;
+    private historyBytes;
+    /** `bytesUpTo[n]`: UTF-8 bytes of the payloads of events 1..n. */
+    private readonly bytesUpTo;
+    private readonly limitEvents;
+    private readonly limitBytes;
+    private readonly root;
+    /**
+     * Scopes whose function is running synchronously right now, innermost
+     * last. The outer `ctx` uses the innermost one, else the root: a scope is
+     * ambient only during the synchronous part of its function, never across
+     * an await, so concurrent branches never see each other's scopes.
+     */
+    private readonly syncScopes;
+    /** A scope that is never cancelled, for waits that ignore cancellation. */
+    private readonly detachedScope;
+    private cancelRequested;
+    private readonly activities;
+    private readonly timers;
+    private readonly children;
+    private readonly externals;
+    private readonly issued;
+    private readonly recordedSideEffects;
+    private readonly recordedMarkers;
+    private readonly patches;
+    private readonly signalBuffers;
+    private readonly signalOrder;
+    private readonly signalHandlers;
+    private readonly signalWaiters;
+    private defaultSignalHandler;
+    private runningHandlers;
+    private conditions;
+    private currentDetails;
+    readonly context: WorkflowContext;
+    private readonly info;
+    constructor(input: ExecutionInput);
+    private continueAsNewSuggested;
+    /** The workflow clock. */
+    now(): number;
+    /** The next deterministic random number. */
+    nextRandom(): number;
+    /** 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. */
+    complete(): WorkflowTaskResult;
+    /** 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;
+    private finishActivation;
+    private deliver;
+    private expectIssued;
+    private settleActivity;
+    private settleChild;
+    private dispatchSignal;
+    private takeBuffered;
+    private runHandler;
+    private startFunction;
+    private onReturn;
+    private isFailureType;
+    /** What an error thrown out of workflow code does (11 §2.25, §2.37). */
+    onWorkflowError(error: unknown): void;
+    private currentScope;
+    /**
+     * Throw `HistoryLimitExceeded` from 95 % of the cap. It runs on replay too:
+     * the history length is the activation's cutoff and the command count is
+     * the activation's own, so replay sees what the first execution saw.
+     */
+    private checkLimit;
+    /** Issue a command; false when the run is already closed (the command is dropped). */
+    private push;
+    private pushTerminal;
+    private stack;
+    private never;
+    scheduleActivity<In, Out>(scope: Scope, operation: Operation<In, Out>, options: RunOptions<In>): Promise<Out>;
+    startTimer(scope: Scope, durationMs: number, summary: string | undefined): Promise<void>;
+    /** Start a durable timer; `timerId` is undefined when no timer was needed or issued. */
+    private timer;
+    /** Cancel a pending timer the runtime started for itself (condition and scope timeouts). */
+    private cancelOwnTimer;
+    condition(scope: Scope, predicate: () => boolean, timeout: Duration | undefined): Promise<boolean>;
+    /** Resolve conditions whose predicate now holds; true when any did. */
+    private checkConditions;
+    signalReceived<P>(scope: Scope, signal: SignalDefinition<P> | string): Promise<P>;
+    onSignal(signal: SignalDefinition<unknown> | string, handler: (payload: unknown) => unknown): void;
+    setDefaultSignalHandler(handler: (name: string, payload: unknown) => unknown): void;
+    private childTarget;
+    private childCommand;
+    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>>;
+    signalExternal(target: RunTarget, name: string, payload: unknown): Promise<void>;
+    cancelExternal(target: RunTarget): Promise<void>;
+    sideEffect<T extends Json>(fn: () => T): T;
+    patched(patchId: string, deprecated: boolean): boolean;
+    setCurrentDetails(markdown: string): void;
+    upsertContext(entries: JsonObject): void;
+    /** 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;
+    private answerQueries;
+    private contextFor;
+}
+
+/** The global a tier-2 bundle defines. */
+declare const RUNTIME_GLOBAL = "__fluidgridsRuntime";
+/** The runtime ABI, protocol 1. */
+interface FluidgridsRuntimeAbi {
+    readonly protocol: 1;
+    readonly sdkVersion: string;
+    start(requestJson: string): void;
+    step(): 'more' | 'done';
+    complete(): string;
+}
+/** The tier-2 functions of a bundle, by export name. */
+interface WorkflowRegistry {
+    byName: ReadonlyMap<string, DurableWorkflow<never, unknown>>;
+    exportNames: ReadonlyMap<DurableWorkflow<never, unknown>, string>;
+    /** Export names declared by more than one module; starting one fails the task. */
+    ambiguous: ReadonlySet<string>;
+}
+/** Build the registry from the bundle's modules (`[path, namespace]` pairs). */
+declare function buildWorkflowRegistry(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): WorkflowRegistry;
+/**
+ * Create the ABI over a registry. `shims` connects the isolate's clock and
+ * random source to the running task (absent in-process).
+ */
+declare function createWorkflowRuntime(registry: WorkflowRegistry, shims?: ShimControl | undefined): FluidgridsRuntimeAbi;
+/**
+ * Define `globalThis.__fluidgridsRuntime` for a bundle's modules. Called by
+ * the generated bundle entry; harmless when the bundle is only lowered.
+ */
+declare function installWorkflowRuntime(modules: ReadonlyArray<readonly [string, Record<string, unknown>]>): void;
+/** True when `value` looks like the runtime ABI (it crossed a realm or an isolate boundary). */
+declare function isRuntimeAbi(value: unknown): value is FluidgridsRuntimeAbi;
+
+export { CommandIds, type FluidgridsRuntimeAbi, RUNTIME_GLOBAL, SDK_NAME, SHIM_HOOK, SHIM_VIOLATION, TASK_PRELUDE, WorkflowExecution, type WorkflowRegistry, buildWorkflowRegistry, createRandom, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId, seedOf, uuidFrom };

package/dist/runtime/index.js

@@ -0,0 +1,8 @@
+export { CommandIds, RUNTIME_GLOBAL, SDK_NAME, WorkflowExecution, buildWorkflowRegistry, createWorkflowRuntime, installWorkflowRuntime, isPatchMarkerId, isRuntimeAbi, matchActivation, mismatch, patchMarkerId } from '../chunk-3FOTFQ3J.js';
+import '../chunk-C5OLWZ42.js';
+import '../chunk-LNUQE6D6.js';
+export { SHIM_HOOK, SHIM_VIOLATION, TASK_PRELUDE, createRandom, seedOf, uuidFrom } from '../chunk-4LYSEANA.js';
+import '../chunk-7NQ37GZU.js';
+export { splitActivations } from '../chunk-ABFZWYHT.js';
+import '../chunk-DJYMDLV5.js';
+import '../chunk-BO6OVILK.js';