@lostgradient/weft 0.2.0

package/dist/server/operations/list-workflows.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { WorkflowListScanCapExceededError } from "../../core/engine/workflow-indexes.js";
+import {
+  ListFilterValidationError,
+  normalizeListFilter
+} from "../../core/list-filter-validation.js";
+import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
+import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+const workflowStatusSchema = z.custom((value) => typeof value === "string"), failureCategorySchema = z.custom((value) => typeof value === "string"), searchAttributeValueSchema = z.custom((value) => {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return !0;
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}), attributeFilterSchema = z.object({
+  key: z.string().min(1),
+  value: searchAttributeValueSchema.optional(),
+  gt: searchAttributeValueSchema.optional(),
+  lt: searchAttributeValueSchema.optional(),
+  gte: searchAttributeValueSchema.optional(),
+  lte: searchAttributeValueSchema.optional()
+}), timeRangeSchema = z.object({
+  gte: z.number().optional(),
+  gt: z.number().optional(),
+  lte: z.number().optional(),
+  lt: z.number().optional()
+}), listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
+  status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
+  type: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  attributes: z.array(attributeFilterSchema).optional(),
+  limit: z.number().int().min(1).max(1000).optional(),
+  offset: z.number().int().min(0).optional(),
+  idPrefix: z.string().optional(),
+  createdAt: timeRangeSchema.optional(),
+  updatedAt: timeRangeSchema.optional(),
+  executionDeadline: timeRangeSchema.optional(),
+  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema)]).optional(),
+  include: listIncludeSchema.optional()
+}), listWorkflowsOutput = z.unknown();
+export const listWorkflowsOperation = defineOperation({
+  name: "weft.workflows.list",
+  mcpExposable: !1,
+  summary: "List workflows",
+  description: "List workflows visible to the caller, optionally filtered by status, type, tags, id prefix, failure category, and time range, with pagination via `limit`/`offset`. Read-only. Returns the matching workflow summaries in the engine default ordering.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: listWorkflowsInput,
+  outputSchema: listWorkflowsOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Unprocessable"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, { include, ...filterInput } = input;
+    let validatedTags;
+    if (filterInput.tags !== void 0)
+      try {
+        validatedTags = coerceStartWorkflowTags(filterInput.tags, "tags");
+      } catch (error) {
+        throw toUnprocessable(error);
+      }
+    let filter;
+    try {
+      filter = normalizeListFilter({
+        ...filterInput,
+        ...validatedTags !== void 0 ? { tags: validatedTags } : {}
+      });
+    } catch (error) {
+      if (error instanceof ListFilterValidationError)
+        throw toUnprocessable(error);
+      throw error;
+    }
+    try {
+      const includeFailureCategory = Array.isArray(include) ? include.includes("failureCategory") : include === "failureCategory";
+      return await e.list(filter, includeFailureCategory ? { includeFailureCategory: !0 } : void 0);
+    } catch (error) {
+      if (error instanceof WorkflowListScanCapExceededError)
+        throw toUnprocessable(error);
+      throw error;
+    }
+  }
+});
+function toUnprocessable(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return { code: "Unprocessable", message, data: { reason: message } };
+}
+function extractListWorkflowsInput(request) {
+  const url = new URL(request.url), filter = extractListFilterFromQuery(url), limit = url.searchParams.get("limit");
+  if (limit !== null) {
+    const parsed = Number(limit);
+    if (Number.isFinite(parsed) && parsed >= 1)
+      filter.limit = Math.min(Math.floor(parsed), 1000);
+  }
+  const offset = url.searchParams.get("offset");
+  if (offset !== null) {
+    const parsed = Number(offset);
+    if (Number.isFinite(parsed) && parsed >= 0)
+      filter.offset = Math.floor(parsed);
+  }
+  const includes = url.searchParams.getAll("include");
+  if (includes.length === 1)
+    filter.include = includes[0];
+  else if (includes.length > 1)
+    filter.include = includes;
+  return filter;
+}
+function shapeListWorkflowsSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeListWorkflowsFault(fault) {
+  if (fault.code === "Unprocessable")
+    return jsonErrorResponse(fault.message, 400);
+  return shapeRestFault(fault);
+}
+export const listWorkflowsRestBinding = {
+  method: "GET",
+  path: "/v1/workflows",
+  pathParamNames: [],
+  operationName: "weft.workflows.list",
+  inputSources: {
+    status: { kind: "query", queryParam: "status", repeating: !0 },
+    type: { kind: "query", queryParam: "type" },
+    tags: { kind: "query", queryParam: "tag", repeating: !0 },
+    limit: { kind: "query", queryParam: "limit" },
+    offset: { kind: "query", queryParam: "offset" },
+    include: { kind: "query", queryParam: "include", repeating: !0 }
+  },
+  extractInput: async (request) => extractListWorkflowsInput(request),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeListWorkflowsSuccess(output),
+  shapeFault: shapeListWorkflowsFault
+};

