@lostgradient/weft 0.2.0

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

@@ -0,0 +1,312 @@
+import type { WorkflowId, WorkflowStatus } from './identity.ts';
+import type { SearchAttributeValue } from './search-attributes.ts';
+export declare const MAX_BULK_OPERATION_REQUEST_ID_LENGTH = 200;
+export declare const MAX_BULK_CONFIRMATION_TOKEN_LENGTH = 256;
+/**
+ * Bulk workflow action names used in previews, confirmations, and audit
+ * records.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationAction } from '@lostgradient/weft';
+ *
+ * const action: BulkOperationAction = 'cancel';
+ * void action;
+ * ```
+ */
+export type BulkOperationAction = 'cancel' | 'signal' | 'delete' | 'tag:add' | 'tag:remove' | 'recover';
+/**
+ * Credential-safe caller summary recorded on bulk audit events. Claims,
+ * bearer tokens, API keys, and other credentials are intentionally absent.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationPrincipal } from '@lostgradient/weft';
+ *
+ * const principal: BulkOperationPrincipal = {
+ *   method: 'api-key',
+ *   subject: 'operator@example.com',
+ * };
+ * void principal;
+ * ```
+ */
+export type BulkOperationPrincipal = {
+    method: string;
+    subject?: string;
+};
+/**
+ * Canonical filter summary used when deriving bulk confirmation tokens.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationFilterSummary } from '@lostgradient/weft';
+ *
+ * const filter: BulkOperationFilterSummary = {
+ *   status: ['running', 'pending'],
+ *   type: 'checkout',
+ *   tags: ['nightly'],
+ * };
+ * void filter;
+ * ```
+ */
+export type BulkOperationFilterSummary = {
+    status?: WorkflowStatus | WorkflowStatus[];
+    type?: string;
+    tags?: string[];
+    attributes?: Array<{
+        key: string;
+        value?: SearchAttributeValue;
+        gt?: SearchAttributeValue;
+        lt?: SearchAttributeValue;
+        gte?: SearchAttributeValue;
+        lte?: SearchAttributeValue;
+    }>;
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Scope summary returned by dry-run previews and persisted in audit records.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationScopeSummary } from '@lostgradient/weft';
+ *
+ * const scope: BulkOperationScopeSummary = {
+ *   matched: 2,
+ *   filter: { status: 'running' },
+ *   statuses: ['running'],
+ *   workflowTypes: ['checkout'],
+ *   sampleWorkflowIds: ['wf-1', 'wf-2'],
+ *   sampleLimit: 20,
+ * };
+ * void scope;
+ * ```
+ */
+export type BulkOperationScopeSummary = {
+    matched: number;
+    filter: BulkOperationFilterSummary;
+    statuses: WorkflowStatus[];
+    workflowTypes: string[];
+    sampleWorkflowIds: WorkflowId[];
+    sampleLimit: number;
+};
+/**
+ * Dry-run result shared by bulk workflow operations.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationDryRunResult } from '@lostgradient/weft';
+ *
+ * const preview: BulkOperationDryRunResult = {
+ *   dryRun: true,
+ *   action: 'cancel',
+ *   matched: 1,
+ *   requestId: 'ops-123',
+ *   scope: {
+ *     matched: 1,
+ *     filter: { status: 'running' },
+ *     statuses: ['running'],
+ *     workflowTypes: ['checkout'],
+ *     sampleWorkflowIds: ['wf-1'],
+ *     sampleLimit: 20,
+ *   },
+ *   sampleWorkflowIds: ['wf-1'],
+ *   confirmationToken: 'bulk:token',
+ *   confirmationTokenVersion: 1,
+ * };
+ * void preview;
+ * ```
+ */
+export type BulkOperationDryRunResult = {
+    dryRun: true;
+    action: BulkOperationAction;
+    matched: number;
+    requestId: string;
+    scope: BulkOperationScopeSummary;
+    sampleWorkflowIds: WorkflowId[];
+    confirmationToken: string;
+    confirmationTokenVersion: 1;
+};
+/**
+ * Options for a dry-run bulk operation preview.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationDryRunOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkOperationDryRunOptions = {
+ *   dryRun: true,
+ *   requestId: 'ops-123',
+ * };
+ * void options;
+ * ```
+ */
+export type BulkOperationDryRunOptions = {
+    dryRun: true;
+    requestId?: string;
+    principal?: BulkOperationPrincipal;
+};
+/**
+ * Options for a committed bulk operation.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationCommitOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkOperationCommitOptions = {
+ *   confirmationToken: 'bulk:token-from-preview',
+ *   requestId: 'ops-123',
+ * };
+ * void options;
+ * ```
+ */
+export type BulkOperationCommitOptions = {
+    dryRun?: false;
+    confirmationToken?: string;
+    requestId?: string;
+    principal?: BulkOperationPrincipal;
+};
+/**
+ * Options accepted by bulk workflow operations.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkOperationOptions = { dryRun: true };
+ * void options;
+ * ```
+ */
+export type BulkOperationOptions = BulkOperationDryRunOptions | BulkOperationCommitOptions;
+/**
+ * Dry-run options for `engine.signalAll`. Pass the signal payload as the
+ * third argument and these controls as the fourth argument.
+ *
+ * @example
+ * ```ts
+ * import type { BulkSignalAllDryRunOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkSignalAllDryRunOptions = { dryRun: true };
+ * void options;
+ * ```
+ */
+export type BulkSignalAllDryRunOptions = BulkOperationDryRunOptions;
+/**
+ * Commit options for `engine.signalAll`. Pass the signal payload as the
+ * third argument and these controls as the fourth argument.
+ *
+ * @example
+ * ```ts
+ * import type { BulkSignalAllCommitOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkSignalAllCommitOptions = {
+ *   confirmationToken: 'bulk:token-from-preview',
+ * };
+ * void options;
+ * ```
+ */
+export type BulkSignalAllCommitOptions = BulkOperationCommitOptions;
+/**
+ * Control options accepted by `engine.signalAll` as the fourth argument.
+ *
+ * @example
+ * ```ts
+ * import type { BulkSignalAllOptions } from '@lostgradient/weft';
+ *
+ * const options: BulkSignalAllOptions = { dryRun: true };
+ * void options;
+ * ```
+ */
+export type BulkSignalAllOptions = BulkSignalAllDryRunOptions | BulkSignalAllCommitOptions;
+/**
+ * Durable audit record persisted after a committed bulk operation succeeds.
+ *
+ * @example
+ * ```ts
+ * import type { BulkOperationAuditEvent } from '@lostgradient/weft';
+ *
+ * const event: BulkOperationAuditEvent = {
+ *   type: 'bulk-operation:audit',
+ *   action: 'cancel',
+ *   requestId: 'ops-123',
+ *   timestamp: Date.now(),
+ *   principal: { method: 'api-key', subject: 'operator@example.com' },
+ *   filterSummary: { status: 'running' },
+ *   scope: {
+ *     matched: 1,
+ *     filter: { status: 'running' },
+ *     statuses: ['running'],
+ *     workflowTypes: ['checkout'],
+ *     sampleWorkflowIds: ['wf-1'],
+ *     sampleLimit: 20,
+ *   },
+ *   affectedCount: 1,
+ *   sampleWorkflowIds: ['wf-1'],
+ *   confirmationToken: 'bulk:token',
+ * };
+ * void event;
+ * ```
+ */
+export type BulkOperationAuditEvent = {
+    type: 'bulk-operation:audit';
+    action: BulkOperationAction;
+    requestId: string;
+    timestamp: number;
+    principal: BulkOperationPrincipal;
+    filterSummary: BulkOperationFilterSummary;
+    scope: BulkOperationScopeSummary;
+    affectedCount: number;
+    sampleWorkflowIds: WorkflowId[];
+    confirmationToken: string;
+};
+/**
+ * Per-workflow error entry in bulk operation results. `id` identifies the
+ * workflow that failed; `error` is the error message string.
+ */
+export type BulkOperationError = {
+    id: WorkflowId;
+    error: string;
+};
+/**
+ * Result of a bulk cancel operation (`engine.cancelAll`). Reports the count
+ * of successfully cancelled workflows, the number that failed, and per-workflow
+ * error details in `errors`.
+ */
+export type BulkCancelResult = {
+    cancelled: number;
+    failed: number;
+    errors: BulkOperationError[];
+    auditEvent?: BulkOperationAuditEvent;
+};
+/**
+ * Result of a bulk signal operation (`engine.signalAll`). Reports the number
+ * of workflows that received the signal and the number for which delivery failed.
+ */
+export type BulkSignalResult = {
+    signalled: number;
+    failed: number;
+    auditEvent?: BulkOperationAuditEvent;
+};
+/**
+ * Result of a bulk delete operation (`engine.deleteAll`). Reports how many
+ * terminal workflows were deleted from storage.
+ */
+export type BulkDeleteResult = {
+    deleted: number;
+    auditEvent?: BulkOperationAuditEvent;
+};
+/**
+ * Result of a bulk tag operation (`engine.tagAll` / `engine.untagAll`).
+ * Reports how many workflows had their tags modified.
+ */
+export type BulkTagResult = {
+    modified: number;
+    auditEvent?: BulkOperationAuditEvent;
+};
+/**
+ * Result of a purge operation (`engine.purge`). Reports how many workflow
+ * records were permanently removed from storage.
+ */
+export interface PurgeResult {
+    deleted: number;
+}

