@voltro/workflow 0.34.0 → 0.35.0

package/dist/index.d.ts

@@ -101,6 +101,15 @@ export declare interface AdmissionDrainDeps {
         readonly executionId: string;
         readonly startedAt: number;
     }>>;
+    /**
+     * EVERY registered workflow name — not just the controlled ones in
+     * `controls`. A `mode: 'delayed'` row is legitimate for a workflow with NO
+     * flow control, so "missing from `controls`" cannot mean "orphan" for it the
+     * way it does for a debounce row. Absent → a delayed row is assumed
+     * registered, and an unknown name surfaces as a per-row failure (attempts +
+     * lastError climb on the row) instead of a silent abandon.
+     */
+    readonly registeredWorkflows?: ReadonlySet<string>;
     readonly log?: DrainLogger;
     readonly now?: () => number;
 }
@@ -831,6 +840,17 @@ export declare const DEFAULT_STALL_EVENT_LOOKBACK = 20;
  *  tick instead of re-reading the same page. */
 export declare const DEFAULT_STALL_RUN_PAGE = 200;
 
+/**
+ * Default threshold: a wait DECLARED longer than this suggests the suspending
+ * variant. Five minutes — well above any interactive approval, well below the
+ * hours-long HITL waits the suspending variant is for; the poll's own backoff
+ * (≤ 5 s) makes the polling cost of a shorter wait negligible.
+ */
+export declare const DEFAULT_SUSPEND_HINT_MS: number;
+
+/** 24 h — see {@link WorkflowScheduleDeclaration.maxRuntime}. */
+export declare const DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS: number;
+
 export declare type DeferMode = DeferringControl | 'paused';
 
 /**
@@ -1005,6 +1025,9 @@ export declare const getCurrentWorkflowRunId: () => Effect.Effect<string | undef
  *  the path it took before this feature existed. */
 export declare const getWorkflowFlowControl: (value: unknown) => ResolvedFlowControl | undefined;
 
+/** The resolved schedule attached to a workflow definition, or undefined. */
+export declare const getWorkflowSchedule: (value: unknown) => ResolvedWorkflowSchedule | undefined;
+
 export declare const getWorkflowVersionMetadata: (value: unknown) => WorkflowVersionMetadata;
 
 /** `true` when this workflow declares at least one `cancelOn` entry — i.e. when
@@ -1145,6 +1168,13 @@ export declare const makeWorkflowRunRecorder: (options: WorkflowRunRecorderOptio
 
 export declare const makeWorkflowUpdateId: () => string;
 
+/**
+ * Emit the steering hint when a polling `awaitSignal` declares a wait longer
+ * than the threshold. Returns `true` when it hinted — the testable fact; the
+ * once-per-name set is module state on purpose (one process, one hint).
+ */
+export declare const maybeHintSuspendingSignal: (input: SuspendHintInput) => boolean;
+
 /** The newest event instant in a batch, or `undefined` for an empty one.
  *  The watermark advances to THIS, never to `now`: advancing to wall-clock
  *  would skip anything written with an older `occurredAt` by a transaction
@@ -1207,6 +1237,37 @@ export declare const normaliseWorkflowPatches: (value: unknown) => ReadonlyArray
 
 export declare const noteIntentAttempt: (store: AdmissionDataStore, intent: PendingIntent, error: string, now: number) => Promise<void>;
 
+/**
+ * Park a `start(name, payload, { at })` as a DURABLE pending row.
+ *
+ * A delayed start that only exists in a `setTimeout` dies with the process, so
+ * it is a row in `_voltro_workflow_pending` (`mode: 'delayed'`) that the
+ * coordinated drainer fires when `dueAt` arrives. Each call is its OWN row —
+ * two delayed starts never collapse, because unlike debounce nothing about
+ * `{ at }` says the second supersedes the first.
+ *
+ * What happens at `dueAt` is an ARRIVAL, not a bypass: the drainer hands the
+ * row to the same `admitStart` a live `ctx.workflows.start` goes through, so a
+ * workflow's declared debounce/singleton/rateLimit judge the start as of the
+ * moment it comes due. `{ at }` delays the arrival; it never outranks a control.
+ */
+export declare const parkDelayedStart: (input: ParkDelayedStartInput) => Promise<{
+    readonly intentId: string;
+    readonly dueAt: number;
+}>;
+
+export declare interface ParkDelayedStartInput {
+    readonly store: AdmissionDataStore;
+    readonly workflowName: string;
+    readonly payload: unknown;
+    readonly callerContext: unknown;
+    readonly tenantId: string | null;
+    /** Epoch ms the start becomes an ARRIVAL. Must be in the future — the facade
+     *  starts a past-`at` immediately and never calls in here. */
+    readonly at: number;
+    readonly now: number;
+}
+
 /**
  * Is a named change marker in effect for the run currently executing?
  *
@@ -1288,7 +1349,7 @@ export declare interface PendingIntent {
     readonly tenantId: string | null;
     readonly workflowName: string;
     readonly controlKey: string;
-    readonly mode: 'debounce' | 'batch' | 'throttle' | 'concurrency' | 'paused';
+    readonly mode: 'debounce' | 'batch' | 'throttle' | 'concurrency' | 'paused' | 'delayed';
     readonly payload: unknown;
     readonly callerContext: unknown;
     readonly priority: number;
@@ -1578,6 +1639,9 @@ export declare interface ReplayShapeTracker {
  */
 export declare const reportNondeterminism: (findings: ReadonlyArray<NondeterminismFinding>) => Effect.Effect<void>;
 
