@lostgradient/weft 0.2.0

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

@@ -0,0 +1,65 @@
+import type { StoredStreamChunk } from '../core/context.ts';
+import type { BulkCancelResult, BulkDeleteResult, BulkSignalResult, BulkTagResult, CoordinatedUpdateResult, ForkOptions, ListFilter, PurgeResult, RetentionOverview, ReviewListEntry, ReviewListFilter, ScheduleSpec, ScheduleSummary, SearchAttributeValue, SignalDeliveryOptions, SubmitReviewOptions, WorkflowReplay, WorkflowState, WorkflowTimelineEntry } from '../core/types.ts';
+import type { UpdateResult } from './interface.ts';
+export type HttpClientRequestContext = {
+    readonly baseUrl: string;
+    readonly headers: Record<string, string>;
+};
+export declare function listReviewRequests(context: HttpClientRequestContext, filter?: ReviewListFilter): Promise<ReviewListEntry[]>;
+export declare function submitReviewRequest(context: HttpClientRequestContext, reviewId: string, options: SubmitReviewOptions): Promise<void>;
+export declare function getStreamChunkRequests(context: HttpClientRequestContext, workflowId: string, key: string, options?: {
+    after?: number;
+}): Promise<StoredStreamChunk[]>;
+export declare function forkWorkflowRequest(context: HttpClientRequestContext, id: string, options?: ForkOptions): Promise<string>;
+export declare function getRetentionOverviewRequest(context: HttpClientRequestContext): Promise<RetentionOverview>;
+export declare function purgeWorkflowRequests(context: HttpClientRequestContext, filter?: ListFilter): Promise<PurgeResult>;
+export declare function cancelAllWorkflowRequests(context: HttpClientRequestContext, filter: ListFilter): Promise<BulkCancelResult>;
+export declare function signalAllWorkflowRequests(context: HttpClientRequestContext, filter: ListFilter, name: string, payload?: unknown): Promise<BulkSignalResult>;
+export declare function deleteAllWorkflowRequests(context: HttpClientRequestContext, filter: ListFilter): Promise<BulkDeleteResult>;
+export declare function tagAllWorkflowRequests(context: HttpClientRequestContext, filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
+export declare function untagAllWorkflowRequests(context: HttpClientRequestContext, filter: ListFilter, tags: string[]): Promise<BulkTagResult>;
+export declare function submitCoordinatedUpdateRequest(context: HttpClientRequestContext, id: string, name: string, payload?: unknown, options?: {
+    timeout?: number;
+    idempotencyKey?: string;
+}): Promise<CoordinatedUpdateResult>;
+export declare function getAttributesRequest(context: HttpClientRequestContext, id: string): Promise<Record<string, SearchAttributeValue> | null>;
+export declare function setAttributesRequest(context: HttpClientRequestContext, id: string, attributes: Record<string, SearchAttributeValue>): Promise<void>;
+export declare function addTagsRequest(context: HttpClientRequestContext, id: string, tags: string[]): Promise<void>;
+export declare function removeTagsRequest(context: HttpClientRequestContext, id: string, tags: string[]): Promise<void>;
+export declare function getTimelineRequest(context: HttpClientRequestContext, id: string): Promise<WorkflowTimelineEntry[]>;
+export declare function replayToRequest(context: HttpClientRequestContext, id: string, step: number): Promise<WorkflowReplay | null>;
+export declare function getUpdateResultRequest(context: HttpClientRequestContext, updateId: string): Promise<UpdateResult>;
+/** Send a named signal (with optional payload + delivery options) to a workflow. */
+export declare function signalWorkflowRequest(context: HttpClientRequestContext, id: string, name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;
+/**
+ * Complete a deferred ("async") activity by task token, resuming its parked
+ * workflow with `result`. Mirrors `LocalClient.activity.complete` over HTTP.
+ */
+export declare function completeAsyncActivityRequest(context: HttpClientRequestContext, token: string, result?: unknown): Promise<void>;
+/**
+ * Fail a deferred ("async") activity by task token. A live `Error` cannot cross
+ * the wire, so the error is reduced to `message` + `name` — exactly the fields
+ * the engine itself keeps when failing an async activity — before sending.
+ */
+export declare function failAsyncActivityRequest(context: HttpClientRequestContext, token: string, error: unknown): Promise<void>;
+/** Fetch a workflow's full persisted state, or `null` if it does not exist. */
+export declare function getWorkflowRequest(context: HttpClientRequestContext, id: string): Promise<WorkflowState | null>;
+/** Fetch a schedule's current summary, or `null` if it does not exist. */
+export declare function getScheduleRequest(context: HttpClientRequestContext, id: string): Promise<ScheduleSummary | null>;
+/** Cancel a running workflow (`DELETE /v1/workflows/:id`). */
+export declare function cancelWorkflowRequest(context: HttpClientRequestContext, id: string): Promise<void>;
+/** Force-timeout a workflow (`POST /v1/workflows/:id/timeout`). */
+export declare function timeoutWorkflowRequest(context: HttpClientRequestContext, id: string): Promise<void>;
+/** Pause a recurring schedule (`POST /v1/schedules/:id/pause`). */
+export declare function pauseScheduleRequest(context: HttpClientRequestContext, id: string): Promise<void>;
+/** Resume a paused schedule (`POST /v1/schedules/:id/resume`). */
+export declare function resumeScheduleRequest(context: HttpClientRequestContext, id: string): Promise<void>;
+/** Cancel a recurring schedule (`DELETE /v1/schedules/:id`). */
+export declare function cancelScheduleRequest(context: HttpClientRequestContext, id: string): Promise<void>;
+/** Update a schedule's recurrence specification (`PATCH /v1/schedules/:id`). */
+export declare function updateScheduleRequest(context: HttpClientRequestContext, id: string, newSpec: string | ScheduleSpec): Promise<void>;
+/**
+ * Query a named read-only accessor on a workflow. A no-input query is a GET;
+ * an input payload is sent as a POST body.
+ */
+export declare function queryWorkflowRequest(context: HttpClientRequestContext, id: string, name: string, input?: unknown): Promise<unknown>;

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

@@ -0,0 +1,178 @@
+import { assertScopedBulkWorkflowFilter } from "../core/bulk-workflow-filter.js";
+import { HttpClientError, request } from "./http-request.js";
+import { buildReviewListSearchParams } from "./search-params.js";
+import { scheduleSpecToWireFields } from "./start-body.js";
+export async function listReviewRequests(context, filter) {
+  const search = buildReviewListSearchParams(filter).toString(), path = search.length > 0 ? `/reviews?${search}` : "/reviews";
+  return (await request(context.baseUrl, path, context.headers)).items;
+}
+export async function submitReviewRequest(context, reviewId, options) {
+  await request(context.baseUrl, `/reviews/${encodeURIComponent(reviewId)}/decision`, context.headers, {
+    method: "POST",
+    body: JSON.stringify(options)
+  });
+}
+export async function getStreamChunkRequests(context, workflowId, key, options) {
+  const search = new URLSearchParams;
+  if (options?.after !== void 0)
+    search.set("after", String(options.after));
+  const query = search.size > 0 ? `?${search.toString()}` : "";
+  return (await request(context.baseUrl, `/workflows/${encodeURIComponent(workflowId)}/streams/${encodeURIComponent(key)}${query}`, context.headers)).chunks;
+}
+export async function forkWorkflowRequest(context, id, options) {
+  const body = {};
+  if (options?.fromStep !== void 0)
+    body.fromStep = options.fromStep;
+  return (await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/fork`, context.headers, {
+    method: "POST",
+    body: JSON.stringify(body)
+  })).id;
+}
+export function getRetentionOverviewRequest(context) {
+  return request(context.baseUrl, "/retention", context.headers);
+}
+export function purgeWorkflowRequests(context, filter) {
+  return request(context.baseUrl, "/workflows/purge", context.headers, {
+    method: "POST",
+    body: JSON.stringify({ filter })
+  });
+}
+export function cancelAllWorkflowRequests(context, filter) {
+  assertScopedBulkWorkflowFilter(filter);
+  return request(context.baseUrl, "/workflows/bulk/cancel", context.headers, {
+    method: "POST",
+    body: JSON.stringify({ filter })
+  });
+}
+export function signalAllWorkflowRequests(context, filter, name, payload) {
+  assertScopedBulkWorkflowFilter(filter);
+  if (name.length === 0)
+    throw Error('Field "name" must be a non-empty string');
+  return request(context.baseUrl, "/workflows/bulk/signal", context.headers, {
+    method: "POST",
+    body: JSON.stringify({ filter, name, payload })
+  });
+}
+export function deleteAllWorkflowRequests(context, filter) {
+  assertScopedBulkWorkflowFilter(filter);
+  return request(context.baseUrl, "/workflows/bulk", context.headers, {
+    method: "DELETE",
+    body: JSON.stringify({ filter })
+  });
+}
+export function tagAllWorkflowRequests(context, filter, tags) {
+  assertScopedBulkWorkflowFilter(filter);
+  return request(context.baseUrl, "/workflows/bulk/tags", context.headers, {
+    method: "PATCH",
+    body: JSON.stringify({ filter, tags, operation: "add" })
+  });
+}
+export function untagAllWorkflowRequests(context, filter, tags) {
+  assertScopedBulkWorkflowFilter(filter);
+  return request(context.baseUrl, "/workflows/bulk/tags", context.headers, {
+    method: "PATCH",
+    body: JSON.stringify({ filter, tags, operation: "remove" })
+  });
+}
+export async function submitCoordinatedUpdateRequest(context, id, name, payload, options) {
+  const body = { payload };
+  if (options?.timeout !== void 0)
+    body.timeout = options.timeout;
+  if (options?.idempotencyKey !== void 0)
+    body.idempotencyKey = options.idempotencyKey;
+  try {
+    return await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/update/${encodeURIComponent(name)}`, context.headers, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  } catch (error) {
+    if (error instanceof HttpClientError && (error.status === 400 || error.status === 422))
+      return { updateId: "", error: error.message };
+    throw error;
+  }
+}
+export function getAttributesRequest(context, id) {
+  return request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/attributes`, context.headers);
+}
+export async function setAttributesRequest(context, id, attributes) {
+  await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/attributes`, context.headers, { method: "PATCH", body: JSON.stringify({ attributes }) });
+}
+export async function addTagsRequest(context, id, tags) {
+  await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/tags`, context.headers, { method: "POST", body: JSON.stringify({ tags }) });
+}
+export async function removeTagsRequest(context, id, tags) {
+  await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/tags`, context.headers, { method: "DELETE", body: JSON.stringify({ tags }) });
+}
+export async function getTimelineRequest(context, id) {
+  return await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/timeline`, context.headers) ?? [];
+}
+export function replayToRequest(context, id, step) {
+  return request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/replay/${step}`, context.headers);
+}
+export async function getUpdateResultRequest(context, updateId) {
+  const response = await request(context.baseUrl, `/updates/${encodeURIComponent(updateId)}`, context.headers);
+  if (response === null || response.status === "pending")
+    return null;
+  const out = { updateId };
+  if (response.result !== void 0)
+    out.result = response.result;
+  if (response.error !== void 0)
+    out.error = response.error;
+  return out;
+}
+export async function signalWorkflowRequest(context, id, name, payload, options) {
+  await request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/signal/${encodeURIComponent(name)}`, context.headers, {
+    method: "POST",
+    body: JSON.stringify({ payload, ...options })
+  });
+}
+export async function completeAsyncActivityRequest(context, token, result) {
+  await request(context.baseUrl, "/activities/complete", context.headers, {
+    method: "POST",
+    body: JSON.stringify({ token, result })
+  });
+}
+export async function failAsyncActivityRequest(context, token, error) {
+  const reduced = { message: error instanceof Error ? error.message : String(error) };
+  if (error instanceof Error)
+    reduced.name = error.name;
+  await request(context.baseUrl, "/activities/fail", context.headers, {
+    method: "POST",
+    body: JSON.stringify({ token, error: reduced })
+  });
+}
+export function getWorkflowRequest(context, id) {
+  return request(context.baseUrl, `/workflows/${encodeURIComponent(id)}`, context.headers);
+}
+export function getScheduleRequest(context, id) {
+  return request(context.baseUrl, `/schedules/${encodeURIComponent(id)}`, context.headers);
+}
+export function cancelWorkflowRequest(context, id) {
+  return request(context.baseUrl, `/workflows/${encodeURIComponent(id)}`, context.headers, {
+    method: "DELETE"
+  });
+}
+export function timeoutWorkflowRequest(context, id) {
+  return request(context.baseUrl, `/workflows/${encodeURIComponent(id)}/timeout`, context.headers, { method: "POST" });
+}
+export function pauseScheduleRequest(context, id) {
+  return request(context.baseUrl, `/schedules/${encodeURIComponent(id)}/pause`, context.headers, { method: "POST" });
+}
+export function resumeScheduleRequest(context, id) {
+  return request(context.baseUrl, `/schedules/${encodeURIComponent(id)}/resume`, context.headers, { method: "POST" });
+}
+export function cancelScheduleRequest(context, id) {
+  return request(context.baseUrl, `/schedules/${encodeURIComponent(id)}`, context.headers, {
+    method: "DELETE"
+  });
+}
+export function updateScheduleRequest(context, id, newSpec) {
+  return request(context.baseUrl, `/schedules/${encodeURIComponent(id)}`, context.headers, {
+    method: "PATCH",
+    body: JSON.stringify(scheduleSpecToWireFields(newSpec))
+  });
+}
+export async function queryWorkflowRequest(context, id, name, input) {
+  const path = `/workflows/${encodeURIComponent(id)}/query/${encodeURIComponent(name)}`;
+  return (await request(context.baseUrl, path, context.headers, input !== void 0 ? { method: "POST", body: JSON.stringify({ input }) } : void 0))?.result;
+}

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

@@ -0,0 +1,130 @@
+import { type CatalogOperationName, type CatalogOperationTypes, type WeftClient as CatalogOperations } from '../cli/generated/operation-client.generated.ts';
+import type { StoredStreamChunk } from '../core/context.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 WorkflowEventSubscription } from './event-stream.ts';
+import type { WorkflowEventTail } from './event-tail.ts';
+import { type HttpClientOptions } from './http-request.ts';
+import type { ClientHandle, ClientScheduleHandle, UpdateResult, WeftClient, WeftClientActivity } from './interface.ts';
+import type { KnownWorkflowName, UnknownNameWhenRegistryEmpty } from './workflow-name-typing.ts';
+/**
+ * Remote Weft client backed by HTTP requests.
+ *
+ * **Error handling**
+ *
+ * - **404 on GET → `null`:** When a GET request returns 404, the client
+ *   treats it as "resource not found" and resolves with `null` instead of
+ *   throwing `HttpClientError`.
+ * - **400/422 in `submitCoordinatedUpdate` → error envelope:** A 400 or 422
+ *   response from `submitCoordinatedUpdate` is translated into a
+ *   `CoordinatedUpdateResult` with an `error` field rather than throwing.
+ *
+ * **Connection resolution**
+ *
+ * With no `baseUrl`/`token`, the client resolves the server address and bearer
+ * token through {@link resolveConnection}: explicit options, then `WEFT_ADDR`/
+ * `WEFT_TOKEN`, then the `~/.weft/config` profile, then `http://localhost:7233`.
+ * The CLI-only run lockfile is not consulted. A caller-supplied
+ * `headers.Authorization` always takes precedence over a resolved token.
+ *
+ * @example
+ * ```ts
+ * import { HttpClient } from '@lostgradient/weft';
+ *
+ * // Explicit address and token.
+ * const client = new HttpClient({
+ *   baseUrl: 'http://localhost:3000',
+ *   headers: { Authorization: 'Bearer my-token' },
+ * });
+ * const handle = await client.start('greet', { name: 'Alice' });
+ * const result = await handle.result();
+ * void result;
+ *
+ * // Or resolve WEFT_ADDR / WEFT_TOKEN from the environment.
+ * const envClient = new HttpClient();
+ * void envClient;
+ * ```
+ */
+export declare class HttpClient implements WeftClient {
+    #private;
+    /** @internal Exposed for handle access. */
+    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;
+    /**
+     * 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']>;
+    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(id: string, name: UpdateDefinition, payload?: void, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    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[]>;
+    /**
+     * @internal Open a live event subscription over the `/watch` WebSocket
+     * channel. Shared by {@link HttpHandle} (push-based `addEventListener`) and
+     * {@link tail}. The subscription catches up from `getEvents` on every
+     * (re)connect, so it covers events emitted before it connected.
+     *
+     * `bufferForIteration` defaults off for the callback-only `addEventListener`
+     * path; {@link tail} sets it so the connect catch-up is buffered for the
+     * async iterator instead of dropped.
+     */
+    openEventSubscription(id: string, onEvent: (event: WorkflowEvent) => void, bufferForIteration?: boolean): WorkflowEventSubscription;
+    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;
+    }): Promise<StoredStreamChunk[]>;
+    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/http-client.js

