@lostgradient/weft 0.2.0

package/dist/server/rest-binding.d.ts

@@ -0,0 +1,158 @@
+/**
+ * `RestBinding<Input, Output>` — the REST-facing wrapper that references
+ * a transport-neutral `OperationDefinition` by name. The binding owns
+ * all HTTP-specific concerns that don't belong on the operation:
+ * method, path, where each input field is extracted from (path /
+ * query / header / body), and how the output is shaped into an HTTP
+ * response.
+ *
+ * This module deliberately does NOT import `route-model.ts`: bindings
+ * describe operation-backed HTTP routes, while that model describes the
+ * remaining REST-only meta and discovery endpoints.
+ */
+import { WeftError } from '../core/weft-error.ts';
+import type { OperationFault } from './operation-fault.ts';
+import type { HttpMethod } from './route-model.ts';
+/**
+ * Thrown by `bindingPathMatches` when a URL path parameter contains malformed
+ * percent-encoding. The top-level handler catches it and returns a 400.
+ */
+export declare class MalformedRouteParameterError extends WeftError<'MalformedRouteParameterError'> {
+    constructor();
+}
+/**
+ * Where a single top-level field of the operation's `inputSchema`
+ * comes from in a REST request. The OpenAPI generator reads this to
+ * emit accurate path / query / header / requestBody schema pieces.
+ */
+export type ParamSource = {
+    readonly kind: 'path';
+    readonly pathParam: string;
+} | {
+    readonly kind: 'query';
+    readonly queryParam: string;
+    readonly repeating?: boolean;
+} | {
+    readonly kind: 'header';
+    readonly headerName: string;
+} | {
+    readonly kind: 'body';
+    readonly mediaType?: 'application/json' | 'application/octet-stream';
+} | {
+    readonly kind: 'body-field';
+    readonly bodyField: string;
+};
+/**
+ * How the operation's output is turned into an HTTP response.
+ *   - `json` — standard `Response.json(output, { status })`.
+ *   - `empty` — 204 No Content; output is ignored.
+ *   - `streaming` — the operation's output is an async iterable of
+ *     bytes/events; the transport adapter streams directly.
+ */
+export type ResponseShape = {
+    readonly kind: 'json';
+    readonly status: number;
+} | {
+    readonly kind: 'empty';
+    readonly status: number;
+} | {
+    readonly kind: 'streaming';
+    readonly mediaType: 'text/event-stream' | 'application/octet-stream' | 'application/x-ndjson';
+};
+/**
+ * Binds a REST mount point to an `OperationDefinition`. Generic over
+ * `Input` / `Output` so `extractInput` returns a value the operation's
+ * schema accepts, and `shapeSuccess` consumes the output without casts.
+ */
+export type RestBinding<Input, Output> = {
+    readonly method: HttpMethod;
+    /** Express-style path with `:name` placeholders (e.g., `/v1/workflows/:id`). */
+    readonly path: string;
+    /** Ordered list of path param names; must match the `:name` tokens in `path`. */
+    readonly pathParamNames: ReadonlyArray<string>;
+    /** Operation-catalog name this binding dispatches to. */
+    readonly operationName: string;
+    /**
+     * Long-lived transport specialization for structural catalog checks.
+     * Omitted bindings are ordinary unary REST request/response operations.
+     */
+    readonly transportKind?: 'unary' | 'sse' | 'websocket-subscription';
+    /**
+     * Declarative map from top-level `Input` field names to their REST
+     * source. Fields omitted from this map are not extracted from the
+     * request by the OpenAPI generator's schema emission — `extractInput`
+     * remains the authoritative runtime source. Keys are constrained to
+     * string-typed keys of `Input` so a typo becomes a compile error
+     * rather than a silent no-op at generator time.
+     */
+    readonly inputSources: Partial<Record<Extract<keyof Input, string>, ParamSource>>;
+    /**
+     * Read the REST request and produce the operation's typed `Input`.
+     * Called before `executeOperation`; the returned value is what the
+     * pipeline's schema parse step sees.
+     */
+    readonly extractInput: (request: Request, pathParams: Record<string, string>) => Promise<Input>;
+    /** Canonical response shape — OpenAPI reads this, handler may override via `shapeSuccess`. */
+    readonly success: ResponseShape;
+    /**
+     * Optional override for response construction. When absent, transport
+     * adapters default to `Response.json(output, { status: success.status })`
+     * (or `new Response(null, { status })` for `empty`). Provide this
+     * when the wire representation differs from `output` verbatim.
+     *
+     * Receives the original `Request` so REST-only response shaping —
+     * `Accept` header negotiation (json vs msgpack), redirect URL
+     * construction, etc. — can stay in the binding without leaking
+     * HTTP-specific state into the operation's `Output` type. Other
+     * transports (JSON-RPC HTTP/WS/stdio) never call `shapeSuccess`;
+     * they emit `output` directly via the canonical envelope, so the
+     * operation contract stays transport-neutral.
+     */
+    readonly shapeSuccess?: (output: Output, request: Request) => Response;
+    /**
+     * Optional override for fault → HTTP response mapping. When absent,
+     * the transport adapter falls back to `faultToHttpResponse` (the
+     * canonical `{ error: { code, message, data? } }` shape).
+     *
+     * During Milestone 1, bindings for REST operations that already exist
+     * with a different legacy error shape MUST provide this so their
+     * parity diff test passes byte-for-byte against the legacy handler.
+     * Milestone 2 drops the per-binding override and all REST endpoints
+     * move to the canonical fault shape.
+     */
+    readonly shapeFault?: (fault: OperationFault) => Response;
+};
+/**
+ * Match a binding's `:name` path pattern against a concrete URL path.
+ * Returns a map of path-param names → URL-decoded values, or `null`
+ * when the path does not match the pattern's structure.
+ *
+ * An empty segment (`/foo//bar`) is treated as a non-match: an empty
+ * path param would propagate to the engine as a confusingly-shaped
+ * "missing" identifier, and surfacing the shape error at the router
+ * (404) produces a cleaner wire response than a downstream 400.
+ */
+export declare function bindingPathMatches(pattern: string, actualPath: string): Record<string, string> | null;
+/**
+ * Runtime guard: a `RestBinding` is only dispatchable if it references
+ * a live `OperationDefinition` that declares `transports.http === true`
+ * AND the binding's `operationName` matches the operation's name. The
+ * OpenAPI generator and the REST router consult this to exclude
+ * bindings whose operation no longer mounts on HTTP.
+ *
+ * The binding and operation are typed independently here. Structural
+ * compatibility between `Input`/`Output` is not checked at the type
+ * level — that's the registry's job at registration, and enforcing it
+ * here would require the caller to thread matching generics through
+ * every call site. This runtime guard only asserts the two concrete
+ * runtime properties the router depends on: name equality and HTTP
+ * availability.
+ */
+export declare function isRestBindingCompatibleWithOperation(binding: {
+    readonly operationName: string;
+}, operation: {
+    readonly name: string;
+    readonly transports: {
+        readonly http: boolean;
+    };
+}): boolean;