+/** Test seam: forget which (workflow, signal) pairs have been hinted. */
+export declare const resetSuspendHintsForTest: () => void;
+
 /** Resolve every declared key against one payload. Pure; throws only
  *  {@link FlowControlKeyError}. */
 export declare const resolveAdmissionKeys: (control: ResolvedFlowControl, payload: unknown) => AdmissionKeys;
@@ -1650,6 +1714,18 @@ export declare interface ResolvedFlowControl {
     readonly cancelOn?: ReadonlyArray<ResolvedCancelOn>;
 }
 
+/** The declaration with defaults filled in — what the CLI lowering reads. */
+export declare interface ResolvedWorkflowSchedule {
+    readonly cron: string;
+    readonly timezone: string;
+    readonly payload?: unknown | ((fire: {
+        readonly scheduledAt: Date;
+    }) => unknown | Promise<unknown>);
+    readonly onOverlap: WorkflowScheduleOverlap;
+    readonly backfill: 'skip' | 'latest' | 'all';
+    readonly maxRuntimeMs: number;
+}
+
 /**
  * Read the run-guard knobs from the environment, for the boot paths to spread
  * into {@link wrapWorkflowExecuteWithRunRecording}. Mirrors
@@ -1664,6 +1740,9 @@ export declare const resolveRunGuardTuning: () => {
     replayShapeLimit?: number;
 };
 
+/** Env (operator, no rebuild) → config (project) → default. */
+export declare const resolveSuspendHintMs: () => number;
+
 export declare const resolveWorkflowMessageRun: (store: WorkflowMessageStore, target: WorkflowMessageTarget) => Promise<WorkflowResolvedRun>;
 
 export declare const resumeWorkflow: (store: AdmissionDataStore, workflowName: string) => Promise<boolean>;
