@lostgradient/weft 0.11.0 → 0.13.0

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,6 +7,12 @@
  *
  * @module client/index
  */
+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,2 +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
+} 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/connection.d.ts

@@ -14,6 +14,14 @@
  * A profile token is only applied when neither an explicit `server` option nor
  * `WEFT_ADDR` redirected the request to a different destination.
  *
+ * This module is imported from `@lostgradient/weft/client` (browser-reachable),
+ * so it must stay statically free of `node:*` and Bun-only imports. Environment
+ * variables go through {@link readEnvironmentVariable}; `~/.weft/config` and the
+ * run lockfile are read through {@link tryLoadNodeBuiltin}, which resolves
+ * `node:fs`/`node:fs/promises` via `process.getBuiltinModule` instead of a
+ * static import. Both return `undefined` outside Bun/Node, so a browser caller
+ * that supplies explicit `server`/`token` never touches either.
+ *
  * @module connection
  */
 /**

package/dist/connection.js

@@ -1,5 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, rm } from "node:fs/promises";
+import { isBunRuntime, readEnvironmentVariable, tryLoadNodeBuiltin } from "./runtime/portable.js";
 export const DEFAULT_WEFT_ADDRESS = "http://localhost:7233";
 
 export class ConnectionConfigurationError extends Error {
@@ -9,7 +8,7 @@ export class ConnectionConfigurationError extends Error {
   }
 }
 export function resolveConnection(options = {}) {
-  const context = resolveConnectionContext(options), server = resolveServerString(context), fallbackProfile = profileForToken(context, server), token = resolveToken(options.token ?? Bun.env.WEFT_TOKEN, fallbackProfile);
+  const context = resolveConnectionContext(options), server = resolveServerString(context), fallbackProfile = profileForToken(context, server), token = resolveToken(options.token ?? readEnvironmentVariable("WEFT_TOKEN"), fallbackProfile);
   return {
     server: parseServerUrl(server),
     ...token === void 0 ? {} : { token }
@@ -26,7 +25,7 @@ function parseServerUrl(server) {
 function profileForToken(context, resolvedServer) {
   if (context.profile === void 0)
     return;
-  if (!(context.options.server !== void 0 || Bun.env.WEFT_ADDR !== void 0))
+  if (!(context.options.server !== void 0 || readEnvironmentVariable("WEFT_ADDR") !== void 0))
     return context.profile;
   const profileServer = context.profile.server;
   if (profileServer === void 0)
@@ -44,7 +43,7 @@ function sameDestination(a, b) {
   return left.origin === right.origin && left.pathname.replace(/\/+$/, "") === right.pathname.replace(/\/+$/, "");
 }
 function resolveConnectionContext(options) {
-  const configuration = readWeftConfiguration(), profileName = options.profile ?? Bun.env.WEFT_PROFILE ?? configuration.defaultProfile, profile = profileName === void 0 ? void 0 : configuration.profiles?.[profileName], runLockfile = options.includeRunLockfile === !1 ? void 0 : readRunLockfile();
+  const configuration = readWeftConfiguration(), profileName = options.profile ?? readEnvironmentVariable("WEFT_PROFILE") ?? configuration.defaultProfile, profile = profileName === void 0 ? void 0 : configuration.profiles?.[profileName], runLockfile = options.includeRunLockfile === !1 ? void 0 : readRunLockfile();
   return {
     options,
     ...profile === void 0 ? {} : { profile },
@@ -52,12 +51,26 @@ function resolveConnectionContext(options) {
   };
 }
 function resolveServerString(context) {
-  return context.options.server ?? Bun.env.WEFT_ADDR ?? context.profile?.server ?? context.runLockfile?.server ?? context.runLockfile?.url ?? DEFAULT_WEFT_ADDRESS;
+  return context.options.server ?? readEnvironmentVariable("WEFT_ADDR") ?? context.profile?.server ?? context.runLockfile?.server ?? context.runLockfile?.url ?? DEFAULT_WEFT_ADDRESS;
+}
+function loadFsModule() {
+  return tryLoadNodeBuiltin("node:fs");
+}
+function loadFsPromisesModule() {
+  return tryLoadNodeBuiltin("node:fs/promises");
 }
 export async function writeRunLockfile(server) {
-  await mkdir(weftHome(), { recursive: !0 });
-  await Bun.write(runLockfilePath(), `${JSON.stringify({ server }, null, 2)}
-`);
+  const fsPromises = loadFsPromisesModule();
+  if (fsPromises === void 0)
+    throw Error("writeRunLockfile requires Bun or Node 22.5+ (process.getBuiltinModule); not available in this runtime.");
+  await fsPromises.mkdir(weftHome(), { recursive: !0 });
+  const contents = `${JSON.stringify({ server }, null, 2)}
+`;
+  if (isBunRuntime()) {
+    await Bun.write(runLockfilePath(), contents);
+    return;
+  }
+  await fsPromises.writeFile(runLockfilePath(), contents, "utf8");
 }
 export async function removeRunLockfile(server) {
   const lockfile = readRunLockfile();
@@ -65,15 +78,23 @@ export async function removeRunLockfile(server) {
     return;
   if ((lockfile.server ?? lockfile.url) !== server)
     return;
-  await rm(runLockfilePath(), { force: !0 });
+  const fsPromises = loadFsPromisesModule();
+  if (fsPromises === void 0)
+    return;
+  await fsPromises.rm(runLockfilePath(), { force: !0 });
 }
 function readWeftConfiguration() {
+  if (!isBunRuntime())
+    return {};
+  const fs = loadFsModule();
+  if (fs === void 0)
+    return {};
   const path = configurationPath();
-  if (!existsSync(path))
+  if (!fs.existsSync(path))
     return {};
   let parsed;
   try {
-    parsed = Bun.TOML.parse(readFileSync(path, "utf8"));
+    parsed = Bun.TOML.parse(fs.readFileSync(path, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new ConnectionConfigurationError(`Failed to read connection configuration at ${path}: ${message}`);
@@ -81,10 +102,13 @@ function readWeftConfiguration() {
   return normalizeConfiguration(parsed);
 }
 function readRunLockfile() {
+  const fs = loadFsModule();
+  if (fs === void 0)
+    return;
   const path = runLockfilePath();
-  if (!existsSync(path))
+  if (!fs.existsSync(path))
     return;
-  const text = readFileSync(path, "utf8").trim();
+  const text = fs.readFileSync(path, "utf8").trim();
   if (text === "")
     return;
   try {
@@ -137,11 +161,11 @@ function normalizeRunLockfile(value) {
 function resolveToken(token, profile) {
   const directToken = token ?? profile?.token;
   if (directToken?.startsWith("env:"))
-    return Bun.env[directToken.slice(4)];
+    return readEnvironmentVariable(directToken.slice(4));
   if (directToken !== void 0)
     return directToken;
   if (profile?.tokenEnv !== void 0)
-    return Bun.env[profile.tokenEnv];
+    return readEnvironmentVariable(profile.tokenEnv);
   return;
 }
 function configurationPath() {
@@ -151,7 +175,7 @@ function runLockfilePath() {
   return `${weftHome()}/run`;
 }
 function weftHome() {
-  return Bun.env.WEFT_HOME ?? `${Bun.env.HOME ?? "."}/.weft`;
+  return readEnvironmentVariable("WEFT_HOME") ?? `${readEnvironmentVariable("HOME") ?? "."}/.weft`;
 }
 function stringValue(value) {
   return typeof value === "string" && value !== "" ? value : void 0;

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.
  *