package/dist/server/rest-binding.js

@@ -0,0 +1,35 @@
+import { WeftError } from "../core/weft-error.js";
+
+export class MalformedRouteParameterError extends WeftError {
+  constructor() {
+    super("MalformedRouteParameterError", "Malformed route parameter encoding");
+  }
+}
+export function bindingPathMatches(pattern, actualPath) {
+  const patternSegments = pattern.split("/"), actualSegments = actualPath.split("/");
+  if (patternSegments.length !== actualSegments.length)
+    return null;
+  const params = {};
+  for (let index = 0;index < patternSegments.length; index += 1) {
+    const patternSegment = patternSegments[index] ?? "", actualSegment = actualSegments[index] ?? "";
+    if (patternSegment.startsWith(":")) {
+      if (actualSegment.length === 0)
+        return null;
+      const name = patternSegment.slice(1);
+      try {
+        params[name] = decodeURIComponent(actualSegment);
+      } catch {
+        throw new MalformedRouteParameterError;
+      }
+    } else if (patternSegment !== actualSegment)
+      return null;
+  }
+  return params;
+}
+export function isRestBindingCompatibleWithOperation(binding, operation) {
+  if (binding.operationName !== operation.name)
+    return !1;
+  if (!operation.transports.http)
+    return !1;
+  return !0;
+}