@@ -1689,6 +1768,15 @@ export declare const sendWorkflowUpdate: (input: {
 
 export declare const serialiseWorkflowRowForWire: (row: Record<string, unknown>) => Record<string, unknown>;
 
+/**
+ * Set the threshold from `app.config.ts` (`workflows.suspendSignalHintMs`).
+ * Called by the framework boot (both paths, through `wireFlowControl`); the
+ * env override below still wins, per the standing tunables rule.
+ * Non-positive/non-finite values are ignored; `0` cannot silence the hint —
+ * pass a very large threshold to effectively disable it.
+ */
+export declare const setSuspendSignalHintMs: (ms: number | undefined) => void;
+
 /**
  * Durable sleep — wake time journaled in the cluster. Wrapper around
  * `DurableClock.sleep` that emits `timer-set` / `timer-fired` events
@@ -1963,6 +2051,16 @@ export declare interface SuspendForBudgetOptions {
     readonly hasHeadroom: Effect.Effect<boolean>;
 }
 
+export declare interface SuspendHintInput {
+    /** Undefined outside an engine context — the hint then keys on the signal
+     *  name alone, which still fires once rather than never. */
+    readonly workflowName: string | undefined;
+    readonly signalName: string;
+    /** The wait's DECLARED timeout, ms. */
+    readonly timeoutMs: number;
+    readonly warn?: (message: string) => void;
+}
+
 /**
  * The stable `DurableDeferred` name for a suspending signal wait. It is a pure
  * function of the workflow name + the signal name, so the awaiting body and an
@@ -2010,6 +2108,14 @@ export declare interface ValidateFlowControlInput {
     readonly control: (WorkflowFlowControl<never> & WorkflowCancelOnDeclared) | undefined;
 }
 
+/**
+ * Validate at DEFINITION time — module load, i.e. boot — with a message naming
+ * the workflow and the field. Same posture as `validateFlowControl` and
+ * `defineSchedule`: a cron typo that surfaces as "never fired" three days in
+ * is the failure class this repo keeps paying for.
+ */
+export declare const validateWorkflowSchedule: (workflowName: string, declaration: WorkflowScheduleDeclaration<never> | undefined) => ResolvedWorkflowSchedule | undefined;
+
 /**
  * One parked run, waiting on budget headroom.
  *
@@ -2519,6 +2625,12 @@ declare type WorkflowFn = <const Name extends string, Payload extends WorkflowPa
      *  type comes from its OWN `schema` — see {@link WorkflowCancelOnList} for
      *  why that needs a tuple type parameter rather than a plain array. */
     readonly cancelOn?: WorkflowCancelOnList<Cancels, DecodedPayload<Payload>>;
+    /** Run this workflow on a cron — the workflow-side spelling of a
+     *  `defineSchedule({ workflow })` target, with Temporal's overlap
+     *  vocabulary (`skip` / `buffer` / `cancelOther`). Lowered by the CLI into
+     *  a real schedule named `workflow:<name>`; see
+     *  {@link WorkflowScheduleDeclaration}. */
+    readonly schedule?: WorkflowScheduleDeclaration<DecodedPayload<Payload>>;
 } & Omit<WorkflowBaseOptions, 'name' | 'payload' | 'idempotencyKey' | 'success' | 'error'> & WorkflowVersionOptions & {
     readonly messages?: Messages;
 } & WorkflowFlowControl<DecodedPayload<Payload>>) => workflowModule.Workflow<Name, PayloadSchemaOf<Payload>, Success, Error> & WorkflowMessagesCarrier<NormaliseWorkflowMessages<Messages>>;
