@lostgradient/weft 0.3.0 → 0.5.0

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

@@ -4,12 +4,12 @@ import type { CompressionOptions } from '../compression.ts';
 import type { Interceptor } from '../interceptor.ts';
 import type { ArchiveAdapter } from './archive-adapter.ts';
 import type { HistoryPolicy } from './history-policy.ts';
-import type { FailureCategory, WorkflowStatus } from './identity.ts';
 import type { PayloadSizePolicy } from './payload-size-policy.ts';
 import type { Duration, RetentionPolicy } from './retry-retention.ts';
-import type { SearchAttributeHandle, SearchAttributeValue } from './search-attributes.ts';
+import type { SearchAttributeValue } from './search-attributes.ts';
 import type { Serializer } from './serializer.ts';
 import type { WorkflowServicesResolution, WorkflowServicesResolverInfo } from './services-resolution.ts';
+import type { WorkflowLogRecord } from './workflow-log.ts';
 /**
  * Options accepted by `engine.start(type, input, options?)`.
  *
@@ -21,6 +21,13 @@ import type { WorkflowServicesResolution, WorkflowServicesResolverInfo } from '.
  * via filters. `id` and `idempotencyKey` are mutually exclusive — idempotency
  * assigns its own generated id and dedups through the key.
  *
+ * This is the shared base accepted by every start-like surface
+ * (`engine.start`, `engine.startOrSignal`, and the clients). `engine.start`
+ * specifically accepts the wider {@link StartWorkflowOptions}, which adds
+ * `onTerminalConflict`; that policy is intentionally absent here so it cannot be
+ * passed to `startOrSignal` (whose at-most-once identity is the permanent
+ * idempotency mapping).
+ *
  * The `idempotencyKey` mapping is durable and permanent: it survives the run
  * reaching a terminal state, so repeat calls keep returning the same handle. When
  * the workflow record is purged or swept by retention the mapping itself survives
@@ -53,7 +60,7 @@ import type { WorkflowServicesResolution, WorkflowServicesResolverInfo } from '.
  * void handle;
  * ```
  */