package/dist/server/rest-bindings.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Live registry of `RestBinding` instances for operation-backed REST routes.
+ *
+ * Each entry is a REST route whose dispatch flows through the shared
+ * `executeOperation` pipeline. The router (handleRequest) checks reserved
+ * direct meta and discovery routes first; remaining requests then match
+ * these operation-backed bindings.
+ *
+ * @module server/rest-bindings
+ */
+import type { MetricsCollector } from '../observability/metrics.ts';
+import type { WorkerRegistry } from '../worker/registry.ts';
+import { type OperationRegistry } from './operation-catalog.ts';
+import type { RestBinding } from './rest-binding.ts';
+import type { TaskQueue } from './task-queue.ts';
+/**
+ * The router stores heterogeneous bindings whose `Input`/`Output` pairs
+ * all differ. `RestBinding<Input, Output>` is strictly-typed at the
+ * author boundary (so `defineOperation` + binding factories catch
+ * mistakes), but at the router level those generics are irrelevant —
+ * every binding produces a `Response` regardless of its output type.
+ *
+ * `RestBinding<any, any>` is the idiomatic way to express "a binding
+ * with SOME Input/Output pair the router doesn't care about." A stricter
+ * `unknown, unknown` form fails under `exactOptionalPropertyTypes`
+ * because `shapeSuccess: (Output) => Response` cannot be safely widened
+ * to `(unknown) => Response` (function parameters are contravariant).
+ */
+export type UnknownRestBinding = RestBinding<any, any>;
+/**
+ * Static REST bindings for all operations that do not need per-server
+ * configuration. The `weft.system.metrics` binding is excluded here
+ * because it is constructed per-server via `createGetSystemMetricsRestBinding`
+ * (to receive the metrics collector without module-level singletons).
+ * Use `createLiveRestBindings()` to get the full set for a given server.
+ */
+export declare const REST_BINDINGS: ReadonlyArray<UnknownRestBinding>;
+/**
+ * Build the full REST binding set for a server instance. Appends the
+ * `weft.system.metrics`, `weft.workers.list`, and `weft.task.queues.list`
+ * bindings. Each takes no per-server data on the binding side; the
+ * runtime dependencies (metrics collector, worker registry, task queue)
+ * are wired into the operations through {@link createLiveOperationRegistry}.
+ */
+export declare function createLiveRestBindings(): ReadonlyArray<UnknownRestBinding>;
+/**
+ * Live operation registry — populated with every operation that has a
+ * `RestBinding`, a JSON-RPC mount, or an stdio mount. Exposed via a
+ * factory so tests can spin up a fresh registry without inheriting
+ * the live one's state.
+ *
+ * Concrete `OperationDefinition<Input, Output>` values are directly
+ * assignable to `RegistrableOperation` by the variance design in
+ * `operation-catalog.ts` — no `as ErasedOperation` cast is needed.
+ */
+/**
+ * Create the live operation registry for a server instance.
+ *
+ * Live `serve()` passes `workerRegistry` and `taskQueue` so the
+ * infrastructure-observability operations (`weft.workers.list`,
+ * `weft.task.queues.list`) bind their `invoke` to real server state.
+ *
+ * Callers that build the registry for **discovery only**
+ * (`openapi.ts`, `asyncapi.ts`) omit both. The operations are still
+ * registered with full metadata so the catalog matches the live wire
+ * surface, but their `invoke` paths throw if reached — no discovery-only
+ * registry is ever used to serve real requests.
+ */
+type LiveOperationRegistryOptions = {
+    metricsCollector?: MetricsCollector;
+    workerRegistry?: WorkerRegistry;
+    taskQueue?: TaskQueue;
+    clock?: () => number;
+};
+export declare function createLiveOperationRegistry(options?: LiveOperationRegistryOptions): OperationRegistry;
+export {};