@@ -2769,6 +2881,23 @@ export declare interface WorkflowRunRecorderOptions {
      * rather than as garbage — see `inspectWorkflow`.
      */
     readonly encryptStepPayload?: (value: unknown) => unknown;
+    /**
+     * How much this recorder writes per STEP — `'full'` (default) or `'coarse'`.
+     *
+     * `'coarse'` makes `startStep` answer "not recording this step" (the
+     * contract callers already handle) and `endStep*` no-ops, removing the two
+     * fire-and-forget store writes every step otherwise costs. Run rows and
+     * `recordEvent` (signals, timers, cancels, stall reports) are DELIBERATELY
+     * unaffected: they are per-run, not per-step, and they are what the
+     * dead-letter view and the cancel/staleness sweeps read. The engine's own
+     * durable journal is not touched either way — this is the introspection
+     * copy, never replay state.
+     *
+     * App-facing spelling: `workflows.recording` in `app.config.ts`, env
+     * override `VOLTRO_WORKFLOW_RECORDING` (resolved by the CLI, threaded to
+     * BOTH boot paths through one resolver).
+     */
+    readonly recording?: 'full' | 'coarse';
 }
 
 /** Per-step lifecycle hooks. Implementations should not throw —
@@ -2841,6 +2970,68 @@ export declare interface WorkflowRunRecorderService {
     }>;
 }
 
+export declare interface WorkflowScheduleDeclaration<Payload> {
+    /** Standard cron expression — 5-field or 6-field (leading seconds). */
+    readonly cron: string;
+    /** IANA timezone the expression is interpreted in. REQUIRED, like
+     *  `defineSchedule` — server-local time in a container is a bug factory. */
+    readonly timezone: string;
+    /**
+     * The payload each firing starts the workflow with. A value, or a function
+     * of the firing (`({ scheduledAt }) => …`) for payloads that carry the slot
+     * — a backfilled firing then computes against ITS instant, not "now".
+     * Omitted ⇒ `{}`, which only typechecks for workflows whose payload has no
+     * required fields; a mismatch fails the start with `WorkflowPayloadError`
+     * naming the missing fields, same as any other start.
+     */
+    readonly payload?: Payload | ((fire: {
+        readonly scheduledAt: Date;
+    }) => Payload | Promise<Payload>);
+    /** Default `'skip'` — Temporal's default too, and the only answer that is
+     *  safe for every job shape. */
+    readonly onOverlap?: WorkflowScheduleOverlap;
+    /** Boot catch-up policy for firings missed during downtime — the scheduler's
+     *  own vocabulary, unchanged. Default `'skip'`. For a RANGE older than boot
+     *  backfill reaches, use `voltro schedule backfill`. */
+    readonly backfill?: 'skip' | 'latest' | 'all';
+    /**
+     * Watchdog on ONE firing — which, for a workflow schedule, INCLUDES the
+     * awaited run (that await is what makes `onOverlap` bind on the run's
+     * duration). Default 24 hours rather than `defineSchedule`'s 30 minutes,
+     * because a durable run legitimately outlives a handler; set it above your
+     * slowest expected run. Past it the FIRING records `failed`/timeout and
+     * releases the overlap guard — the workflow run itself is NOT cancelled
+     * (declare flow-control `timeouts.finish` to bound the run).
+     */
+    readonly maxRuntime?: FlowDuration;
+}
+
+/**
+ * What happens when a firing arrives while the RUN from the previous firing is
+ * still going — Temporal Schedules' overlap vocabulary, applied to the
+ * workflow run (not merely to the handler invocation):
+ *
+ *   `'skip'`        — the new firing stands down; recorded as `skipped`.
+ *   `'buffer'`      — the new firing waits and runs after the previous one
+ *                     finishes; firings serialize, none is lost.
+ *   `'cancelOther'` — the new firing CANCELS the still-running previous run
+ *                     and starts fresh — for "recompute the latest state"
+ *                     jobs where the old run's partial work is worthless.
+ *
+ * The first two lower into the scheduler's own `onOverlap: 'skip' | 'queue'`;
+ * what makes them bind on the RUN's duration is that the synthesised handler
+ * AWAITS the workflow run to completion, so the schedule-run row is `running`
+ * for exactly as long as the workflow is.
+ */
+export declare type WorkflowScheduleOverlap = 'skip' | 'buffer' | 'cancelOther';
+
+/** Attached via `defineProperty` like the flow-control carrier — the value's
+ *  TYPE does not know about it, and the web bundle never reads it. A STRING
+ *  property rather than a symbol for the same reason as
+ *  `WorkflowFlowControlProperty`: the CLI's discovery reads it off a module
+ *  that crossed a bundler boundary, and symbols do not survive every one. */
+export declare const WorkflowScheduleProperty = "__voltroWorkflowSchedule";
+
 /**
  * At most one run per key. The newcomer either stands down or evicts.
  *

package/dist/index.js

@@ -1,3 +1,3 @@
-import { A as e, B as t, C as n, D as r, E as i, F as a, I as o, L as s, M as c, N as l, O as u, P as d, R as f, S as p, T as m, V as h, _ as g, a as _, b as v, c as y, d as b, f as x, g as S, h as C, i as w, k as T, l as E, m as D, n as O, o as k, p as A, r as j, s as M, t as N, u as P, v as F, w as I, x as L, y as R, z } from "./primitives-oLKOTbvJ.js";
-import { $ as B, A as V, At as H, B as U, C as W, Ct as G, D as K, Dt as q, E as J, Et as Y, F as X, G as Z, H as Q, I as $, J as ee, K as te, L as ne, M as re, Mt as ie, N as ae, Nt as oe, O as se, Ot as ce, P as le, Q as ue, R as de, S as fe, St as pe, T as me, Tt as he, U as ge, V as _e, W as ve, X as ye, Y as be, Z as xe, _ as Se, _t as Ce, a as we, at as Te, b as Ee, bt as De, c as Oe, ct as ke, d as Ae, dt as je, et as Me, f as Ne, ft as Pe, g as Fe, gt as Ie, h as Le, ht as Re, i as ze, it as Be, j as Ve, jt as He, k as Ue, kt as We, l as Ge, lt as Ke, m as qe, mt as Je, n as Ye, nt as Xe, o as Ze, ot as Qe, p as $e, pt as et, q as tt, r as nt, rt, s as it, st as at, t as ot, tt as st, u as ct, ut as lt, v as ut, vt as dt, w as ft, wt as pt, x as mt, xt as ht, y as gt, yt as _t, z as vt } from "./src-BXObaqb-.js";
-export { ue as ADMISSIONS_TABLE, $e as BUDGET_HOLDS_TABLE, qe as BudgetHoldExpired, vt as CANCEL_ON_WATERMARK, u as CurrentWorkflowExecutionId, T as CurrentWorkflowPatches, I as CurrentWorkflowReplayShape, e as CurrentWorkflowRunId, Le as DEFAULT_BUDGET_HOLD_TIMEOUT_MS, U as DEFAULT_COLD_LOOKBACK_MS, ae as DEFAULT_DRAIN_BATCH, _e as DEFAULT_EVENT_BATCH, B as DEFAULT_LEASE_MS, ze as DEFAULT_MAX_RUN_RECLAIMS, we as DEFAULT_REPLAY_SHAPE_LIMIT, X as DEFAULT_STALL_AFTER_MS, $ as DEFAULT_STALL_EVENT_LOOKBACK, ne as DEFAULT_STALL_RUN_PAGE, o as DEFERRING_CONTROLS, Q as EVENTS_TABLE, dt as FlowControlKeyError, Me as PAUSES_TABLE, st as PENDING_TABLE, ge as WATERMARKS_TABLE, N as WorkflowFlowControlProperty, O as WorkflowMessagesProperty, c as WorkflowRunRecorder, l as WorkflowStepInterceptorTag, j as WorkflowVersionTypeId, w as WorkflowWorkerLayerTypeId, Fe as _voltroBudgetHoldsTable, Y as _voltroWorkflowAdmissionsTable, q as _voltroWorkflowPausesTable, ce as _voltroWorkflowPendingTable, H as _voltroWorkflowRunEventsTable, He as _voltroWorkflowRunStepsTable, ie as _voltroWorkflowRunsTable, We as _voltroWorkflowStartContextsTable, be as _voltroWorkflowWatermarksTable, ye as admitStart, Xe as allIntents, s as assertConsistentPools, Ve as awaitEvent, re as awaitSignal, ft as awaitSignalSuspending, Ne as awaitUpdate, Se as budgetHoldGeneration, ut as budgetHoldKey, gt as budgetHoldSignalName, nt as closeWorkflowChildrenForParent, _t as comparePendingOrder, me as completeSuspendingSignal, De as decideAdmission, f as deferringControlsOf, rt as deleteIntent, Be as discardIntent, le as drainTick, Te as dueIntents, _ as durableClock, k as durableQueue, M as durableQueueModule, y as durableRateLimiterModule, Qe as evaluateAdmission, d as getCurrentWorkflowExecutionId, a as getCurrentWorkflowRunId, E as getWorkflowFlowControl, P as getWorkflowVersionMetadata, z as hasCancelOn, t as hasFlowControl, Ee as heldBudgets, oe as inMemoryWorkflowEngineLayer, Ye as inspectWorkflow, ht as isFinishExpired, pe as isStartExpired, b as isWorkflowWorkerLayer, xe as linkExecution, ot as makeInMemoryRecorder, m as makeReplayShapeTracker, Ze as makeWorkflowRunRecorder, K as makeWorkflowUpdateId, tt as newestEventAt, G as nextSlotAt, i as nondeterminismEventPayload, it as normaliseWorkflowPatches, at as noteIntentAttempt, x as patch, ke as pauseWorkflow, mt as pendingBudgetHolds, Ke as pendingSlotId, lt as pendingWindow, je as persistDefer, ee as planCancellations, pt as pooledConcurrencyKey, A as processQueue, Pe as pruneAdmissions, D as queueWorker, C as rateLimit, et as readAdmissionState, Je as readPausedWorkflows, ve as readWatermark, Re as recordAdmission, fe as releaseBudgetHolds, Ie as releaseLease, r as reportNondeterminism, he as resolveAdmissionKeys, Oe as resolveRunGuardTuning, se as resolveWorkflowMessageRun, Ce as resumeWorkflow, Ue as sendWorkflowSignal, V as sendWorkflowUpdate, Ge as serialiseWorkflowRowForWire, S as sleep, g as sleepUntil, F as step, R as stepIdempotencyKey, v as stepModule, W as suspendForBudget, J as suspendingSignalDeferredName, Z as sweepCancelOn, de as sweepStalledRuns, ct as truncateWorkflowValue, h as validateFlowControl, L as withCompensation, p as workflow, n as workflowModule, Ae as wrapWorkflowExecuteWithRunRecording, te as writeWatermark };
+import { A as e, B as t, C as n, D as r, E as i, G as a, H as o, I as s, L as c, M as l, N as u, O as d, P as f, R as p, S as m, T as h, U as g, V as _, W as v, _ as y, a as b, b as x, c as S, d as C, f as w, g as T, h as E, i as D, j as O, k, l as A, m as j, n as M, o as N, p as P, r as F, s as I, t as L, u as R, v as z, w as B, x as V, y as H, z as U } from "./primitives-CyQZeT1t.js";
+import { $ as W, A as G, At as K, B as q, C as J, Ct as Y, D as X, Dt as Z, E as Q, Et as $, F as ee, Ft as te, G as ne, H as re, I as ie, It as ae, J as oe, K as se, L as ce, Lt as le, M as ue, Mt as de, N as fe, Nt as pe, O as me, Ot as he, P as ge, Pt as _e, Q as ve, R as ye, Rt as be, S as xe, St as Se, T as Ce, Tt as we, U as Te, V as Ee, W as De, X as Oe, Y as ke, Z as Ae, _ as je, _t as Me, a as Ne, at as Pe, b as Fe, bt as Ie, c as Le, ct as Re, d as ze, dt as Be, et as Ve, f as He, ft as Ue, g as We, gt as Ge, h as Ke, ht as qe, i as Je, it as Ye, j as Xe, jt as Ze, k as Qe, kt as $e, l as et, lt as tt, m as nt, mt as rt, n as it, nt as at, o as ot, ot as st, p as ct, pt as lt, q as ut, r as dt, rt as ft, s as pt, st as mt, t as ht, tt as gt, u as _t, ut as vt, v as yt, vt as bt, w as xt, wt as St, x as Ct, xt as wt, y as Tt, yt as Et, z as Dt, zt as Ot } from "./src-DPkbBZDD.js";
+export { ft as ADMISSIONS_TABLE, ct as BUDGET_HOLDS_TABLE, nt as BudgetHoldExpired, De as CANCEL_ON_WATERMARK, l as CurrentWorkflowExecutionId, u as CurrentWorkflowPatches, B as CurrentWorkflowReplayShape, f as CurrentWorkflowRunId, Ke as DEFAULT_BUDGET_HOLD_TIMEOUT_MS, ne as DEFAULT_COLD_LOOKBACK_MS, ye as DEFAULT_DRAIN_BATCH, se as DEFAULT_EVENT_BATCH, Ye as DEFAULT_LEASE_MS, Je as DEFAULT_MAX_RUN_RECLAIMS, Ne as DEFAULT_REPLAY_SHAPE_LIMIT, q as DEFAULT_STALL_AFTER_MS, Ee as DEFAULT_STALL_EVENT_LOOKBACK, re as DEFAULT_STALL_RUN_PAGE, fe as DEFAULT_SUSPEND_HINT_MS, d as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, t as DEFERRING_CONTROLS, ut as EVENTS_TABLE, St as FlowControlKeyError, Pe as PAUSES_TABLE, st as PENDING_TABLE, oe as WATERMARKS_TABLE, L as WorkflowFlowControlProperty, M as WorkflowMessagesProperty, s as WorkflowRunRecorder, k as WorkflowScheduleProperty, c as WorkflowStepInterceptorTag, F as WorkflowVersionTypeId, D as WorkflowWorkerLayerTypeId, We as _voltroBudgetHoldsTable, de as _voltroWorkflowAdmissionsTable, pe as _voltroWorkflowPausesTable, _e as _voltroWorkflowPendingTable, ae as _voltroWorkflowRunEventsTable, le as _voltroWorkflowRunStepsTable, be as _voltroWorkflowRunsTable, te as _voltroWorkflowStartContextsTable, Ve as _voltroWorkflowWatermarksTable, gt as admitStart, mt as allIntents, _ as assertConsistentPools, Xe as awaitEvent, ue as awaitSignal, xt as awaitSignalSuspending, He as awaitUpdate, je as budgetHoldGeneration, yt as budgetHoldKey, Tt as budgetHoldSignalName, dt as closeWorkflowChildrenForParent, we as comparePendingOrder, Ce as completeSuspendingSignal, $ as decideAdmission, o as deferringControlsOf, Re as deleteIntent, tt as discardIntent, Dt as drainTick, vt as dueIntents, b as durableClock, N as durableQueue, I as durableQueueModule, S as durableRateLimiterModule, Be as evaluateAdmission, p as getCurrentWorkflowExecutionId, U as getCurrentWorkflowRunId, A as getWorkflowFlowControl, e as getWorkflowSchedule, R as getWorkflowVersionMetadata, g as hasCancelOn, v as hasFlowControl, Fe as heldBudgets, Ot as inMemoryWorkflowEngineLayer, it as inspectWorkflow, Z as isFinishExpired, he as isStartExpired, C as isWorkflowWorkerLayer, at as linkExecution, ht as makeInMemoryRecorder, h as makeReplayShapeTracker, ot as makeWorkflowRunRecorder, X as makeWorkflowUpdateId, ge as maybeHintSuspendingSignal, ve as newestEventAt, $e as nextSlotAt, i as nondeterminismEventPayload, pt as normaliseWorkflowPatches, Ue as noteIntentAttempt, lt as parkDelayedStart, w as patch, rt as pauseWorkflow, Ct as pendingBudgetHolds, qe as pendingSlotId, Ge as pendingWindow, Me as persistDefer, W as planCancellations, K as pooledConcurrencyKey, P as processQueue, bt as pruneAdmissions, j as queueWorker, E as rateLimit, Et as readAdmissionState, Ie as readPausedWorkflows, ke as readWatermark, wt as recordAdmission, xe as releaseBudgetHolds, Se as releaseLease, r as reportNondeterminism, ee as resetSuspendHintsForTest, Ze as resolveAdmissionKeys, Le as resolveRunGuardTuning, ie as resolveSuspendHintMs, me as resolveWorkflowMessageRun, Y as resumeWorkflow, Qe as sendWorkflowSignal, G as sendWorkflowUpdate, et as serialiseWorkflowRowForWire, ce as setSuspendSignalHintMs, T as sleep, y as sleepUntil, z as step, H as stepIdempotencyKey, x as stepModule, J as suspendForBudget, Q as suspendingSignalDeferredName, Oe as sweepCancelOn, Te as sweepStalledRuns, _t as truncateWorkflowValue, a as validateFlowControl, O as validateWorkflowSchedule, V as withCompensation, m as workflow, n as workflowModule, ze as wrapWorkflowExecuteWithRunRecording, Ae as writeWatermark };