@lostgradient/weft 0.12.0 → 0.13.0

package/dist/client/http-client-storage.js

@@ -0,0 +1,110 @@
+import { decodeBase64ToBytes, encodeBytesToBase64, isRecord } from "../storage/byte-encoding.js";
+import {
+  assertStorageBatchOperationCount
+} from "../storage/interface.js";
+import { request, requestResponse } from "./http-request.js";
+const MAX_SCAN_RESPONSE_BYTES = 67108864;
+function encodeOperation(operation) {
+  return operation.type === "put" ? { type: "put", key: operation.key, value: encodeBytesToBase64(operation.value) } : { type: "delete", key: operation.key };
+}
+function scanPath(prefix, options) {
+  const parameters = new URLSearchParams({ prefix });
+  for (const [name, value] of Object.entries(options))
+    if (value !== void 0)
+      parameters.set(name, String(value));
+  return `/storage?${parameters.toString()}`;
+}
+function scanEntry(value) {
+  if (!isRecord(value) || typeof value.key !== "string" || typeof value.value !== "string")
+    throw Error("HttpClient storage scan response contained an invalid NDJSON entry.");
+  return [value.key, decodeBase64ToBytes(value.value)];
+}
+async function releaseScanReader(reader, reachedEndOfStream) {
+  if (!reachedEndOfStream)
+    try {
+      await reader.cancel();
+    } catch {}
+  reader.releaseLock();
+}
+async function* scanResponse(response) {
+  if (response.body === null)
+    return;
+  const reader = response.body.getReader(), decoder = new TextDecoder;
+  let bufferedText = "", bytesRead = 0, reachedEndOfStream = !1;
+  try {
+    while (!0) {
+      const { done, value } = await reader.read();
+      if (done) {
+        reachedEndOfStream = !0;
+        break;
+      }
+      bytesRead += value.byteLength;
+      if (bytesRead > MAX_SCAN_RESPONSE_BYTES)
+        throw Error("HttpClient storage scan response exceeded the maximum allowed size.");
+      bufferedText += decoder.decode(value, { stream: !0 });
+      const lines = bufferedText.split(`
+`);
+      bufferedText = lines.pop() ?? "";
+      for (const line of lines)
+        if (line.trim().length > 0)
+          yield scanEntry(JSON.parse(line));
+    }
+    bufferedText += decoder.decode();
+    if (bufferedText.trim().length > 0)
+      yield scanEntry(JSON.parse(bufferedText));
+  } finally {
+    await releaseScanReader(reader, reachedEndOfStream);
+  }
+}
+export function createHttpClientStorage(baseUrl, headers) {
+  return {
+    async get(key) {
+      const response = await requestResponse(baseUrl, `/storage/${encodeURIComponent(key)}`, headers, { method: "GET" });
+      return response === null ? null : new Uint8Array(await response.arrayBuffer());
+    },
+    async put(key, value) {
+      await requestResponse(baseUrl, `/storage/${encodeURIComponent(key)}`, headers, {
+        method: "PUT",
+        headers: { "content-type": "application/octet-stream" },
+        body: new Blob([value])
+      });
+    },
+    async delete(key) {
+      await requestResponse(baseUrl, `/storage/${encodeURIComponent(key)}`, headers, {
+        method: "DELETE"
+      });
+    },
+    async* scan(prefix, options = {}) {
+      const response = await requestResponse(baseUrl, scanPath(prefix, options), headers, {
+        method: "GET",
+        headers: { accept: "application/x-ndjson" }
+      });
+      if (response !== null)
+        yield* scanResponse(response);
+    },
+    async batch(operations) {
+      assertStorageBatchOperationCount("batch operations", operations.length);
+      await request(baseUrl, "/storage/-/batch", headers, {
+        method: "POST",
+        body: JSON.stringify({ operations: operations.map(encodeOperation) })
+      });
+    },
+    async conditionalBatch(conditions, operations) {
+      assertStorageBatchOperationCount("conditionalBatch conditions", conditions.length);
+      assertStorageBatchOperationCount("conditionalBatch operations", operations.length);
+      const result = await request(baseUrl, "/storage/-/conditional-batch", headers, {
+        method: "POST",
+        body: JSON.stringify({
+          conditions: conditions.map((condition) => ({
+            key: condition.key,
+            expectedValue: condition.expectedValue === null ? null : encodeBytesToBase64(condition.expectedValue)
+          })),
+          operations: operations.map(encodeOperation)
+        })
+      });
+      if (!isRecord(result) || typeof result.applied !== "boolean")
+        throw Error('HttpClient storage conditional batch response must include a boolean "applied" field.');
+      return result.applied;
+    }
+  };
+}