package/dist/core/types/bulk.js

@@ -0,0 +1 @@
+export const MAX_BULK_OPERATION_REQUEST_ID_LENGTH = 200, MAX_BULK_CONFIRMATION_TOKEN_LENGTH = 256;

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

@@ -0,0 +1,237 @@
+import type { ContextOperationRequest } from '../context/operation-request.ts';
+import { WeftError } from '../weft-error.ts';
+import type { FailureCategory, OperationId, WorkflowId } from './identity.ts';
+import type { Duration, RetryPolicy } from './retry-retention.ts';
+import type { SearchAttributeValue } from './search-attributes.ts';
+/** Version tag for Worker-mode operation replay signatures stored in checkpoints. */
+export declare const WORKER_REPLAY_SIGNATURE_FORMAT = "weft-worker-operation-signature-v1";
+/**
+ * Canonical fingerprint of an operation yielded by a Worker-mode workflow.
+ *
+ * The Worker runner stores these optional signatures next to cached operation
+ * results so recovery can prove a cached result still belongs to the operation
+ * currently yielded by the workflow code before replaying it.
+ *
+ * @example
+ * ```ts
+ * import type { WorkerReplayOperationSignature } from '@lostgradient/weft';
+ *
+ * const signature: WorkerReplayOperationSignature = {
+ *   format: 'weft-worker-operation-signature-v1',
+ *   operationType: 'activity',
+ *   stableFieldsDigest: '0123456789abcdef',
+ *   stableFieldsByteLength: 128,
+ * };
+ *
+ * void signature;
+ * ```
+ */
+export interface WorkerReplayOperationSignature {
+    /** Signature format tag. */
+    format: typeof WORKER_REPLAY_SIGNATURE_FORMAT;
+    /** Operation type or kind used by the workflow runner. */
+    operationType: string;
+    /** SHA-256 digest of the canonical stable operation fields. */
+    stableFieldsDigest: string;
+    /** Encoded byte length of the canonical stable operation fields. */
+    stableFieldsByteLength: number;
+}
+/**
+ * Failed operation outcome cached by a Worker-mode checkpoint.
+ *
+ * Stored in a dedicated side table rather than inside `accumulatedResults` so
+ * user-controlled result values can never be reinterpreted as internal failure
+ * records by matching an object shape.
+ *
+ * @example
+ * ```ts
+ * import type { WorkerReplayOperationFailure } from '@lostgradient/weft';
+ *
+ * const failure: WorkerReplayOperationFailure = {
+ *   status: 'failed',
+ *   error: 'activity timed out',
+ *   failureCategory: 'timeout',
+ * };
+ *
+ * void failure;
+ * ```
+ */
+export interface WorkerReplayOperationFailure {
+    /** Failed operation status marker. */
+    status: 'failed';
+    /** Error message captured from the failed operation outcome. */
+    error: string;
+    /** Optional JavaScript error name captured from the failed operation outcome. */
+    errorName?: string;
+    /** Optional Weft failure category captured from the failed operation outcome. */
+    failureCategory?: FailureCategory;
+}
+/**
+ * Durable snapshot of a workflow's execution state persisted at each
+ * `yield` boundary. Contains the accumulated operation results, local
+ * variables, pending signals, search attributes, and the step counter.
+ * Users don't construct checkpoints directly; the engine manages them.
+ * Available via time-travel APIs and {@link WorkflowReplay}.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type Checkpoint } from '@lostgradient/weft';
+ *
+ * const engine = new Engine({ checkpointHistory: 5 });
+ * engine.register(workflow({ name: 'counter' }).execute(async function* () { return 42; }));
+ * const handle = await engine.start('counter', null);
+ * await handle.result();
+ * // Checkpoints are persisted by the engine; retrieve via engine.getCheckpoint()
+ * const _engine: typeof engine = engine;
+ * void _engine;
+ * ```
+ */
+export interface Checkpoint {
+    workflowId: WorkflowId;
+    step: number;
+    locals: Record<string, unknown>;
+    accumulatedResults: Array<[number, unknown]>;
+    /**
+     * Worker-mode replay guards for cached operation results. Inline execution
+     * ignores this optional field; Worker recovery uses it to prove a cached
+     * result still belongs to the yielded operation before reusing it.
+     */
+    workerReplaySignatures?: Array<[number, WorkerReplayOperationSignature]>;
+    /**
+     * Worker-mode failed operation outcomes keyed by step. Completed operation
+     * results stay in `accumulatedResults`; failed outcomes live here so replay
+     * can throw them back into the generator without trusting user result shape.
+     */
+    workerReplayFailures?: Array<[number, WorkerReplayOperationFailure]>;
+    pendingSignals: string[];
+    searchAttributes: Record<string, SearchAttributeValue>;
+    /** User-defined workflow code version. Used for code migrations. */
+    version: string;
+    /**
+     * Checkpoint schema version. Distinct from `version` (which is the
+     * user's workflow code version). Bumped whenever the engine changes
+     * the on-disk checkpoint format. Pre-1.0: refuse to load older
+     * versions; post-1.0: every bump must ship a migration.
+     */
+    schemaVersion: number;
+    createdAt: number;
+}
+/**
+ * Current checkpoint schema version. Skipped from `1` to `2` to make the
+ * discontinuity unambiguous — pre-versioned checkpoints (no field) are
+ * conceptually `< 1`, and v2 introduces the `ParallelOperationCacheEntry`
+ * format with per-branch slots for `ctx.all` / `ctx.runAll` partial
+ * persistence.
+ */
+export declare const CURRENT_CHECKPOINT_SCHEMA_VERSION = 2;
+/**
+ * Thrown by `validateCheckpointShape` when a checkpoint's
+ * `schemaVersion` does not match the engine's current version. Pre-1.0
+ * we refuse to load mismatched checkpoints rather than migrating.
+ */
+export declare class CheckpointSchemaVersionError extends WeftError<'CheckpointSchemaVersionError'> {
+    readonly found: number | 'pre-versioned';
+    readonly expected: number;
+    constructor(found: number | 'pre-versioned', expected: number);
+}
+/** Summary metadata for a single checkpoint history entry. */
+export type CheckpointSummary = {
+    step: number;
+    timestamp: number;
+    sizeBytes: number;
+};
+/** Full deserialized state at a specific checkpoint step. */
+export type CheckpointState = Pick<Checkpoint, 'step' | 'locals' | 'searchAttributes' | 'version' | 'createdAt'>;
+export type OperationKind = 'activity' | 'timer' | 'signal-wait' | 'child-workflow';
+export interface OperationRequest {
+    id: OperationId;
+    workflowId: WorkflowId;
+    kind: OperationKind;
+    queue: string;
+    activityName?: string;
+    input?: unknown;
+    attempt: number;
+    retryPolicy: RetryPolicy;
+    scheduledAt: number;
+    timeout?: Duration;
+    idempotencyKey?: string;
+    /** Visibility timeout in milliseconds. Defaults to 30 000. */
+    visibilityTimeout?: number;
+}
+export type OperationOutcome = {
+    status: 'completed';
+    value: unknown;
+} | WorkerReplayOperationFailure;
+/**
+ * Persistent record of a single scheduled timer. Stored under a
+ * deterministic key so timers survive process restarts; the engine
+ * resumes the associated workflow when the timer fires.
+ *
+ * Most code receives `TimerEntry` values from the scheduler; users only
+ * construct one when implementing an external scheduler that drives
+ * `engine.fireTimer()` (e.g. a Service Worker periodic-sync handler).
+ *
+ * @example
+ * ```ts
+ * import { Engine, type TimerEntry } from '@lostgradient/weft';
+ * declare const engine: Engine;
+ * declare const entry: TimerEntry;
+ * await engine.fireTimer(entry);
+ * ```
+ */
+export interface TimerEntry {
+    id: string;
+    workflowId: WorkflowId;
+    fireAt: number;
+    kind: 'sleep' | 'visibility-timeout' | 'execution-deadline' | 'delayed-start' | 'schedule' | 'terminal-cleanup';
+    executionTimeoutMs?: number;
+}
+export type WorkerInboundMessage = {
+    type: 'run';
+    protocolVersion?: number;
+    turnId?: number;
+    maxProtocolMessageBytes?: number;
+    workflowId: WorkflowId;
+    workflowType: string;
+    checkpoint: ArrayBuffer;
+    input: unknown;
+    executionStateOwnerId?: string;
+    deadline?: number;
+    headers?: [string, string][];
+} | {
+    type: 'resume';
+    protocolVersion?: number;
+    turnId?: number;
+    maxProtocolMessageBytes?: number;
+    workflowId: WorkflowId;
+    checkpoint: ArrayBuffer;
+    operationResult: OperationOutcome;
+} | {
+    type: 'cancel';
+    protocolVersion?: number;
+    turnId?: number;
+    workflowId: WorkflowId;
+};
+export type WorkerOutboundMessage = {
+    type: 'checkpoint';
+    protocolVersion?: number;
+    turnId?: number;
+    workflowId: WorkflowId;
+    checkpoint: ArrayBuffer;
+    operationRequest: OperationRequest | ContextOperationRequest;
+} | {
+    type: 'completed';
+    protocolVersion?: number;
+    turnId?: number;
+    workflowId: WorkflowId;
+    result: unknown;
+} | {
+    type: 'failed';
+    protocolVersion?: number;
+    turnId?: number;
+    workflowId: WorkflowId;
+    error: string;
+    errorStack?: string;
+    /** Populated when the execution strategy can classify the failure cause. */
+    failureCategory?: FailureCategory;
+};