@@ -0,0 +1,217 @@
+import {
+  CATALOG_OPERATION_NAMES
+} from "../cli/generated/operation-client.generated.js";
+import { createCatalogWeftClient } from "../cli/operation-client-runtime.js";
+import { messageName } from "../core/types.js";
+import {
+  addTagsRequest,
+  cancelAllWorkflowRequests,
+  cancelScheduleRequest,
+  cancelWorkflowRequest,
+  completeAsyncActivityRequest,
+  deleteAllWorkflowRequests,
+  failAsyncActivityRequest,
+  forkWorkflowRequest,
+  getAttributesRequest,
+  getRetentionOverviewRequest,
+  getScheduleRequest,
+  getStreamChunkRequests,
+  getTimelineRequest,
+  getUpdateResultRequest,
+  getWorkflowRequest,
+  listReviewRequests,
+  pauseScheduleRequest,
+  purgeWorkflowRequests,
+  queryWorkflowRequest,
+  removeTagsRequest,
+  replayToRequest,
+  resumeScheduleRequest,
+  setAttributesRequest,
+  signalAllWorkflowRequests,
+  signalWorkflowRequest,
+  submitCoordinatedUpdateRequest,
+  submitReviewRequest,
+  tagAllWorkflowRequests,
+  timeoutWorkflowRequest,
+  untagAllWorkflowRequests,
+  updateScheduleRequest
+} from "./http-client-requests.js";
+import { HttpHandle } from "./http-handle.js";
+import { httpClientCatalogTransport } 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, scheduleSpecToWireFields } from "./start-body.js";
+
+export class HttpClient {
+  baseUrl;
+  headers;
+  operations;
+  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.activity = {
+      complete: (token, result) => completeAsyncActivityRequest(this, token, result),
+      completeExceptionally: (token, error) => failAsyncActivityRequest(this, token, error)
+    };
+    this.#streamOptions = options.webSocketFactory === void 0 ? {} : { webSocketFactory: options.webSocketFactory };
+  }
+  call(name, input) {
+    return this.operations[name](input);
+  }
+  async start(type, input, options) {
+    const body = buildStartBody(type, input, options), response = await request(this.baseUrl, "/workflows", this.headers, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return new HttpHandle(response.id, this);
+  }
+  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, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return new HttpScheduleHandle(response.id, this);
+  }
+  async get(id) {
+    return getWorkflowRequest(this, id);
+  }
+  async getSchedule(id) {
+    return getScheduleRequest(this, id);
+  }
+  async list(filter) {
+    const query = buildWorkflowListSearchParams(filter).toString(), path = query ? `/workflows?${query}` : "/workflows";
+    return request(this.baseUrl, path, this.headers);
+  }
+  async listSchedules(filter) {
+    const query = buildScheduleListSearchParams(filter).toString(), path = query ? `/schedules?${query}` : "/schedules";
+    return request(this.baseUrl, path, this.headers);
+  }
+  async cancel(id) {
+    return cancelWorkflowRequest(this, id);
+  }
+  async pauseSchedule(id) {
+    return pauseScheduleRequest(this, id);
+  }
+  async resumeSchedule(id) {
+    return resumeScheduleRequest(this, id);
+  }
+  async cancelSchedule(id) {
+    return cancelScheduleRequest(this, id);
+  }
+  async updateSchedule(id, newSpec) {
+    return updateScheduleRequest(this, id, newSpec);
+  }
+  async signal(id, nameOrDefinition, payload, options) {
+    await signalWorkflowRequest(this, id, messageName(nameOrDefinition), payload, options);
+  }
+  async query(id, nameOrDefinition, input) {
+    return queryWorkflowRequest(this, id, messageName(nameOrDefinition), input);
+  }
+  async update(id, nameOrDefinition, payload, options) {
+    const name = messageName(nameOrDefinition), body = { payload };
+    if (options?.timeout !== void 0)
+      body.timeout = options.timeout;
+    return (await request(this.baseUrl, `/workflows/${encodeURIComponent(id)}/update/${encodeURIComponent(name)}`, this.headers, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }))?.result;
+  }
+  async resume(id) {
+    const response = await request(this.baseUrl, `/workflows/${encodeURIComponent(id)}/resume`, this.headers, { method: "POST" });
+    return new HttpHandle(response.id, this);
+  }
+  async recoverAll() {
+    return (await request(this.baseUrl, "/recover", this.headers, { method: "POST" })).recovered.map((id) => new HttpHandle(id, this));
+  }
+  async timeout(id) {
+    return timeoutWorkflowRequest(this, id);
+  }
+  async getAttributes(id) {
+    return getAttributesRequest(this, id);
+  }
+  async setAttributes(id, attributes) {
+    return setAttributesRequest(this, id, attributes);
+  }
+  async addTags(id, ...tags) {
+    return addTagsRequest(this, id, tags);
+  }
+  async removeTags(id, ...tags) {
+    return removeTagsRequest(this, id, tags);
+  }
+  async getEvents(id) {
+    const response = await request(this.baseUrl, `/workflows/${encodeURIComponent(id)}/events`, this.headers);
+    if (response === null)
+      return [];
+    return response.events;
+  }
+  openEventSubscription(id, onEvent, bufferForIteration = !1) {
+    return openClientEventSubscription(this, this.#streamOptions, id, onEvent, bufferForIteration);
+  }
+  tail(id) {
+    return this.openEventSubscription(id, () => {}, !0);
+  }
+  async getTimeline(id) {
+    return getTimelineRequest(this, id);
+  }
+  async replayTo(id, step) {
+    return replayToRequest(this, id, step);
+  }
+  async listReviews(filter) {
+    return listReviewRequests(this, filter);
+  }
+  async submitReview(reviewId, options) {
+    return submitReviewRequest(this, reviewId, options);
+  }
+  async getStreamChunks(workflowId, key, options) {
+    return getStreamChunkRequests(this, workflowId, key, options);
+  }
+  async fork(id, options) {
+    const workflowId = await forkWorkflowRequest(this, id, options);
+    return new HttpHandle(workflowId, this);
+  }
+  async getRetentionOverview() {
+    return getRetentionOverviewRequest(this);
+  }
+  async purge(filter) {
+    return purgeWorkflowRequests(this, filter);
+  }
+  async cancelAll(filter) {
+    return cancelAllWorkflowRequests(this, filter);
+  }
+  async signalAll(filter, name, payload) {
+    return signalAllWorkflowRequests(this, filter, name, payload);
+  }
+  async deleteAll(filter) {
+    return deleteAllWorkflowRequests(this, filter);
+  }
+  async tagAll(filter, tags) {
+    return tagAllWorkflowRequests(this, filter, tags);
+  }
+  async untagAll(filter, tags) {
+    return untagAllWorkflowRequests(this, filter, tags);
+  }
+  async submitCoordinatedUpdate(id, name, payload, options) {
+    return submitCoordinatedUpdateRequest(this, id, name, payload, options);
+  }
+  async getUpdateResult(updateId) {
+    return getUpdateResultRequest(this, updateId);
+  }
+}

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