package/dist/client/http-client.d.ts

@@ -1,6 +1,7 @@
-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 { StoredStreamChunk } from '../core/context.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, 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, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, 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 HttpClientOptions } from './http-request.ts';
 import type { ClientHandle, ClientScheduleHandle, ClientStartOptions, ClientStartOrSignalOptions, UpdateResult, WeftClient, WeftClientActivity } from './interface.ts';
@@ -49,15 +50,17 @@ export declare class HttpClient implements WeftClient {
     readonly baseUrl: string;
     /** @internal Exposed for handle access. */
     readonly headers: Record<string, string>;
-    /** Typed low-level accessor for every catalog operation over JSON-RPC. */
-    readonly operations: CatalogOperations;
+    /** Typed low-level accessor over JSON-RPC and generated ordinary REST bindings. */
+    readonly operations: ClientOperations;
+    /** Raw storage administration over the byte-oriented REST bindings. */
+    readonly storage: WeftClientStorage;
     /**
      * Out-of-band ("async") activity completion over HTTP. POSTs to
      * `/v1/activities/{complete,fail}`; mirrors {@link LocalClient}'s `activity`.
      */
     readonly activity: WeftClientActivity;
     constructor(options?: HttpClientOptions);
-    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?: ClientStartOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
     start<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, options?: ClientStartOptions): Promise<ClientHandle>;
     startOrSignal<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, signal: StartOrSignalSignal, options?: ClientStartOrSignalOptions): Promise<ClientHandle<WorkflowOutput<WorkflowRegistry, TName>>>;