package/dist/core/types/checkpoint.js

@@ -0,0 +1,12 @@
+import { WeftError } from "../weft-error.js";
+export const WORKER_REPLAY_SIGNATURE_FORMAT = "weft-worker-operation-signature-v1", CURRENT_CHECKPOINT_SCHEMA_VERSION = 2;
+
+export class CheckpointSchemaVersionError extends WeftError {
+  found;
+  expected;
+  constructor(found, expected) {
+    super("CheckpointSchemaVersionError", found === "pre-versioned" ? `Checkpoint has no schemaVersion field (pre-versioned format); engine expects schemaVersion ${expected}. Pre-1.0: in-flight workflows must be drained before upgrade.` : found > expected ? `Checkpoint schemaVersion ${found} is newer than engine version ${expected}. The engine is too old to read this checkpoint.` : `Checkpoint schemaVersion ${found} is older than engine version ${expected}. Pre-1.0: in-flight workflows must be drained before upgrade.`);
+    this.found = found;
+    this.expected = expected;
+  }
+}

package/dist/core/types/clone-plain.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Defensive recursive POJO clone used by the workflow builder and the engine's
+ * per-workflow `ActivityRegistry` construction.
+ *
+ * `structuredClone` rejects function values, which we deliberately carry on
+ * activity option subtrees (`execute`, `compensate`, `verify`) and on the
+ * builder's frozen activity/signal/update/query maps. This helper preserves
+ * function references verbatim and recursively clones plain objects and
+ * arrays. Class instances pass through by reference; the outer container is
+ * always frozen by the calling code, so reassignment cannot reach the stored
+ * copy.
+ *
+ * Both `WorkflowBuilderImpl.execute()` and `engine.register(builderWorkflow)`
+ * call this so the engine's stored copies cannot be mutated through references
+ * the user retains.
+ */
+export declare function clonePlain<T>(value: T): T;