package/dist/server/operations/operation-helpers.d.ts

@@ -0,0 +1,21 @@
+import { type OperationFault } from '../operation-fault.ts';
+/** Type guard distinguishing an `OperationFault` from a value type. */
+export declare function isOperationFault(value: unknown): value is OperationFault;
+/**
+ * Build a JSON error response with the flat shape `{ error: <message> }` and
+ * `Content-Type: application/json`. Used by per-operation `shapeFault`
+ * implementations that need ad-hoc status codes outside the canonical map.
+ */
+export declare function jsonErrorResponse(message: string, status: number): Response;
+/**
+ * Construct an `InvalidParams` fault with the `{ issues: [] }` data
+ * shape. This is the canonical 400-class fault for caller-input validation
+ * errors raised inside `invoke()` or `extractInput()`.
+ */
+export declare function invalidParamsFault(message: string): OperationFault;
+/**
+ * Default REST fault shaper: masks `EngineFailure` to a generic
+ * `"Internal server error"` 500; other faults map by `FAULT_CODE_TO_HTTP_STATUS`.
+ * REST-only — JSON-RPC transports receive unmasked faults.
+ */
+export declare function shapeRestFault(fault: OperationFault): Response;

package/dist/server/operations/operation-helpers.js

@@ -0,0 +1,22 @@
+import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
+export function isOperationFault(value) {
+  return typeof value === "object" && value !== null && "code" in value && "message" in value && "data" in value;
+}
+export function jsonErrorResponse(message, status) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export function invalidParamsFault(message) {
+  return {
+    code: "InvalidParams",
+    message,
+    data: { issues: [] }
+  };
+}
+export function shapeRestFault(fault) {
+  if (fault.code === "EngineFailure")
+    return jsonErrorResponse("Internal server error", 500);
+  return jsonErrorResponse(fault.message, FAULT_CODE_TO_HTTP_STATUS[fault.code]);
+}

package/dist/server/operations/pause-schedule.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const pauseScheduleInput: z.ZodObject<{
+    scheduleId: z.ZodString;
+}, z.core.$strip>;
+declare const pauseScheduleOutput: z.ZodUndefined;
+export type PauseScheduleInput = z.infer<typeof pauseScheduleInput>;
+export type PauseScheduleOutput = z.infer<typeof pauseScheduleOutput>;
+export declare const pauseScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    scheduleId: string;
+}, undefined>;
+export declare const pauseScheduleRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/pause-schedule.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+import { mapScheduleErrorToFault } from "./schedule-faults.js";
+const pauseScheduleInput = z.object({
+  scheduleId: z.string().min(1)
+}), pauseScheduleOutput = z.undefined();
+export const pauseScheduleOperation = defineOperation({
+  name: "weft.schedules.pause",
+  mcpExposable: !1,
+  summary: "Pause a recurring schedule",
+  description: "Pause a recurring schedule by `scheduleId` so it stops launching new workflows while retaining its definition. Reversible via resume. Faults with NotFound when no schedule with the given id exists.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: pauseScheduleInput,
+  outputSchema: pauseScheduleOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound", "Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine;
+    try {
+      await typedEngine.pauseSchedule(input.scheduleId);
+      return;
+    } catch (error) {
+      throw mapScheduleErrorToFault(input.scheduleId, error);
+    }
+  }
+}), pauseScheduleRestBinding = {
+  method: "POST",
+  path: "/v1/schedules/:id/pause",
+  pathParamNames: ["id"],
+  operationName: "weft.schedules.pause",
+  inputSources: {
+    scheduleId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    scheduleId: pathParams.id ?? ""
+  }),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/purge-workflows.d.ts