@@ -75,7 +78,7 @@ export declare class HttpClient implements WeftClient {
     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/http-client.js

@@ -1,5 +1,6 @@
 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 { messageName } from "../core/types.js";
@@ -19,6 +20,7 @@ import {
   getTimelineRequest,
   getUpdateResultRequest,
   getWorkflowRequest,
+  listPendingAsyncActivitiesRequest,
   listReviewRequests,
   pauseScheduleRequest,
   purgeWorkflowRequests,
@@ -38,27 +40,31 @@ import {
   untagAllWorkflowRequests,
   updateScheduleRequest
 } from "./http-client-requests.js";
+import { createHttpClientStorage } from "./http-client-storage.js";
 import { HttpHandle } from "./http-handle.js";
-import { httpClientCatalogTransport } from "./http-operations.js";
+import { httpClientOperationTransport } from "./http-operations.js";
 import { request, resolveHttpClientConnection } from "./http-request.js";
 import { HttpScheduleHandle } from "./http-schedule-handle.js";
 import { openClientEventSubscription } from "./open-event-subscription.js";
 import { buildScheduleListSearchParams } from "./schedule-list-search-params.js";
 import { buildWorkflowListSearchParams } from "./search-params.js";
-import { buildStartBody, buildStartOrSignalBody, scheduleSpecToWireFields } from "./start-body.js";
+import { buildScheduleBody, buildStartBody, buildStartOrSignalBody } from "./start-body.js";
 
 export class HttpClient {
   baseUrl;
   headers;
   operations;
+  storage;
   activity;
   #streamOptions;
   constructor(options = {}) {
     const connection = resolveHttpClientConnection(options);
     this.baseUrl = connection.baseUrl;
     this.headers = connection.headers;
-    this.operations = createCatalogWeftClient(CATALOG_OPERATION_NAMES, httpClientCatalogTransport(this.baseUrl, this.headers));
+    this.operations = createCatalogWeftClient(CLIENT_OPERATION_NAMES, httpClientOperationTransport(this.baseUrl, this.headers, CLIENT_REST_OPERATION_BINDINGS));
+    this.storage = createHttpClientStorage(this.baseUrl, this.headers);
     this.activity = {
+      listPending: (workflowId, listOptions) => listPendingAsyncActivitiesRequest(this, workflowId, listOptions),
       complete: (token, result) => completeAsyncActivityRequest(this, token, result),
       completeExceptionally: (token, error) => failAsyncActivityRequest(this, token, error)
     };
@@ -82,18 +88,7 @@ export class HttpClient {
     return new HttpHandle(response.id, this, response.outcome);
   }
   async schedule(type, input, spec, options) {
-    const body = {
-      type,
-      input,
-      ...scheduleSpecToWireFields(spec)
-    };
-    if (options?.id !== void 0)
-      body.id = options.id;
-    if (options?.overlap !== void 0)
-      body.overlap = options.overlap;
-    if (options?.backfill !== void 0)
-      body.backfill = options.backfill;
-    const response = await request(this.baseUrl, "/schedules", this.headers, {
+    const body = buildScheduleBody(type, input, spec, options), response = await request(this.baseUrl, "/schedules", this.headers, {
       method: "POST",
       body: JSON.stringify(body)
     });
@@ -133,8 +128,8 @@ export class HttpClient {
   async cancelSchedule(id) {
     return cancelScheduleRequest(this, id);
   }
-  async updateSchedule(id, newSpec) {
-    return updateScheduleRequest(this, id, newSpec);
+  async updateSchedule(id, newSpec, options) {
+    return updateScheduleRequest(this, id, newSpec, options);
   }
   async signal(id, nameOrDefinition, payload, options) {
     await signalWorkflowRequest(this, id, messageName(nameOrDefinition), payload, options);

package/dist/client/http-operations.d.ts

@@ -10,7 +10,7 @@
  *
  * @module client/http-operations
  */
-import type { CatalogTransport } from '../cli/operation-client-runtime.ts';
+import type { CatalogTransport, ClientRestOperationBinding } from '../cli/operation-client-runtime.ts';
 /**
  * Build a {@link CatalogTransport} that dispatches catalog operations as
  * JSON-RPC requests to a remote Weft server at `${baseUrl}/jsonrpc`.
@@ -27,3 +27,5 @@ import type { CatalogTransport } from '../cli/operation-client-runtime.ts';
  * `HttpClientError` rather than a raw `SyntaxError`.
  */
 export declare function httpClientCatalogTransport(baseUrl: string, headers: Record<string, string>): CatalogTransport;
+/** Route generated client operations over JSON-RPC or ordinary REST metadata. */
+export declare function httpClientOperationTransport(baseUrl: string, headers: Record<string, string>, restBindings: Readonly<Record<string, ClientRestOperationBinding>>): CatalogTransport;

package/dist/client/http-operations.js

@@ -1,5 +1,5 @@
 import { isFaultCode } from "../core/fault-code.js";
-import { HttpClientError } from "./http-request.js";
+import { HttpClientError, request } from "./http-request.js";
 function isJsonRpcFailure(value) {
   return typeof value === "object" && value !== null && "error" in value && typeof value.error === "object" && value.error !== null && "message" in value.error && typeof value.error.message === "string";
 }
@@ -40,3 +40,79 @@ export function httpClientCatalogTransport(baseUrl, headers) {
     throw new HttpClientError(response.status, `Invalid JSON-RPC response from ${endpoint}`);
   };
 }
+function inputRecord(operationName, input) {
+  if (isRecord(input))
+    return input;
+  throw new HttpClientError(400, `Operation ${operationName} input must be an object.`);
+}
+function requiredString(operationName, field, value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  throw new HttpClientError(400, `Operation ${operationName} requires a non-empty string "${field}" field.`);
+}
+function restParameterValue(operationName, field, value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  throw new HttpClientError(400, `Operation ${operationName} requires a string, number, or boolean "${field}" field.`);
+}
+function appendQueryValues(projection, operationName, field, queryParameter, value, repeating) {
+  if (repeating && Array.isArray(value)) {
+    for (const entry of value)
+      projection.searchParameters.append(queryParameter, restParameterValue(operationName, field, entry));
+    return;
+  }
+  projection.searchParameters.set(queryParameter, restParameterValue(operationName, field, value));
+}
+function projectRestInput(projection, operationName, field, source, value) {
+  if (source.kind === "path") {
+    const pathValue = requiredString(operationName, field, value);
+    projection.path = projection.path.replaceAll(`:${source.pathParam}`, encodeURIComponent(pathValue));
+    return;
+  }
+  if (value === void 0)
+    return;
+  if (source.kind === "query") {
+    appendQueryValues(projection, operationName, field, source.queryParam, value, source.repeating === !0);
+    return;
+  }
+  if (source.kind === "header") {
+    projection.requestHeaders.set(source.headerName, restParameterValue(operationName, field, value));
+    return;
+  }
+  if (source.kind === "body-field") {
+    projection.bodyFields[source.bodyField] = value;
+    return;
+  }
+  projection.directBody = value;
+  projection.directBodyMediaType = source.mediaType ?? "application/json";
+}
+async function callRestOperation(baseUrl, headers, operationName, binding, input) {
+  const fields = inputRecord(operationName, input), projection = {
+    path: binding.path,
+    searchParameters: new URLSearchParams,
+    requestHeaders: new Headers,
+    bodyFields: {},
+    directBody: void 0,
+    directBodyMediaType: void 0
+  };
+  for (const [field, source] of Object.entries(binding.inputSources))
+    projectRestInput(projection, operationName, field, source, fields[field]);
+  const query = projection.searchParameters.toString();
+  if (query.length > 0)
+    projection.path += `?${query}`;
+  const hasBodyFields = Object.keys(projection.bodyFields).length > 0, body = projection.directBody === void 0 ? hasBodyFields ? projection.bodyFields : void 0 : projection.directBody;
+  if (body !== void 0)
+    projection.requestHeaders.set("content-type", projection.directBodyMediaType ?? "application/json");
+  return request(baseUrl, projection.path, headers, {
+    method: binding.method,
+    ...[...projection.requestHeaders].length === 0 ? {} : { headers: projection.requestHeaders },
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+}
+export function httpClientOperationTransport(baseUrl, headers, restBindings) {
+  const jsonRpc = httpClientCatalogTransport(baseUrl, headers);
+  return (operationName, input) => {
+    const restBinding = restBindings[operationName];
+    return restBinding === void 0 ? jsonRpc(operationName, input) : callRestOperation(baseUrl, headers, operationName, restBinding, input);
+  };
+}

package/dist/client/http-request.d.ts

@@ -63,14 +63,14 @@ export declare function resolveHttpClientConnection(options: HttpClientOptions):
 /**
  * Error thrown when the server returns a non-2xx response.
  *
- * When the server sends a structured fault body (`{ error: { code, message } }`),
- * the wire fault `code` is surfaced as {@link HttpClientError.faultCode} and a
- * derived {@link HttpClientError.category} so callers can branch programmatically
- * instead of string-matching `message`. Both are `undefined` when the body is a
- * plain `{ error: string }` or carries no recognized code. The fault's typed
+ * When the server sends a fault body with a recognized coarse `code`, the wire
+ * value is surfaced as {@link HttpClientError.faultCode} with a derived
+ * {@link HttpClientError.category}, so callers can branch without
+ * string-matching `message`. Both are `undefined` for the production flat REST
+ * body, which carries no coarse code. The fault's typed
  * `data` payload (e.g. `InvalidParams`'s `issues`, `NotFound`/`Conflict`'s
  * `resource`/`identifier`) is surfaced verbatim as {@link HttpClientError.data}
- * when the body carries a structured `data` object; `undefined` otherwise —
+ * when the body carries an audited `data` object; `undefined` otherwise —
  * including for a masked `EngineFailure`, whose flat body carries no `data`.
  *
  * @example
@@ -82,7 +82,7 @@ export declare function resolveHttpClientConnection(options: HttpClientOptions):
  *   await client.cancel('nonexistent-id');
  * } catch (err) {
  *   if (err instanceof HttpClientError) {
- *     if (err.faultCode === 'NotFound') {
+ *     if (err.status === 404 && err.data?.['resource'] === 'workflow') {
  *       // handle a missing resource specifically
  *     } else if (err.category === 'resource') {
  *       // back off on rate limits and capacity faults
@@ -116,7 +116,8 @@ export declare class HttpClientError extends WeftError<'HttpClientError'> {
     readonly weftCode?: WeftErrorCode | undefined;
     /**
      * The fault's wire `data` payload, when the response carried a structured
-     * body (`{ error: { data } }` for REST, `error.data` for JSON-RPC). Shape is
+     * body (`{ error, data }` for production REST, nested `{ error: { data } }`
+     * for structured REST responses, or `error.data` for JSON-RPC). Shape is
      * fault-code-dependent — see {@link FaultCode} and the server's
      * `OperationFault` per-code `data` union for what each code carries (e.g.
      * `InvalidParams.data.issues`, `NotFound.data.resource`). `undefined` for
@@ -138,3 +139,9 @@ export declare class HttpClientError extends WeftError<'HttpClientError'> {
     });
 }
 export declare function request<T>(baseUrl: string, path: string, baseHeaders: Record<string, string>, options?: RequestInit): Promise<T>;
+/**
+ * Execute a REST request with the canonical {@link HttpClientError} shaping
+ * while leaving the successful response body available to binary or streaming
+ * client surfaces.
+ */
+export declare function requestResponse(baseUrl: string, path: string, baseHeaders: Record<string, string>, options?: RequestInit): Promise<Response | null>;

package/dist/client/http-request.js

@@ -41,6 +41,14 @@ function buildRequestHeaders(baseHeaders, options) {
 function isFlatErrorBody(value) {
   return value !== null && typeof value === "object" && typeof value.error === "string";
 }
+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 isStructuredErrorBody(value) {
   if (value === null || typeof value !== "object")
     return !1;
@@ -69,16 +77,22 @@ async function parseErrorBody(response) {
         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;
@@ -86,7 +100,5 @@ export async function request(baseUrl, path, baseHeaders, options) {
     const { message, faultCode, weftCode, data } = await parseErrorBody(response);
     throw new HttpClientError(response.status, message, { faultCode, 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']>;
 }