package/dist/core/types/clone-plain.js

@@ -0,0 +1,25 @@
+export function clonePlain(value) {
+  return cloneWithSeen(value, new WeakMap);
+}
+function cloneWithSeen(value, seen) {
+  if (value === null || typeof value !== "object")
+    return value;
+  const objectValue = value, existing = seen.get(objectValue);
+  if (existing !== void 0)
+    return existing;
+  if (Array.isArray(value)) {
+    const cloned = [];
+    seen.set(objectValue, cloned);
+    for (const item of value)
+      cloned.push(cloneWithSeen(item, seen));
+    return cloned;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return value;
+  const out = {};
+  seen.set(objectValue, out);
+  for (const key of Object.keys(value))
+    out[key] = cloneWithSeen(value[key], seen);
+  return out;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Default checkpoint size (in bytes) above which the engine emits a
+ * {@link CheckpointSizeWarningEvent}. Currently 64 KB. Override via
+ * {@link EngineOptions.checkpointSizeWarningThreshold}.
+ *
+ * @example
+ * ```ts
+ * import { Engine, DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD } from '@lostgradient/weft';
+ *
+ * const engine = new Engine({
+ *   checkpointSizeWarningThreshold: DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD * 2,
+ * });
+ * void engine;
+ * ```
+ */
+export declare const DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD = 65536;
+/**
+ * Maximum allowed nesting depth for child workflow invocations before the
+ * engine throws. Prevents unbounded recursion. Override via
+ * {@link EngineOptions.maxNestingDepth}.
+ *
+ * @example
+ * ```ts
+ * import { Engine, DEFAULT_MAX_NESTING_DEPTH } from '@lostgradient/weft';
+ *
+ * const engine = new Engine({ maxNestingDepth: DEFAULT_MAX_NESTING_DEPTH + 5 });
+ * void engine;
+ * ```
+ */
+export declare const DEFAULT_MAX_NESTING_DEPTH = 10;
+export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
+/**
+ * Default activity visibility timeout in milliseconds (30 seconds). The engine
+ * marks an activity as failed if no heartbeat or result is received within this
+ * window. Override per-activity via {@link ActivityDefinition.visibilityTimeout}
+ * or per-call via {@link ActivityCallOptions.visibilityTimeout}.
+ *
+ * @example
+ * ```ts
+ * import { Engine, DEFAULT_VISIBILITY_TIMEOUT_MS, activity } from '@lostgradient/weft';
+ *
+ * const longTask = activity({
+ *   name: 'longTask',
+ *   visibilityTimeout: DEFAULT_VISIBILITY_TIMEOUT_MS * 4, // 2 minutes
+ *   execute: async (input: unknown) => input,
+ * });
+ * const engine = new Engine();
+ * void engine;
+ * void longTask;
+ * ```
+ */
+export declare const DEFAULT_VISIBILITY_TIMEOUT_MS = 30000;
+export declare const DEFAULT_RETENTION_SWEEP_INTERVAL_MS = 300000;
+export declare const DEFAULT_RETENTION_SWEEP_BATCH_SIZE = 1000;

package/dist/core/types/constants.js

@@ -0,0 +1 @@
+export const DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD = 65536, DEFAULT_MAX_NESTING_DEPTH = 10, DEFAULT_POLL_INTERVAL_MS = 1000, DEFAULT_VISIBILITY_TIMEOUT_MS = 30000, DEFAULT_RETENTION_SWEEP_INTERVAL_MS = 300000, DEFAULT_RETENTION_SWEEP_BATCH_SIZE = 1000;

package/dist/core/types/deep-freeze.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Recursive `Object.freeze` for plain objects and arrays.
+ *
+ * The workflow builder calls this from `.execute(fn)` to lock every cloned
+ * activity, signal, update, query, and search-attribute definition before
+ * handing the built workflow off to the engine. Deep freezing prevents post-
+ * definition mutation from invalidating idempotency, replay, or registry
+ * invariants — including mutations against nested option subtrees like
+ * `activity.retry.backoff.initialInterval`.
+ *
+ * Functions are intentionally not frozen. `Object.freeze` on a function does
+ * not meaningfully prevent reassignment of the calling site, and frozen
+ * functions can interact badly with library code that augments them. The outer
+ * container that holds the function reference is frozen, so `definition.execute
+ * = differentFn` still fails in strict mode.
+ *
+ * @example
+ * ```ts
+ * import { deepFreeze } from '@lostgradient/weft';
+ *
+ * const frozen = deepFreeze({ retry: { backoff: { initialInterval: 100 } } });
+ * // In strict mode, the next line throws TypeError; outside strict mode it
+ * // silently no-ops.
+ * try {
+ *   frozen.retry.backoff.initialInterval = 999;
+ * } catch (error) {
+ *   void error;
+ * }
+ * ```
+ */
+export declare function deepFreeze<T>(value: T): T;