@lostgradient/weft 0.2.0

package/dist/client/local-event-tail.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Library-mode live workflow-event tail for {@link LocalClient}.
+ *
+ * Server mode rides the `/watch` WebSocket channel; library mode has the engine
+ * in-process, so it iterates the engine's own {@link WorkflowHandle} event
+ * stream — the same primitive `handle.addEventListener` already uses — and maps
+ * each dispatched `Event` into the transport-neutral {@link WorkflowEvent}
+ * record (`{ type, timestamp, data }`). That mapping mirrors the server's
+ * watch-channel serialization, so both clients deliver the same event records
+ * and terminate on the same lifecycle events; only the wire in between differs.
+ *
+ * Like the HTTP tail, the local tail also replays the workflow's persisted
+ * event history on connect (via `engine.getEvents`) so a tail opened after
+ * events were already persisted still delivers them — the two transports honor
+ * the same unified catch-up contract — deduping the overlap window so an event
+ * present in both the replayed history and the live stream is delivered once.
+ *
+ * @module client/local-event-tail
+ */
+import type { Engine } from '../core/engine.ts';
+import type { WorkflowEventTail } from './event-tail.ts';
+/**
+ * Build a {@link WorkflowEventTail} backed by the in-process engine. The tail
+ * replays the workflow's persisted event history on connect, then delivers live
+ * lifecycle/activity events until the workflow reaches a terminal state or
+ * {@link WorkflowEventTail.close} is called. If the workflow has already
+ * finished, the persisted history ends with the terminal event so the tail
+ * still terminates cleanly.
+ */
+export declare function createLocalWorkflowEventTail(engine: Engine, workflowId: string): WorkflowEventTail;

package/dist/client/local-event-tail.js

@@ -0,0 +1,131 @@
+import { WORKFLOW_TERMINAL_EVENT_TYPES } from "../core/events/workflow-events.js";
+import { dropOverlappingLiveFrames } from "./event-stream-transport.js";
+function serializeEngineEvent(event) {
+  const raw = {};
+  for (const [key, value] of Object.entries(event)) {
+    if (key === "type")
+      continue;
+    raw[key] = value instanceof Error ? value.message : value;
+  }
+  const data = JSON.parse(JSON.stringify(raw));
+  return { type: event.type, timestamp: Date.now(), data };
+}
+export function createLocalWorkflowEventTail(engine, workflowId) {
+  const iterator = engine.getHandle(workflowId)[Symbol.asyncIterator](), output = [], pendingLive = [];
+  let catchUpDone = !1, terminated = !1, pumpDone = !1, pumpError = null, closed = !1, waker = null;
+  const ready = Promise.withResolvers();
+  let readySettled = !1;
+  function settleReady() {
+    if (readySettled)
+      return;
+    readySettled = !0;
+    ready.resolve();
+  }
+  const closeSignal = Promise.withResolvers();
+  function wake() {
+    const resolve = waker;
+    if (resolve !== null) {
+      waker = null;
+      resolve();
+    }
+  }
+  function emit(event) {
+    if (terminated)
+      return;
+    output.push(event);
+    wake();
+    if (WORKFLOW_TERMINAL_EVENT_TYPES.has(event.type))
+      terminated = !0;
+  }
+  function deliverLive(event) {
+    if (!catchUpDone) {
+      pendingLive.push(event);
+      return;
+    }
+    emit(event);
+  }
+  function close() {
+    if (closed)
+      return;
+    closed = !0;
+    iterator.return?.(void 0);
+    closeSignal.resolve();
+    settleReady();
+    wake();
+  }
+  const CLOSED = Symbol("closed");
+  (async () => {
+    try {
+      while (!0) {
+        if (closed)
+          return;
+        const next = await Promise.race([iterator.next(), closeSignal.promise.then(() => CLOSED)]);
+        if (typeof next === "symbol")
+          return;
+        if (closed)
+          return;
+        if (next.done === !0)
+          return;
+        deliverLive(serializeEngineEvent(next.value));
+        if (terminated)
+          return;
+      }
+    } catch (error) {
+      pumpError = error;
+    } finally {
+      pumpDone = !0;
+      iterator.return?.(void 0);
+      wake();
+    }
+  })().catch(() => {});
+  (async () => {
+    let history = [];
+    try {
+      history = await engine.getEvents(workflowId);
+    } catch {
+      history = [];
+    }
+    if (closed)
+      return;
+    for (const event of history) {
+      emit(event);
+      if (terminated)
+        break;
+    }
+    const buffered = pendingLive.splice(0, pendingLive.length), fresh = terminated ? [] : dropOverlappingLiveFrames(history, buffered);
+    catchUpDone = !0;
+    for (const live of fresh) {
+      if (terminated)
+        break;
+      emit(live);
+    }
+    wake();
+  })().catch(() => {}).finally(() => settleReady());
+  return {
+    close,
+    whenConnected: () => ready.promise,
+    async* [Symbol.asyncIterator]() {
+      try {
+        while (!0) {
+          while (output.length > 0) {
+            const event = output.shift();
+            yield event;
+            if (WORKFLOW_TERMINAL_EVENT_TYPES.has(event.type))
+              return;
+          }
+          if (pumpError !== null)
+            throw pumpError;
+          if (closed)
+            return;
+          if (pumpDone && catchUpDone)
+            return;
+          await new Promise((resolve) => {
+            waker = resolve;
+          });
+        }
+      } finally {
+        close();
+      }
+    }
+  };
+}

