@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/types/schedules.d.ts

@@ -51,8 +51,8 @@ export type ScheduleSpec = {
 /**
  * Options accepted by {@link Engine.schedule}. `id` assigns a deterministic
  * schedule identifier; `overlap` controls what happens when a tick fires while a
- * previous run is still active; `backfill` triggers immediate runs for any ticks
- * that were missed since the schedule was created.
+ * previous run is still active; `backfill` controls missed ticks after downtime;
+ * `jitter` deterministically spreads each occurrence's effective dispatch time.
  *
  * @example
  * ```ts
@@ -60,7 +60,12 @@ export type ScheduleSpec = {
  *
  * const engine = new Engine();
  * engine.register(workflow({ name: 'report' }).execute(async function* () { return 'ok'; }));
- * const options: ScheduleOptions = { id: 'daily-report', overlap: 'skip', backfill: false };
+ * const options: ScheduleOptions = {
+ *   id: 'daily-report',
+ *   overlap: 'skip',
+ *   backfill: false,
+ *   jitter: '30s',
+ * };
  * const handle = await engine.schedule('report', null, '0 9 * * *', options);
  * void handle;
  * ```
@@ -68,7 +73,23 @@ export type ScheduleSpec = {
 export interface ScheduleOptions {
     id?: string;
     overlap?: ScheduleOverlapPolicy;
+    /**
+     * When `false` (the default), a tick that is more than one second late is
+     * skipped instead of backfilled. Skipped ticks increment
+     * {@link ScheduleState.missedFireCount}, update
+     * {@link ScheduleState.lastMissedFireAt}, and emit a
+     * `ScheduleMissedFireEvent`.
+     *
+     * When `true`, missed ticks are processed immediately, up to the engine's
+     * per-tick backfill cap.
+     */
     backfill?: boolean;
+    /**
+     * Deterministic per-occurrence delay applied to the effective dispatch timer.
+     * The persisted {@link ScheduleState.nextFireAt} remains the nominal
+     * pre-jitter occurrence timestamp.
+     */
+    jitter?: Duration;
 }
 /**
  * Declarative recurring schedule definition returned by {@link schedule}. Supply
@@ -99,6 +120,7 @@ export type ScheduleDefinition<TInput = unknown> = ScheduleSpec & {
     id?: string;
     overlapPolicy?: ScheduleOverlapPolicy;
     backfill?: boolean;
+    jitter?: Duration;
 };
 /**
  * Create a recurring schedule definition for `engine.schedule(definition)`.
@@ -134,9 +156,16 @@ export interface ScheduleState {
     status: ScheduleStatus;
     overlap: ScheduleOverlapPolicy;
     backfill: boolean;
+    /** Normalized deterministic jitter window in milliseconds. */
+    jitterMs?: number;
     createdAt: number;
     updatedAt: number;
+    /** Most recent occurrence that started a scheduled workflow. */
     lastFireAt?: number;
+    /** Most recent occurrence skipped because a non-backfill timer was late. */
+    lastMissedFireAt?: number;
+    /** Lifetime count of occurrences skipped because a non-backfill timer was late. */
+    missedFireCount: number;
     nextFireAt: number | null;
     currentWorkflowId?: string;
     queuedRuns: number;
