@lostgradient/weft 0.12.0 → 0.13.0

package/dist/client/local.d.ts

@@ -7,9 +7,10 @@
  *
  * @module client/local
  */
-import { type CatalogOperationName, type CatalogOperationTypes, type WeftClient as CatalogOperations } from '../cli/generated/operation-client.generated.ts';
+import { type ClientOperationName, type ClientOperationTypes, type ClientOperations } from '../cli/generated/operation-client.generated.ts';
 import type { Engine } from '../core/engine.ts';
-import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, DefaultActivityTypes, DefaultWorkflowRegistry, ForkOptions, ListFilter, PaginatedResult, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TypedListFilter, UpdateDefinition, WorkflowEvent, WorkflowInput, WorkflowOutput, WorkflowRegistry, WorkflowReplay, WorkflowState, WorkflowSummary, WorkflowTimelineEntry } from '../core/types.ts';
+import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, DefaultActivityTypes, DefaultWorkflowRegistry, ForkOptions, ListFilter, PaginatedResult, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TypedListFilter, UpdateDefinition, WorkflowEvent, WorkflowInput, WorkflowOutput, WorkflowRegistry, WorkflowReplay, WorkflowState, WorkflowSummary, WorkflowTimelineEntry } from '../core/types.ts';
+import { type WeftClientStorage } from './client-storage.ts';
 import type { WorkflowEventTail } from './event-tail.ts';
 import type { ClientHandle, ClientScheduleHandle, UpdateResult, WeftClient, WeftClientActivity } from './interface.ts';
 import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow-name-typing.ts';
@@ -34,8 +35,10 @@ import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow
  */
 export declare class LocalClient<TWorkflows extends object = DefaultWorkflowRegistry, TActivities extends object = DefaultActivityTypes> implements WeftClient {
     #private;
-    /** Typed low-level accessor for every catalog operation, routed in-process. */
-    readonly operations: CatalogOperations;
+    /** Typed low-level accessor for every client-callable operation, routed in-process. */
+    readonly operations: ClientOperations;
+    /** Raw storage administration against the engine-owned backend. */
+    readonly storage: WeftClientStorage;
     /**
      * Out-of-band ("async") activity completion. An activity that called
      * `ActivityContext.completeAsync()` parks its workflow until an external
@@ -54,7 +57,7 @@ export declare class LocalClient<TWorkflows extends object = DefaultWorkflowRegi
      */
     readonly activity: WeftClientActivity;
     constructor(engine: Engine<TWorkflows, TActivities> | Engine);
-    call<Name extends CatalogOperationName>(name: Name, input: CatalogOperationTypes[Name]['input']): Promise<CatalogOperationTypes[Name]['output']>;
+    call<Name extends ClientOperationName>(name: Name, input: ClientOperationTypes[Name]['input']): Promise<ClientOperationTypes[Name]['output']>;
     start<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, options?: StartOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
     start<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, options?: StartOptions): Promise<ClientHandle>;
     startOrSignal<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, signal: StartOrSignalSignal, options?: StartOrSignalOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
@@ -72,7 +75,7 @@ export declare class LocalClient<TWorkflows extends object = DefaultWorkflowRegi
     pauseSchedule(id: string): Promise<void>;
     resumeSchedule(id: string): Promise<void>;
     cancelSchedule(id: string): Promise<void>;