-export interface StartOptions {
+export interface StartOptions<TServices = unknown> {
     id?: string;
     idempotencyKey?: string;
     executionTimeout?: Duration;
@@ -72,7 +79,7 @@ export interface StartOptions {
      * `workflowExecutionMode: 'worker'` throws at `engine.start()`, because a
      * non-serializable value cannot cross to a Worker.
      */
-    services?: unknown;
+    services?: TServices;
     /**
      * When `false`, `engine.start()` resolves only after the workflow has begun
      * executing (its generator has been driven its first turn), not merely after
@@ -87,6 +94,47 @@ export interface StartOptions {
      */
     defer?: boolean;
 }
+/**
+ * Options accepted by `engine.start(type, input, options?)` — the shared
+ * {@link StartOptions} plus the start-only `onTerminalConflict` policy.
+ *
+ * `onTerminalConflict` lives here, not on {@link StartOptions}, so it is
+ * structurally rejected on every other start-like surface: `engine.startOrSignal`
+ * (whose identity is the permanent at-most-once idempotency mapping),
+ * `ctx.startChild` (which re-attaches to an existing run by id on replay), and the
+ * REST/JSON-RPC transport (which keeps `weft.workflows.start` honestly
+ * `destructive: false`). It is therefore an in-process `engine.start`-only policy.
+ */
+export interface StartWorkflowOptions<TServices = unknown> extends StartOptions<TServices> {
+    /**
+     * What `engine.start()` does when the supplied `id` already belongs to a run
+     * that has reached a **terminal** state (`completed` | `failed` | `cancelled`
+     * | `timed-out`). This is Weft's equivalent of Temporal's
+     * `WorkflowIdReusePolicy.ALLOW_DUPLICATE`, for the common case of a periodic
+     * job keyed by a stable id (e.g. `reconcile:installation-42`) whose previous
+     * run has already finished.
+     *
+     * - `'error'` (default): preserve the existing contract — a duplicate id always
+     *   throws {@link WorkflowAlreadyExistsError}, terminal or not.
+     * - `'start-new'`: if the prior run under this id is terminal, purge it (while
+     *   holding the in-process start reservation, the same teardown as
+     *   `engine.purge`, sweeping every key the run owns) and start a fresh run in
+     *   its place; if the prior run is still **non-terminal** (running/pending),
+     *   throw {@link WorkflowAlreadyExistsError} unchanged — `'start-new'` never
+     *   displaces a live run.
+     *
+     * Requires an explicit `id` (the policy only makes sense for a caller-chosen,
+     * reusable id) and is mutually exclusive with `idempotencyKey` (whose mapping
+     * is permanent and at-most-once — restarting under it would violate that
+     * contract). The previous run's durable record is gone after a `'start-new'`
+     * restart, so a {@link WorkflowHandle} held against the old id resolves to the
+     * fresh run for every method (`result()`, `snapshot()`, status), because handles
+     * are id-scoped, not run-attempt-scoped. The restart holds the same in-process
+     * start reservation as a normal start, so two concurrent `'start-new'` calls for
+     * one id cannot both win — the loser sees {@link WorkflowAlreadyExistsError}.
+     */
+    onTerminalConflict?: 'error' | 'start-new';
+}
 /**
  * Options for {@link Engine.fork}. Controls which checkpoint step to fork
  * from; defaults to the latest persisted checkpoint when omitted.
@@ -130,7 +178,7 @@ export interface ForkOptions {
  * void engine;
  * ```
  */
-export interface EngineOptions {
+export interface EngineOptions<TServices = unknown> {
     storage?: WeftStorage;
     development?: boolean;
     serializer?: Serializer;
@@ -156,6 +204,61 @@ export interface EngineOptions {
      * well above your deploy drain window. Ignored when detection is disabled.
      */
     secondInstanceHeartbeatInterval?: Duration;
+    /**
+     * Single-writer ownership posture over the shared durable store. Default
+     * `'none'` — the engine recovers immediately at boot and relies on
+     * infrastructure (one replica + a `Recreate` deploy) for mutual exclusion.
+     *
+     * `'lease'` opts into a storage-keyed ownership lease: at boot the engine
+     * acquires the lease (waiting, up to {@link EngineOptions.leaseWaitTimeout}, if
+     * another instance still holds it) **before** recovering, renews it on a
+     * heartbeat, and releases it on dispose. This turns a rolling deploy into a
+     * clean handoff — the incoming instance parks until the outgoing one releases
+     * (or its lease expires), so the two never recover concurrently.
+     *
+     * Requires a storage backend with the `conditionalBatch` capability (every
+     * durable recovery backend already provides it).
+     *
+     * **Step-1 acquisition boundary.** The lease is acquired on the standard boot
+     * paths — `Engine.create()` and `Engine.recoverAll()` (so `new Engine({ ownership:
+     * 'lease' })` followed by `recoverAll()` acquires it too). It is **not** yet
+     * acquired on a first durable write, so a `new Engine({ ownership: 'lease' })`
+     * that calls `engine.start(...)` *without* ever calling `recoverAll()` will write
+     * without holding the lease. Use `Engine.create()` (or call `recoverAll()` before
+     * accepting traffic) so acquisition runs before any write.
+     *
+     * **Lease alone is deploy ergonomics, not a correctness guarantee.** It
+     * prevents the *new* instance from recovering early; it does not by itself stop
+     * a stalled *old* instance (e.g. a long GC pause past the lease TTL) from
+     * writing after its lease expired. Epoch fencing of durable writes is what
+     * closes that gap. Keep infrastructure-level single-instance enforcement as the
+     * real control.
+     */
+    ownership?: 'none' | 'lease';
+    /**
+     * Lease time-to-live for `ownership: 'lease'` (default `30s`). A holder renews
+     * well within this window; once it lapses without renewal, a waiting instance
+     * may steal the lease. Must comfortably exceed the renewal interval plus the
+     * worst-case GC pause, clock skew, and storage round-trip. Ignored when
+     * `ownership` is not `'lease'`.
+     */
+    leaseTtl?: Duration;
+    /**
+     * Lease renewal interval for `ownership: 'lease'` (default `5s`). The holder
+     * re-asserts the lease this often; keep it well below {@link EngineOptions.leaseTtl}
+     * so a single slow renewal cannot let the lease lapse. Ignored when `ownership`
+     * is not `'lease'`.
+     */
+    leaseRenewInterval?: Duration;
+    /**
+     * How long a booting `ownership: 'lease'` instance waits to acquire the lease
+     * when another instance still holds it, before throwing
+     * {@link EngineLeaseAcquisitionTimeoutError} (default `60s`). Size this above
+     * both the outgoing instance's drain time and the lease TTL, so a graceful
+     * handoff and a crash (no clean release, lease expires after TTL) both resolve.
+     * Ignored when `ownership` is not `'lease'`.
+     */
+    leaseWaitTimeout?: Duration;
     /**
      * History circuit-breaker thresholds. When `history.maxEvents` is set, a
      * workflow whose event-log record count would exceed it is forced to a
@@ -261,8 +364,9 @@ export interface EngineOptions {
      * Return `{ status: 'available', services }` to supply the rebuilt
      * capabilities, or `{ status: 'unavailable', reason }` to fail just that one
      * recovered run — the engine and every other recovered run are unaffected.
-     * Without a resolver, a recovered inline workflow that reads `ctx.services`
-     * sees `undefined`.
+     * Without a resolver, a recovered run that carries the durable "expects
+     * services" marker fails before the generator advances and emits a diagnostic
+     * warning naming this option.
      *
      * Contract a fresh integrator must know:
      * - Fires only for recovered inline runs that were launched WITH `services`
@@ -279,165 +383,17 @@ export interface EngineOptions {
      * Engine-scoped: each engine instance carries its own resolver, so two engines
      * in one process never collide on per-run dependency reconstruction.
      */
-    resolveWorkflowServices?: (info: WorkflowServicesResolverInfo) => WorkflowServicesResolution | Promise<WorkflowServicesResolution>;
-}
-/**
- * Filter criteria for {@link Engine.list}. All fields are optional and
- * combine with AND semantics. `status` accepts a single value or an array;
- * `attributes` is a list of attribute predicates evaluated on indexed search
- * attributes. Pairs with `limit`/`offset` for pagination.
- *
- * @example
- * ```ts
- * import { Engine, type ListFilter } from '@lostgradient/weft';
- *
- * const engine = new Engine();
- * const filter: ListFilter = {
- *   status: ['running', 'pending'],
- *   tags: ['nightly'],
- *   attributes: [{ key: 'customerId', value: 'acme' }],
- *   limit: 20,
- *   offset: 0,
- * };
- * const result = await engine.list(filter);
- * console.log(result.items.length);
- * ```
- */
-/**
- * Numeric half-open range bound, used by visibility filters that match a
- * stored numeric field (timestamps, deadlines). Provide at least one of the
- * four bounds. `gt`/`gte` are mutually exclusive on the lower side; `lt`/`lte`
- * are mutually exclusive on the upper side.
- */
-export interface TimeRange {
-    gte?: number;
-    lte?: number;
-    gt?: number;
-    lt?: number;
-}
-/**
- * Filter passed to {@link Engine.list} (and equivalent visibility transports)
- * to narrow which {@link WorkflowSummary} entries are returned. Every field
- * is optional; combining fields applies them as AND.
- *
- * @example
- * ```ts
- * import { Engine, type ListFilter } from '@lostgradient/weft';
- *
- * const engine = new Engine();
- * const filter: ListFilter = {
- *   status: ['running', 'failed'],
- *   createdAt: { gte: Date.now() - 60_000 },
- * };
- *
- * const page = await engine.list(filter);
- * ```
- */
-export interface ListFilter {
-    /** Match workflows whose {@link WorkflowState.status} is one of the listed values. */
-    status?: WorkflowStatus | WorkflowStatus[];
+    resolveWorkflowServices?: (info: WorkflowServicesResolverInfo) => WorkflowServicesResolution<TServices> | Promise<WorkflowServicesResolution<TServices>>;
     /**
-     * Match workflows by registered workflow type (e.g. `'order-fulfillment'`).
+     * Optional host sink for `ctx.log` records. When provided, every non-replayed
+     * record from inline workflow execution is routed here (into your pino / winston
+     * / OpenTelemetry stack, etc.) **instead of** the console; when omitted, records
+     * fall back to the matching `console` method, preserving the default behavior.
      *
-     * @example
-     * ```ts
-     * import type { ListFilter } from '@lostgradient/weft';
-     * const filter: ListFilter = { type: 'order-fulfillment' };
-     * ```
-     */
-    type?: string;
-    /** Match workflows that carry every listed tag. */
-    tags?: string[];
-    /** Filter on indexed search attributes (equality or range). */
-    attributes?: readonly AttributeFilter[];
-    /** Maximum number of summaries to return. Server enforces an upper bound. */
-    limit?: number;
-    /** Number of summaries to skip before returning results. */
-    offset?: number;
-    /**
-     * Workflow id prefix. Restricted to `[A-Za-z0-9_-]+`; values containing
-     * other characters are rejected during validation. Matches by raw
-     * `state.id.startsWith(idPrefix)` after candidate enumeration.
+     * Engine-scoped infrastructure: set once at construction, never per run. The sink
+     * is not invoked for records suppressed during replay, so a recovered run does
+     * not re-emit its replayed prefix. Worker-mode records still log to the worker
+     * process's console — routing them back to the host is tracked separately.
      */
-    idPrefix?: string;
-    /** Range filter on `WorkflowState.createdAt` (ms epoch). */
-    createdAt?: TimeRange;
-    /** Range filter on `WorkflowState.updatedAt` (ms epoch). */
-    updatedAt?: TimeRange;
-    /** Range filter on `WorkflowState.executionDeadline` (ms epoch). */
-    executionDeadline?: TimeRange;
-    /**
-     * Match by the workflow's `failureCategory`. The engine uses the
-     * `failureCategory` search-attribute index to narrow candidate workflow IDs,
-     * then still verifies the loaded `WorkflowState.failureCategory` so state
-     * remains authoritative when index entries are stale.
-     */
-    failureCategory?: FailureCategory | FailureCategory[];
-}
-/**
- * Projection options for {@link Engine.list}. These options do not change
- * which workflows match the list filter; they only control optional summary
- * fields that may require additional storage reads.
- *
- * @example Include failure categories projected from search attributes
- * ```ts
- * import { Engine, type ListOptions } from '@lostgradient/weft';
- *
- * const engine = new Engine();
- * const options: ListOptions = { includeFailureCategory: true };
- * const page = await engine.list({ status: 'failed' }, options);
- * void page;
- * ```
- */
-export interface ListOptions {
-    /**
-     * Populate `WorkflowSummary.failureCategory` for failed workflows from the
-     * stored `failureCategory` search attribute when the workflow state itself
-     * does not carry a category. Defaults to `false`.
-     */
-    includeFailureCategory?: boolean;
-}
-export type AttributeFilterKey = string | SearchAttributeHandle;
-export type AttributeFilterValue<TKey extends AttributeFilterKey> = TKey extends SearchAttributeHandle<infer TValue> ? TValue extends string[] ? string : TValue : SearchAttributeValue;
-export type AttributeRangeValue<TKey extends AttributeFilterKey> = TKey extends SearchAttributeHandle<infer TValue> ? Extract<TValue, Date | number> : SearchAttributeValue;
-export type AttributeFilter<TKey extends AttributeFilterKey = AttributeFilterKey> = TKey extends SearchAttributeHandle ? {
-    key: TKey;
-    value?: AttributeFilterValue<TKey>;
-    gt?: never;
-    lt?: never;
-    gte?: never;
-    lte?: never;
-} | {
-    key: TKey;
-    value?: never;
-    gt?: AttributeRangeValue<TKey>;
-    lt?: AttributeRangeValue<TKey>;
-    gte?: AttributeRangeValue<TKey>;
-    lte?: AttributeRangeValue<TKey>;
-} : {
-    key: TKey;
-    value?: SearchAttributeValue;
-    gt?: SearchAttributeValue;
-    lt?: SearchAttributeValue;
-    gte?: SearchAttributeValue;
-    lte?: SearchAttributeValue;
-};
-export type AttributeFilterList<TAttributeKeys extends readonly AttributeFilterKey[]> = {
-    readonly [TIndex in keyof TAttributeKeys]: AttributeFilter<TAttributeKeys[TIndex]>;
-};
-export type TypedListFilter<TAttributeKeys extends readonly AttributeFilterKey[]> = Omit<ListFilter, 'attributes'> & {
-    attributes?: AttributeFilterList<TAttributeKeys>;
-};
-/**
- * Generic paginated response envelope returned by list operations such as
- * {@link Engine.list} and `engine.listSchedules`. `total` is the full count
- * matching the filter; `items` is the current page slice. `items.length` is
- * bounded by `limit`; the consumer reaches the end of the result set when
- * `offset + items.length >= total`.
- */
-export interface PaginatedResult<T> {
-    items: T[];
-    total: number;
-    offset: number;
-    limit: number;
+    onLog?: (record: WorkflowLogRecord) => void;
 }

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

@@ -18,9 +18,9 @@
  * void no;
  * ```
  */
-export type WorkflowServicesResolution = {
+export type WorkflowServicesResolution<TServices = unknown> = {
     status: 'available';
-    services: unknown;
+    services: TServices;
 } | {
     status: 'unavailable';
     reason: string;

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 } : {}
     };