package/dist/client/local.d.ts

@@ -0,0 +1,115 @@
+/**
+ * In-process client that wraps an {@link Engine} instance directly.
+ * Use this when running Weft as an embedded library — no network hop.
+ *
+ * Implements the same {@link WeftClient} interface as {@link HttpClient},
+ * so switching from library mode to server mode is a constructor change.
+ *
+ * @module client/local
+ */
+import { type CatalogOperationName, type CatalogOperationTypes, type WeftClient as CatalogOperations } from '../cli/generated/operation-client.generated.ts';
+import type { Engine } from '../core/engine.ts';
+import type { AttributeFilterKey, BulkCancelResult, BulkDeleteResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, ForkOptions, ListFilter, PaginatedResult, PurgeResult, QueryDefinition, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleFilter, ScheduleOptions, ScheduleSpec, ScheduleSummary, SearchAttributeValue, SignalDefinition, SignalDeliveryOptions, StartOptions, SubmitReviewOptions, TypedListFilter, UpdateDefinition, WorkflowEvent, WorkflowInput, WorkflowOutput, WorkflowRegistry, WorkflowReplay, WorkflowState, WorkflowSummary, WorkflowTimelineEntry } from '../core/types.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';
+/**
+ * In-process Weft client backed by a local {@link Engine}.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, MemoryStorage, LocalClient, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * await using engine = new Engine({ storage: new MemoryStorage() });
+ * engine.register(
+ *   workflow({ name: 'greet' }).execute(async function* (ctx: WorkflowContext, input: { name: string }) {
+ *     return `Hello, ${input.name}!`;
+ *   }),
+ * );
+ *
+ * const client = new LocalClient(engine);
+ * const handle = await client.start('greet', { name: 'World' });
+ * console.log(await handle.result()); // 'Hello, World!'
+ * ```
+ */
+export declare class LocalClient implements WeftClient {
+    #private;
+    /** Typed low-level accessor for every catalog operation, routed in-process. */
+    readonly operations: CatalogOperations;
+    /**
+     * Out-of-band ("async") activity completion. An activity that called
+     * `ActivityContext.completeAsync()` parks its workflow until an external
+     * system resolves it by task token through these methods.
+     *
+     * @example
+     * ```ts
+     * import { Engine, LocalClient } from '@lostgradient/weft';
+     *
+     * const engine = new Engine();
+     * const client = new LocalClient(engine);
+     * // `token` came from the engine's `activity:async-pending` event.
+     * // await client.activity.complete(token, { ok: true });
+     * void client;
+     * ```
+     */
+    readonly activity: WeftClientActivity;
+    constructor(engine: Engine);
+    call<Name extends CatalogOperationName>(name: Name, input: CatalogOperationTypes[Name]['input']): Promise<CatalogOperationTypes[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>;
+    schedule<TName extends KnownWorkflowName>(type: TName, input: WorkflowInput<WorkflowRegistry, TName>, spec: string | ScheduleSpec, options?: ScheduleOptions): Promise<ClientScheduleHandle>;
+    schedule<TName extends string>(type: UnknownNameWhenRegistryEmpty<TName>, input: unknown, spec: string | ScheduleSpec, options?: ScheduleOptions): Promise<ClientScheduleHandle>;
+    get(id: string): Promise<WorkflowState | null>;
+    getSchedule(id: string): Promise<ScheduleSummary | null>;
+    list<const TAttributeKeys extends readonly AttributeFilterKey[] = readonly AttributeFilterKey[]>(filter?: TypedListFilter<TAttributeKeys>): Promise<PaginatedResult<WorkflowSummary>>;
+    listSchedules(filter?: ScheduleFilter): Promise<PaginatedResult<ScheduleSummary>>;
+    cancel(id: string): Promise<void>;
+    pauseSchedule(id: string): Promise<void>;
+    resumeSchedule(id: string): Promise<void>;
+    cancelSchedule(id: string): Promise<void>;
+    updateSchedule(id: string, newSpec: string | ScheduleSpec): 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>;
+    query<TOutput>(id: string, name: QueryDefinition<void, TOutput>): Promise<TOutput>;
+    query<TInput, TOutput>(id: string, name: QueryDefinition<TInput, TOutput>, input: TInput): Promise<TOutput>;
+    query(id: string, name: string, input?: unknown): Promise<unknown>;
+    update<TOutput>(id: string, name: UpdateDefinition<void, TOutput>, payload?: void, options?: {
+        timeout?: number;
+    }): Promise<TOutput>;
+    update<TInput, TOutput>(id: string, name: UpdateDefinition<TInput, TOutput>, payload: TInput, options?: {
+        timeout?: number;
+    }): Promise<TOutput>;
+    update(id: string, name: string, payload?: unknown, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    resume(id: string): Promise<ClientHandle>;
+    recoverAll(): Promise<ClientHandle[]>;
+    timeout(id: string): Promise<void>;
+    getAttributes(id: string): Promise<Record<string, SearchAttributeValue> | null>;
+    setAttributes(id: string, attributes: Record<string, SearchAttributeValue>): Promise<void>;
+    addTags(id: string, ...tags: string[]): Promise<void>;
+    removeTags(id: string, ...tags: string[]): Promise<void>;
+    getEvents(id: string): Promise<WorkflowEvent[]>;
+    tail(id: string): WorkflowEventTail;
+    getTimeline(id: string): Promise<WorkflowTimelineEntry[]>;
+    replayTo(id: string, step: number): Promise<WorkflowReplay | null>;
+    listReviews(filter?: ReviewListFilter): Promise<ReviewListEntry[]>;
+    submitReview(reviewId: string, options: SubmitReviewOptions): Promise<void>;
+    getStreamChunks(workflowId: string, key: string, options?: {
+        after?: number;
+    }): ReturnType<Engine['getStreamChunks']>;
+    fork(id: string, options?: ForkOptions): Promise<ClientHandle>;
+    getRetentionOverview(): Promise<RetentionOverview>;
+    purge(filter?: ListFilter): Promise<PurgeResult>;
+    cancelAll(filter: ListFilter): Promise<BulkCancelResult>;
+    signalAll(filter: ListFilter, name: string, payload?: unknown): Promise<BulkSignalResult>;
+    deleteAll(filter: ListFilter): Promise<BulkDeleteResult>;
+    tagAll(filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
+    untagAll(filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
+    submitCoordinatedUpdate(id: string, name: string, payload?: unknown, options?: {
+        timeout?: number;
+        idempotencyKey?: string;
+    }): Promise<CoordinatedUpdateResult>;
+    getUpdateResult(updateId: string): Promise<UpdateResult>;
+}

package/dist/client/local.js

@@ -0,0 +1,178 @@
+import {
+  CATALOG_OPERATION_NAMES
+} 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 { ScheduleHandleDelegation, WorkflowHandleDelegation } from "./handle-delegation.js";
+import { inProcessCatalogTransport } from "./in-process-operations.js";
+import { createLocalWorkflowEventTail } from "./local-event-tail.js";
+
+class LocalHandle extends WorkflowHandleDelegation {
+  #handle;
+  constructor(handle, client) {
+    super(handle.id, client);
+    this.#handle = handle;
+  }
+  async result() {
+    return this.#handle.result();
+  }
+  addEventListener(type, listener, options) {
+    this.#handle.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener, options) {
+    this.#handle.removeEventListener(type, listener, options);
+  }
+  [Symbol.dispose]() {}
+}
+
+class LocalScheduleHandle extends ScheduleHandleDelegation {
+  [Symbol.dispose]() {}
+}
+
+export class LocalClient {
+  #engine;
+  #rawEngine;
+  operations;
+  activity;
+  constructor(engine) {
+    this.#engine = runtimeWorkflowEngine(engine);
+    this.#rawEngine = engine;
+    this.activity = {
+      complete: (token, result) => this.#engine.completeAsyncActivity(token, result),
+      completeExceptionally: (token, error) => this.#engine.failAsyncActivity(token, error)
+    };
+    this.operations = createCatalogWeftClient(CATALOG_OPERATION_NAMES, inProcessCatalogTransport(engine));
+  }
+  call(name, input) {
+    return this.operations[name](input);
+  }
+  async start(type, input, options) {
+    const handle = await this.#engine.start(type, input, options);
+    return new LocalHandle(handle, this);
+  }
+  async schedule(type, input, spec, options) {
+    const handle = await this.#engine.schedule(type, input, spec, options);
+    return new LocalScheduleHandle(handle.id, this);
+  }
+  async get(id) {
+    return this.#engine.get(id);
+  }
+  async getSchedule(id) {
+    return this.#engine.getSchedule(id);
+  }
+  async list(filter) {
+    return this.#engine.list(filter);
+  }
+  async listSchedules(filter) {
+    return this.#engine.listSchedules(filter);
+  }
+  async cancel(id) {
+    return this.#engine.cancel(id);
+  }
+  async pauseSchedule(id) {
+    return this.#engine.pauseSchedule(id);
+  }
+  async resumeSchedule(id) {
+    return this.#engine.resumeSchedule(id);
+  }
+  async cancelSchedule(id) {
+    return this.#engine.cancelSchedule(id);
+  }
+  async updateSchedule(id, newSpec) {
+    return this.#engine.updateSchedule(id, newSpec);
+  }
+  async signal(id, nameOrDefinition, payload, options) {
+    if (options === void 0)
+      return this.#engine.signal(id, messageName(nameOrDefinition), payload);
+    return this.#engine.signal(id, messageName(nameOrDefinition), payload, options);
+  }
+  async query(id, nameOrDefinition, input) {
+    return this.#engine.query(id, messageName(nameOrDefinition), input);
+  }
+  async update(id, nameOrDefinition, payload, options) {
+    return this.#engine.update(id, messageName(nameOrDefinition), payload, options);
+  }
+  async resume(id) {
+    const handle = await this.#engine.resume(id);
+    return new LocalHandle(handle, this);
+  }
+  async recoverAll() {
+    return (await this.#engine.recoverAll()).map((handle) => new LocalHandle(handle, this));
+  }
+  async timeout(id) {
+    return this.#engine.timeout(id);
+  }
+  async getAttributes(id) {
+    return this.#engine.getAttributes(id);
+  }
+  async setAttributes(id, attributes) {
+    return this.#engine.setAttributes(id, attributes);
+  }
+  async addTags(id, ...tags) {
+    return this.#engine.addTags(id, ...tags);
+  }
+  async removeTags(id, ...tags) {
+    return this.#engine.removeTags(id, ...tags);
+  }
+  async getEvents(id) {
+    return this.#engine.getEvents(id);
+  }
+  tail(id) {
+    return createLocalWorkflowEventTail(this.#rawEngine, id);
+  }
+  async getTimeline(id) {
+    return this.#engine.getTimeline(id);
+  }
+  async replayTo(id, step) {
+    return this.#engine.replayTo(id, step);
+  }
+  async listReviews(filter) {
+    return this.#engine.listReviews(filter);
+  }
+  async submitReview(reviewId, options) {
+    return this.#engine.submitReview(reviewId, options);
+  }
+  async getStreamChunks(workflowId, key, options) {
+    return this.#engine.getStreamChunks(workflowId, key, options);
+  }
+  async fork(id, options) {
+    const handle = await this.#engine.fork(id, options);
+    return new LocalHandle(handle, this);
+  }
+  async getRetentionOverview() {
+    return this.#engine.getRetentionOverview();
+  }
+  async purge(filter) {
+    return this.#engine.purge(filter);
+  }
+  async cancelAll(filter) {
+    return this.#engine.cancelAll(filter);
+  }
+  async signalAll(filter, name, payload) {
+    return this.#engine.signalAll(filter, name, payload);
+  }
+  async deleteAll(filter) {
+    return this.#engine.deleteAll(filter);
+  }
+  async tagAll(filter, tags) {
+    return this.#engine.tagAll(filter, tags);
+  }
+  async untagAll(filter, tags) {
+    return this.#engine.untagAll(filter, tags);
+  }
+  async submitCoordinatedUpdate(id, name, payload, options) {
+    return this.#engine.submitCoordinatedUpdate(id, name, payload, options);
+  }
+  async getUpdateResult(updateId) {
+    const response = await this.#engine.getUpdateResult(updateId);
+    if (response === null)
+      return null;
+    const out = { updateId: response.updateId, result: response.result };
+    if (response.error !== void 0)
+      out.error = response.error;
+    return out;
+  }
+}

package/dist/client/open-event-subscription.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Opens a {@link WorkflowEventSubscription} from a client-like host.
+ *
+ * Splitting this concern out of `event-stream.ts` keeps the subscription class
+ * file focused on the socket/catch-up/reconnect state machine. The host shape
+ * and the `openClientEventSubscription` factory are the seam both `HttpHandle`
+ * (push-based `addEventListener`) and `HttpClient.tail` use to turn a client
+ * into a live `/watch` subscription.
+ *
+ * @module client/open-event-subscription
+ */
+import type { WorkflowEvent } from '../core/types.ts';
+import { WorkflowEventSubscription, type WorkflowEventStreamOptions } from './event-stream.ts';
+/**
+ * The streaming-relevant view of an HTTP client: the fields a workflow event
+ * subscription needs to open its `/watch` socket and run `getEvents` catch-up.
+ * `HttpClient` satisfies this structurally, so {@link openClientEventSubscription}
+ * takes the client directly instead of an assembled context literal.
+ */
+export type WorkflowEventStreamHost = {
+    readonly baseUrl: string;
+    readonly headers: Record<string, string>;
+    getEvents(workflowId: string): Promise<WorkflowEvent[]>;
+};
+/**
+ * Open a live {@link WorkflowEventSubscription} for a workflow over the `/watch`
+ * WebSocket channel, wiring the watch URL and the `getEvents` catch-up fetch
+ * from the given client. Shared by `HttpHandle` (push-based `addEventListener`)
+ * and `HttpClient.tail`. Pass `bufferForIteration` for iteration-intended
+ * consumers (`tail()`) so the connect catch-up is buffered for the async
+ * iterator rather than dropped.
+ */
+export declare function openClientEventSubscription(host: WorkflowEventStreamHost, streamOptions: WorkflowEventStreamOptions, workflowId: string, onEvent: (event: WorkflowEvent) => void, bufferForIteration?: boolean): WorkflowEventSubscription;

package/dist/client/open-event-subscription.js

@@ -0,0 +1,5 @@
+import { workflowWatchWebSocketUrl } from "./event-stream-transport.js";
+import { WorkflowEventSubscription } from "./event-stream.js";
+export function openClientEventSubscription(host, streamOptions, workflowId, onEvent, bufferForIteration = !1) {
+  return new WorkflowEventSubscription(workflowWatchWebSocketUrl(host.baseUrl, workflowId), host.headers, workflowId, (id) => host.getEvents(id), onEvent, bufferForIteration ? { ...streamOptions, bufferForIteration } : streamOptions);
+}

package/dist/client/schedule-list-search-params.d.ts

@@ -0,0 +1,3 @@
+import type { ScheduleFilter } from '../core/types.ts';
+/** Build query parameters for schedule list requests shared by all HTTP clients. */
+export declare function buildScheduleListSearchParams(filter?: ScheduleFilter): URLSearchParams;

package/dist/client/schedule-list-search-params.js

@@ -0,0 +1,18 @@
+function appendScheduleStatusFilters(params, status) {
+  if (status === void 0)
+    return;
+  const statuses = (Array.isArray(status) ? status : [status]).filter(Boolean);
+  for (const value of statuses)
+    params.append("status", value);
+}
+export function buildScheduleListSearchParams(filter) {
+  const params = new URLSearchParams;
+  appendScheduleStatusFilters(params, filter?.status);
+  if (filter?.workflowType !== void 0)
+    params.set("workflowType", filter.workflowType);
+  if (filter?.limit !== void 0)
+    params.set("limit", String(filter.limit));
+  if (filter?.offset !== void 0)
+    params.set("offset", String(filter.offset));
+  return params;
+}

package/dist/client/search-params.d.ts

@@ -0,0 +1,3 @@
+import { type ListFilter, type ReviewListFilter } from '../core/types.ts';
+export declare function buildWorkflowListSearchParams(filter?: ListFilter): URLSearchParams;
+export declare function buildReviewListSearchParams(filter?: ReviewListFilter): URLSearchParams;

package/dist/client/search-params.js

@@ -0,0 +1,54 @@
+import { searchAttributeName } from "../core/types.js";
+function appendStatusFilters(params, status) {
+  if (status === void 0)
+    return;
+  const statuses = (Array.isArray(status) ? status : [status]).filter(Boolean);
+  for (const value of statuses)
+    params.append("status", value);
+}
+function appendTagFilters(params, tags) {
+  if (tags === void 0)
+    return;
+  for (const tag of tags)
+    params.append("tag", tag);
+}
+function appendAttributeFilters(params, attributes) {
+  if (attributes === void 0)
+    return;
+  for (const attribute of attributes) {
+    const key = searchAttributeName(attribute.key);
+    if (attribute.value !== void 0)
+      params.set(`attr.${key}`, String(attribute.value));
+    if (attribute.gt !== void 0)
+      params.set(`attr.${key}.gt`, String(attribute.gt));
+    if (attribute.lt !== void 0)
+      params.set(`attr.${key}.lt`, String(attribute.lt));
+    if (attribute.gte !== void 0)
+      params.set(`attr.${key}.gte`, String(attribute.gte));
+    if (attribute.lte !== void 0)
+      params.set(`attr.${key}.lte`, String(attribute.lte));
+  }
+}
+export function buildWorkflowListSearchParams(filter) {
+  const params = new URLSearchParams;
+  appendStatusFilters(params, filter?.status);
+  if (filter?.type !== void 0)
+    params.set("type", filter.type);
+  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));
+  appendAttributeFilters(params, filter?.attributes);
+  return params;
+}
+export function buildReviewListSearchParams(filter) {
+  const params = new URLSearchParams;
+  if (filter?.status !== void 0)
+    params.set("status", filter.status);
+  if (filter?.workflowId !== void 0)
+    params.set("workflowId", filter.workflowId);
+  if (filter?.reviewType !== void 0)
+    params.set("reviewType", filter.reviewType);
+  return params;
+}

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

@@ -0,0 +1,9 @@
+import type { ScheduleSpec, StartOptions } from '../core/types.ts';
+export declare function setIfDefined(body: Record<string, unknown>, key: string, value: unknown): void;
+/**
+ * Translate a schedule recurrence specification into the wire body fields the
+ * REST/JSON-RPC schedule operations accept. A bare string is sent as
+ * `cronExpression`; an interval spec is sent as `every`.
+ */
+export declare function scheduleSpecToWireFields(spec: string | ScheduleSpec): Record<string, unknown>;
+export declare function buildStartBody(type: string, input: unknown, options?: StartOptions): Record<string, unknown>;

package/dist/client/start-body.js

@@ -0,0 +1,23 @@
+export function setIfDefined(body, key, value) {
+  if (value !== void 0)
+    body[key] = value;
+}
+export function scheduleSpecToWireFields(spec) {
+  if (typeof spec === "string")
+    return { cronExpression: spec };
+  if (spec.every !== void 0)
+    return { every: spec.every };
+  return { cronExpression: spec.cron };
+}
+export function buildStartBody(type, input, options) {
+  if (options?.idempotencyKey !== void 0)
+    throw Error("idempotencyKey is not supported over HttpClient because the start workflow HTTP protocol does not implement start idempotency");
+  const body = { type, input };
+  setIfDefined(body, "id", options?.id);
+  setIfDefined(body, "executionTimeout", options?.executionTimeout);
+  setIfDefined(body, "startAt", options?.startAt);
+  setIfDefined(body, "startAfter", options?.startAfter);
+  setIfDefined(body, "tags", options?.tags);
+  setIfDefined(body, "searchAttributes", options?.searchAttributes);
+  return body;
+}

package/dist/client/workflow-name-typing.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Registry-driven type-level helpers that gate the client's typed
+ * `start`/`schedule` overloads on the augmented {@link WorkflowRegistry}.
+ *
+ * @module client/workflow-name-typing
+ */
+import type { WorkflowRegistry } from '../core/types.ts';
+/**
+ * Workflow names known to the augmented {@link WorkflowRegistry}. Empty
+ * (`never`) until a project augments the registry — typically by running
+ * `weft codegen` and including the generated `.d.ts` in its compilation. The
+ * client's typed `start`/`schedule` overloads key off this set, so without
+ * codegen they degrade to the permissive string-name overloads.
+ *
+ * `weft codegen` only ever emits explicit string-literal entries, so in
+ * practice this resolves to a finite union of registered names. If a project
+ * hand-augments `WorkflowRegistry` with an index signature
+ * (`[name: string]: ...`), `KnownWorkflowName` widens to `string` and the
+ * typed overload accepts any name with that entry's input type — the same
+ * behavior the engine exhibits, and a deliberate consequence of opting into a
+ * permissive augmentation.
+ */
+export type KnownWorkflowName = Extract<keyof WorkflowRegistry, string>;
+/**
+ * Resolves to `TName` only when the {@link WorkflowRegistry} carries no known
+ * names (codegen has not run, or no workflow types were emitted). This gates
+ * the permissive string-name `start`/`schedule` overload so that, once the
+ * registry is populated, callers must pass a registered name (or fall through
+ * to the typed overload). Mirrors the engine's
+ * `UnknownWorkflowNameWhenDefaultRegistryIsEmpty` gate, scoped to the global
+ * registry the client consumes.
+ */
+export type UnknownNameWhenRegistryEmpty<TName extends string> = [KnownWorkflowName] extends [never] ? TName : never;