package/dist/server/rest-bindings.js

@@ -0,0 +1,376 @@
+import { createOperationRegistry } from "./operation-catalog.js";
+import {
+  addWorkflowTagsOperation,
+  addWorkflowTagsRestBinding
+} from "./operations/add-workflow-tags.js";
+import {
+  aggregateWorkflowsOperation,
+  aggregateWorkflowsRestBinding
+} from "./operations/aggregate-workflows.js";
+import {
+  completeAsyncActivityOperation,
+  completeAsyncActivityRestBinding,
+  failAsyncActivityOperation,
+  failAsyncActivityRestBinding
+} from "./operations/async-activity.js";
+import {
+  bulkCancelWorkflowsOperation,
+  bulkCancelWorkflowsRestBinding
+} from "./operations/bulk-cancel-workflows.js";
+import {
+  bulkDeleteWorkflowsOperation,
+  bulkDeleteWorkflowsRestBinding
+} from "./operations/bulk-delete-workflows.js";
+import {
+  bulkMutateWorkflowTagsOperation,
+  bulkMutateWorkflowTagsRestBinding
+} from "./operations/bulk-mutate-workflow-tags.js";
+import {
+  bulkSignalWorkflowsOperation,
+  bulkSignalWorkflowsRestBinding
+} from "./operations/bulk-signal-workflows.js";
+import {
+  cancelScheduleOperation,
+  cancelScheduleRestBinding
+} from "./operations/cancel-schedule.js";
+import {
+  cancelWorkflowOperation,
+  cancelWorkflowRestBinding
+} from "./operations/cancel-workflow.js";
+import {
+  createScheduleOperation,
+  createScheduleRestBinding
+} from "./operations/create-schedule.js";
+import { forkWorkflowOperation, forkWorkflowRestBinding } from "./operations/fork-workflow.js";
+import {
+  getCheckpointAtOperation,
+  getCheckpointAtRestBinding
+} from "./operations/get-checkpoint-at.js";
+import { getRegistryOperation, getRegistryRestBinding } from "./operations/get-registry.js";
+import {
+  getRetentionOverviewOperation,
+  getRetentionOverviewRestBinding
+} from "./operations/get-retention-overview.js";
+import { getReviewOperation, getReviewRestBinding } from "./operations/get-review.js";
+import { getScheduleOperation, getScheduleRestBinding } from "./operations/get-schedule.js";
+import {
+  getStreamChunksOperation,
+  getStreamChunksRestBinding
+} from "./operations/get-stream-chunks.js";
+import {
+  createGetSystemMetricsOperation,
+  createGetSystemMetricsRestBinding
+} from "./operations/get-system-metrics.js";
+import {
+  createGetTaskDiagnosticsOperation,
+  getTaskDiagnosticsOperation,
+  getTaskDiagnosticsRestBinding
+} from "./operations/get-task-diagnostics.js";
+import {
+  getUpdateResultOperation,
+  getUpdateResultRestBinding
+} from "./operations/get-update-result.js";
+import {
+  getWorkflowAttributesOperation,
+  getWorkflowAttributesRestBinding
+} from "./operations/get-workflow-attributes.js";
+import {
+  getWorkflowEventsOperation,
+  getWorkflowEventsRestBinding
+} from "./operations/get-workflow-events.js";
+import {
+  getWorkflowResultOperation,
+  getWorkflowResultRestBinding
+} from "./operations/get-workflow-result.js";
+import {
+  getWorkflowTimelineOperation,
+  getWorkflowTimelineRestBinding
+} from "./operations/get-workflow-timeline.js";
+import { getWorkflowOperation, getWorkflowRestBinding } from "./operations/get-workflow.js";
+import {
+  listCheckpointsOperation,
+  listCheckpointsRestBinding
+} from "./operations/list-checkpoints.js";
+import { listReviewsOperation, listReviewsRestBinding } from "./operations/list-reviews.js";
+import { listSchedulesOperation, listSchedulesRestBinding } from "./operations/list-schedules.js";
+import {
+  createListTaskQueuesOperation,
+  createListTaskQueuesRestBinding,
+  listTaskQueuesOperation
+} from "./operations/list-task-queues.js";
+import {
+  createListWorkersOperation,
+  createListWorkersRestBinding,
+  listWorkersOperation
+} from "./operations/list-workers.js";
+import { listWorkflowsOperation, listWorkflowsRestBinding } from "./operations/list-workflows.js";
+import { pauseScheduleOperation, pauseScheduleRestBinding } from "./operations/pause-schedule.js";
+import {
+  purgeWorkflowsOperation,
+  purgeWorkflowsRestBinding
+} from "./operations/purge-workflows.js";
+import {
+  queryWorkflowOperation,
+  queryWorkflowRestBinding,
+  queryWorkflowWithInputRestBinding
+} from "./operations/query-workflow.js";
+import { recoverAllOperation, recoverAllRestBinding } from "./operations/recover-all.js";
+import {
+  removeWorkflowTagsOperation,
+  removeWorkflowTagsRestBinding
+} from "./operations/remove-workflow-tags.js";
+import {
+  replayWorkflowOperation,
+  replayWorkflowRestBinding
+} from "./operations/replay-workflow.js";
+import {
+  resumeScheduleOperation,
+  resumeScheduleRestBinding
+} from "./operations/resume-schedule.js";
+import {
+  resumeWorkflowOperation,
+  resumeWorkflowRestBinding
+} from "./operations/resume-workflow.js";
+import {
+  setWorkflowAttributesOperation,
+  setWorkflowAttributesRestBinding
+} from "./operations/set-workflow-attributes.js";
+import {
+  signalWorkflowOperation,
+  signalWorkflowRestBinding
+} from "./operations/signal-workflow.js";
+import { startWorkflowOperation, startWorkflowRestBinding } from "./operations/start-workflow.js";
+import {
+  storageBatchOperation,
+  storageBatchRestBinding,
+  storageConditionalBatchOperation,
+  storageConditionalBatchRestBinding,
+  storageDeleteOperation,
+  storageDeleteRestBinding,
+  storageGetOperation,
+  storageGetRestBinding,
+  storagePutOperation,
+  storagePutRestBinding,
+  storageScanOperation,
+  storageScanRestBinding
+} from "./operations/storage.js";
+import {
+  streamWorkflowSseOperation,
+  streamWorkflowSseRestBinding
+} from "./operations/stream-workflow-sse.js";
+import {
+  submitReviewDecisionOperation,
+  submitReviewDecisionRestBinding
+} from "./operations/submit-review-decision.js";
+import {
+  timeoutWorkflowOperation,
+  timeoutWorkflowRestBinding
+} from "./operations/timeout-workflow.js";
+import {
+  updateScheduleOperation,
+  updateScheduleRestBinding
+} from "./operations/update-schedule.js";
+import {
+  updateWorkflowOperation,
+  updateWorkflowRestBinding
+} from "./operations/update-workflow.js";
+import {
+  clearDeploymentDrainOperation,
+  clearWorkerDrainOperation,
+  createClearDeploymentDrainOperation,
+  createClearDeploymentDrainRestBinding,
+  createClearWorkerDrainOperation,
+  createClearWorkerDrainRestBinding,
+  createDrainDeploymentOperation,
+  createDrainDeploymentRestBinding,
+  createDrainWorkerOperation,
+  createDrainWorkerRestBinding,
+  drainDeploymentOperation,
+  drainWorkerOperation
+} from "./operations/worker-drain.js";
+import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
+export const REST_BINDINGS = [
+  startWorkflowRestBinding,
+  recoverAllRestBinding,
+  listWorkflowsRestBinding,
+  aggregateWorkflowsRestBinding,
+  purgeWorkflowsRestBinding,
+  bulkCancelWorkflowsRestBinding,
+  bulkSignalWorkflowsRestBinding,
+  bulkDeleteWorkflowsRestBinding,
+  bulkMutateWorkflowTagsRestBinding,
+  getWorkflowRestBinding,
+  cancelWorkflowRestBinding,
+  getWorkflowResultRestBinding,
+  getWorkflowAttributesRestBinding,
+  getWorkflowEventsRestBinding,
+  setWorkflowAttributesRestBinding,
+  signalWorkflowRestBinding,
+  completeAsyncActivityRestBinding,
+  failAsyncActivityRestBinding,
+  queryWorkflowRestBinding,
+  queryWorkflowWithInputRestBinding,
+  resumeWorkflowRestBinding,
+  forkWorkflowRestBinding,
+  timeoutWorkflowRestBinding,
+  updateWorkflowRestBinding,
+  createScheduleRestBinding,
+  updateScheduleRestBinding,
+  getRegistryRestBinding,
+  getRetentionOverviewRestBinding,
+  getUpdateResultRestBinding,
+  listReviewsRestBinding,
+  getReviewRestBinding,
+  listCheckpointsRestBinding,
+  getCheckpointAtRestBinding,
+  getWorkflowTimelineRestBinding,
+  addWorkflowTagsRestBinding,
+  removeWorkflowTagsRestBinding,
+  submitReviewDecisionRestBinding,
+  cancelScheduleRestBinding,
+  pauseScheduleRestBinding,
+  resumeScheduleRestBinding,
+  getStreamChunksRestBinding,
+  streamWorkflowSseRestBinding,
+  getTaskDiagnosticsRestBinding,
+  listSchedulesRestBinding,
+  getScheduleRestBinding,
+  replayWorkflowRestBinding,
+  storageGetRestBinding,
+  storagePutRestBinding,
+  storageDeleteRestBinding,
+  storageScanRestBinding,
+  storageBatchRestBinding,
+  storageConditionalBatchRestBinding
+];
+export function createLiveRestBindings() {
+  return [
+    ...REST_BINDINGS,
+    createGetSystemMetricsRestBinding(),
+    createListWorkersRestBinding(),
+    createDrainWorkerRestBinding(),
+    createClearWorkerDrainRestBinding(),
+    createDrainDeploymentRestBinding(),
+    createClearDeploymentDrainRestBinding(),
+    createListTaskQueuesRestBinding()
+  ];
+}
+function buildSystemMetricsOperation(options) {
+  return createGetSystemMetricsOperation({ metricsCollector: options.metricsCollector });
+}
+function buildListWorkersOperationForRegistry(options) {
+  if (options.workerRegistry === void 0)
+    return listWorkersOperation;
+  return createListWorkersOperation({
+    workerRegistry: options.workerRegistry,
+    ...options.clock !== void 0 ? { clock: options.clock } : {}
+  });
+}
+function buildDrainWorkerOperationForRegistry(options) {
+  if (options.workerRegistry === void 0)
+    return drainWorkerOperation;
+  return createDrainWorkerOperation({
+    workerRegistry: options.workerRegistry,
+    ...options.clock !== void 0 ? { clock: options.clock } : {}
+  });
+}
+function buildClearWorkerDrainOperationForRegistry(options) {
+  if (options.workerRegistry === void 0)
+    return clearWorkerDrainOperation;
+  return createClearWorkerDrainOperation({ workerRegistry: options.workerRegistry });
+}
+function buildDrainDeploymentOperationForRegistry(options) {
+  if (options.workerRegistry === void 0)
+    return drainDeploymentOperation;
+  return createDrainDeploymentOperation({
+    workerRegistry: options.workerRegistry,
+    ...options.clock !== void 0 ? { clock: options.clock } : {}
+  });
+}
+function buildClearDeploymentDrainOperationForRegistry(options) {
+  if (options.workerRegistry === void 0)
+    return clearDeploymentDrainOperation;
+  return createClearDeploymentDrainOperation({ workerRegistry: options.workerRegistry });
+}
+function buildListTaskQueuesOperationForRegistry(options) {
+  if (options.workerRegistry === void 0 || options.taskQueue === void 0)
+    return listTaskQueuesOperation;
+  return createListTaskQueuesOperation({
+    workerRegistry: options.workerRegistry,
+    taskQueue: options.taskQueue,
+    ...options.clock !== void 0 ? { clock: options.clock } : {}
+  });
+}
+function buildTaskDiagnosticsOperationForRegistry(options) {
+  if (options.workerRegistry === void 0 || options.taskQueue === void 0)
+    return getTaskDiagnosticsOperation;
+  return createGetTaskDiagnosticsOperation({
+    registry: options.workerRegistry,
+    taskQueue: options.taskQueue,
+    ...options.clock !== void 0 ? { now: options.clock } : {}
+  });
+}
+export function createLiveOperationRegistry(options) {
+  const resolved = options ?? {};
+  return createOperationRegistry([
+    startWorkflowOperation,
+    recoverAllOperation,
+    listWorkflowsOperation,
+    aggregateWorkflowsOperation,
+    purgeWorkflowsOperation,
+    bulkCancelWorkflowsOperation,
+    bulkSignalWorkflowsOperation,
+    bulkDeleteWorkflowsOperation,
+    bulkMutateWorkflowTagsOperation,
+    getWorkflowOperation,
+    cancelWorkflowOperation,
+    getWorkflowResultOperation,
+    getWorkflowAttributesOperation,
+    getWorkflowEventsOperation,
+    setWorkflowAttributesOperation,
+    signalWorkflowOperation,
+    completeAsyncActivityOperation,
+    failAsyncActivityOperation,
+    queryWorkflowOperation,
+    resumeWorkflowOperation,
+    forkWorkflowOperation,
+    timeoutWorkflowOperation,
+    updateWorkflowOperation,
+    createScheduleOperation,
+    updateScheduleOperation,
+    getRegistryOperation,
+    getRetentionOverviewOperation,
+    getUpdateResultOperation,
+    listReviewsOperation,
+    getReviewOperation,
+    listCheckpointsOperation,
+    getCheckpointAtOperation,
+    getWorkflowTimelineOperation,
+    addWorkflowTagsOperation,
+    removeWorkflowTagsOperation,
+    submitReviewDecisionOperation,
+    cancelScheduleOperation,
+    pauseScheduleOperation,
+    resumeScheduleOperation,
+    getStreamChunksOperation,
+    streamWorkflowSseOperation,
+    workflowEventsSubscriptionOperation,
+    buildTaskDiagnosticsOperationForRegistry(resolved),
+    listSchedulesOperation,
+    getScheduleOperation,
+    replayWorkflowOperation,
+    storageGetOperation,
+    storagePutOperation,
+    storageDeleteOperation,
+    storageScanOperation,
+    storageBatchOperation,
+    storageConditionalBatchOperation,
+    buildSystemMetricsOperation(resolved),
+    buildListWorkersOperationForRegistry(resolved),
+    buildDrainWorkerOperationForRegistry(resolved),
+    buildClearWorkerDrainOperationForRegistry(resolved),
+    buildDrainDeploymentOperationForRegistry(resolved),
+    buildClearDeploymentDrainOperationForRegistry(resolved),
+    buildListTaskQueuesOperationForRegistry(resolved)
+  ]);
+}