@lostgradient/weft 0.12.0 → 0.14.0

package/dist/client/http-request.js

@@ -1,5 +1,5 @@
 import { resolveConnection } from "../connection.js";
-import { failureCategoryForFaultCode, isFaultCode } from "../core/fault-code.js";
+import { failureCategoryForFaultCode } from "../core/fault-code.js";
 import { isWeftErrorCode, WeftError } from "../core/weft-error.js";
 export function resolveHttpClientConnection(options) {
   const connection = resolveConnection({
@@ -41,19 +41,13 @@ function buildRequestHeaders(baseHeaders, options) {
 function isFlatErrorBody(value) {
   return value !== null && typeof value === "object" && typeof value.error === "string";
 }
-function isStructuredErrorBody(value) {
-  if (value === null || typeof value !== "object")
-    return !1;
-  const error = value.error;
-  if (error === null || typeof error !== "object")
-    return !1;
-  return typeof error.message === "string";
-}
-function weftCodeFromData(data) {
-  if (data === null || typeof data !== "object")
-    return;
-  const candidate = data.weftCode;
-  return isWeftErrorCode(candidate) ? candidate : void 0;
+function parseFlatErrorBody(body) {
+  const weftCode = isWeftErrorCode(body.weftCode) ? body.weftCode : void 0, data = isRecord(body.data) ? body.data : void 0;
+  return {
+    message: body.error,
+    ...weftCode === void 0 ? {} : { weftCode },
+    ...data === void 0 ? {} : { data }
+  };
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -61,32 +55,28 @@ function isRecord(value) {
 async function parseErrorBody(response) {
   try {
     const body = await response.json();
-    if (isStructuredErrorBody(body)) {
-      const { code, message, data } = body.error, weftCode = weftCodeFromData(data), base = { message };
-      if (weftCode !== void 0)
-        base.weftCode = weftCode;
-      if (isRecord(data))
-        base.data = data;
-      return isFaultCode(code) ? { ...base, faultCode: code } : base;
-    }
-    if (isFlatErrorBody(body) && body.error) {
-      const weftCode = isWeftErrorCode(body.weftCode) ? body.weftCode : void 0;
-      return weftCode === void 0 ? { message: body.error } : { message: body.error, weftCode };
-    }
+    if (isFlatErrorBody(body) && body.error)
+      return parseFlatErrorBody(body);
     return { message: response.statusText };
   } catch {
     return { message: response.statusText };
   }
 }
 export async function request(baseUrl, path, baseHeaders, options) {
+  const response = await requestResponse(baseUrl, path, baseHeaders, options);
+  if (response === null)
+    return null;
+  if (response.status === 204)
+    return;
+  return response.json();
+}
+export async function requestResponse(baseUrl, path, baseHeaders, options) {
   const headers = buildRequestHeaders(baseHeaders, options), response = await fetch(`${baseUrl}/v1${path}`, { ...options, headers });
   if (response.status === 404 && (!options?.method || options.method === "GET"))
     return null;
   if (!response.ok) {
-    const { message, faultCode, weftCode, data } = await parseErrorBody(response);
-    throw new HttpClientError(response.status, message, { faultCode, weftCode, data });
+    const { message, weftCode, data } = await parseErrorBody(response);
+    throw new HttpClientError(response.status, message, { weftCode, data });
   }
-  if (response.status === 204)
-    return;
-  return response.json();
+  return response;
 }

package/dist/client/in-process-operations.d.ts

@@ -22,9 +22,9 @@ import type { Engine } from '../core/engine.ts';
  *
  * The registry and trusted principal are constructed once and reused across
  * calls. Operations run with `transport: 'jsonRpcHttp'` so input/output
- * validation and unknown-key handling match the remote JSON-RPC path exactly.
+ * validation and unknown-key handling match the selected remote transport.
  * A failed dispatch throws with the fault message, mirroring the HTTP
  * transport's `throw new Error(result.error.message)` contract so both clients
  * surface operation faults the same way.
  */
-export declare function inProcessCatalogTransport(engine: Engine): CatalogTransport;
+export declare function inProcessCatalogTransport(engine: Engine, restOperationNames?: ReadonlySet<string>): CatalogTransport;

package/dist/client/in-process-operations.js

@@ -1,13 +1,13 @@
 import { executeOperation } from "../server/operation-catalog.js";
 import { principalFromStdioLocal } from "../server/principal.js";
 import { createLiveOperationRegistry } from "../server/rest-bindings.js";
-export function inProcessCatalogTransport(engine) {
+export function inProcessCatalogTransport(engine, restOperationNames = new Set) {
   const registry = createLiveOperationRegistry(), principal = principalFromStdioLocal();
   return async (operationName, input) => {
     const result = await executeOperation(operationName, input, {
       principal,
       engine,
-      transport: "jsonRpcHttp",
+      transport: restOperationNames.has(operationName) ? "http-rest" : "jsonRpcHttp",
       registry
     });
     if (!result.ok)

package/dist/client/index.d.ts

@@ -7,8 +7,12 @@
  *
  * @module client/index
  */
-export { isWeftError, isWeftErrorCode, isWeftErrorLike, isWeftFault, WeftError, } from '../core/weft-error.ts';
+export { WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowFailedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowSuspendedEvent, WorkflowTeardownEvent, WorkflowTimedOutEvent, } from '../core/events/workflow-events.ts';
+export { isFaultCode, type FaultCode } from '../core/fault-code.ts';
+export type { PendingAsyncActivityInfo, PendingAsyncActivityListOptions, PendingAsyncActivityPage, } from '../core/types.ts';
+export { WeftError, isWeftError, isWeftErrorCode, isWeftErrorLike, isWeftFault, } from '../core/weft-error.ts';
 export type { WeftErrorCode } from '../core/weft-error.ts';
+export type { WeftClientStorage } from './client-storage.ts';
 export type { WorkflowEventStreamOptions, WorkflowEventTransport } from './event-stream-options.ts';
 export type { WorkflowEventTail } from './event-tail.ts';
 export { HttpClient } from './http-client.ts';

package/dist/client/index.js

@@ -1,9 +1,20 @@
 export {
+  WorkflowCancelledEvent,
+  WorkflowCompletedEvent,
+  WorkflowFailedEvent,
+  WorkflowResumedEvent,
+  WorkflowStartedEvent,
+  WorkflowSuspendedEvent,
+  WorkflowTeardownEvent,
+  WorkflowTimedOutEvent
+} from "../core/events/workflow-events.js";
+export { isFaultCode } from "../core/fault-code.js";
+export {
+  WeftError,
   isWeftError,
   isWeftErrorCode,
   isWeftErrorLike,
-  isWeftFault,
-  WeftError
+  isWeftFault
 } from "../core/weft-error.js";
 export { HttpClient } from "./http-client.js";
 export { HttpClientError } from "./http-request.js";

package/dist/client/interface.d.ts

@@ -5,11 +5,12 @@
  *
  * @module client/interface
  */
-import type { CatalogOperationName, CatalogOperationTypes, WeftClient as CatalogOperations } from '../cli/generated/operation-client.generated.ts';
+import type { ClientOperationName, ClientOperationTypes, ClientOperations } from '../cli/generated/operation-client.generated.ts';
 import type { StoredStreamChunk } from '../core/context.ts';
 import type { StartOrSignalOutcome as EngineStartOrSignalOutcome } from '../core/engine/handles.ts';
 import type { TypedEventTarget, WeftEventMap } from '../core/events.ts';
-import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, 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, ForkOptions, ListFilter, PaginatedResult, PendingAsyncActivityListOptions, PendingAsyncActivityPage, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleUpdateOptions as ScheduleEdit, 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 { WeftClientStorage } from './client-storage.ts';
 import type { WorkflowEventTail } from './event-tail.ts';
 import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow-name-typing.ts';
 /**
@@ -197,8 +198,8 @@ export interface ClientScheduleHandle extends Disposable {
     resume(): Promise<void>;
     /** Cancel this schedule. */
     cancel(): Promise<void>;
-    /** Update the schedule's recurrence specification (cron string or interval spec). */
-    update(newSpec: string | ScheduleSpec): Promise<void>;
+    /** Update the schedule cadence and optional mutable schedule settings. */
+    update(newSpec: string | ScheduleSpec, options?: ScheduleEdit): Promise<void>;
     /** Read the latest persisted summary for this schedule. */
     describe(): Promise<ScheduleSummary | null>;
 }
@@ -212,24 +213,21 @@ export type UpdateResult = {
  * Out-of-band ("async") activity completion surface, shared by every client.
  *
  * An activity that called `ActivityContext.completeAsync()` parks its workflow
- * until an external system resolves it by the durable task token announced on
- * the engine's `activity:async-pending` event. Library mode calls the engine
- * directly; server mode POSTs to `/v1/activities/{complete,fail}`. After a
- * restart, wait for recovery to settle first — a completion racing `recoverAll()`
- * consumes the single-use token before re-adoption and strands the workflow. The
- * token is a deterministic identifier, not a secret (see `completeAsync`).
+ * until an external system resolves it by durable task token. `listPending()`
+ * queries the durable record after a missed live event or process restart.
+ * Library mode calls the engine directly; server mode uses the matching REST
+ * operations. The token is a deterministic identifier, not a secret.
  *
  * @example
  * ```ts
- * import { Engine, LocalClient, type WeftClientActivity } from '@lostgradient/weft';
- *
- * const activity: WeftClientActivity = new LocalClient(new Engine()).activity;
- * // `token` comes from the engine's `activity:async-pending` event:
- * // await activity.complete(token, { approved: true });
- * void activity;
+ * import type { WeftClientActivity } from '@lostgradient/weft/client';
+ * declare const activity: WeftClientActivity;
+ * void activity.listPending('order-1');
  * ```
  */
 export interface WeftClientActivity {
+    /** List a bounded page of durable activities awaiting completion for one workflow. */
+    listPending(workflowId: string, options?: PendingAsyncActivityListOptions): Promise<PendingAsyncActivityPage>;
     /** Complete a deferred activity by token, resuming its workflow with `result` (optional; omitted/`undefined` resumes with `undefined`). */
     complete(token: string, result?: unknown): Promise<void>;
     /** Fail a deferred activity by token; the error is thrown into its workflow. */
@@ -259,7 +257,6 @@ export interface WeftClient {
      * returned handle's `result()` to its output type. Without augmentation the
      * permissive string-name overload applies, so the client stays usable with
      * plain string names and no hard dependency on codegen.
-     *
      * Pass `options.idempotencyKey` for at-most-once starts: a repeated key returns
      * a handle to the existing run rather than starting a second. Conflicts (a
      * duplicate `id`, or a key whose run was purged) are transport-dependent:
@@ -339,8 +336,8 @@ export interface WeftClient {
     resumeSchedule(id: string): Promise<void>;
     /** Cancel a recurring schedule. */
     cancelSchedule(id: string): Promise<void>;
-    /** Update a recurring schedule's recurrence specification (cron string or interval spec). */
-    updateSchedule(id: string, newSpec: string | ScheduleSpec): Promise<void>;
+    /** Update a recurring schedule's cadence and optional mutable schedule settings. */
+    updateSchedule(id: string, newSpec: string | ScheduleSpec, options?: ScheduleEdit): Promise<void>;
     /** Send a named signal to a workflow. */
     signal(id: string, name: SignalDefinition): Promise<void>;
     signal<TInput>(id: string, name: SignalDefinition<TInput>, payload: TInput, options?: SignalDeliveryOptions): Promise<void>;
@@ -433,11 +430,12 @@ export interface WeftClient {
     /**
      * Typed low-level accessor for the full operation catalog.
      *
-     * Every catalog operation is reachable as `client.operations['weft.<op>']`,
-     * including server operations the ergonomic surface does not curate (workers,
-     * task queues, task diagnostics, system metrics/registry, checkpoints). New
-     * catalog operations appear here automatically when the snapshot regenerates,
-     * so the client never drifts behind the server.
+     * Every unary JSON-RPC operation and ordinary schema-shaped REST-only
+     * operation is reachable as `client.operations['weft.<op>']`, including
+     * server operations the ergonomic surface does not curate (workers, task
+     * queues, task diagnostics, system lease/metrics/registry, checkpoints). Binary
+     * and streaming raw-storage routes use {@link storage} instead. New compatible
+     * operations appear here when the snapshot regenerates.
      *
      * @example
      * ```ts
@@ -450,11 +448,13 @@ export interface WeftClient {
      * void metrics;
      * ```
      */
-    readonly operations: CatalogOperations;
+    readonly operations: ClientOperations;
+    /** Raw storage administration with byte values and streaming scans. */
+    readonly storage: WeftClientStorage;
     /**
      * Invoke a single catalog operation by name, with its input and output typed
      * from the generated catalog. Equivalent to `client.operations[name](input)`
      * but ergonomic when the operation name is known dynamically.
      */
-    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']>;
 }

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/context/parallel-operations.d.ts

@@ -1,8 +1,6 @@
 import type { Context } from './index.ts';
 import type { ContextInternals } from './internals.ts';
 import type { ContextOperationRequest } from './operation-request.ts';
-import { assertValidParallelOperationCacheEntry, BranchTopologyChangedError, createParallelOperationCacheEntry, isParallelOperationCacheEntry, type ParallelBranchSlot, type ParallelOperationCacheEntry } from './parallel-cache-entry.ts';
-export { assertValidParallelOperationCacheEntry, BranchTopologyChangedError, createParallelOperationCacheEntry, isParallelOperationCacheEntry, type ParallelBranchSlot, type ParallelOperationCacheEntry, };
 export declare function all(context: Context, internals: ContextInternals, operations: Generator<ContextOperationRequest, unknown, unknown>[]): Generator<ContextOperationRequest, unknown[], unknown>;
 export declare function race(context: Context, internals: ContextInternals, operations: Generator<ContextOperationRequest, unknown, unknown>[], branchNames?: string[]): Generator<ContextOperationRequest, unknown, unknown>;
 export declare function memo<T>(context: Context, internals: ContextInternals, key: string, fn: () => T | Promise<T>): Generator<ContextOperationRequest, T, unknown>;

package/dist/core/context/parallel-operations.js

@@ -6,13 +6,6 @@ import {
   isParallelOperationCacheEntry
 } from "./parallel-cache-entry.js";
 import { captureCallerStack } from "./validation.js";
-
-export {
-  assertValidParallelOperationCacheEntry,
-  BranchTopologyChangedError,
-  createParallelOperationCacheEntry,
-  isParallelOperationCacheEntry
-};
 function reconstructAllResult(entry) {
   return entry.branches.map((slot) => {
     if (slot.status !== "fulfilled")

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;