@lostgradient/weft 0.2.0

package/dist/server/operations/bulk-mutate-workflow-tags.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import type { BulkOperationDryRunResult, BulkTagResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const bulkMutateWorkflowTagsInput: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodObject<{
+        status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
+        type: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+            gt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+            lt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+            gte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+            lte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        }, z.core.$strip>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        idPrefix: z.ZodOptional<z.ZodString>;
+        failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>, z.ZodArray<z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>>]>>;
+        createdAt: z.ZodOptional<z.ZodObject<{
+            gte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        updatedAt: z.ZodOptional<z.ZodObject<{
+            gte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        executionDeadline: z.ZodOptional<z.ZodObject<{
+            gte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
+            lte: z.ZodOptional<z.ZodNumber>;
+            lt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tags: z.ZodArray<z.ZodString>;
+    operation: z.ZodEnum<{
+        add: "add";
+        remove: "remove";
+    }>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    confirmationToken: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BulkMutateWorkflowTagsInput = z.infer<typeof bulkMutateWorkflowTagsInput>;
+export type BulkMutateWorkflowTagsOutput = BulkTagResult | BulkOperationDryRunResult;
+export declare const bulkMutateWorkflowTagsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    tags: string[];
+    operation: "add" | "remove";
+    filter?: {
+        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;
+    } | undefined;
+    dryRun?: boolean | undefined;
+    confirmationToken?: string | undefined;
+    requestId?: string | undefined;
+}, BulkMutateWorkflowTagsOutput>;
+export declare const bulkMutateWorkflowTagsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/bulk-mutate-workflow-tags.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { BulkOperationConfirmationError } from "../../core/engine.js";
+import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  bulkListFilterInputSchema,
+  bulkOperationControlInputSchema,
+  bulkOperationOptionsFromInput,
+  bulkOperatorAccessPolicy,
+  engineFailureFault,
+  faultMessage,
+  parseBulkListFilterFromBody,
+  parseBulkOperationControlFromBody,
+  readOptionalJsonBody
+} from "./bulk-filter-helpers.js";
+import {
+  shapeBulkJsonSuccess,
+  validatedListFilterFromBulkInput
+} from "./bulk-operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const bulkMutateWorkflowTagsInput = z.object({
+  filter: bulkListFilterInputSchema.optional(),
+  tags: z.array(z.string()),
+  operation: z.enum(["add", "remove"])
+}).merge(bulkOperationControlInputSchema), bulkMutateWorkflowTagsOutput = z.unknown();
+export const bulkMutateWorkflowTagsOperation = defineOperation({
+  name: "weft.workflows.bulk.tags",
+  mcpExposable: !1,
+  summary: "Add or remove workflow tags in bulk",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkMutateWorkflowTagsInput,
+  outputSchema: bulkMutateWorkflowTagsOutput,
+  access: bulkOperatorAccessPolicy,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    const e = engine, filter = validatedListFilterFromBulkInput(input.filter ?? {});
+    let validatedTags;
+    try {
+      validatedTags = coerceStartWorkflowTags(input.tags, 'Field "tags"');
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+    const operationOptions = bulkOperationOptionsFromInput(input, principal);
+    try {
+      return await executeBulkTagMutation(e, filter, validatedTags, input.operation, operationOptions);
+    } catch (error) {
+      if (error instanceof BulkOperationConfirmationError)
+        throw invalidParamsFault(error.message);
+      throw engineFailureFault(faultMessage(error));
+    }
+  }
+});
+async function executeBulkTagMutation(engine, filter, tags, operation, options) {
+  if (options.dryRun === !0)
+    return operation === "add" ? await engine.tagAll(filter, tags, options) : await engine.untagAll(filter, tags, options);
+  return operation === "add" ? await engine.tagAll(filter, tags, options) : await engine.untagAll(filter, tags, options);
+}
+export const bulkMutateWorkflowTagsRestBinding = {
+  method: "PATCH",
+  path: "/v1/workflows/bulk/tags",
+  pathParamNames: [],
+  operationName: "weft.workflows.bulk.tags",
+  inputSources: {
+    filter: { kind: "body-field", bodyField: "filter" },
+    tags: { kind: "body-field", bodyField: "tags" },
+    operation: { kind: "body-field", bodyField: "operation" }
+  },
+  extractInput: async (request) => {
+    const raw = await readOptionalJsonBody(request);
+    if (raw === void 0 || typeof raw !== "object" || raw === null || Array.isArray(raw))
+      throw invalidParamsFault("Request body must be a JSON object");
+    const body = raw;
+    let filter;
+    try {
+      filter = { ...parseBulkListFilterFromBody(body) };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+    let tags;
+    try {
+      tags = coerceStartWorkflowTags(body.tags, 'Field "tags"');
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+    const operation = body.operation;
+    if (operation !== "add" && operation !== "remove")
+      throw invalidParamsFault('Field "operation" must be "add" or "remove"');
+    return {
+      filter,
+      tags,
+      operation,
+      ...parseBulkOperationControlFromBody(body)
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,27 @@
+import type { BulkCancelResult, BulkDeleteResult, BulkOperationDryRunResult, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../../core/types.ts';
+import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
+/**
+ * Coerces filter tags (label `Field "filter.tags"`), builds a `ListFilter`
+ * via `listFilterFromBulkInput`, and asserts the result satisfies the
+ * scoped-bulk constraints. Tag-coercion and scoped-assertion failures
+ * surface as `invalidParamsFault(faultMessage)` to match the per-file
+ * behavior across bulk delete / cancel / signal and the filter portion of
+ * bulk mutate-tags. `listFilterFromBulkInput` itself is unguarded because
+ * its only documented throw paths (malformed time-range bounds) are
+ * rejected upstream — by Zod for JSON-RPC callers and by
+ * `parseBulkListFilterFromBody` for REST callers — before this helper
+ * runs.
+ *
+ * Not used by `purge-workflows.ts`: purge allows empty/unscoped filters and
+ * shapes faults through `shapeRestFault` (sanitized) rather than passing
+ * raw engine messages through unmasked.
+ */
+export declare function validatedListFilterFromBulkInput(input: BulkListFilterInput): ListFilter;
+export type BulkOperationSuccessResult = BulkCancelResult | BulkDeleteResult | BulkSignalResult | BulkTagResult | BulkOperationDryRunResult | PurgeResult;
+/**
+ * Standard JSON 200 response shape for bulk-workflow operations. Used by
+ * every bulk operation's REST `shapeSuccess`; the result types are unioned
+ * rather than left as `unknown` so the type system catches accidental
+ * `undefined` / `Response` / `Error` arguments at the call site.
+ */
+export declare function shapeBulkJsonSuccess(result: BulkOperationSuccessResult): Response;

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

@@ -0,0 +1,29 @@
+import { assertScopedBulkWorkflowFilter } from "../../core/bulk-workflow-filter.js";
+import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
+import {
+  faultMessage,
+  listFilterFromBulkInput
+} from "./bulk-filter-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
+export function validatedListFilterFromBulkInput(input) {
+  let tags;
+  if (input.tags !== void 0)
+    try {
+      tags = coerceStartWorkflowTags(input.tags, 'Field "filter.tags"');
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+  const filter = listFilterFromBulkInput(tags === void 0 ? input : { ...input, tags });
+  try {
+    assertScopedBulkWorkflowFilter(filter);
+  } catch (error) {
+    throw invalidParamsFault(faultMessage(error));
+  }
+  return filter;
+}
+export function shapeBulkJsonSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}

package/dist/server/operations/bulk-signal-workflows.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import type { BulkOperationDryRunResult, BulkSignalResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const bulkSignalWorkflowsInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
+    type: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        gt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        lt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        gte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        lte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+    }, z.core.$strip>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    idPrefix: z.ZodOptional<z.ZodString>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>, z.ZodArray<z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>>]>>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    executionDeadline: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    name: z.ZodString;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    confirmationToken: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BulkSignalWorkflowsInput = z.infer<typeof bulkSignalWorkflowsInput>;
+export type BulkSignalWorkflowsOutput = BulkSignalResult | BulkOperationDryRunResult;
+export declare const bulkSignalWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: string;
+    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;
+    payload?: unknown;
+    dryRun?: boolean | undefined;
+    confirmationToken?: string | undefined;
+    requestId?: string | undefined;
+}, BulkSignalWorkflowsOutput>;
+export declare const bulkSignalWorkflowsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/bulk-signal-workflows.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { BulkOperationConfirmationError } from "../../core/engine.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  bulkListFilterInputSchema,
+  bulkOperationControlInputSchema,
+  bulkOperationOptionsFromInput,
+  bulkOperatorAccessPolicy,
+  engineFailureFault,
+  faultMessage,
+  parseBulkListFilterFromBody,
+  parseBulkOperationControlFromBody,
+  readOptionalJsonBody
+} from "./bulk-filter-helpers.js";
+import {
+  shapeBulkJsonSuccess,
+  validatedListFilterFromBulkInput
+} from "./bulk-operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const bulkSignalWorkflowsInput = bulkListFilterInputSchema.extend({
+  name: z.string().min(1),
+  payload: z.unknown().optional()
+}).merge(bulkOperationControlInputSchema), bulkSignalWorkflowsOutput = z.unknown();
+export const bulkSignalWorkflowsOperation = defineOperation({
+  name: "weft.workflows.bulk.signal",
+  mcpExposable: !1,
+  summary: "Signal workflows in bulk",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkSignalWorkflowsInput,
+  outputSchema: bulkSignalWorkflowsOutput,
+  access: bulkOperatorAccessPolicy,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    const e = engine, filter = validatedListFilterFromBulkInput(input), operationOptions = bulkOperationOptionsFromInput(input, principal);
+    try {
+      if (operationOptions.dryRun === !0)
+        return await e.signalAll(filter, input.name, input.payload, operationOptions);
+      return await e.signalAll(filter, input.name, input.payload, operationOptions);
+    } catch (error) {
+      if (error instanceof BulkOperationConfirmationError)
+        throw invalidParamsFault(error.message);
+      throw engineFailureFault(faultMessage(error));
+    }
+  }
+}), bulkSignalWorkflowsRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/bulk/signal",
+  pathParamNames: [],
+  operationName: "weft.workflows.bulk.signal",
+  inputSources: {
+    name: { kind: "body-field", bodyField: "name" },
+    payload: { kind: "body-field", bodyField: "payload" }
+  },
+  extractInput: async (request) => {
+    const raw = await readOptionalJsonBody(request);
+    if (raw === void 0 || typeof raw !== "object" || raw === null || Array.isArray(raw))
+      throw invalidParamsFault("Request body must be a JSON object");
+    const body = raw;
+    let filter;
+    try {
+      filter = { ...parseBulkListFilterFromBody(body) };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+    const name = body.name;
+    if (typeof name !== "string" || name.length === 0)
+      throw invalidParamsFault('Field "name" must be a non-empty string');
+    return {
+      ...filter,
+      name,
+      ...body.payload === void 0 ? {} : { payload: body.payload },
+      ...parseBulkOperationControlFromBody(body)
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const cancelScheduleInput: z.ZodObject<{
+    scheduleId: z.ZodString;
+}, z.core.$strip>;
+declare const cancelScheduleOutput: z.ZodUndefined;
+export type CancelScheduleInput = z.infer<typeof cancelScheduleInput>;
+export type CancelScheduleOutput = z.infer<typeof cancelScheduleOutput>;
+export declare const cancelScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    scheduleId: string;
+}, undefined>;
+export declare const cancelScheduleRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/cancel-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 cancelScheduleInput = z.object({
+  scheduleId: z.string().min(1)
+}), cancelScheduleOutput = z.undefined();
+export const cancelScheduleOperation = defineOperation({
+  name: "weft.schedules.cancel",
+  mcpExposable: !1,
+  summary: "Cancel a recurring schedule",
+  description: "Permanently cancel a recurring schedule by `scheduleId` so it stops launching new " + "workflows. Irreversible \u2014 recreate the schedule to resume the cadence. Already-started " + "workflows are unaffected. Faults with NotFound when no schedule with the given id exists.",
+  destructive: !0,
+  tags: ["Schedules"],
+  inputSchema: cancelScheduleInput,
+  outputSchema: cancelScheduleOutput,
+  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.cancelSchedule(input.scheduleId);
+      return;
+    } catch (error) {
+      throw mapScheduleErrorToFault(input.scheduleId, error);
+    }
+  }
+}), cancelScheduleRestBinding = {
+  method: "DELETE",
+  path: "/v1/schedules/:id",
+  pathParamNames: ["id"],
+  operationName: "weft.schedules.cancel",
+  inputSources: {
+    scheduleId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    scheduleId: pathParams.id ?? ""
+  }),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const cancelWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+declare const cancelWorkflowOutput: z.ZodUndefined;
+export type CancelWorkflowInput = z.infer<typeof cancelWorkflowInput>;
+export type CancelWorkflowOutput = z.infer<typeof cancelWorkflowOutput>;
+export declare const cancelWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, undefined>;
+export declare const cancelWorkflowRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  createSingleWorkflowControlOperation,
+  extractWorkflowIdFromPath
+} from "./single-workflow-control-operation.js";
+const cancelWorkflowInput = z.object({
+  workflowId: z.string().min(1)
+}), cancelWorkflowOutput = z.undefined();
+export const cancelWorkflowOperation = createSingleWorkflowControlOperation({
+  name: "weft.workflows.cancel",
+  summary: "Cancel a running workflow",
+  description: "Request cancellation of a running workflow by `id`. Cancellation is cooperative: the workflow observes a cancellation signal and unwinds via its own cleanup logic, so this is irreversible from the caller perspective. Faults with NotFound when the workflow is not visible.",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: cancelWorkflowInput,
+  outputSchema: cancelWorkflowOutput,
+  producibleFaults: ["NotFound"],
+  invoke: async ({ input, engine }) => {
+    await engine.cancel(input.workflowId);
+    return;
+  }
+}), cancelWorkflowRestBinding = {
+  method: "DELETE",
+  path: "/v1/workflows/:id",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.cancel",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const createScheduleInput: z.ZodObject<{
+    type: z.ZodUnknown;
+    cronExpression: z.ZodOptional<z.ZodUnknown>;
+    every: z.ZodOptional<z.ZodUnknown>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    id: z.ZodOptional<z.ZodUnknown>;
+    overlap: z.ZodOptional<z.ZodUnknown>;
+    backfill: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const createScheduleOutput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type CreateScheduleInput = z.infer<typeof createScheduleInput>;
+export type CreateScheduleOutput = z.infer<typeof createScheduleOutput>;
+export declare const createScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    type: unknown;
+    cronExpression?: unknown;
+    every?: unknown;
+    input?: unknown;
+    id?: unknown;
+    overlap?: unknown;
+    backfill?: unknown;
+}, {
+    id: string;
+}>;
+export declare const createScheduleRestBinding: UnknownRestBinding;
+export {};