@@ -0,0 +1,41 @@
+import type { PurgeResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
+export type PurgeWorkflowsInput = BulkListFilterInput;
+export type PurgeWorkflowsOutput = PurgeResult;
+export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
+    type?: string | undefined;
+    tags?: string[] | undefined;
+    attributes?: {
+        key: string;
+        value?: import("../../index.ts").SearchAttributeValue | undefined;
+        gt?: import("../../index.ts").SearchAttributeValue | undefined;
+        lt?: import("../../index.ts").SearchAttributeValue | undefined;
+        gte?: import("../../index.ts").SearchAttributeValue | undefined;
+        lte?: import("../../index.ts").SearchAttributeValue | undefined;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    idPrefix?: string | undefined;
+    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
+    createdAt?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    updatedAt?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    executionDeadline?: {
+        gte?: number | undefined;
+        gt?: number | undefined;
+        lte?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+}, PurgeResult>;
+export declare const purgeWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/purge-workflows.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  bulkListFilterInputSchema,
+  faultMessage,
+  listFilterFromBulkInput,
+  parseBulkListFilterFromBody,
+  readOptionalJsonBody
+} from "./bulk-filter-helpers.js";
+import { shapeBulkJsonSuccess } from "./bulk-operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const purgeWorkflowsOutput = z.unknown();
+export const purgeWorkflowsOperation = defineOperation({
+  name: "weft.workflows.purge",
+  mcpExposable: !1,
+  summary: "Purge terminal workflows",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkListFilterInputSchema,
+  outputSchema: purgeWorkflowsOutput,
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    let validatedTags;
+    if (input.tags !== void 0)
+      try {
+        validatedTags = coerceStartWorkflowTags(input.tags, 'Field "filter.tags"');
+      } catch (error) {
+        throw invalidParamsFault(faultMessage(error));
+      }
+    const filter = listFilterFromBulkInput({
+      ...input,
+      ...validatedTags === void 0 ? {} : { tags: validatedTags }
+    });
+    return await e.purge(Object.keys(filter).length === 0 ? void 0 : filter);
+  }
+}), purgeWorkflowsRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/purge",
+  pathParamNames: [],
+  operationName: "weft.workflows.purge",
+  inputSources: {},
+  extractInput: async (request) => {
+    const raw = await readOptionalJsonBody(request);
+    try {
+      return { ...parseBulkListFilterFromBody(raw) };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/query-workflow.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const queryWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    queryName: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type QueryWorkflowInput = z.infer<typeof queryWorkflowInput>;
+export type QueryWorkflowOutput = {
+    result: unknown;
+};
+export declare const queryWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    queryName: string;
+    input?: unknown;
+}, QueryWorkflowOutput>;
+export declare const queryWorkflowRestBinding: UnknownRestBinding;
+export declare const queryWorkflowWithInputRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/query-workflow.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const queryWorkflowInput = z.object({
+  workflowId: z.string().min(1),
+  queryName: z.string().min(1),
+  input: z.unknown().optional()
+}), queryWorkflowOutput = z.unknown();
+export const queryWorkflowOperation = defineOperation({
+  name: "weft.workflows.query",
+  mcpExposable: !1,
+  summary: "Query workflow state by id",
+  description: "Run a named read-only query handler against a workflow and return its result. Requires the workflow `id` and the query `name`; `input` is optional. Queries do not mutate workflow state. Faults with NotFound when the workflow is not visible.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: queryWorkflowInput,
+  outputSchema: queryWorkflowOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotImplemented"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    try {
+      return { result: await e.query(input.workflowId, input.queryName, input.input) ?? null };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not supported"))
+        throw {
+          code: "NotImplemented",
+          message,
+          data: {}
+        };
+      throw {
+        code: "EngineFailure",
+        message,
+        data: {}
+      };
+    }
+  }
+});
+function shapeQueryWorkflowSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const queryWorkflowRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/query/:name",
+  pathParamNames: ["id", "name"],
+  operationName: "weft.workflows.query",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    queryName: { kind: "path", pathParam: "name" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    workflowId: pathParams.id ?? "",
+    queryName: pathParams.name ?? ""
+  }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeQueryWorkflowSuccess(output),
+  shapeFault: shapeRestFault
+}, queryWorkflowWithInputRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/query/:name",
+  pathParamNames: ["id", "name"],
+  operationName: "weft.workflows.query",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    queryName: { kind: "path", pathParam: "name" },
+    input: { kind: "body-field", bodyField: "input" }
+  },
+  extractInput: async (request, pathParams) => {
+    const rawBody = await request.text();
+    if (rawBody.trim().length === 0)
+      return {
+        workflowId: pathParams.id ?? "",
+        queryName: pathParams.name ?? "",
+        input: void 0
+      };
+    let body;
+    try {
+      body = JSON.parse(rawBody);
+    } catch {
+      throw invalidParamsFault("Invalid JSON body");
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+      throw invalidParamsFault("Request body must be a JSON object");
+    return {
+      workflowId: pathParams.id ?? "",
+      queryName: pathParams.name ?? "",
+      input: body.input
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeQueryWorkflowSuccess(output),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/recover-all.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const recoverAllInput: z.ZodObject<{}, z.core.$strip>;
+declare const recoverAllOutput: z.ZodObject<{
+    recovered: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RecoverAllInput = z.infer<typeof recoverAllInput>;
+export type RecoverAllOutput = z.infer<typeof recoverAllOutput>;
+export declare const recoverAllOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, {
+    recovered: string[];
+}>;
+export declare const recoverAllRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/recover-all.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { WorkflowTypeNotRegisteredForRecoveryError } from "../../core/engine.js";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const recoverAllInput = z.object({}), recoverAllOutput = z.object({
+  recovered: z.array(z.string())
+});
+export const recoverAllOperation = defineOperation({
+  name: "weft.recover.all",
+  mcpExposable: !1,
+  summary: "Recover all interrupted workflows",
+  destructive: !0,
+  tags: ["System"],
+  inputSchema: recoverAllInput,
+  outputSchema: recoverAllOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => {
+    const typedEngine = engine;
+    try {
+      return { recovered: (await typedEngine.recoverAll()).map((handle) => handle.id) };
+    } catch (error) {
+      if (error instanceof WorkflowTypeNotRegisteredForRecoveryError)
+        throw {
+          code: "Conflict",
+          message: error.message,
+          data: {
+            reason: error.message,
+            missingTypes: error.missingTypes,
+            missingWorkflowCount: error.missingWorkflowCount,
+            samplesTruncated: error.samplesTruncated
+          }
+        };
+      throw {
+        code: "EngineFailure",
+        message: error instanceof Error ? error.message : String(error),
+        data: {}
+      };
+    }
+  }
+}), recoverAllRestBinding = {
+  method: "POST",
+  path: "/v1/recover",
+  pathParamNames: [],
+  operationName: "weft.recover.all",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeRecoverAllFault
+};
+function shapeRecoverAllFault(fault) {
+  if (fault.code !== "Conflict" || fault.data.missingTypes === void 0)
+    return shapeRestFault(fault);
+  return new Response(JSON.stringify({
+    error: "workflow_type_not_registered_for_recovery",
+    missingTypes: fault.data.missingTypes,
+    missingWorkflowCount: fault.data.missingWorkflowCount,
+    samplesTruncated: fault.data.samplesTruncated
+  }), {
+    status: 409,
+    headers: { "Content-Type": "application/json" }
+  });
+}

package/dist/server/operations/remove-workflow-tags.d.ts

@@ -0,0 +1,15 @@
+import { type SingleWorkflowTagMutationInput, type SingleWorkflowTagMutationOutput } from './single-workflow-tag-mutation.ts';
+export type RemoveWorkflowTagsInput = SingleWorkflowTagMutationInput;
+export type RemoveWorkflowTagsOutput = SingleWorkflowTagMutationOutput;
+export declare const removeWorkflowTagsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    tags?: unknown;
+}, {
+    ok: true;
+}>;
+export declare const removeWorkflowTagsRestBinding: import("../rest-binding.ts").RestBinding<{
+    workflowId: string;
+    tags?: unknown;
+}, {
+    ok: true;
+}>;

package/dist/server/operations/remove-workflow-tags.js

@@ -0,0 +1,13 @@
+import {
+  createSingleWorkflowTagMutationOperation,
+  createSingleWorkflowTagMutationRestBinding
+} from "./single-workflow-tag-mutation.js";
+export const removeWorkflowTagsOperation = createSingleWorkflowTagMutationOperation({
+  name: "weft.workflows.tags.remove",
+  summary: "Remove workflow tags",
+  destructive: !1,
+  mutateTags: (engine, workflowId, tags) => engine.removeTags(workflowId, ...tags)
+}), removeWorkflowTagsRestBinding = createSingleWorkflowTagMutationRestBinding({
+  method: "DELETE",
+  operationName: removeWorkflowTagsOperation.name
+});

package/dist/server/operations/replay-workflow.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `weft.workflows.replay` operation + REST binding.
+ *
+ * Reconstructs historical workflow state at a checkpoint step. This is a
+ * side-effecting read (it does not mutate the live workflow), so it is
+ * declared `authenticated` with a scope requirement to prevent anonymous
+ * access to sensitive historical state.
+ *
+ * REST response: content-negotiated JSON or msgpack, 404 for missing
+ * workflow or step.
+ *
+ * @module server/operations/replay-workflow
+ */
+import { z } from 'zod';
+import type { WorkflowReplay } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const replayWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    step: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+export type ReplayWorkflowInput = z.infer<typeof replayWorkflowInput>;
+export type ReplayWorkflowOutput = WorkflowReplay;
+export declare const replayWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    step: string | number;
+}, WorkflowReplay>;
+export declare const replayWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/replay-workflow.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { negotiatedResponse } from "../handler/response-helpers.js";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const replayWorkflowInput = z.object({
+  workflowId: z.string().min(1),
+  step: z.union([z.string(), z.number()])
+}), replayWorkflowOutput = z.unknown();
+export const replayWorkflowOperation = defineOperation({
+  name: "weft.workflows.replay",
+  mcpExposable: !1,
+  summary: "Replay a workflow to a historical checkpoint step",
+  description: "Reconstruct the historical state of a workflow at a given checkpoint step and return a " + "replay view. This is a read-only reconstruction via the engine replay machinery \u2014 the " + "live workflow is never mutated or rewound. Faults with NotFound when the workflow or checkpoint step is not visible.",
+  destructive: !1,
+  tags: ["Checkpoints"],
+  inputSchema: replayWorkflowInput,
+  outputSchema: replayWorkflowOutput,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["workflows:read"] }
+  },
+  producibleFaults: ["NotFound", "Conflict"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    if (await e.get(input.workflowId) === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    const stepNumber = Number(input.step);
+    if (!Number.isSafeInteger(stepNumber) || stepNumber < 0)
+      throw invalidParamsFault(`Invalid step: ${String(input.step)}`);
+    const replay = await e.replayTo(input.workflowId, stepNumber);
+    if (replay === null)
+      throw {
+        code: "NotFound",
+        message: `Replay not found at step ${stepNumber} for workflow ${input.workflowId}`,
+        data: { resource: "replay", identifier: `${input.workflowId}@${stepNumber}` }
+      };
+    return replay;
+  }
+});
+function shapeReplayWorkflowFault(fault) {
+  return shapeRestFault(fault);
+}
+function shapeReplayWorkflowSuccess(output, request) {
+  return negotiatedResponse(request, output, 200);
+}
+export const replayWorkflowRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/replay/:step",
+  pathParamNames: ["id", "step"],
+  operationName: "weft.workflows.replay",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    step: { kind: "path", pathParam: "step" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    workflowId: pathParams.id ?? "",
+    step: pathParams.step ?? "0"
+  }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output, request) => shapeReplayWorkflowSuccess(output, request),
+  shapeFault: shapeReplayWorkflowFault
+};