@@ -0,0 +1,27 @@
+import type { WeftEventMap } from '../core/events.ts';
+import { WorkflowHandleDelegation } from './handle-delegation.ts';
+import type { HttpClient } from './http-client.ts';
+/**
+ * Server-mode workflow handle. Lifecycle events are delivered push-based over
+ * the server's per-workflow `/v1/workflows/:id/watch` WebSocket channel rather
+ * than by polling `getEvents()` on a timer — listeners fire the moment an event
+ * lands on the server. Each delivered event is re-dispatched as a `CustomEvent`
+ * whose `detail` is the event's `data`, matching the long-standing handle
+ * contract.
+ */
+export declare class HttpHandle extends WorkflowHandleDelegation<HttpClient> {
+    #private;
+    /**
+     * Resolves once the handle's live event subscription is connected, so a
+     * caller can attach listeners and then trigger work without missing the
+     * events emitted in the window before the socket connects. Opens the
+     * subscription if it is not already open.
+     */
+    whenConnected(): Promise<void>;
+    /** Stop the event subscription and release resources. Cannot be restarted. */
+    close(): void;
+    [Symbol.dispose](): void;
+    result(): Promise<unknown>;
+    addEventListener<K extends keyof WeftEventMap>(type: K, listener: (event: WeftEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof WeftEventMap>(type: K, listener: (event: WeftEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+}

package/dist/client/http-handle.js

@@ -0,0 +1,43 @@
+import { WorkflowHandleDelegation } from "./handle-delegation.js";
+import { HttpClientError, request } from "./http-request.js";
+
+export class HttpHandle extends WorkflowHandleDelegation {
+  #events = new EventTarget;
+  #subscription = null;
+  #closed = !1;
+  #ensureSubscribed() {
+    if (this.#closed)
+      return null;
+    if (this.#subscription === null)
+      this.#subscription = this.client.openEventSubscription(this.id, (event) => {
+        this.#events.dispatchEvent(new CustomEvent(event.type, { detail: event.data }));
+      });
+    return this.#subscription;
+  }
+  whenConnected() {
+    return this.#ensureSubscribed()?.whenConnected() ?? Promise.resolve();
+  }
+  close() {
+    this.#closed = !0;
+    if (this.#subscription !== null) {
+      this.#subscription.close();
+      this.#subscription = null;
+    }
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  async result() {
+    const response = await request(this.client.baseUrl, `/workflows/${encodeURIComponent(this.id)}/result`, this.client.headers);
+    if (response === null)
+      throw new HttpClientError(404, `Workflow "${this.id}" not found`);
+    return response.result;
+  }
+  addEventListener(type, listener, options) {
+    this.#ensureSubscribed();
+    this.#events.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener, options) {
+    this.#events.removeEventListener(type, listener, options);
+  }
+}