@lostgradient/weft 0.2.1 → 0.4.0

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

@@ -10,10 +10,10 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
     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;
+        gt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        lt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        gte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        lte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
     }[] | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
@@ -37,5 +37,5 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
         lte?: number | undefined;
         lt?: number | undefined;
     } | undefined;
-}, PurgeResult>;
+}, PurgeResult, unknown>;
 export declare const purgeWorkflowsRestBinding: UnknownRestBinding;

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

@@ -43,8 +43,8 @@ export const purgeWorkflowsOperation = defineOperation({
   pathParamNames: [],
   operationName: "weft.workflows.purge",
   inputSources: {},
-  extractInput: async (request) => {
-    const raw = await readOptionalJsonBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const raw = await readOptionalJsonBody(request, context);
     try {
       return { ...parseBulkListFilterFromBody(raw) };
     } catch (error) {

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

@@ -13,7 +13,7 @@ export declare const queryWorkflowOperation: import("../operation-catalog.ts").O
     workflowId: string;
     queryName: string;
     input?: unknown;
-}, QueryWorkflowOutput>;
+}, QueryWorkflowOutput, unknown>;
 export declare const queryWorkflowRestBinding: UnknownRestBinding;
 export declare const queryWorkflowWithInputRestBinding: UnknownRestBinding;
 export {};

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
+import { readRestTextBody } from "../rest-body.js";
 import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 const queryWorkflowInput = z.object({
   workflowId: z.string().min(1),
@@ -71,8 +72,8 @@ export const queryWorkflowRestBinding = {
     queryName: { kind: "path", pathParam: "name" },
     input: { kind: "body-field", bodyField: "input" }
   },
-  extractInput: async (request, pathParams) => {
-    const rawBody = await request.text();
+  extractInput: async (request, pathParams, context) => {
+    const rawBody = await readRestTextBody(request, context);
     if (rawBody.trim().length === 0)
       return {
         workflowId: pathParams.id ?? "",

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

@@ -8,6 +8,6 @@ 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[];
-}>;
+}, unknown>;
 export declare const recoverAllRestBinding: UnknownRestBinding;
 export {};

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

@@ -23,6 +23,6 @@ export type ReplayWorkflowOutput = WorkflowReplay;
 export declare const replayWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
     workflowId: string;
     step: string | number;
-}, WorkflowReplay>;
+}, WorkflowReplay, unknown>;
 export declare const replayWorkflowRestBinding: UnknownRestBinding;
 export {};

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

@@ -8,6 +8,6 @@ export type ResumeScheduleInput = z.infer<typeof resumeScheduleInput>;
 export type ResumeScheduleOutput = z.infer<typeof resumeScheduleOutput>;
 export declare const resumeScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
     scheduleId: string;
-}, undefined>;
+}, undefined, unknown>;
 export declare const resumeScheduleRestBinding: UnknownRestBinding;
 export {};

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

@@ -11,8 +11,8 @@ const resumeWorkflowInput = z.object({
 });
 export const resumeWorkflowOperation = createSingleWorkflowControlOperation({
   name: "weft.workflows.resume",
-  summary: "Resume a suspended workflow",
-  description: "Resume a workflow that is suspended (for example, paused awaiting a human review or an operator hold) by `workflowId`, returning the workflow `id`. Faults with NotFound when the workflow is not visible.",
+  summary: "Resume a suspended or recovered workflow",
+  description: "Re-drive a workflow from its persisted checkpoint by `workflowId`, returning the workflow `id`. Accepts a workflow that was explicitly suspended (`weft.workflows.suspend`) or one left running by a prior process; a suspended workflow is durably flipped back to running as part of resuming. Faults with NotFound when the workflow is not visible, or Conflict when it is in a status that cannot be resumed (terminal or pending).",
   destructive: !1,
   tags: ["Workflows"],
   inputSchema: resumeWorkflowInput,

package/dist/server/operations/set-workflow-attributes.d.ts

@@ -14,6 +14,6 @@ export declare const setWorkflowAttributesOperation: import("../operation-catalo
     attributes?: unknown;
 }, {
     ok: true;
-}>;
+}, unknown>;
 export declare const setWorkflowAttributesRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/set-workflow-attributes.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const setWorkflowAttributesInput = z.object({
   workflowId: z.string().min(1),
   attributes: z.unknown().optional()
@@ -50,8 +51,10 @@ export const setWorkflowAttributesRestBinding = {
     workflowId: { kind: "path", pathParam: "id" },
     attributes: { kind: "body-field", bodyField: "attributes" }
   },
-  extractInput: async (request, pathParams) => {
-    const body = await request.json().catch(() => {
+  extractInput: async (request, pathParams, context) => {
+    const body = await readRestJsonBody(request, context).catch((error) => {
+      if (isOperationFault(error))
+        throw error;
       throw Error("Invalid JSON body");
     });
     if (body === null)

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
-import { shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -43,8 +44,12 @@ export const signalWorkflowRestBinding = {
     signalName: { kind: "path", pathParam: "name" },
     payload: { kind: "body-field", bodyField: "payload" }
   },
-  extractInput: async (request, pathParams) => {
-    const body = await request.json().catch(() => null), payload = typeof body === "object" && body !== null ? body.payload : void 0, signalId = typeof body === "object" && body !== null ? body.signalId : void 0;
+  extractInput: async (request, pathParams, context) => {
+    const body = await readRestJsonBody(request, context).catch((error) => {
+      if (isOperationFault(error))
+        throw error;
+      return null;
+    }), payload = typeof body === "object" && body !== null ? body.payload : void 0, signalId = typeof body === "object" && body !== null ? body.signalId : void 0;
     return {
       ...extractWorkflowIdFromPath(pathParams),
       signalName: pathParams.name ?? "",

package/dist/server/operations/single-workflow-tag-mutation.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
+import { WorkflowNotFoundError } from "../../core/engine/errors.js";
 import {
   coerceStartWorkflowTags,
   StartWorkflowValidationError
 } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
-import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
 const singleWorkflowTagMutationInput = z.object({
   workflowId: z.string().min(1),
   tags: z.unknown().optional()
@@ -50,8 +52,10 @@ export function createSingleWorkflowTagMutationRestBinding(configuration) {
       workflowId: { kind: "path", pathParam: "id" },
       tags: { kind: "body-field", bodyField: "tags" }
     },
-    extractInput: async (request, pathParams) => {
-      const body = await request.json().catch(() => {
+    extractInput: async (request, pathParams, context) => {
+      const body = await readRestJsonBody(request, context).catch((error) => {
+        if (isOperationFault(error))
+          throw error;
         throw Error("Invalid JSON body");
       });
       if (!isJsonObject(body))
@@ -79,6 +83,12 @@ function shapeSingleWorkflowTagMutationFault(fault) {
 }
 function mapTagMutationErrorToFault(error, workflowId) {
   const message = faultMessage(error);
+  if (error instanceof WorkflowNotFoundError)
+    return {
+      code: "NotFound",
+      message,
+      data: { resource: "workflow", identifier: workflowId, weftCode: error.code }
+    };
   if (message.includes("not found"))
     return {
       code: "NotFound",

package/dist/server/operations/start-or-signal-workflow.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const startOrSignalWorkflowInput: z.ZodObject<{
+    type: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
+    signalName: z.ZodString;
+    signalPayload: z.ZodOptional<z.ZodUnknown>;
+    signalId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodUnknown>;
+    executionTimeout: z.ZodOptional<z.ZodUnknown>;
+    startAt: z.ZodOptional<z.ZodUnknown>;
+    startAfter: z.ZodOptional<z.ZodUnknown>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    idempotencyKey: z.ZodOptional<z.ZodUnknown>;
+    searchAttributes: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const startOrSignalWorkflowOutput: z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodEnum<{
+        started: "started";
+        signalled: "signalled";
+    }>;
+}, z.core.$strip>;
+export type StartOrSignalWorkflowInput = z.infer<typeof startOrSignalWorkflowInput>;
+export type StartOrSignalWorkflowOutput = z.infer<typeof startOrSignalWorkflowOutput>;
+export declare const startOrSignalWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    type: unknown;
+    signalName: string;
+    input?: unknown;
+    signalPayload?: unknown;
+    signalId?: string | undefined;
+    id?: unknown;
+    executionTimeout?: unknown;
+    startAt?: unknown;
+    startAfter?: unknown;
+    tags?: unknown;
+    idempotencyKey?: unknown;
+    searchAttributes?: unknown;
+}, {
+    id: string;
+    outcome: "started" | "signalled";
+}, unknown>;
+export declare const startOrSignalWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/start-or-signal-workflow.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import {
+  IdempotencyKeyPurgedError,
+  StartOrSignalConflictError,
+  WorkflowNotRegisteredError
+} from "../../core/engine/errors.js";
+import { runtimeWorkflowEngine } from "../../core/runtime-workflow-engine.js";
+import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
+import { StartWorkflowValidationError } from "../../core/start-workflow-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { buildSharedStartWorkflowOptions } from "./start-workflow-options.js";
+import {
+  extractSharedStartWorkflowRestFields,
+  parseStartWorkflowRequestRecord
+} from "./start-workflow-rest-input.js";
+const startOrSignalWorkflowInput = z.object({
+  type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
+  input: z.unknown().optional(),
+  signalName: z.string().min(1).describe("Signal name. Must be a non-empty string."),
+  signalPayload: z.unknown().optional(),
+  signalId: z.string().min(1).refine(isSignalIdWithinByteLimit, "signalId must be at most 128 bytes").optional(),
+  id: z.unknown().optional(),
+  executionTimeout: z.unknown().optional(),
+  startAt: z.unknown().optional(),
+  startAfter: z.unknown().optional(),
+  tags: z.unknown().optional(),
+  idempotencyKey: z.unknown().optional(),
+  searchAttributes: z.unknown().optional()
+}), startOrSignalWorkflowOutput = z.object({
+  id: z.string(),
+  outcome: z.enum(["started", "signalled"])
+});
+function validateStartOrSignalWorkflowInput(input, lookupSearchAttributeSchema) {
+  if (typeof input.type !== "string" || input.type.length === 0)
+    throw invalidParamsFault("Missing required field: type");
+  let options;
+  try {
+    options = buildSharedStartWorkflowOptions(input, lookupSearchAttributeSchema(input.type));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalidParamsFault(message);
+  }
+  assertConvergenceTokenProvided(input.signalId, options.idempotencyKey);
+  const signal = {
+    name: input.signalName,
+    payload: input.signalPayload,
+    ...input.signalId === void 0 ? {} : { signalId: input.signalId }
+  };
+  return { type: input.type, signal, options };
+}
+function assertConvergenceTokenProvided(signalId, idempotencyKey) {
+  if (signalId === void 0 && idempotencyKey === void 0)
+    throw invalidParamsFault("startOrSignal requires either signalId or idempotencyKey to identify the signal to deliver. (Concurrent callers converge on one workflow and one signal only with a shared idempotencyKey, or a shared id plus signalId; a bare signalId starts a fresh run per caller.)");
+  if (signalId !== void 0 && idempotencyKey !== void 0)
+    throw invalidParamsFault("startOrSignal does not accept both signalId and idempotencyKey: the signal id derives from the idempotency key for convergence. Provide exactly one.");
+}
+function resolveStartOrSignalWorkflowFault(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof WorkflowNotRegisteredError)
+    throw invalidParamsFault(message, error.code);
+  if (error instanceof StartOrSignalConflictError || error instanceof IdempotencyKeyPurgedError)
+    throw {
+      code: "Conflict",
+      message,
+      data: { reason: message, weftCode: error.code }
+    };
+  if (error instanceof StartWorkflowValidationError)
+    throw invalidParamsFault(message);
+  throw {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+export const startOrSignalWorkflowOperation = defineOperation({
+  name: "weft.workflows.startorsignal",
+  mcpExposable: !1,
+  summary: "Atomically start a workflow or signal it if it already exists",
+  description: 'Start a workflow or deliver a signal to it if it already exists (signal-with-start). An absent target is created and delivered the signal in one batch; a non-terminal target (running, pending, or suspended) is signalled; a terminal target faults with Conflict, as does a spent `idempotencyKey` whose run was purged or swept by retention. Requires `type`, `signalName`, and exactly one of `signalId` or `idempotencyKey` (not both). Accepts `input`, `signalPayload`, and the non-idempotency start options from weft.workflows.start (`id`, `executionTimeout`, `startAt`/`startAfter`, `tags`, `searchAttributes`); `idempotencyKey` is governed solely by the "exactly one of" rule above. Returns the workflow `id`. Concurrent callers converge on one workflow and one signal only with a shared `idempotencyKey`, or a shared `id` plus `signalId`; a bare `signalId` (no `id`/`idempotencyKey`) starts a fresh run per caller and does not converge.',
+  destructive: !1,
+  tags: ["Workflows", "Signals"],
+  inputSchema: startOrSignalWorkflowInput,
+  outputSchema: startOrSignalWorkflowOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = runtimeWorkflowEngine(engine), { type, signal, options } = validateStartOrSignalWorkflowInput(input, (validType) => {
+      return typedEngine.getWorkflowDefinition(validType)?.searchAttributes;
+    });
+    try {
+      const { handle, outcome } = await typedEngine.startOrSignal(type, input.input, signal, options);
+      return { id: handle.id, outcome };
+    } catch (error) {
+      resolveStartOrSignalWorkflowFault(error);
+    }
+  }
+}), startOrSignalWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/start-or-signal",
+  pathParamNames: [],
+  operationName: "weft.workflows.startorsignal",
+  inputSources: {
+    type: { kind: "body-field", bodyField: "type" },
+    input: { kind: "body-field", bodyField: "input" },
+    signalName: { kind: "body-field", bodyField: "signalName" },
+    signalPayload: { kind: "body-field", bodyField: "signalPayload" },
+    signalId: { kind: "body-field", bodyField: "signalId" },
+    id: { kind: "body-field", bodyField: "id" },
+    executionTimeout: { kind: "body-field", bodyField: "executionTimeout" },
+    startAt: { kind: "body-field", bodyField: "startAt" },
+    startAfter: { kind: "body-field", bodyField: "startAfter" },
+    tags: { kind: "body-field", bodyField: "tags" },
+    idempotencyKey: { kind: "body-field", bodyField: "idempotencyKey" },
+    searchAttributes: { kind: "body-field", bodyField: "searchAttributes" }
+  },
+  extractInput: async (request, _pathParams, context) => {
+    const record = await parseStartWorkflowRequestRecord(request, context);
+    return {
+      ...extractSharedStartWorkflowRestFields(record),
+      signalName: record.signalName,
+      signalPayload: record.signalPayload,
+      signalId: record.signalId
+    };
+  },
+  success: { kind: "json", status: 201 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/start-workflow-options.d.ts

@@ -0,0 +1,38 @@
+import type { SearchAttributeSchema, SearchAttributeValue, StartOptions } from '../../core/types.ts';
+/**
+ * The raw, transport-supplied start-option fields shared by `weft.workflows.start`
+ * and `weft.workflows.startorsignal`. Each is `unknown` because validation happens
+ * in {@link buildSharedStartWorkflowOptions}, not at the schema boundary, so both
+ * surfaces hit one cross-transport error path.
+ */
+export type SharedStartWorkflowOptionInput = {
+    id?: unknown;
+    executionTimeout?: unknown;
+    startAt?: unknown;
+    startAfter?: unknown;
+    tags?: unknown;
+    idempotencyKey?: unknown;
+    searchAttributes?: unknown;
+};
+/**
+ * Coerce the shared start-option fields into a validated {@link StartOptions}.
+ * Both start operations call this so they cannot drift in how they validate `id`,
+ * `executionTimeout`, `startAt`/`startAfter`, `tags`, `idempotencyKey`, and
+ * `searchAttributes` (a new field added here covers both surfaces at once). Throws
+ * {@link StartWorkflowValidationError} on any malformed field.
+ *
+ * `onTerminalConflict` is intentionally NOT part of this shared path: it is an
+ * in-process `engine.start`-only policy (its purge-and-restart would make the
+ * transport `weft.workflows.start` operation conditionally destructive and would
+ * violate `startOrSignal`'s at-most-once identity), so it is not exposed over
+ * REST/JSON-RPC. See follow-up issue #489.
+ */
+export declare function buildSharedStartWorkflowOptions(input: SharedStartWorkflowOptionInput, searchAttributeSchema: SearchAttributeSchema | undefined): StartOptions;
+/**
+ * Coerce a transport-supplied `searchAttributes` object into validated
+ * {@link SearchAttributeValue}s. Shared by `weft.workflows.start` and
+ * `weft.workflows.startorsignal` so both apply the same null-prototype guard,
+ * date-time normalization, schema-presence check, and type validation —
+ * preventing the two start surfaces from drifting in how they accept attributes.
+ */
+export declare function coerceStartWorkflowSearchAttributes(value: unknown, fieldName: string, schema: SearchAttributeSchema | undefined): Record<string, SearchAttributeValue>;

package/dist/server/operations/start-workflow-options.js

@@ -0,0 +1,63 @@
+import { validateAttributeType } from "../../core/search-attributes.js";
+import {
+  assertExclusiveStartWorkflowOptions,
+  coerceStartWorkflowDuration,
+  coerceStartWorkflowId,
+  coerceStartWorkflowIdempotencyKey,
+  coerceStartWorkflowTags,
+  coerceStartWorkflowTimestamp,
+  StartWorkflowValidationError
+} from "../../core/start-workflow-validation.js";
+export function buildSharedStartWorkflowOptions(input, searchAttributeSchema) {
+  const options = {};
+  if (input.id !== void 0)
+    options.id = coerceStartWorkflowId(input.id, 'Field "id"');
+  if (input.executionTimeout !== void 0)
+    options.executionTimeout = coerceStartWorkflowDuration(input.executionTimeout, 'Field "executionTimeout"');
+  if (input.startAt !== void 0)
+    options.startAt = coerceStartWorkflowTimestamp(input.startAt, 'Field "startAt"');
+  if (input.startAfter !== void 0)
+    options.startAfter = coerceStartWorkflowDuration(input.startAfter, 'Field "startAfter"');
+  if (input.tags !== void 0)
+    options.tags = coerceStartWorkflowTags(input.tags, 'Field "tags"');
+  if (input.idempotencyKey !== void 0)
+    options.idempotencyKey = coerceStartWorkflowIdempotencyKey(input.idempotencyKey, 'Field "idempotencyKey"');
+  if (input.searchAttributes !== void 0)
+    options.searchAttributes = coerceStartWorkflowSearchAttributes(input.searchAttributes, 'Field "searchAttributes"', searchAttributeSchema);
+  assertExclusiveStartWorkflowOptions(options.startAt, options.startAfter);
+  return options;
+}
+export function coerceStartWorkflowSearchAttributes(value, fieldName, schema) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new StartWorkflowValidationError(`${fieldName} must be an object`);
+  const attributes = Object.create(null);
+  for (const [key, attributeValue] of Object.entries(value))
+    attributes[key] = coerceStartWorkflowSearchAttributeValue(key, attributeValue, fieldName, schema);
+  return attributes;
+}
+function coerceStartWorkflowSearchAttributeValue(key, value, fieldName, schema) {
+  if (!isSearchAttributeValue(value))
+    throw new StartWorkflowValidationError(`${fieldName}.${key} must be a string, number, boolean, Date, or string array`);
+  if (schema === void 0)
+    return value;
+  const definition = schema[key];
+  if (definition === void 0)
+    throw new StartWorkflowValidationError(`Unknown search attribute "${key}". Registered attributes: ${Object.keys(schema).join(", ")}`);
+  const normalizedValue = definition.type === "string" && definition.format === "date-time" && typeof value === "string" ? coerceDateTimeSearchAttribute(key, value, fieldName) : value;
+  try {
+    validateAttributeType(key, normalizedValue, definition);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new StartWorkflowValidationError(message);
+  }
+  return normalizedValue;
+}
+function coerceDateTimeSearchAttribute(key, value, fieldName) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    throw new StartWorkflowValidationError(`${fieldName}.${key} must be a valid date-time string`);
+  return date;
+}
+function isSearchAttributeValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date || Array.isArray(value) && value.every((item) => typeof item === "string");
+}

package/dist/server/operations/start-workflow-rest-input.d.ts

@@ -0,0 +1,14 @@
+import type { RestInputContext } from '../rest-binding.ts';
+export type SharedStartWorkflowRestFields = {
+    readonly type: unknown;
+    readonly input: unknown;
+    readonly id: unknown;
+    readonly executionTimeout: unknown;
+    readonly startAt: unknown;
+    readonly startAfter: unknown;
+    readonly tags: unknown;
+    readonly idempotencyKey: unknown;
+    readonly searchAttributes: unknown;
+};
+export declare function parseStartWorkflowRequestRecord(request: Request, context?: RestInputContext): Promise<Record<string, unknown>>;
+export declare function extractSharedStartWorkflowRestFields(record: Record<string, unknown>): SharedStartWorkflowRestFields;

package/dist/server/operations/start-workflow-rest-input.js

@@ -0,0 +1,31 @@
+import { readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
+function isJsonObjectLikeRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export async function parseStartWorkflowRequestRecord(request, context) {
+  let body;
+  try {
+    body = await readRestJsonBody(request, context);
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
+    throw invalidParamsFault("Invalid JSON body");
+  }
+  if (body === null || typeof body !== "object")
+    throw invalidParamsFault("Request body must be a JSON object");
+  return isJsonObjectLikeRecord(body) ? body : {};
+}
+export function extractSharedStartWorkflowRestFields(record) {
+  return {
+    type: record.type,
+    input: record.input,
+    id: record.id,
+    executionTimeout: record.executionTimeout,
+    startAt: record.startAt,
+    startAfter: record.startAfter,
+    tags: record.tags,
+    idempotencyKey: record.idempotencyKey,
+    searchAttributes: record.searchAttributes
+  };
+}

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

@@ -28,6 +28,6 @@ export declare const startWorkflowOperation: import("../operation-catalog.ts").O
     searchAttributes?: unknown;
 }, {
     id: string;
-}>;
+}, unknown>;
 export declare const startWorkflowRestBinding: UnknownRestBinding;
 export {};