@@ -157,9 +186,16 @@ export interface ScheduleSummary {
     status: ScheduleStatus;
     overlap: ScheduleOverlapPolicy;
     backfill: boolean;
+    /** Normalized deterministic jitter window in milliseconds. */
+    jitterMs?: number;
     createdAt: number;
     updatedAt: number;
+    /** Most recent occurrence that started a scheduled workflow. */
     lastFireAt?: number;
+    /** Most recent occurrence skipped because a non-backfill timer was late. */
+    lastMissedFireAt?: number;
+    /** Lifetime count of occurrences skipped because a non-backfill timer was late. */
+    missedFireCount: number;
     nextFireAt: number | null;
     currentWorkflowId?: string;
     queuedRuns: number;

package/dist/core/types/services-resolution.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Result of {@link EngineOptions.resolveWorkflowServices}. An explicit union
+ * rather than a nullable return: `'unavailable'` is a deliberate, named outcome
+ * (the run's dependencies cannot be rebuilt in this process) that fails just
+ * that recovered run — it does not overload the resolved value with a lifecycle
+ * signal.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolution } from '@lostgradient/weft';
+ *
+ * const ok: WorkflowServicesResolution = {
+ *   status: 'available',
+ *   services: { db: { query: () => [] } },
+ * };
+ * const no: WorkflowServicesResolution = { status: 'unavailable', reason: 'no config' };
+ * void ok;
+ * void no;
+ * ```
+ */
+export type WorkflowServicesResolution<TServices = unknown> = {
+    status: 'available';
+    services: TServices;
+} | {
+    status: 'unavailable';
+    reason: string;
+};
+/**
+ * Information passed to {@link EngineOptions.resolveWorkflowServices} for each
+ * recovered workflow. `input` is the original durable launch input, available
+ * at resume time — typically enough to rebuild the run's dependencies (tenant,
+ * model, tool registry) without a side table.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolverInfo } from '@lostgradient/weft';
+ *
+ * function describe(info: WorkflowServicesResolverInfo): string {
+ *   return `${info.workflowType}/${info.workflowId}`;
+ * }
+ * ```
+ */
+export interface WorkflowServicesResolverInfo {
+    workflowId: string;
+    workflowType: string;
+    input: unknown;
+}

package/dist/core/types/state.d.ts

@@ -42,7 +42,17 @@ export interface WorkflowState {
      * leaves this `undefined`).
      */
     terminationReason?: TerminationReason;
-    version: string;
+    /**
+     * The `(workflowVersion, agentVersion?, toolVersions?)` tuple captured for
+     * this workflow. This is the single canonical representation of version
+     * metadata on the state: it shares the {@link WorkflowVersionTuple} shape the
+     * event log records, so the two cannot drift, and it is rewritten on every
+     * versioned persist. `workflowVersion` is always present;
+     * `agentVersion`/`toolVersions` are present only when the workflow declares
+     * them. Resuming compares this against the currently registered definition to
+     * detect version drift.
+     */
+    versionTuple: WorkflowVersionTuple;
     /**
      * Owner identifier for execution-scoped durable state. Top-level workflows
      * own their own execution state; durable child workflows inherit the
@@ -50,16 +60,6 @@ export interface WorkflowState {
      * tree.
      */
     executionStateOwnerId?: string;
-    /**
-     * Legacy version tuple metadata retained so existing persisted workflow
-     * states can still be decoded and compared during recovery.
-     */
-    agentVersion?: string;
-    /**
-     * Legacy version tuple metadata retained so existing persisted workflow
-     * states can still be decoded and compared during recovery.
-     */
-    toolVersions?: string[];
     createdAt: number;
     startedAt?: number;
     updatedAt: number;

package/dist/core/types/workflow-builder-runtime.d.ts

@@ -11,7 +11,9 @@ import type { RetentionPolicy } from './retry-retention.ts';
 import type { SearchAttributeSchema } from './search-attributes.ts';
 import type { ActivityMap, ActivityMapInput, QueryMap, SignalMap, UpdateMap } from './workflow-builder-helpers.ts';
 import type { BuiltWorkflowDefinition } from './workflow-builder.ts';
+import type { WorkflowConcurrencyOptions } from './workflow-concurrency.ts';
 import type { WorkflowFunction } from './workflow-function.ts';
+import type { AnyActivityDefinition } from './workflow-registries.ts';
 /**
  * Thrown by the chained workflow builder for runtime invariants that the type
  * system cannot reliably catch — duplicate chain calls, key/name collisions
@@ -44,7 +46,7 @@ export declare class WorkflowBuilderError extends WeftError<'WorkflowBuilderErro
 /**
  * Initial options accepted by the builder-form `workflow({ name, ... })` call.
  * Extra metadata fields (`version`, `description`, `tags`, `retention`,
- * `inputSchema`, `outputSchema`, `migrate`, `constraints`) are passed through
+ * `concurrency`, `inputSchema`, `outputSchema`, `constraints`) are passed through
  * onto the returned {@link BuiltWorkflowDefinition} when `.execute(fn)` runs.
  * Only `name` is required.
  *
@@ -60,14 +62,20 @@ export declare class WorkflowBuilderError extends WeftError<'WorkflowBuilderErro
  * void welcome;
  * ```
  */
-export interface WorkflowBuilderOptions<TName extends string = string> {
+export interface WorkflowBuilderOptions<TName extends string = string, TConcurrencyInput = unknown> {
     name: TName;
     version?: string;
     description?: string;
     tags?: ReadonlyArray<string>;
     retention?: RetentionPolicy;
+    concurrency?: WorkflowConcurrencyOptions<TConcurrencyInput>;
     constraints?: ConstraintDefinition[];
-    migrate?: (checkpoint: unknown, fromVersion: string) => unknown;
+    /**
+     * Definition-level teardown activity driven by the engine after a
+     * `cancelled`/`timed-out` terminal (issue #446). See
+     * {@link WorkflowDefinition.finalizer}.
+     */
+    finalizer?: AnyActivityDefinition;
     inputSchema?: DefinitionSchema<unknown, unknown>;
     outputSchema?: DefinitionSchema<unknown, unknown>;
     /**
@@ -93,5 +101,6 @@ export declare class WorkflowBuilderImpl<TName extends string> {
     updates: (map: UpdateMap) => this;
     queries: (map: QueryMap) => this;
     searchAttributes: (schema: SearchAttributeSchema) => this;
+    services: () => this;
     execute: (fn: WorkflowFunction) => BuiltWorkflowDefinition<unknown, unknown, TName, ActivityMap, SignalMap, UpdateMap, QueryMap, SearchAttributeSchema>;
 }

package/dist/core/types/workflow-builder-runtime.js

@@ -16,7 +16,8 @@ export class WorkflowBuilderImpl {
     signals: !1,
     updates: !1,
     queries: !1,
-    searchAttributes: !1
+    searchAttributes: !1,
+    services: !1
   };
   #executed = !1;
   #activities = {};
@@ -66,6 +67,11 @@ export class WorkflowBuilderImpl {
     this.#searchAttributes = { ...schema };
     return this;
   };
+  services = () => {
+    this.#assertOpen("services");
+    this.#markCalled("services");
+    return this;
+  };
   execute = (fn) => {
     this.#assertOpen("execute");
     this.#executed = !0;
@@ -81,8 +87,11 @@ export class WorkflowBuilderImpl {
       ...this.#options.description !== void 0 ? { description: this.#options.description } : {},
       ...this.#options.tags !== void 0 ? { tags: this.#options.tags } : {},
       ...this.#options.retention !== void 0 ? { retention: this.#options.retention } : {},
+      ...this.#options.concurrency !== void 0 ? {
+        concurrency: deepFreeze(clonePlain(this.#options.concurrency))
+      } : {},
       ...this.#options.constraints !== void 0 ? { constraints: this.#options.constraints } : {},
-      ...this.#options.migrate !== void 0 ? { migrate: this.#options.migrate } : {},
+      ...this.#options.finalizer !== void 0 ? { finalizer: this.#options.finalizer } : {},
       ...this.#options.inputSchema !== void 0 ? { inputSchema: this.#options.inputSchema } : {},
       ...this.#options.outputSchema !== void 0 ? { outputSchema: this.#options.outputSchema } : {}
     };

package/dist/core/types/workflow-builder.d.ts

@@ -39,7 +39,7 @@ import type { WorkflowDefinition, WorkflowOperation } from './workflow-function.
  * void job;
  * ```
  */
-export type WorkflowGenerator<TInput, TOutput, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema> = (context: WorkflowContextOf<TActivities, TSignals, TUpdates, TQueries, TSearchAttributes>, input: TInput) => AsyncGenerator<unknown, TOutput, unknown>;
+export type WorkflowGenerator<TInput, TOutput, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema, TServices = unknown> = (context: WorkflowContextOf<TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, TServices>, input: TInput) => AsyncGenerator<unknown, TOutput, unknown>;
 /**
  * Convenience alias for the workflow-scoped `WorkflowContext` projection. The
  * underlying `WorkflowContext` interface accepts the same five generic
@@ -47,12 +47,13 @@ export type WorkflowGenerator<TInput, TOutput, TActivities extends ActivityMap,
  * `TSearchAttributes`), and the builder threads its normalised maps through
  * this alias so `.execute(fn)` sees the right `ctx` shape inside `fn`.
  *
- * Legacy bare-`WorkflowContext` callers continue to typecheck because the
- * interface's generics all default to empty/permissive shapes, so the typed
- * overloads de-prioritise to `never` and existing string-name/callable
- * overloads still match.
+ * Bare-`WorkflowContext` callers (no declared activity/signal/etc. maps)
+ * typecheck because the interface's generics all default to permissive shapes:
+ * the typed overloads de-prioritise to `never` and the dynamic string-name /
+ * callable overloads match instead. This permissive path is current API — it is
+ * how untyped, ad-hoc-name authoring is supported, not a compatibility shim.
  */
-export type WorkflowContextOf<TActivities extends ActivityMap = ActivityMap, TSignals extends SignalMap = SignalMap, TUpdates extends UpdateMap = UpdateMap, TQueries extends QueryMap = QueryMap, TSearchAttributes extends SearchAttributeSchema = SearchAttributeSchema> = WorkflowContext<TActivities, TSignals, TUpdates, TQueries, TSearchAttributes>;
+export type WorkflowContextOf<TActivities extends ActivityMap = ActivityMap, TSignals extends SignalMap = SignalMap, TUpdates extends UpdateMap = UpdateMap, TQueries extends QueryMap = QueryMap, TSearchAttributes extends SearchAttributeSchema = SearchAttributeSchema, TServices = unknown> = WorkflowContext<TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, TServices>;
 /**
  * Tracks which `WorkflowBuilder` chain methods have already been called. Each
  * call flips its flag from `false` to `true`; the method's type becomes `never`
@@ -81,6 +82,7 @@ export interface BuilderState {
     readonly updates: boolean;
     readonly queries: boolean;
     readonly searchAttributes: boolean;
+    readonly services?: boolean | undefined;
 }
 /**
  * Initial builder state — every chain method is still available. A fresh
@@ -101,6 +103,7 @@ export interface InitialBuilderState {
     readonly updates: false;
     readonly queries: false;
     readonly searchAttributes: false;
+    readonly services?: false | undefined;
 }
 /**
  * Flip one builder-state flag from `false` to `true`. Each chain method on
@@ -117,7 +120,9 @@ export interface InitialBuilderState {
  * void _check;
  * ```
  */
-export type MarkBuilderState<S extends BuilderState, K extends keyof BuilderState> = {
+export type MarkBuilderState<S extends BuilderState, K extends keyof BuilderState> = K extends 'services' ? Omit<S, 'services'> & {
+    readonly services: true;
+} : {
     readonly [P in keyof S]: P extends K ? true : S[P];
 };
 declare const workflowAlreadyRegisteredBrand: unique symbol;
@@ -175,7 +180,7 @@ export interface WorkflowAlreadyRegistered<TName extends string> {
  * void welcome;
  * ```
  */
-export interface WorkflowBuilder<TName extends string, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema, TState extends BuilderState> {
+export interface WorkflowBuilder<TName extends string, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema, TState extends BuilderState, TServices = unknown> {
     /**
      * Declare the activity table this workflow can dispatch with
      * `ctx.run('name', input)`. The outer object key is the canonical activity
@@ -195,7 +200,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void welcome;
      * ```
      */
-    activities: TState['activities'] extends true ? never : <TInput extends ActivityMapInput>(map: TInput) => WorkflowBuilder<TName, NormalizeActivities<TInput>, TSignals, TUpdates, TQueries, TSearchAttributes, MarkBuilderState<TState, 'activities'>>;
+    activities: TState['activities'] extends true ? never : <TInput extends ActivityMapInput>(map: TInput) => WorkflowBuilder<TName, NormalizeActivities<TInput>, TSignals, TUpdates, TQueries, TSearchAttributes, MarkBuilderState<TState, 'activities'>, TServices>;
     /**
      * Declare the signals this workflow accepts so `ctx.waitForSignal('name')`
      * autocompletes and types the payload. Type-safety and introspection
@@ -214,7 +219,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void approval;
      * ```
      */
-    signals: TState['signals'] extends true ? never : <TInput extends SignalMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TInput, TUpdates, TQueries, TSearchAttributes, MarkBuilderState<TState, 'signals'>>;
+    signals: TState['signals'] extends true ? never : <TInput extends SignalMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TInput, TUpdates, TQueries, TSearchAttributes, MarkBuilderState<TState, 'signals'>, TServices>;
     /**
      * Declare the request-response update handlers this workflow accepts.
      * Type-safety and introspection metadata only — the update-dispatch path
@@ -230,7 +235,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void order;
      * ```
      */
-    updates: TState['updates'] extends true ? never : <TInput extends UpdateMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TInput, TQueries, TSearchAttributes, MarkBuilderState<TState, 'updates'>>;
+    updates: TState['updates'] extends true ? never : <TInput extends UpdateMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TInput, TQueries, TSearchAttributes, MarkBuilderState<TState, 'updates'>, TServices>;
     /**
      * Declare the read-only query handlers this workflow accepts. Type-safety
      * and introspection metadata only — `.queries` does not introduce new
@@ -246,7 +251,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void job;
      * ```
      */
-    queries: TState['queries'] extends true ? never : <TInput extends QueryMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TUpdates, TInput, TSearchAttributes, MarkBuilderState<TState, 'queries'>>;
+    queries: TState['queries'] extends true ? never : <TInput extends QueryMap>(map: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TUpdates, TInput, TSearchAttributes, MarkBuilderState<TState, 'queries'>, TServices>;
     /**
      * Declare the search-attribute schema this workflow populates via
      * `ctx.setAttribute('key', value)`. Each entry pins the attribute's value
@@ -266,7 +271,32 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void order;
      * ```
      */
-    searchAttributes: TState['searchAttributes'] extends true ? never : <TInput extends SearchAttributeSchema>(schema: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TUpdates, TQueries, TInput, MarkBuilderState<TState, 'searchAttributes'>>;
+    searchAttributes: TState['searchAttributes'] extends true ? never : <TInput extends SearchAttributeSchema>(schema: TInput) => WorkflowBuilder<TName, TActivities, TSignals, TUpdates, TQueries, TInput, MarkBuilderState<TState, 'searchAttributes'>, TServices>;
+    /**
+     * Declare the per-run services type exposed at `ctx.services`. This is a
+     * type-only marker: services remain supplied at launch through
+     * `engine.start(type, input, { services })` and re-provided on recovery by
+     * `EngineOptions.resolveWorkflowServices`. Calling `.services` twice before
+     * `.execute()` is a type error and throws `WorkflowBuilderError` at runtime.
+     *
+     * @example
+     * ```ts
+     * import { workflow } from '@lostgradient/weft';
+     *
+     * interface Services {
+     *   repository: { load(id: string): Promise<string> };
+     * }
+     *
+     * const job = workflow({ name: 'job' })
+     *   .services<Services>()
+     *   .execute(async function* (ctx, id: string) {
+     *     const services = ctx.services;
+     *     return services === undefined ? id : yield* ctx.run(() => services.repository.load(id));
+     *   });
+     * void job;
+     * ```
+     */
+    services: TState['services'] extends true ? never : <TInput>() => WorkflowBuilder<TName, TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, MarkBuilderState<TState, 'services'>, TInput>;
     /**
      * Seal the builder and produce a `BuiltWorkflowDefinition`. The generator's
      * `input` and `output` types are re-inferred from `fn`'s signature, so the
@@ -287,7 +317,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
      * void welcome;
      * ```
      */
-    execute<TInput, TOutput>(fn: WorkflowGenerator<TInput, TOutput, TActivities, TSignals, TUpdates, TQueries, TSearchAttributes>): BuiltWorkflowDefinition<TInput, Awaited<TOutput>, TName, TActivities, TSignals, TUpdates, TQueries, TSearchAttributes>;
+    execute<TInput, TOutput>(fn: WorkflowGenerator<TInput, TOutput, TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, TServices>): BuiltWorkflowDefinition<TInput, Awaited<TOutput>, TName, TActivities, TSignals, TUpdates, TQueries, TSearchAttributes, TServices>;
 }
 /**
  * The `WorkflowDefinition` returned by `.execute(fn)`. Carries the normalised
@@ -318,7 +348,7 @@ export interface WorkflowBuilder<TName extends string, TActivities extends Activ
  * void built;
  * ```
  */
-export interface BuiltWorkflowDefinition<TInput, TOutput, TName extends string, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema> extends WorkflowDefinition<TInput, TOutput, TName> {
+export interface BuiltWorkflowDefinition<TInput, TOutput, TName extends string, TActivities extends ActivityMap, TSignals extends SignalMap, TUpdates extends UpdateMap, TQueries extends QueryMap, TSearchAttributes extends SearchAttributeSchema, TServices = unknown> extends WorkflowDefinition<TInput, TOutput, TName, TServices> {
     readonly activities: Readonly<Record<string, Readonly<ActivityDefinition>>>;
     readonly signals: Readonly<Record<string, Readonly<SignalDefinition<unknown>>>>;
     readonly updates: Readonly<Record<string, Readonly<UpdateDefinition>>>;
@@ -334,6 +364,8 @@ export interface BuiltWorkflowDefinition<TInput, TOutput, TName extends string,
     readonly _queries?: TQueries;
     /** Phantom marker for the search-attribute schema. Not present at runtime. */
     readonly _searchAttributes?: TSearchAttributes;
+    /** Phantom marker for the per-run services type. Not present at runtime. */
+    readonly _services?: TServices;
 }
 /**
  * Re-exported so Phase 2 (`workflow()` runtime rewrite) and Phase 3 (engine

package/dist/core/types/workflow-concurrency.d.ts

@@ -0,0 +1,39 @@
+type WorkflowConcurrencyKeyResolver<TInput> = {
+    resolve(input: TInput): string;
+}['resolve'];
+/**
+ * Workflow-level start admission policy. When present on a workflow definition,
+ * the engine admits at most `max` non-terminal runs for the same partition.
+ *
+ * @example
+ * ```ts
+ * import { workflow, type WorkflowConcurrencyOptions } from '@lostgradient/weft';
+ *
+ * type OrderInput = { customerId: string };
+ *
+ * const concurrency: WorkflowConcurrencyOptions<OrderInput> = {
+ *   max: 3,
+ *   key: (input) => input.customerId,
+ * };
+ *
+ * const processOrder = workflow({ name: 'process-order', concurrency }).execute(
+ *   async function* () {
+ *     return 'done';
+ *   },
+ * );
+ * void processOrder;
+ * ```
+ */
+export interface WorkflowConcurrencyOptions<TInput = unknown> {
+    /**
+     * Maximum number of non-terminal runs admitted for the workflow type or
+     * partition key. Excess starts are rejected immediately.
+     */
+    max: number;
+    /**
+     * Optional partition key resolver. When omitted, the limit applies to the
+     * workflow type as a whole.
+     */
+    key?: WorkflowConcurrencyKeyResolver<TInput>;
+}
+export {};