-    updateSchedule(id: string, newSpec: string | ScheduleSpec): Promise<void>;
+    updateSchedule(id: string, newSpec: string | ScheduleSpec, options?: ScheduleUpdateOptions): Promise<void>;
     signal(id: string, name: SignalDefinition): Promise<void>;
     signal<TInput>(id: string, name: SignalDefinition<TInput>, payload: TInput, options?: SignalDeliveryOptions): Promise<void>;
     signal(id: string, name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;

package/dist/client/local.js

@@ -1,11 +1,13 @@
 import {
-  CATALOG_OPERATION_NAMES
+  CLIENT_OPERATION_NAMES,
+  CLIENT_REST_OPERATION_BINDINGS
 } from "../cli/generated/operation-client.generated.js";
 import { createCatalogWeftClient } from "../cli/operation-client-runtime.js";
 import {
   runtimeWorkflowEngine
 } from "../core/runtime-workflow-engine.js";
 import { messageName } from "../core/types.js";
+import { createLocalClientStorage } from "./client-storage.js";
 import { inProcessCatalogTransport } from "./in-process-operations.js";
 import { createLocalWorkflowEventTail } from "./local-event-tail.js";
 import { LocalHandle, LocalScheduleHandle } from "./local-handles.js";
@@ -14,15 +16,18 @@ export class LocalClient {
   #engine;
   #rawEngine;
   operations;
+  storage;
   activity;
   constructor(engine) {
     this.#engine = runtimeWorkflowEngine(engine);
     this.#rawEngine = engine;
+    this.storage = createLocalClientStorage(this.#rawEngine.storage);
     this.activity = {
+      listPending: (workflowId, options) => this.#engine.listPendingAsyncActivities(workflowId, options),
       complete: (token, result) => this.#engine.completeAsyncActivity(token, result),
       completeExceptionally: (token, error) => this.#engine.failAsyncActivity(token, error)
     };
-    this.operations = createCatalogWeftClient(CATALOG_OPERATION_NAMES, inProcessCatalogTransport(this.#rawEngine));
+    this.operations = createCatalogWeftClient(CLIENT_OPERATION_NAMES, inProcessCatalogTransport(this.#rawEngine, new Set(Object.keys(CLIENT_REST_OPERATION_BINDINGS))));
   }
   call(name, input) {
     return this.operations[name](input);
@@ -71,8 +76,8 @@ export class LocalClient {
   async cancelSchedule(id) {
     return this.#engine.cancelSchedule(id);
   }
-  async updateSchedule(id, newSpec) {
-    return this.#engine.updateSchedule(id, newSpec);
+  async updateSchedule(id, newSpec, options) {
+    return this.#engine.updateSchedule(id, newSpec, options);
   }
   async signal(id, nameOrDefinition, payload, options) {
     if (options === void 0)

package/dist/client/search-params.js

@@ -29,16 +29,20 @@ function appendAttributeFilters(params, attributes) {
       params.set(`attr.${key}.lte`, String(attribute.lte));
   }
 }
+function appendOptionalSearchParameter(params, key, value) {
+  if (value !== void 0)
+    params.set(key, String(value));
+}
 export function buildWorkflowListSearchParams(filter) {
   const params = new URLSearchParams;
   appendStatusFilters(params, filter?.status);
-  if (filter?.type !== void 0)
-    params.set("type", filter.type);
+  appendOptionalSearchParameter(params, "type", filter?.type);
+  appendOptionalSearchParameter(params, "schedule_id", filter?.scheduleId);
+  appendOptionalSearchParameter(params, "parent_workflow_id", filter?.parentWorkflowId);
+  appendOptionalSearchParameter(params, "parent_workflow_execution_token", filter?.parentWorkflowExecutionToken);
   appendTagFilters(params, filter?.tags);
-  if (filter?.limit !== void 0)
-    params.set("limit", String(filter.limit));
-  if (filter?.offset !== void 0)
-    params.set("offset", String(filter.offset));
+  appendOptionalSearchParameter(params, "limit", filter?.limit);
+  appendOptionalSearchParameter(params, "offset", filter?.offset);
   appendAttributeFilters(params, filter?.attributes);
   return params;
 }

package/dist/client/start-body.d.ts

@@ -1,4 +1,4 @@
-import type { ScheduleSpec, StartOrSignalSignal } from '../core/types.ts';
+import type { ScheduleOptions, ScheduleSpec, StartOrSignalSignal } from '../core/types.ts';
 import type { ClientStartOptions, ClientStartOrSignalOptions } from './interface.ts';
 export declare function setIfDefined(body: Record<string, unknown>, key: string, value: unknown): void;
 /**
@@ -7,6 +7,8 @@ export declare function setIfDefined(body: Record<string, unknown>, key: string,
  * `cronExpression`; an interval spec is sent as `every`.
  */
 export declare function scheduleSpecToWireFields(spec: string | ScheduleSpec): Record<string, unknown>;
+/** Build a schedule-create wire body from the explicitly supported option fields. */
+export declare function buildScheduleBody(type: string, input: unknown, spec: string | ScheduleSpec, options?: ScheduleOptions): Record<string, unknown>;
 export declare function buildStartBody(type: string, input: unknown, options?: ClientStartOptions): Record<string, unknown>;
 /**
  * Build the wire body for `weft.workflows.startorsignal`. Flattens the signal

package/dist/client/start-body.js

@@ -9,6 +9,15 @@ export function scheduleSpecToWireFields(spec) {
     return { every: spec.every };
   return { cronExpression: spec.cron };
 }
+export function buildScheduleBody(type, input, spec, options) {
+  const body = { type, input, ...scheduleSpecToWireFields(spec) };
+  setIfDefined(body, "id", options?.id);
+  setIfDefined(body, "description", options?.description);
+  setIfDefined(body, "overlap", options?.overlap);
+  setIfDefined(body, "backfill", options?.backfill);
+  setIfDefined(body, "jitter", options?.jitter);
+  return body;
+}
 function applyStartOptionsToBody(body, options) {
   setIfDefined(body, "id", options?.id);
   setIfDefined(body, "executionTimeout", options?.executionTimeout);

package/dist/core/bulk-workflow-filter.d.ts

@@ -1,5 +1,5 @@
 import type { ListFilter } from './types.ts';
-export declare const BULK_WORKFLOW_FILTER_ERROR_MESSAGE = "Field \"filter\" must include at least one of status, type, tags, attributes, idPrefix (\u22653 chars), or failureCategory paired with status";
+export declare const BULK_WORKFLOW_FILTER_ERROR_MESSAGE = "Field \"filter\" must include at least one of status, type, scheduleId, tags, attributes, idPrefix (\u22653 chars), or failureCategory paired with status";
 /**
  * Returns `true` when the filter narrows destructive bulk operations
  * to a scoped subset rather than every workflow on the engine.
@@ -7,6 +7,7 @@ export declare const BULK_WORKFLOW_FILTER_ERROR_MESSAGE = "Field \"filter\" must
  * Valid scopes:
  * - `status` (non-empty after normalization).
  * - `type` (non-empty after trim).
+ * - `scheduleId` (non-empty after trim).
  * - `tags` (at least one tag after normalization).
  * - `attributes` (at least one attribute predicate with a non-empty key).
  * - `idPrefix` (length ≥ 3 — short prefixes match too much to be a safe scope).

package/dist/core/bulk-workflow-filter.js

@@ -1,7 +1,7 @@
 import { searchAttributeName } from "./search-attributes.js";
 import { normalizeWorkflowTags } from "./workflow-tags.js";
 const ID_PREFIX_MIN_LENGTH = 3;
-export const BULK_WORKFLOW_FILTER_ERROR_MESSAGE = 'Field "filter" must include at least one of status, type, tags, attributes, idPrefix (\u22653 chars), or failureCategory paired with status';
+export const BULK_WORKFLOW_FILTER_ERROR_MESSAGE = 'Field "filter" must include at least one of status, type, scheduleId, tags, attributes, idPrefix (\u22653 chars), or failureCategory paired with status';
 function hasScopedStatusFilter(filter) {
   if (filter.status === void 0)
     return !1;
@@ -12,6 +12,9 @@ function hasScopedStatusFilter(filter) {
 function hasScopedTypeFilter(filter) {
   return filter.type !== void 0 && filter.type.trim().length > 0;
 }
+function hasScopedScheduleFilter(filter) {
+  return filter.scheduleId !== void 0 && filter.scheduleId.trim().length > 0;
+}
 function hasScopedTagsFilter(filter) {
   return (normalizeWorkflowTags(filter.tags)?.length ?? 0) > 0;
 }
@@ -24,6 +27,7 @@ function hasScopedIdPrefix(filter) {
 const BULK_FILTER_DIMENSION_CHECKS = {
   status: hasScopedStatusFilter,
   type: hasScopedTypeFilter,
+  scheduleId: hasScopedScheduleFilter,
   tags: hasScopedTagsFilter,
   attributes: hasScopedAttributesFilter,
   idPrefix: hasScopedIdPrefix

package/dist/core/engine/async-activity-records.d.ts

@@ -16,8 +16,11 @@
  * key derivations, and the in-memory resolution queue that recovery drains.
  */
 import { type BatchOperation } from '../../storage/interface.ts';
-import type { OperationOutcome } from '../types.ts';
+import type { OperationOutcome, PendingAsyncActivityListOptions, PendingAsyncActivityPage } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
+export declare const DEFAULT_PENDING_ASYNC_ACTIVITY_LIMIT = 50;
+export declare const MAX_PENDING_ASYNC_ACTIVITY_LIMIT = 200;
+export declare const MAX_PENDING_ASYNC_ACTIVITY_CURSOR_LENGTH = 8192;
 /**
  * Storage-key prefix for durable async-activity records. Matches the base of
  * {@link KEYS.asyncActivity}; the full key appends `<workflowId>:<token>` (and
@@ -60,6 +63,14 @@ export type PendingAsyncActivityResolution = {
     readonly timelineStatus: 'completed' | 'failed';
     readonly timelineOutput: unknown;
 };
+export declare function isPendingAsyncActivityCursor(cursor: string): boolean;
+export declare function isPendingAsyncActivityCursorForWorkflow(cursor: string, workflowId: string): boolean;
+/**
+ * Read a bounded page directly from the durable per-workflow async-activity
+ * namespace. Pagination advances over raw storage keys, so corrupt or resolved
+ * records cannot stall a caller or expand one request beyond `limit + 1` reads.
+ */
+export declare function listPendingAsyncActivities(internals: EngineInternals, workflowId: string, options?: PendingAsyncActivityListOptions): Promise<PendingAsyncActivityPage>;
 /**
  * Derive the durable, deterministic task token for an async activity.
  *

package/dist/core/engine/async-activity-records.js

@@ -2,8 +2,8 @@ import { KEYS, encodeStorageKeyComponent } from "../../storage/interface.js";
 import { decode, encode } from "../codec.js";
 import { ActivityAsyncPendingEvent } from "../events.js";
 import { commitFencedEngineWrite } from "./fenced-write.js";
-const ASYNC_ACTIVITY_TOKEN_PREFIX = "async-act:v1";
-export const ASYNC_ACTIVITY_KEY_PREFIX = "async-act:v1:";
+const ASYNC_ACTIVITY_TOKEN_PREFIX = "async-act:v1", PENDING_ASYNC_ACTIVITY_CURSOR_PREFIX = "pending-async:v1:";
+export const DEFAULT_PENDING_ASYNC_ACTIVITY_LIMIT = 50, MAX_PENDING_ASYNC_ACTIVITY_LIMIT = 200, MAX_PENDING_ASYNC_ACTIVITY_CURSOR_LENGTH = 8192, ASYNC_ACTIVITY_KEY_PREFIX = "async-act:v1:";
 export function asyncActivityWorkflowPrefix(workflowId) {
   return `${ASYNC_ACTIVITY_KEY_PREFIX}${encodeStorageKeyComponent(workflowId)}:`;
 }
@@ -13,6 +13,85 @@ function isPersistedAsyncActivity(value) {
   const record = value;
   return record.version === 1 && typeof record.token === "string" && typeof record.workflowId === "string" && typeof record.activityName === "string" && typeof record.operationId === "string" && typeof record.step === "number" && typeof record.attempt === "number" && typeof record.createdAt === "number";
 }
+function decodePendingAsyncActivityCursor(cursor) {
+  if (cursor.length > MAX_PENDING_ASYNC_ACTIVITY_CURSOR_LENGTH || !cursor.startsWith(PENDING_ASYNC_ACTIVITY_CURSOR_PREFIX))
+    return null;
+  try {
+    const suffix = decodeURIComponent(cursor.slice(PENDING_ASYNC_ACTIVITY_CURSOR_PREFIX.length));
+    return suffix.length > 0 ? suffix : null;
+  } catch {
+    return null;
+  }
+}
+export function isPendingAsyncActivityCursor(cursor) {
+  return decodePendingAsyncActivityCursor(cursor) !== null;
+}
+export function isPendingAsyncActivityCursorForWorkflow(cursor, workflowId) {
+  const key = decodePendingAsyncActivityCursor(cursor), prefix = asyncActivityWorkflowPrefix(workflowId);
+  return key !== null && key.startsWith(prefix) && key.length > prefix.length;
+}
+function encodePendingAsyncActivityCursor(key) {
+  return `${PENDING_ASYNC_ACTIVITY_CURSOR_PREFIX}${encodeURIComponent(key)}`;
+}
+function resolvePendingAsyncActivityLimit(limit) {
+  const resolved = limit ?? DEFAULT_PENDING_ASYNC_ACTIVITY_LIMIT;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > MAX_PENDING_ASYNC_ACTIVITY_LIMIT)
+    throw RangeError(`Pending async activity limit must be an integer between 1 and ${MAX_PENDING_ASYNC_ACTIVITY_LIMIT}.`);
+  return resolved;
+}
+function toPendingAsyncActivityInfo(value, key, workflowId) {
+  if (!isPersistedAsyncActivity(value))
+    return null;
+  if (value.workflowId !== workflowId || key !== KEYS.asyncActivity(workflowId, value.token))
+    return null;
+  if (!Number.isSafeInteger(value.step) || value.step < 0 || !Number.isSafeInteger(value.attempt) || value.attempt < 1 || !Number.isFinite(value.createdAt))
+    return null;
+  return {
+    token: value.token,
+    operationId: value.operationId,
+    activityName: value.activityName,
+    step: value.step,
+    attempt: value.attempt,
+    createdAt: value.createdAt
+  };
+}
+function resolvePendingAsyncActivityAfterKey(cursor, workflowId) {
+  if (cursor === void 0)
+    return;
+  const key = decodePendingAsyncActivityCursor(cursor);
+  if (key === null || !isPendingAsyncActivityCursorForWorkflow(cursor, workflowId))
+    throw TypeError("Invalid pending async activity cursor.");
+  return key;
+}
+function decodePendingAsyncActivityInfo(bytes, key, workflowId) {
+  try {
+    return toPendingAsyncActivityInfo(decode(bytes), key, workflowId);
+  } catch {
+    return null;
+  }
+}
+function pendingAsyncActivityPage(scanned, limit, workflowId) {
+  const pageEntries = scanned.slice(0, limit), items = pageEntries.flatMap(([key, bytes]) => {
+    const item = decodePendingAsyncActivityInfo(bytes, key, workflowId);
+    return item === null ? [] : [item];
+  }), cursorKey = pageEntries.at(-1)?.[0];
+  return {
+    items,
+    ...scanned.length > limit && cursorKey !== void 0 ? { nextCursor: encodePendingAsyncActivityCursor(cursorKey) } : {}
+  };
+}
+export async function listPendingAsyncActivities(internals, workflowId, options = {}) {
+  const limit = resolvePendingAsyncActivityLimit(options.limit), prefix = asyncActivityWorkflowPrefix(workflowId), afterKey = resolvePendingAsyncActivityAfterKey(options.cursor, workflowId), scanned = [];
+  for await (const entry of internals.storage.scan(prefix, {
+    limit: limit + 1,
+    ...afterKey === void 0 ? {} : { gt: afterKey }
+  })) {
+    scanned.push(entry);
+    if (scanned.length >= limit + 1)
+      break;
+  }
+  return pendingAsyncActivityPage(scanned, limit, workflowId);
+}
 function isPersistedOperationOutcome(value) {
   if (typeof value !== "object" || value === null)
     return !1;

package/dist/core/engine/bulk-operations-purge.js

@@ -12,6 +12,7 @@ import { asyncActivityWorkflowPrefix } from "./async-activity-records.js";
 import { forgetCommittedCheckpointBytes } from "./checkpoint-commit-snapshots.js";
 import { commitFencedEngineWrite } from "./fenced-write.js";
 import { streamWorkflowStates } from "./listing.js";
+import { decodeScheduleRunMetadata } from "./schedule-run-metadata.js";
 import { createTerminalCleanupTimerId } from "./state-utilities.js";
 import {
   decodeWorkflowState,
@@ -181,12 +182,22 @@ async function collectWorkflowPurgeDeleteKeys(internals, state) {
   const workflowId = state.id, deleteKeys = buildBaseWorkflowDeleteKeys(state);
   addExecutionDeadlineDeleteKeys(deleteKeys, state);
   addTerminalCleanupDeleteKey(deleteKeys, state);
+  await addScheduleRunHistoryDeleteKeys(internals.storage, deleteKeys, workflowId);
   await addUpdateRequestDeleteKeys(internals.storage, deleteKeys, workflowId);
   await addWorkflowPrefixDeleteKeys(internals.storage, deleteKeys, workflowId);
   return deleteKeys;
 }
+async function addScheduleRunHistoryDeleteKeys(storage, deleteKeys, workflowId) {
+  const linkKey = KEYS.scheduleRunLink(workflowId), linkBytes = await storage.get(linkKey);
+  deleteKeys.add(linkKey);
+  if (linkBytes === null)
+    return;
+  const metadata = decodeScheduleRunMetadata(linkBytes);
+  if (metadata !== null)
+    deleteKeys.add(KEYS.scheduleRunBySchedule(metadata.id, workflowId));
+}
 function buildBaseWorkflowDeleteKeys(state) {
-  return new Set([
+  const keys = new Set([
     KEYS.workflow(state.id),
     KEYS.checkpoint(state.id),
     KEYS.workflowHeaders(state.id),
@@ -196,9 +207,13 @@ function buildBaseWorkflowDeleteKeys(state) {
     KEYS.workflowHasServices(state.id),
     KEYS.finalizerState(state.id),
     KEYS.teardownOwed(state.id),
+    KEYS.teardownSucceeded(state.id),
     KEYS.attribute(state.id),
     KEYS.terminalWorkflow(state.updatedAt, state.id)
   ]);
+  if (state.parentWorkflowId !== void 0)
+    keys.add(KEYS.childWorkflowByParent(state.parentWorkflowId, state.parentWorkflowExecutionToken, state.id));
+  return keys;
 }
 function addExecutionDeadlineDeleteKeys(deleteKeys, state) {
   if (state.executionDeadline === void 0)

package/dist/core/engine/bulk-operations-shared.js

@@ -63,6 +63,8 @@ function summarizeBulkFilter(filter) {
     summary.status = Array.isArray(filter.status) ? uniqueSorted(filter.status) : filter.status;
   if (filter.type !== void 0)
     summary.type = filter.type;
+  if (filter.scheduleId !== void 0)
+    summary.scheduleId = filter.scheduleId;
   const normalizedTags = normalizeWorkflowTags(filter.tags);
   if (normalizedTags !== void 0)
     summary.tags = normalizedTags;

package/dist/core/engine/callback-creators-schedule.d.ts

@@ -1,12 +1,13 @@
 import type { ScheduleState, TimerEntry } from '../types.ts';
 import type { Engine } from './index.ts';
 import type { ReviewOperationCallbacks, SubmitReviewCallbacks } from './reviews.ts';
+import type { ScheduledRunStartOptions } from './schedule-run.ts';
 import { type RefreshedScheduleState, type ScheduleCallbacks } from './schedules.ts';
 export declare function createScheduleCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ScheduleCallbacks;
 export declare function createReviewOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ReviewOperationCallbacks;
 export declare function createSubmitReviewCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): SubmitReviewCallbacks;
 export declare function refreshScheduledWorkflowStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<RefreshedScheduleState>;
-export declare function startScheduledRunForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, occurrence?: number): Promise<string>;
+export declare function startScheduledRunForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, options?: ScheduledRunStartOptions): Promise<string>;
 export declare function applyScheduleOccurrenceForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, occurrence?: number): Promise<ScheduleState>;
 export declare function settleBackfillScheduleStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<ScheduleState>;
 export declare function handleScheduleTimerForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, entry: TimerEntry): Promise<void>;

package/dist/core/engine/callback-creators-schedule.js

@@ -27,7 +27,7 @@ export function createScheduleCallbacks(engine) {
     cancelWorkflow: (workflowId) => engine.cancel(workflowId),
     getWorkflowResult: (workflowId) => engine.getHandle(workflowId).result(),
     refreshScheduledWorkflowState: (state) => refreshScheduledWorkflowStateForEngine(engine, state),
-    startScheduledRun: (state, occurrence) => startScheduledRunForEngine(engine, state, occurrence),
+    startScheduledRun: (state, options) => startScheduledRunForEngine(engine, state, options),
     applyScheduleOccurrence: (state, occurrence) => applyScheduleOccurrenceForEngine(engine, state, occurrence),
     settleBackfillScheduleState: (state) => settleBackfillScheduleStateForEngine(engine, state),
     flushQueuedInlineWorkflowStartsDirectly: () => flushQueuedInlineWorkflowStartsDirectly(getInternals(engine), createInlineLaunchQueueCallbacks(engine)),
@@ -51,8 +51,8 @@ export function createSubmitReviewCallbacks(engine) {
 export async function refreshScheduledWorkflowStateForEngine(engine, state) {
   return refreshScheduledWorkflowState(getInternals(engine), state, createScheduleCallbacks(engine));
 }
-export async function startScheduledRunForEngine(engine, state, occurrence) {
-  return startScheduledRun(getInternals(engine), state, createScheduleCallbacks(engine), occurrence);
+export async function startScheduledRunForEngine(engine, state, options) {
+  return startScheduledRun(getInternals(engine), state, createScheduleCallbacks(engine), options);
 }
 export async function applyScheduleOccurrenceForEngine(engine, state, occurrence) {
   return applyScheduleOccurrence(getInternals(engine), state, createScheduleCallbacks(engine), occurrence);

package/dist/core/engine/checkpoint-reads.js

@@ -66,12 +66,22 @@ export async function getTimeline(internals, workflowId) {
         inputSummary: sanitizeTimelineSummary(decoded.inputSummary) ?? decoded.inputSummary,
         ...decoded.outputSummary !== void 0 ? {
           outputSummary: sanitizeTimelineSummary(decoded.outputSummary) ?? decoded.outputSummary
-        } : {}
+        } : {},
+        ...decoded.branches === void 0 ? {} : { branches: decoded.branches.map(sanitizeTimelineOperationDetail) },
+        ...decoded.children === void 0 ? {} : { children: decoded.children.map(sanitizeTimelineOperationDetail) }
       });
   }
   timeline.sort((left, right) => left.step - right.step);
   return timeline;
 }
+function sanitizeTimelineOperationDetail(detail) {
+  if (detail.errorSummary === void 0)
+    return detail;
+  return {
+    ...detail,
+    errorSummary: sanitizeTimelineSummary(detail.errorSummary) ?? detail.errorSummary
+  };
+}
 export async function replayTo(internals, workflowId, step) {
   const bytes = await internals.storage.get(KEYS.checkpointHistory(workflowId, step));
   if (!bytes)

package/dist/core/engine/child-workflow.js

@@ -22,6 +22,8 @@ function applyPendingChildExecutionContext(internals, context) {
   internals.pendingNestingDepth = context.pendingNestingDepth;
   internals.pendingParentHeaders = context.pendingParentHeaders;
   internals.pendingExecutionStateOwnerId = context.pendingExecutionStateOwnerId;
+  internals.pendingParentWorkflowId = context.pendingParentWorkflowId;
+  internals.pendingParentWorkflowExecutionToken = context.pendingParentWorkflowExecutionToken;
 }
 function clearPendingChildExecutionContext(internals, context) {
   if (internals.pendingNestingDepth === context.pendingNestingDepth)
@@ -30,15 +32,20 @@ function clearPendingChildExecutionContext(internals, context) {
     internals.pendingParentHeaders = void 0;
   if (internals.pendingExecutionStateOwnerId === context.pendingExecutionStateOwnerId)
     internals.pendingExecutionStateOwnerId = void 0;
+  if (internals.pendingParentWorkflowId === context.pendingParentWorkflowId)
+    internals.pendingParentWorkflowId = void 0;
+  if (internals.pendingParentWorkflowExecutionToken === context.pendingParentWorkflowExecutionToken)
+    internals.pendingParentWorkflowExecutionToken = void 0;
 }
-function existingChildMatchesRequest(existingState, operation, executionStateOwnerId) {
-  return existingState.type === operation.workflowType && encodedValuesEqual(existingState.input, operation.input) && existingState.executionStateOwnerId === executionStateOwnerId;
+function existingChildMatchesRequest(existingState, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken) {
+  const lineageMatches = existingState.parentWorkflowId === void 0 && existingState.parentWorkflowExecutionToken === void 0 || existingState.parentWorkflowId === parentWorkflowId && existingState.parentWorkflowExecutionToken === parentWorkflowExecutionToken;
+  return existingState.type === operation.workflowType && encodedValuesEqual(existingState.input, operation.input) && existingState.executionStateOwnerId === executionStateOwnerId && lineageMatches;
 }
-async function resolveCollisionChildHandle(childWorkflowId, operation, executionStateOwnerId, collisionError, callbacks) {
+async function resolveCollisionChildHandle(childWorkflowId, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken, collisionError, callbacks) {
   const existingState = await callbacks.loadWorkflowState(childWorkflowId);
   if (!existingState)
     throw collisionError;
-  if (!existingChildMatchesRequest(existingState, operation, executionStateOwnerId))
+  if (!existingChildMatchesRequest(existingState, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken))
     throw Error(`Child workflow id collision for "${childWorkflowId}" does not match the requested child workflow`, { cause: collisionError });
   return callbacks.getHandle(childWorkflowId);
 }
@@ -52,7 +59,7 @@ async function dispatchChildWorkflowStart(internals, childWorkflowId, operation,
   } catch (error) {
     if (!(error instanceof WorkflowAlreadyExistsError))
       throw error;
-    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId ?? void 0, error, callbacks);
+    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId ?? void 0, context.pendingParentWorkflowId, context.pendingParentWorkflowExecutionToken, error, callbacks);
   } finally {
     clearPendingChildExecutionContext(internals, context);
   }
@@ -62,7 +69,9 @@ export async function executeChildWorkflow(internals, workflowId, operation, cur
     const context = {
       pendingNestingDepth: currentDepth + 1,
       pendingParentHeaders: internals.workflowHeaders.get(workflowId),
-      pendingExecutionStateOwnerId: executionStateOwnerId
+      pendingExecutionStateOwnerId: executionStateOwnerId,
+      pendingParentWorkflowId: workflowId,
+      pendingParentWorkflowExecutionToken: parentState?.workflowExecutionToken
     }, childHandle = await dispatchChildWorkflowStart(internals, childWorkflowId, operation, context, callbacks);
     if (parentClosePolicy === "abandon")
       return createChildWorkflowHandleReference(childHandle.id);

package/dist/core/engine/construction.js

@@ -72,6 +72,9 @@ export function copyWorkflowDefinition(type, registration) {
     ...registration.description === void 0 ? {} : { description: registration.description },
     ...registration.inputSchema === void 0 ? {} : { inputSchema: registration.inputSchema },
     ...registration.outputSchema === void 0 ? {} : { outputSchema: registration.outputSchema },
+    ...registration.signals === void 0 ? {} : { signals: { ...registration.signals } },
+    ...registration.updates === void 0 ? {} : { updates: { ...registration.updates } },
+    ...registration.queries === void 0 ? {} : { queries: { ...registration.queries } },
     ...registration.searchAttributes === void 0 ? {} : { searchAttributes: registration.searchAttributes },
     ...registration.concurrency === void 0 ? {} : { concurrency: registration.concurrency }
   };

package/dist/core/engine/disposal.js

@@ -53,6 +53,8 @@ export function disposeEngine(internals) {
   internals.sleepTimersFiredWithoutResolver.clear();
   internals.checkpoints.clear();
   internals.pendingExecutionStateOwnerId = void 0;
+  internals.pendingParentWorkflowId = void 0;
+  internals.pendingParentWorkflowExecutionToken = void 0;
   internals.workflowNestingDepths.clear();
   internals.workflowServices.clear();
   internals.workflowHeaders.clear();

package/dist/core/engine/engine-internal-types.d.ts

@@ -2,7 +2,7 @@ import type { Storage as WeftStorage } from '../../storage/interface.ts';
 import type { ConstraintDefinition } from '../constraint.ts';
 import type { ExecutionStrategy } from '../execution-strategy.ts';
 import type { InlineExecutionStrategy } from '../inline-execution-strategy.ts';
-import type { AnyActivityDefinition, ArchiveAdapter, Checkpoint, DefinitionSchema, EngineOptions, NormalizedHistoryPolicy, NormalizedPayloadSizePolicy, NormalizedRetentionPolicy, SearchAttributeSchema, WorkflowConcurrencyOptions, WorkflowFunction, WorkflowTimelineEntry } from '../types.ts';
+import type { AnyActivityDefinition, ArchiveAdapter, Checkpoint, DefinitionSchema, EngineOptions, NormalizedHistoryPolicy, NormalizedPayloadSizePolicy, NormalizedRetentionPolicy, QueryDefinition, SearchAttributeSchema, SignalDefinition, UpdateDefinition, WorkflowConcurrencyOptions, WorkflowFunction, WorkflowTimelineEntry } from '../types.ts';
 export interface RegistrationEntry {
     handler: WorkflowFunction;
     version: string;
@@ -10,6 +10,9 @@ export interface RegistrationEntry {
     tags?: ReadonlyArray<string>;
     inputSchema?: DefinitionSchema;
     outputSchema?: DefinitionSchema;
+    signals?: Readonly<Record<string, Readonly<SignalDefinition<unknown>>>>;
+    updates?: Readonly<Record<string, Readonly<UpdateDefinition<unknown>>>>;
+    queries?: Readonly<Record<string, Readonly<QueryDefinition<unknown>>>>;
     searchAttributes?: SearchAttributeSchema;
     retention?: NormalizedRetentionPolicy;
     concurrency?: WorkflowConcurrencyOptions;

package/dist/core/engine/fenced-write.d.ts

@@ -27,9 +27,11 @@ import type { EngineInternals } from './internals.ts';
  * work before `recoverAll()` would otherwise durably write workflow state without
  * single-writer ownership and without having recovered existing runs. Placed at
  * each public awaited entry so the caller gets a clean {@link EngineLeaseNotHeldError}
- * — without this, fork/resume would reach `resolveFenceEpochOrHalt` with no held
- * epoch and be misreported as a deposition (warn + teardown) rather than the true
- * "lease not held yet" condition. A no-op under `ownership: 'none'`.
+ * — without this, fork, resume, and the schedule mutators (`schedule`,
+ * `pauseSchedule`, `resumeSchedule`, `cancelSchedule`, and `updateSchedule`) would
+ * reach `resolveFenceEpochOrHalt` with no held epoch and be misreported as a
+ * deposition (warn + teardown) rather than the true "lease not held yet"
+ * condition. A no-op under `ownership: 'none'`.
  */
 export declare function assertLeaseHeldForEngineWork(internals: EngineInternals): void;
 /**

package/dist/core/engine/finalizer-status.d.ts

@@ -0,0 +1,10 @@
+import { type BatchOperation } from '../../storage/interface.ts';
+import type { WorkflowFinalizerStatus, WorkflowState } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+export interface TeardownSucceededRecord {
+    attempts: number;
+    completedAt: number;
+    workflowExecutionToken?: string;
+}
+export declare function buildTeardownSuccessOperations(workflowId: string, attempts: number, completedAt: number, workflowExecutionToken: string | undefined): BatchOperation[];
+export declare function getFinalizerStatus(internals: EngineInternals, workflowId: string, state: WorkflowState | null): Promise<WorkflowFinalizerStatus | null>;