@lostgradient/weft 0.2.0

package/dist/server/operations/async-activity.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { AsyncActivityTokenNotFoundError } from "../../core/engine.js";
+import { PayloadSizeExceededError } from "../../core/payload-size.js";
+import { raiseFault } from "../operation-catalog.js";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const asyncActivityAccess = { kind: "public" }, httpAndJsonRpcTransports = {
+  http: !0,
+  jsonRpcHttp: !0,
+  jsonRpcStdio: !0,
+  jsonRpcWebSocket: !0
+}, completeAsyncActivityInput = z.object({
+  token: z.string().min(1),
+  result: z.unknown().optional()
+}), failAsyncActivityInput = z.object({
+  token: z.string().min(1),
+  error: z.object({
+    message: z.string(),
+    name: z.string().optional()
+  })
+}), okOutput = z.object({ ok: z.literal(!0) });
+function errorFromFailInput(input) {
+  const error = Error(input.error.message);
+  if (input.error.name !== void 0)
+    error.name = input.error.name;
+  return error;
+}
+function raiseAsyncActivityFault(operation, token, error) {
+  if (error instanceof AsyncActivityTokenNotFoundError)
+    raiseFault(operation, {
+      code: "NotFound",
+      message: error.message,
+      data: { resource: "async-activity", identifier: token }
+    });
+  if (error instanceof PayloadSizeExceededError)
+    raiseFault(operation, invalidParamsFault(error.message));
+  throw error;
+}
+export const completeAsyncActivityOperation = defineOperation({
+  name: "weft.activities.complete",
+  mcpExposable: !1,
+  summary: "Complete a deferred activity by task token",
+  description: 'Resolve an out-of-band ("async") activity with a result, resuming its parked workflow as though the activity had returned that result inline. Requires the durable task token announced through the `activity:async-pending` event. Faults with NotFound when the token is unknown or already completed/failed (tokens are single-use), and InvalidParams when the result exceeds the payload size limit.',
+  destructive: !0,
+  tags: ["Activities"],
+  inputSchema: completeAsyncActivityInput,
+  outputSchema: okOutput,
+  access: asyncActivityAccess,
+  producibleFaults: ["NotFound", "InvalidParams"],
+  transports: httpAndJsonRpcTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const liveEngine = engine;
+    try {
+      await liveEngine.completeAsyncActivity(input.token, input.result);
+    } catch (error) {
+      raiseAsyncActivityFault(completeAsyncActivityOperation, input.token, error);
+    }
+    return { ok: !0 };
+  }
+}), failAsyncActivityOperation = defineOperation({
+  name: "weft.activities.fail",
+  mcpExposable: !1,
+  summary: "Fail a deferred activity by task token",
+  description: 'Fail an out-of-band ("async") activity, throwing the supplied error into its ' + "parked workflow at the deferred step \u2014 identical to an inline activity that threw, " + "so the workflow\u2019s own try/catch and retry policy apply unchanged. Requires the " + "durable task token from the `activity:async-pending` event. Faults with NotFound when the token is unknown or already completed/failed (tokens are single-use), and InvalidParams when the failure message exceeds the payload size limit.",
+  destructive: !0,
+  tags: ["Activities"],
+  inputSchema: failAsyncActivityInput,
+  outputSchema: okOutput,
+  access: asyncActivityAccess,
+  producibleFaults: ["NotFound", "InvalidParams"],
+  transports: httpAndJsonRpcTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const liveEngine = engine;
+    try {
+      await liveEngine.failAsyncActivity(input.token, errorFromFailInput(input));
+    } catch (error) {
+      raiseAsyncActivityFault(failAsyncActivityOperation, input.token, error);
+    }
+    return { ok: !0 };
+  }
+});
+function shapeAsyncActivitySuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function readJsonObjectBody(request) {
+  const body = await request.json().catch(() => null);
+  if (typeof body !== "object" || body === null || Array.isArray(body))
+    throw invalidParamsFault("Request body must be a JSON object.");
+  return body;
+}
+export const completeAsyncActivityRestBinding = {
+  method: "POST",
+  path: "/v1/activities/complete",
+  pathParamNames: [],
+  operationName: "weft.activities.complete",
+  inputSources: {
+    token: { kind: "body-field", bodyField: "token" },
+    result: { kind: "body-field", bodyField: "result" }
+  },
+  extractInput: async (request) => {
+    const body = await readJsonObjectBody(request);
+    return {
+      token: body.token,
+      ..."result" in body ? { result: body.result } : {}
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeAsyncActivitySuccess(output),
+  shapeFault: shapeRestFault
+}, failAsyncActivityRestBinding = {
+  method: "POST",
+  path: "/v1/activities/fail",
+  pathParamNames: [],
+  operationName: "weft.activities.fail",
+  inputSources: {
+    token: { kind: "body-field", bodyField: "token" },
+    error: { kind: "body-field", bodyField: "error" }
+  },
+  extractInput: async (request) => {
+    const body = await readJsonObjectBody(request);
+    return {
+      token: body.token,
+      error: body.error
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeAsyncActivitySuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,7 @@
+import type { BulkCancelResult, BulkOperationDryRunResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import { type BulkListFilterInput, type BulkOperationControlInput } from './bulk-filter-helpers.ts';
+export type BulkCancelWorkflowsInput = BulkListFilterInput & BulkOperationControlInput;
+export type BulkCancelWorkflowsOutput = BulkCancelResult | BulkOperationDryRunResult;
+export declare const bulkCancelWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkCancelWorkflowsInput, BulkCancelWorkflowsOutput>;
+export declare const bulkCancelWorkflowsRestBinding: UnknownRestBinding;

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

@@ -0,0 +1,64 @@
+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 bulkCancelWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkCancelWorkflowsOutput = z.unknown();
+export const bulkCancelWorkflowsOperation = defineOperation({
+  name: "weft.workflows.bulk.cancel",
+  mcpExposable: !1,
+  summary: "Cancel workflows in bulk",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkCancelWorkflowsInput,
+  outputSchema: bulkCancelWorkflowsOutput,
+  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.cancelAll(filter, operationOptions);
+      return await e.cancelAll(filter, operationOptions);
+    } catch (error) {
+      if (error instanceof BulkOperationConfirmationError)
+        throw invalidParamsFault(error.message);
+      throw engineFailureFault(faultMessage(error));
+    }
+  }
+}), bulkCancelWorkflowsRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/bulk/cancel",
+  pathParamNames: [],
+  operationName: "weft.workflows.bulk.cancel",
+  inputSources: {},
+  extractInput: async (request) => {
+    const raw = await readOptionalJsonBody(request);
+    try {
+      return {
+        ...parseBulkListFilterFromBody(raw),
+        ...parseBulkOperationControlFromBody(raw)
+      };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,7 @@
+import type { BulkDeleteResult, BulkOperationDryRunResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import { type BulkListFilterInput, type BulkOperationControlInput } from './bulk-filter-helpers.ts';
+export type BulkDeleteWorkflowsInput = BulkListFilterInput & BulkOperationControlInput;
+export type BulkDeleteWorkflowsOutput = BulkDeleteResult | BulkOperationDryRunResult;
+export declare const bulkDeleteWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkDeleteWorkflowsInput, BulkDeleteWorkflowsOutput>;
+export declare const bulkDeleteWorkflowsRestBinding: UnknownRestBinding;

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

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import {
+  BulkDeleteRequiresTerminalWorkflowsError,
+  BulkOperationConfirmationError
+} from "../../core/engine.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  bulkListFilterInputSchema,
+  bulkOperationControlInputSchema,
+  bulkOperationOptionsFromInput,
+  bulkOperatorAccessPolicy,
+  engineFailureFault,
+  faultMessage,
+  parseBulkListFilterFromBody,
+  parseBulkOperationControlFromBody,
+  readOptionalJsonBody,
+  unprocessableFault
+} from "./bulk-filter-helpers.js";
+import {
+  shapeBulkJsonSuccess,
+  validatedListFilterFromBulkInput
+} from "./bulk-operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const bulkDeleteWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkDeleteWorkflowsOutput = z.unknown();
+export const bulkDeleteWorkflowsOperation = defineOperation({
+  name: "weft.workflows.bulk.delete",
+  mcpExposable: !1,
+  summary: "Delete terminal workflows in bulk",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkDeleteWorkflowsInput,
+  outputSchema: bulkDeleteWorkflowsOutput,
+  access: bulkOperatorAccessPolicy,
+  producibleFaults: ["Unprocessable"],
+  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.deleteAll(filter, operationOptions);
+      return await e.deleteAll(filter, operationOptions);
+    } catch (error) {
+      if (error instanceof BulkOperationConfirmationError)
+        throw invalidParamsFault(error.message);
+      if (error instanceof BulkDeleteRequiresTerminalWorkflowsError)
+        throw unprocessableFault(error.message);
+      throw engineFailureFault(faultMessage(error));
+    }
+  }
+}), bulkDeleteWorkflowsRestBinding = {
+  method: "DELETE",
+  path: "/v1/workflows/bulk",
+  pathParamNames: [],
+  operationName: "weft.workflows.bulk.delete",
+  inputSources: {},
+  extractInput: async (request) => {
+    const raw = await readOptionalJsonBody(request);
+    try {
+      return {
+        ...parseBulkListFilterFromBody(raw),
+        ...parseBulkOperationControlFromBody(raw)
+      };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { BulkOperationCommitOptions, BulkOperationDryRunOptions, FailureCategory, ListFilter, SearchAttributeValue, WorkflowStatus } from '../../core/types.ts';
+import type { OperationFault } from '../operation-fault.ts';
+import type { Principal } from '../principal.ts';
+export declare const bulkListFilterInputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, 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<SearchAttributeValue, SearchAttributeValue>>;
+        gt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        lt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        gte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        lte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, 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<FailureCategory, FailureCategory>, z.ZodArray<z.ZodCustom<FailureCategory, 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>;
+export type BulkListFilterInput = z.infer<typeof bulkListFilterInputSchema>;
+export declare const bulkOperationControlInputSchema: z.ZodObject<{
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    confirmationToken: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BulkOperationControlInput = z.infer<typeof bulkOperationControlInputSchema>;
+export declare const bulkOperatorAccessPolicy: {
+    kind: "scoped";
+    scopes: {
+        kind: "anyOf";
+        scopes: ["workflows:admin"];
+    };
+};
+export declare function faultMessage(error: unknown): string;
+export declare function unprocessableFault(message: string): OperationFault;
+export declare function engineFailureFault(message: string): OperationFault;
+export declare function readOptionalJsonBody(request: Request): Promise<unknown>;
+export declare function parseBulkListFilterFromBody(body: unknown): ListFilter;
+export declare function parseRequiredBulkListFilter(body: unknown): ListFilter;
+export declare function listFilterFromBulkInput(input: BulkListFilterInput): ListFilter;
+export declare function parseBulkOperationControlFromBody(body: unknown): BulkOperationControlInput;
+export declare function bulkOperationOptionsFromInput(input: BulkOperationControlInput, principal: Principal): BulkOperationDryRunOptions | BulkOperationCommitOptions;

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

@@ -0,0 +1,334 @@
+import { z } from "zod";
+import { assertScopedBulkWorkflowFilter } from "../../core/bulk-workflow-filter.js";
+import { isFailureCategory } from "../../core/failure-categories.js";
+import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
+import {
+  MAX_BULK_CONFIRMATION_TOKEN_LENGTH,
+  MAX_BULK_OPERATION_REQUEST_ID_LENGTH
+} from "../../core/types/bulk.js";
+import { parseOptionalFailureCategoryFilter } from "./failure-category-filter.js";
+import { invalidParamsFault } from "./operation-helpers.js";
+const workflowStatusSchema = 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()
+}), failureCategorySchema = z.custom(isFailureCategory), timeRangeSchema = z.object({
+  gte: z.number().optional(),
+  gt: z.number().optional(),
+  lte: z.number().optional(),
+  lt: z.number().optional()
+});
+export const bulkListFilterInputSchema = 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(0).optional(),
+  offset: z.number().int().min(0).optional(),
+  idPrefix: z.string().optional(),
+  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema)]).optional(),
+  createdAt: timeRangeSchema.optional(),
+  updatedAt: timeRangeSchema.optional(),
+  executionDeadline: timeRangeSchema.optional()
+}), bulkOperationControlInputSchema = z.object({
+  dryRun: z.boolean().optional(),
+  confirmationToken: z.string().min(1).max(MAX_BULK_CONFIRMATION_TOKEN_LENGTH).optional(),
+  requestId: z.string().min(1).max(MAX_BULK_OPERATION_REQUEST_ID_LENGTH).optional()
+}), bulkOperatorAccessPolicy = {
+  kind: "scoped",
+  scopes: { kind: "anyOf", scopes: ["workflows:admin"] }
+};
+export function faultMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function unprocessableFault(message) {
+  return {
+    code: "Unprocessable",
+    message,
+    data: { reason: message }
+  };
+}
+export function engineFailureFault(message) {
+  return {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+export async function readOptionalJsonBody(request) {
+  try {
+    const text = await request.text();
+    return text.trim() === "" ? void 0 : JSON.parse(text);
+  } catch {
+    throw invalidParamsFault("Invalid JSON body");
+  }
+}
+function isJsonSearchAttributeValue(value) {
+  if (typeof value === "string" || typeof value === "boolean")
+    return !0;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function parseAttributeFiltersFromBody(value) {
+  if (!Array.isArray(value))
+    throw Error('Field "filter.attributes" must be an array');
+  return value.map((entry, index) => {
+    if (typeof entry !== "object" || entry === null)
+      throw Error(`Field "filter.attributes[${index}]" must be an object`);
+    const record = entry, key = record.key;
+    if (typeof key !== "string" || key.length === 0)
+      throw Error(`Field "filter.attributes[${index}].key" must be a non-empty string`);
+    const filter = { key };
+    for (const property of ["value", "gt", "lt", "gte", "lte"]) {
+      const attributeValue = record[property];
+      if (attributeValue === void 0)
+        continue;
+      if (!isJsonSearchAttributeValue(attributeValue))
+        throw Error(`Field "filter.attributes[${index}].${property}" must be a string, number, boolean, or string array`);
+      filter[property] = attributeValue;
+    }
+    return filter;
+  });
+}
+function parseFilterStatus(value) {
+  if (value === void 0)
+    return;
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value) && value.every((entry) => typeof entry === "string"))
+    return value;
+  throw Error('Field "filter.status" must be a string or an array of strings');
+}
+function parseOptionalFilterType(value) {
+  if (value === void 0)
+    return;
+  if (typeof value === "string")
+    return value;
+  throw Error('Field "filter.type" must be a string');
+}
+function parseOptionalFilterTags(value) {
+  if (value === void 0)
+    return;
+  return coerceStartWorkflowTags(value, 'Field "filter.tags"');
+}
+function parseOptionalFilterNumber(value, fieldName) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    throw Error(`Field "filter.${fieldName}" must be a non-negative number`);
+  return Math.floor(value);
+}
+const BULK_FILTER_DIMENSION_PARSERS = [
+  (filter, record) => {
+    const status = parseFilterStatus(record.status);
+    if (status !== void 0)
+      filter.status = status;
+  },
+  (filter, record) => {
+    const type = parseOptionalFilterType(record.type);
+    if (type !== void 0)
+      filter.type = type;
+  },
+  (filter, record) => {
+    const tags = parseOptionalFilterTags(record.tags);
+    if (tags !== void 0)
+      filter.tags = tags;
+  },
+  (filter, record) => {
+    if (record.attributes !== void 0)
+      filter.attributes = parseAttributeFiltersFromBody(record.attributes);
+  },
+  (filter, record) => {
+    const limit = parseOptionalFilterNumber(record.limit, "limit");
+    if (limit !== void 0)
+      filter.limit = limit;
+  },
+  (filter, record) => {
+    const offset = parseOptionalFilterNumber(record.offset, "offset");
+    if (offset !== void 0)
+      filter.offset = offset;
+  },
+  (filter, record) => {
+    const idPrefix = record.idPrefix;
+    if (typeof idPrefix === "string")
+      filter.idPrefix = idPrefix;
+  },
+  (filter, record) => {
+    const failureCategory = parseOptionalFailureCategoryFilter(record.failureCategory);
+    if (failureCategory !== void 0)
+      filter.failureCategory = failureCategory;
+  },
+  (filter, record) => {
+    const createdAt = parseOptionalTimeRange(record.createdAt);
+    if (createdAt !== void 0)
+      filter.createdAt = createdAt;
+  },
+  (filter, record) => {
+    const updatedAt = parseOptionalTimeRange(record.updatedAt);
+    if (updatedAt !== void 0)
+      filter.updatedAt = updatedAt;
+  },
+  (filter, record) => {
+    const executionDeadline = parseOptionalTimeRange(record.executionDeadline);
+    if (executionDeadline !== void 0)
+      filter.executionDeadline = executionDeadline;
+  }
+];
+export function parseBulkListFilterFromBody(body) {
+  if (body === void 0)
+    return {};
+  if (typeof body !== "object" || body === null)
+    throw Error("Request body must be a JSON object");
+  const rawFilter = body.filter;
+  if (rawFilter === void 0)
+    return {};
+  if (typeof rawFilter !== "object" || rawFilter === null)
+    throw Error('Field "filter" must be an object');
+  const filterRecord = rawFilter, filter = {};
+  for (const applyDimension of BULK_FILTER_DIMENSION_PARSERS)
+    applyDimension(filter, filterRecord);
+  return filter;
+}
+const TIME_RANGE_BOUNDS = ["gte", "gt", "lte", "lt"];
+function parseOptionalTimeRange(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "object" || value === null)
+    throw Error("Time-range filter must be an object with gte/gt/lte/lt numeric bounds");
+  const record = value, range = {};
+  for (const bound of TIME_RANGE_BOUNDS) {
+    const entry = record[bound];
+    if (entry === void 0)
+      continue;
+    if (typeof entry !== "number" || !Number.isFinite(entry))
+      throw Error(`Time-range bound "${bound}" must be a finite number`);
+    range[bound] = entry;
+  }
+  return Object.keys(range).length > 0 ? range : void 0;
+}
+export function parseRequiredBulkListFilter(body) {
+  try {
+    return assertScopedBulkWorkflowFilter(parseBulkListFilterFromBody(body));
+  } catch (error) {
+    throw invalidParamsFault(faultMessage(error));
+  }
+}
+export function listFilterFromBulkInput(input) {
+  const filter = {};
+  applyBasicBulkFilterFields(filter, input);
+  applyExtendedBulkFilterFields(filter, input);
+  applyBulkTimeRangeFields(filter, input);
+  return filter;
+}
+function applyBasicBulkFilterFields(filter, input) {
+  if (input.status !== void 0)
+    filter.status = input.status;
+  if (input.type !== void 0)
+    filter.type = input.type;
+  if (input.tags !== void 0)
+    filter.tags = input.tags;
+  if (input.attributes !== void 0)
+    filter.attributes = input.attributes.map(copyAttributeFilter);
+  if (input.limit !== void 0)
+    filter.limit = input.limit;
+  if (input.offset !== void 0)
+    filter.offset = input.offset;
+}
+function copyAttributeFilter(attribute) {
+  return {
+    key: attribute.key,
+    ...attribute.value === void 0 ? {} : { value: attribute.value },
+    ...attribute.gt === void 0 ? {} : { gt: attribute.gt },
+    ...attribute.lt === void 0 ? {} : { lt: attribute.lt },
+    ...attribute.gte === void 0 ? {} : { gte: attribute.gte },
+    ...attribute.lte === void 0 ? {} : { lte: attribute.lte }
+  };
+}
+function applyExtendedBulkFilterFields(filter, input) {
+  if (input.idPrefix !== void 0)
+    filter.idPrefix = input.idPrefix;
+  if (input.failureCategory !== void 0)
+    filter.failureCategory = input.failureCategory;
+}
+function applyBulkTimeRangeFields(filter, input) {
+  const createdAt = parseOptionalTimeRange(input.createdAt);
+  if (createdAt !== void 0)
+    filter.createdAt = createdAt;
+  const updatedAt = parseOptionalTimeRange(input.updatedAt);
+  if (updatedAt !== void 0)
+    filter.updatedAt = updatedAt;
+  const executionDeadline = parseOptionalTimeRange(input.executionDeadline);
+  if (executionDeadline !== void 0)
+    filter.executionDeadline = executionDeadline;
+}
+export function parseBulkOperationControlFromBody(body) {
+  if (body === void 0)
+    return {};
+  const record = parseJsonObjectBody(body), dryRun = parseOptionalBooleanControl(record, "dryRun"), confirmationToken = parseOptionalNonEmptyStringControl(record, "confirmationToken"), requestId = parseOptionalBulkRequestId(record);
+  return {
+    ...dryRun === void 0 ? {} : { dryRun },
+    ...confirmationToken === void 0 ? {} : { confirmationToken },
+    ...requestId === void 0 ? {} : { requestId }
+  };
+}
+export function bulkOperationOptionsFromInput(input, principal) {
+  const auditPrincipal = principalToBulkOperationPrincipal(principal);
+  if (input.dryRun === !0)
+    return {
+      dryRun: !0,
+      principal: auditPrincipal,
+      ...input.requestId === void 0 ? {} : { requestId: input.requestId }
+    };
+  if (input.confirmationToken === void 0)
+    throw invalidParamsFault('Field "confirmationToken" is required after a dry run');
+  return {
+    confirmationToken: input.confirmationToken,
+    principal: auditPrincipal,
+    ...input.requestId === void 0 ? {} : { requestId: input.requestId }
+  };
+}
+function principalToBulkOperationPrincipal(principal) {
+  if (principal.method === "unauthenticated")
+    return { method: "unauthenticated" };
+  return {
+    method: principal.method,
+    ...principal.subject === void 0 ? {} : { subject: principal.subject }
+  };
+}
+function parseJsonObjectBody(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body))
+    throw Error("Request body must be a JSON object");
+  return body;
+}
+function parseOptionalBooleanControl(record, fieldName) {
+  const value = record[fieldName];
+  if (value === void 0)
+    return;
+  if (typeof value === "boolean")
+    return value;
+  throw Error(`Field "${fieldName}" must be a boolean`);
+}
+function parseOptionalNonEmptyStringControl(record, fieldName) {
+  const value = record[fieldName];
+  if (value === void 0)
+    return;
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  throw Error(`Field "${fieldName}" must be a non-empty string`);
+}
+function parseOptionalBulkRequestId(record) {
+  const requestId = parseOptionalNonEmptyStringControl(record, "requestId");
+  if (requestId === void 0)
+    return;
+  if (requestId.length <= MAX_BULK_OPERATION_REQUEST_ID_LENGTH)
+    return requestId;
+  throw Error(`Field "requestId" must be at most ${MAX_BULK_OPERATION_REQUEST_ID_LENGTH} characters`);
+}