@zapier/zapier-sdk 0.117.0 → 0.119.0

package/dist/chunk-QTG5EPTI.cjs

@@ -0,0 +1,2419 @@
+'use strict';
+
+var chunkTJXDMXEE_cjs = require('./chunk-TJXDMXEE.cjs');
+var kitcore = require('@zapier/kitcore');
+var zod = require('zod');
+
+var codeSubstrateDefaults = {
+  categories: [chunkTJXDMXEE_cjs.taxonomy.categories["code-workflow"]],
+  stability: "beta"
+};
+var CODE_SUBSTRATE_ANALYZER_API = "/code-substrate-analyzer";
+var CODE_SUBSTRATE_RUNNER_API = "/code-substrate-runner/api/v0";
+var CODE_SUBSTRATE_WORKFLOWS_API = "/code-substrate-workflows/api/v0";
+function toWireWorkflowClientAttribution({
+  creationHarness,
+  creationAccessMethod
+}) {
+  if (creationAccessMethod === void 0) return void 0;
+  return {
+    ...creationHarness === void 0 ? {} : { harness: creationHarness },
+    access_method: creationAccessMethod,
+    sdk_version: chunkTJXDMXEE_cjs.SDK_VERSION
+  };
+}
+var JsonPayloadSchema = zod.z.preprocess((val) => {
+  if (typeof val === "string") {
+    const trimmed = val.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return val;
+      }
+    }
+  }
+  return val;
+}, zod.z.unknown());
+var SourceFilesSchema = zod.z.record(zod.z.string(), zod.z.string()).refine((files) => Object.keys(files).length > 0, {
+  message: "sourceFiles must contain at least one file"
+}).describe("Source files keyed by filename \u2192 contents");
+var UUID_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var ConnectionIdValueSchema = zod.z.union([
+  zod.z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
+  zod.z.string().regex(UUID_PATTERN, "must be a UUID"),
+  zod.z.number().int().positive()
+]).describe(
+  "Zapier connection ID. Accepts a positive integer (legacy) or a UUID string (newer connections)."
+);
+var ConnectionBindingSchema = zod.z.object({
+  connectionId: ConnectionIdValueSchema.optional(),
+  /** @deprecated Use `connectionId` instead. */
+  connection_id: ConnectionIdValueSchema.optional().meta({ deprecated: true })
+});
+var AppVersionBindingSchema = zod.z.object({
+  implementationName: zod.z.string().min(1).optional().describe("Zapier app implementation name (e.g. `SlackCLIAPI`)"),
+  /** @deprecated Use `implementationName` instead. */
+  implementation_name: zod.z.string().min(1).optional().meta({ deprecated: true }),
+  version: zod.z.string().optional().describe("Pinned app version (e.g. `1.27.1`). Latest if omitted.")
+});
+function toWireConnections(connections) {
+  const wire = {};
+  for (const [alias, entry] of Object.entries(connections)) {
+    const connectionId = entry.connectionId ?? entry.connection_id;
+    if (connectionId === void 0) {
+      throw new chunkTJXDMXEE_cjs.ZapierValidationError(
+        `connections["${alias}"] is missing connectionId`
+      );
+    }
+    wire[alias] = { connection_id: connectionId };
+  }
+  return wire;
+}
+var TriggerConfigSchema = zod.z.object({
+  selectedApi: zod.z.string().optional().describe(
+    "Zapier app/API identifier (e.g. 'GoogleSheetsAPI'). Required when a trigger is configured."
+  ),
+  /** @deprecated Use `selectedApi` instead. */
+  selected_api: zod.z.string().optional().meta({ deprecated: true }),
+  action: zod.z.string().describe("Trigger action key (e.g. 'new_row')"),
+  authenticationId: zod.z.string().nullish().describe(
+    "Connection ID for the trigger source. Omit or pass null for no-auth triggers (e.g. Schedule by Zapier)."
+  ),
+  /** @deprecated Use `authenticationId` instead. */
+  authentication_id: zod.z.string().nullish().meta({ deprecated: true }),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Trigger parameters as a JSON object")
+}).describe(
+  "Zapier trigger configuration. When set, the workflow subscribes to trigger events."
+);
+function toWireTrigger(trigger) {
+  const selectedApi = trigger.selectedApi ?? trigger.selected_api;
+  if (selectedApi === void 0) {
+    throw new chunkTJXDMXEE_cjs.ZapierValidationError("trigger is missing selectedApi");
+  }
+  const wire = {
+    selected_api: selectedApi,
+    action: trigger.action
+  };
+  if ("authenticationId" in trigger) {
+    wire.authentication_id = trigger.authenticationId;
+  } else if ("authentication_id" in trigger) {
+    wire.authentication_id = trigger.authentication_id;
+  }
+  if (trigger.params !== void 0) {
+    wire.params = trigger.params;
+  }
+  return wire;
+}
+function toWireAppVersions(appVersions) {
+  const wire = {};
+  for (const [key, entry] of Object.entries(appVersions)) {
+    const implementationName = entry.implementationName ?? entry.implementation_name;
+    if (implementationName === void 0) {
+      throw new chunkTJXDMXEE_cjs.ZapierValidationError(
+        `appVersions["${key}"] is missing implementationName`
+      );
+    }
+    wire[key] = {
+      implementation_name: implementationName,
+      ...entry.version !== void 0 ? { version: entry.version } : {}
+    };
+  }
+  return wire;
+}
+var WorkflowTriggerUrlSchema = zod.z.string().describe(
+  "Public URL that fires this workflow when POSTed to. Embeds a trigger token in the path \u2014 treat as sensitive. Requests must also be authenticated as the account."
+);
+var WorkflowEditorUrlSchema = zod.z.string().url().describe("URL to the Zapier workflow editor for this workflow");
+var ConnectionBindingSchema2 = zod.z.object({
+  connection_id: zod.z.union([
+    zod.z.number().int().positive(),
+    zod.z.string().regex(/^[1-9][0-9]*$/, "must be a positive integer string"),
+    zod.z.string().uuid("must be a UUID")
+  ]).describe(
+    "Zapier connection ID. Positive integer (legacy) or UUID string (newer)."
+  )
+}).describe(
+  "Connection binding: maps a single alias to a concrete connection."
+);
+var AppVersionBindingSchema2 = zod.z.object({
+  implementation_name: zod.z.string().describe("App implementation identifier (e.g. 'SlackCLIAPI')"),
+  version: zod.z.string().optional().describe("App implementation version (e.g. '1.27.1')")
+}).describe("App-version binding: maps a single alias to an app version.");
+var WorkflowDraftStatusSchema = zod.z.enum(["open", "discarded"]).describe("Lifecycle status of a workflow draft.");
+var WorkflowClientAccessMethodSchema = zod.z.enum(["sdk_cli", "sdk_mcp", "zapier_mcp", "editor", "api", "unknown"]).describe(
+  "Client access method making this request. `sdk_cli` and `sdk_mcp` are derived by the server from the calling package; `zapier_mcp` is caller-declared."
+);
+var WORKFLOW_CLIENT_ATTRIBUTION_HARNESS_MAX_LENGTH = 64;
+var WORKFLOW_CLIENT_ATTRIBUTION_SDK_VERSION_MAX_LENGTH = 64;
+var WorkflowClientAttributionSchema = zod.z.object({
+  harness: zod.z.string().max(WORKFLOW_CLIENT_ATTRIBUTION_HARNESS_MAX_LENGTH).nullable().optional().describe("Client harness that made the request"),
+  access_method: zod.z.string().describe("Client access method that made the request (SDK, MCP, etc)"),
+  sdk_version: zod.z.string().max(WORKFLOW_CLIENT_ATTRIBUTION_SDK_VERSION_MAX_LENGTH).nullable().optional().describe("Version of the client package or SDK that made the request")
+}).describe("Client identity recorded for a workflow, draft or version write");
+var WorkflowClientAttributionFieldSchema = WorkflowClientAttributionSchema.nullable().optional().describe("Client that made the request").meta({ internal: true });
+var WorkflowClientAttributionInputSchema = zod.z.object({
+  creationHarness: WorkflowClientAttributionSchema.shape.harness.describe(
+    "Optional client harness making this request; null means the client did not report a harness"
+  ).meta({ internal: true }),
+  creationAccessMethod: WorkflowClientAccessMethodSchema.optional().describe(
+    WorkflowClientAccessMethodSchema.description ?? "Client access method making this request"
+  ).meta({ internal: true })
+});
+function hasAccessMethodForHarness({
+  creationHarness,
+  creationAccessMethod
+}) {
+  return creationHarness === void 0 || creationAccessMethod !== void 0;
+}
+var HARNESS_WITHOUT_ACCESS_METHOD_ISSUE = {
+  message: "creationAccessMethod is required when creationHarness is provided",
+  path: ["creationAccessMethod"]
+};
+var WorkflowVersionTriggerConfigSchema = zod.z.object({
+  selected_api: zod.z.string().describe("Zapier app/API identifier (e.g. 'GoogleSheetsAPI')"),
+  action: zod.z.string().describe("Trigger action key (e.g. 'new_row')"),
+  authentication_id: zod.z.string().nullish().describe(
+    "Connection ID for the trigger source. Omit or pass null for no-auth triggers (e.g. Schedule by Zapier)."
+  ),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Trigger parameters as a JSON object")
+}).describe("Trigger configuration persisted on a workflow version.");
+var WorkflowDraftSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow draft ID (UUID)"),
+  workflow_id: zod.z.string().describe("Parent workflow ID (UUID)"),
+  slug: zod.z.string().describe(
+    "Human-friendly display name, not an identifier: two open drafts of a workflow may share one"
+  ),
+  base_version_id: zod.z.string().nullable().describe(
+    "The version this draft was forked from (the live version at draft creation), or null when the workflow had no published version yet"
+  ),
+  source_files: zod.z.record(zod.z.string(), zod.z.string()).describe("Source files keyed by filename \u2192 contents"),
+  zapier_durable_version: zod.z.string().describe("Pinned semver of @zapier/zapier-durable used by this draft"),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).nullable().describe("Additional npm dependencies pinned for this draft (or null)"),
+  draft_revision: zod.z.number().int().describe(
+    "Monotonic revision counter for optimistic concurrency. Echo it back on draft updates to detect concurrent edits."
+  ),
+  status: WorkflowDraftStatusSchema,
+  created_by_user_id: zod.z.string().describe("ID of the user who created (forked) this draft"),
+  last_edited_by_user_id: zod.z.string().nullable().describe("ID of the user who last saved this draft (or null)"),
+  last_edited_at: zod.z.string().nullable().describe("When the draft was last edited (ISO-8601, or null)"),
+  discarded_at: zod.z.string().nullable().describe("When the draft was discarded (ISO-8601), or null while open"),
+  created_at: zod.z.string().describe("When the draft was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the draft row was last updated (ISO-8601)"),
+  trigger: WorkflowVersionTriggerConfigSchema.nullable().describe(
+    "Trigger configuration held on this draft, or null for webhook-only workflows."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this draft (or null)."),
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this draft (or null)."),
+  creation_client: WorkflowClientAttributionFieldSchema,
+  last_edited_client: WorkflowClientAttributionFieldSchema
+});
+var WorkflowVersionSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow version ID (UUID)"),
+  workflow_id: zod.z.string().describe("Parent workflow ID (UUID)"),
+  source_files: zod.z.record(zod.z.string(), zod.z.string()).describe("Source files keyed by filename \u2192 contents"),
+  zapier_durable_version: zod.z.string().describe(
+    "Pinned semver of @zapier/zapier-durable used by this version's runs"
+  ),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).nullable().describe("Additional npm dependencies pinned for this version (or null)"),
+  created_by_user_id: zod.z.string().describe("ID of the user who published this version"),
+  created_at: zod.z.string().describe("When the version was published (ISO-8601)"),
+  trigger: WorkflowVersionTriggerConfigSchema.nullable().describe(
+    "Trigger configuration persisted on this version, or null for webhook-only workflows."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null)."),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+var WorkflowTriggerStatusSchema = zod.z.enum([
+  "unclaimed",
+  "pending",
+  "active",
+  "releasing",
+  "released",
+  "failed"
+]);
+var WorkflowDisabledReasonSchema = zod.z.enum(["trigger_claim_failed"]);
+var WorkflowTriggerDetailsSchema = zod.z.object({
+  webhook_url: zod.z.string().optional().describe(
+    "Public catch URL for this trigger. Present on catch-hook triggers (e.g. Webhooks by Zapier)."
+  )
+}).describe("Trigger-type-specific metadata. Shape varies by trigger type.");
+var WorkflowTriggerSchema = zod.z.object({
+  selected_api: zod.z.string().describe("Zapier app/API identifier (e.g. 'GoogleSheetsAPI')"),
+  action: zod.z.string().describe("Trigger action key (e.g. 'new_row')"),
+  authentication_id: zod.z.string().nullish().describe(
+    "Connection ID for the trigger source. Null for no-auth triggers."
+  ),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Trigger parameters as a JSON object"),
+  status: WorkflowTriggerStatusSchema.describe(
+    "Live trigger claim status \u2014 whether the trigger is currently subscribed to its source."
+  ),
+  // Optional until COSUB-630 ships the field server-side; afterwards the API
+  // always sends it (null unless status=failed). Already sanitized at write
+  // time — surface verbatim.
+  error: zod.z.string().nullable().optional().describe(
+    "Failure reason for the latest claim. Present (non-null) only when status is 'failed'."
+  ),
+  // webhook_url is named in this prose because the generated README doesn't
+  // expand fields nested this deep.
+  details: WorkflowTriggerDetailsSchema.nullable().optional().describe(
+    "Trigger-type-specific metadata; shape varies by trigger type (e.g. `webhook_url` on catch-hook triggers). Null or absent when none applies."
+  )
+}).describe(
+  "Trigger from a workflow's current version, combined with the live claim status."
+);
+
+// src/plugins/codeSubstrate/listWorkflows/schemas.ts
+var WorkflowItemSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  name: zod.z.string().describe("Workflow name"),
+  description: zod.z.string().nullable().describe("Optional workflow description (null if unset)"),
+  trigger_url: WorkflowTriggerUrlSchema,
+  editor_url: WorkflowEditorUrlSchema,
+  enabled: zod.z.boolean().describe("Whether the workflow currently accepts triggers"),
+  // Optional until COSUB-630 ships the field server-side; afterwards the API
+  // always sends it (null unless the workflow was system-disabled).
+  disabled_reason: WorkflowDisabledReasonSchema.nullable().optional().describe(
+    "Why the workflow is off, when system-disabled. Null when not system-disabled."
+  ),
+  is_private: zod.z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  created_by_user_id: zod.z.string().nullable().describe("User ID of the workflow creator (null in legacy data)"),
+  current_version_id: zod.z.string().nullable().describe(
+    "ID of the workflow version that runs handle. Null until a version is published."
+  ),
+  triggers: zod.z.array(WorkflowTriggerSchema).describe(
+    "Trigger configurations from the current version, with live claim status. Empty array when the workflow has no triggers."
+  ),
+  created_at: zod.z.string().describe("When the workflow was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the workflow was last modified (ISO-8601)"),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+var ListWorkflowsOptionsSchema = zod.z.object({
+  pageSize: zod.z.number().int().min(1).max(100).optional().describe("Number of workflows per page (max 100)"),
+  maxItems: zod.z.number().int().min(1).optional().describe("Maximum total workflows to return across all pages"),
+  cursor: zod.z.string().optional().describe("Cursor to start from for pagination")
+}).describe("List all active durable workflows for the authenticated account");
+var ListWorkflowsApiResponseSchema = zod.z.object({
+  results: zod.z.array(WorkflowItemSchema),
+  meta: zod.z.object({
+    limit: zod.z.number(),
+    cursor: zod.z.string().nullable().optional(),
+    next_cursor: zod.z.string().nullable().optional()
+  }),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+
+// src/plugins/codeSubstrate/listWorkflows/index.ts
+var listWorkflowsPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "listWorkflows",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "list",
+  itemType: "Workflow",
+  inputSchema: ListWorkflowsOptionsSchema,
+  outputSchema: WorkflowItemSchema,
+  skipOutputValidation: true,
+  // The handler already returns a clean `{ data, nextCursor }` page, so the
+  // standard list output (no `adaptPage`) applies.
+  output: { type: "list", defaultPageSize: chunkTJXDMXEE_cjs.DEFAULT_PAGE_SIZE },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const searchParams = {};
+    if (input.pageSize !== void 0) {
+      searchParams.limit = input.pageSize.toString();
+    }
+    if (input.cursor) {
+      searchParams.cursor = input.cursor;
+    }
+    const raw = await api.get(`${CODE_SUBSTRATE_WORKFLOWS_API}/workflows`, {
+      searchParams,
+      authRequired: true
+    });
+    const response = ListWorkflowsApiResponseSchema.parse(raw);
+    return {
+      data: response.results,
+      nextCursor: response.meta.next_cursor ?? void 0
+    };
+  }
+});
+var WorkflowVersionSchema2 = zod.z.object({
+  id: zod.z.string().describe("Workflow version ID (UUID)"),
+  workflow_id: zod.z.string().describe("Parent workflow ID"),
+  source_files: zod.z.record(zod.z.string(), zod.z.string()).describe("Source files keyed by filename \u2192 contents"),
+  zapier_durable_version: zod.z.string().describe(
+    "Pinned semver of @zapier/zapier-durable used by this version's runs"
+  ),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).nullable().describe("Additional npm dependencies pinned for this version (or null)"),
+  // Backend column is NOT NULL (see code-substrate-workflows prisma schema:
+  // workflow_versions.created_by_user_id), so this is always emitted.
+  created_by_user_id: zod.z.string().describe("ID of the user who published this version"),
+  created_at: zod.z.string().describe("When the version was published (ISO-8601)"),
+  trigger: WorkflowVersionTriggerConfigSchema.nullable().describe(
+    "Trigger configuration persisted on this version, or null for webhook-only workflows."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null)."),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+var GetWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID")
+}).describe(
+  "Get a durable workflow with its current version details and trigger claim status"
+);
+var GetWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  name: zod.z.string().describe("Workflow name"),
+  description: zod.z.string().nullable().describe("Optional workflow description (null if unset)"),
+  trigger_url: WorkflowTriggerUrlSchema,
+  editor_url: WorkflowEditorUrlSchema,
+  enabled: zod.z.boolean().describe("Whether the workflow currently accepts triggers"),
+  // Optional until COSUB-630 ships the field server-side; afterwards the API
+  // always sends it (null unless the workflow was system-disabled). Kept
+  // independent of per-trigger status+error — see WorkflowDisabledReasonSchema.
+  disabled_reason: WorkflowDisabledReasonSchema.nullable().optional().describe(
+    "Why the workflow is off, when system-disabled. Null when not system-disabled. Independent of per-trigger claim status: an enabled workflow can still have a failed trigger."
+  ),
+  is_private: zod.z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  created_by_user_id: zod.z.string().nullable().describe("User ID of the workflow creator (null in legacy data)"),
+  current_version: WorkflowVersionSchema2.optional().describe(
+    "The currently published version, if any. Absent for workflows with no version published yet."
+  ),
+  triggers: zod.z.array(WorkflowTriggerSchema).describe(
+    "Trigger configurations from the current version, with live claim status. Empty array when the workflow has no triggers."
+  ),
+  created_at: zod.z.string().describe("When the workflow was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the workflow was last modified (ISO-8601)"),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+
+// src/plugins/codeSubstrate/getWorkflow/index.ts
+var getWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "Workflow",
+  inputSchema: GetWorkflowOptionsSchema,
+  outputSchema: GetWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}`,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: GetWorkflowResponseSchema.parse(raw) };
+  }
+});
+var CreateWorkflowOptionsSchema = zod.z.object({
+  name: zod.z.string().min(1).describe("Workflow name"),
+  description: zod.z.string().optional().describe("Optional description for the workflow"),
+  private: zod.z.boolean().optional().describe(
+    "If true, only the creating user can see or manage this workflow. Defaults to false (account-visible)."
+  ),
+  ...WorkflowClientAttributionInputSchema.shape,
+  /** @deprecated Use `private` instead. */
+  is_private: zod.z.boolean().optional().describe(
+    "If true, only the creating user can see or manage this workflow. Defaults to false (account-visible)."
+  ).meta({ deprecated: true })
+}).refine(hasAccessMethodForHarness, HARNESS_WITHOUT_ACCESS_METHOD_ISSUE).describe(
+  "Create a durable workflow container. Starts disabled with no version; publish a version to add code."
+);
+var CreateWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  name: zod.z.string().describe("Workflow name"),
+  description: zod.z.string().nullable().describe("Workflow description (null if unset)"),
+  trigger_url: WorkflowTriggerUrlSchema,
+  editor_url: WorkflowEditorUrlSchema,
+  enabled: zod.z.boolean().describe(
+    "Whether the workflow currently accepts triggers. Always false on a new workflow until enabled."
+  ),
+  is_private: zod.z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  created_by_user_id: zod.z.string().nullable().describe("User ID of the workflow creator (null in legacy data)"),
+  created_at: zod.z.string().describe("When the workflow was created (ISO-8601)"),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+
+// src/plugins/codeSubstrate/createWorkflow/index.ts
+var createWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "createWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "Workflow",
+  inputSchema: CreateWorkflowOptionsSchema,
+  outputSchema: CreateWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = { name: input.name };
+    if (input.description !== void 0) {
+      body.description = input.description;
+    }
+    const isPrivate = input.private ?? input.is_private;
+    if (isPrivate !== void 0) {
+      body.is_private = isPrivate;
+    }
+    const creationClient = toWireWorkflowClientAttribution(input);
+    if (creationClient !== void 0) {
+      body.creation_client = creationClient;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows`,
+      body,
+      {
+        authRequired: true
+      }
+    );
+    return { data: CreateWorkflowResponseSchema.parse(raw) };
+  }
+});
+var ImportWorkflowOptionsSchema = zod.z.object({
+  zap: zod.z.string().min(1).max(128).describe(
+    "ID of the Zap to import. Must be owned by the requesting user. Recorded on the created workflow as source_zap_id."
+  ),
+  name: zod.z.string().optional().describe(
+    `Name for the created workflow. Defaults to a kebab-cased form of the Zap's title, or "imported-workflow" when the Zap has no title.`
+  ),
+  private: zod.z.boolean().optional().describe(
+    "Restrict the created workflow to the creating user. Defaults to false, which makes it account-visible."
+  ),
+  ...WorkflowClientAttributionInputSchema.shape
+}).refine(hasAccessMethodForHarness, HARNESS_WITHOUT_ACCESS_METHOD_ISSUE).describe(
+  "Convert an existing Zap into a durable workflow. Transforms the Zap's latest published version (falling back to its draft only when the Zap has never been published) and puts the resulting source in an open draft. The workflow is created disabled with no published version, so publish the draft to make it live. The original Zap is untouched and keeps running."
+);
+var TranslationIssueSchema = zod.z.object({
+  line: zod.z.number().int().describe(
+    "1-based line in the generated source the issue relates to, or 0 when not line-specific."
+  ),
+  column: zod.z.number().int().describe("1-based column, or 0 when not column-specific."),
+  node_kind: zod.z.string().describe(
+    'Category of the issue, used to group and message them, e.g. "invalid-connection-id", "DelayStep", "app-version-conflict".'
+  ),
+  step_name: zod.z.string().optional().describe("ZDL step id or name the issue originated from, when known."),
+  message: zod.z.string().describe("Human-readable description of the issue."),
+  blocking: zod.z.boolean().describe(
+    "Whether the issue must be resolved before the draft can be published. Computed server-side, so callers do not re-derive it. A blocking issue does not prevent the draft being created."
+  )
+});
+var ImportedWorkflowSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  name: zod.z.string().describe("Workflow name"),
+  description: zod.z.string().nullable().optional().describe("Optional workflow description (null if unset)"),
+  trigger_url: WorkflowTriggerUrlSchema,
+  editor_url: WorkflowEditorUrlSchema,
+  enabled: zod.z.boolean().describe(
+    "Whether the workflow accepts triggers. An import always lands disabled."
+  ),
+  disabled_reason: WorkflowDisabledReasonSchema.nullable().optional().describe("Why the workflow is off, when system-disabled."),
+  is_private: zod.z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  source_zap_id: zod.z.string().nullable().optional().describe("The Zap this workflow was imported from."),
+  created_by_user_id: zod.z.string(),
+  updated_by_user_id: zod.z.string().nullable().optional(),
+  current_version_id: zod.z.string().nullable().optional().describe("Null on a fresh import, which has no published version yet."),
+  triggers: zod.z.array(WorkflowTriggerSchema).describe("Empty on a fresh import, which has no published version yet."),
+  created_at: zod.z.string(),
+  updated_at: zod.z.string().optional()
+});
+var ImportWorkflowResponseSchema = zod.z.object({
+  workflow: ImportedWorkflowSchema.describe(
+    "The created workflow. Disabled, with no published version, and source_zap_id set to the imported Zap."
+  ),
+  draft: WorkflowDraftSchema.describe(
+    "The open draft holding the transformed source."
+  ),
+  issues: zod.z.array(TranslationIssueSchema).describe(
+    "Blocking and non-blocking translation issues from the transform, passed through unchanged. Blocking issues do not prevent draft creation; they must be resolved before the draft will publish."
+  )
+});
+
+// src/plugins/codeSubstrate/importWorkflow/index.ts
+var importWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "importWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "Workflow",
+  // The response is the composite `{ workflow, draft, issues }`, not the bare
+  // `WorkflowItem` the docs generator derives from itemType.
+  returnType: "ImportWorkflowResponse",
+  inputSchema: ImportWorkflowOptionsSchema,
+  outputSchema: ImportWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = { zap_id: input.zap };
+    if (input.name !== void 0) {
+      body.name = input.name;
+    }
+    if (input.private !== void 0) {
+      body.is_private = input.private;
+    }
+    const creationClient = toWireWorkflowClientAttribution(input);
+    if (creationClient !== void 0) {
+      body.creation_client = creationClient;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/import`,
+      body,
+      {
+        authRequired: true,
+        // Import is owner-gated upstream: the endpoint refuses a Zap the
+        // requesting user does not own. A bare 403 tells the caller nothing
+        // about which gate they hit or what to do, so name both.
+        customErrorHandler: ({ status, data }) => {
+          if (status === 403) {
+            const detail = chunkTJXDMXEE_cjs.extractErrorDetail(data);
+            return new chunkTJXDMXEE_cjs.ZapierApiError(
+              `${detail ?? "Zap import forbidden"} \u2014 only Zaps owned by the requesting user can be imported. Check the Zap ID belongs to this user, or ask its owner to run the import. Retrying will not help.`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    return { data: ImportWorkflowResponseSchema.parse(raw) };
+  }
+});
+var UpdateWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  name: zod.z.string().min(1).optional().describe("New name for the workflow"),
+  description: zod.z.string().nullish().describe("New description for the workflow (pass null to clear)")
+}).refine((data) => data.name !== void 0 || data.description !== void 0, {
+  message: "Provide name or description (at least one is required)"
+}).describe("Update a durable workflow's name and/or description");
+var UpdateWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  name: zod.z.string().describe("Workflow name (post-update)"),
+  description: zod.z.string().nullable().describe("Workflow description, post-update (null if unset)"),
+  trigger_url: WorkflowTriggerUrlSchema,
+  editor_url: WorkflowEditorUrlSchema,
+  enabled: zod.z.boolean().describe("Whether the workflow currently accepts triggers"),
+  is_private: zod.z.boolean().describe(
+    "Whether the workflow is private to the creating user. False means account-visible."
+  ),
+  created_by_user_id: zod.z.string().nullable().describe("User ID of the workflow creator (null in legacy data)"),
+  created_at: zod.z.string().describe("When the workflow was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When this update was applied (ISO-8601)")
+});
+
+// src/plugins/codeSubstrate/updateWorkflow/index.ts
+var updateWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "updateWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "update",
+  itemType: "Workflow",
+  inputSchema: UpdateWorkflowOptionsSchema,
+  outputSchema: UpdateWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = {};
+    if (input.name !== void 0) {
+      body.name = input.name;
+    }
+    if (input.description !== void 0) {
+      body.description = input.description;
+    }
+    const raw = await api.patch(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: UpdateWorkflowResponseSchema.parse(raw) };
+  }
+});
+var EnableWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID")
+}).describe("Enable a durable workflow so it accepts triggers");
+var EnableWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  enabled: zod.z.boolean().describe("Workflow's enabled state after the operation (always true)")
+});
+
+// src/plugins/codeSubstrate/enableWorkflow/index.ts
+var enableWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "enableWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "update",
+  itemType: "Workflow",
+  inputSchema: EnableWorkflowOptionsSchema,
+  outputSchema: EnableWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/enable`,
+      void 0,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: EnableWorkflowResponseSchema.parse(raw) };
+  }
+});
+var DisableWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID")
+}).describe("Disable a durable workflow so it stops accepting triggers");
+var DisableWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID (UUID)"),
+  enabled: zod.z.boolean().describe(
+    "Workflow's enabled state after the operation. Typically false; mirrors the row's true state in case a concurrent enable raced with this call."
+  )
+});
+
+// src/plugins/codeSubstrate/disableWorkflow/index.ts
+var disableWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "disableWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "update",
+  itemType: "Workflow",
+  inputSchema: DisableWorkflowOptionsSchema,
+  outputSchema: DisableWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/disable`,
+      void 0,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: DisableWorkflowResponseSchema.parse(raw) };
+  }
+});
+var DeleteWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID")
+}).describe(
+  "Delete a durable workflow. Throws `ZapierNotFoundError` if the workflow doesn't exist; callers wanting idempotency should catch that themselves."
+);
+var DeleteWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow ID that was targeted for deletion")
+});
+
+// src/plugins/codeSubstrate/deleteWorkflow/index.ts
+var deleteWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "deleteWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "delete",
+  itemType: "Workflow",
+  confirm: "delete",
+  inputSchema: DeleteWorkflowOptionsSchema,
+  outputSchema: DeleteWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "raw",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    await api.delete(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}`,
+      void 0,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: { id: input.workflow } };
+  }
+});
+var RunStatusSchema = kitcore.openEnum(
+  ["initialized", "started", "finished", "failed", "cancelled"],
+  "Run lifecycle status. `finished` / `failed` / `cancelled` are terminal."
+);
+var RunErrorSchema = zod.z.object({
+  code: zod.z.string().describe("Machine-readable error category"),
+  message: zod.z.string().describe("Human-readable error summary")
+}).passthrough().describe(
+  "Structured run error. Always carries `code` and `message`; additional keys may appear depending on the error type."
+);
+var RunItemSchema = zod.z.object({
+  id: zod.z.string().describe("Run ID (UUID)"),
+  status: RunStatusSchema,
+  input: zod.z.unknown().describe("Input data passed to the run"),
+  output: zod.z.unknown().nullable().describe("Return value, present when status is `finished`"),
+  error: RunErrorSchema.nullable().describe(
+    "Structured error details when the run failed (null otherwise)"
+  ),
+  execution_id: zod.z.string().nullable().describe(
+    "Linked execution ID. Null until the run leaves the `initialized` state."
+  ),
+  is_private: zod.z.boolean().describe(
+    "When true, the run is visible only to the creating user; otherwise visible across the account."
+  ),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+var ListDurableRunsOptionsSchema = zod.z.object({
+  pageSize: zod.z.number().min(1).max(100).optional().describe("Number of runs per page (max 100)"),
+  cursor: zod.z.string().optional().describe("Pagination cursor"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
+}).describe(
+  "List run-once durable runs for the authenticated account, newest first"
+);
+var ListDurableRunsApiResponseSchema = zod.z.object({
+  results: zod.z.array(RunItemSchema),
+  meta: zod.z.object({
+    limit: zod.z.number(),
+    cursor: zod.z.string().nullable().optional(),
+    next_cursor: zod.z.string().nullable().optional()
+  }),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+
+// src/plugins/codeSubstrate/listDurableRuns/index.ts
+var listDurableRunsPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "listDurableRuns",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "list",
+  itemType: "DurableRun",
+  inputSchema: ListDurableRunsOptionsSchema,
+  outputSchema: RunItemSchema,
+  skipOutputValidation: true,
+  // The handler already returns a clean `{ data, nextCursor }` page, so the
+  // standard list output (no `adaptPage`) applies.
+  output: { type: "list", defaultPageSize: chunkTJXDMXEE_cjs.DEFAULT_PAGE_SIZE },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const searchParams = {};
+    if (input.pageSize !== void 0) {
+      searchParams.limit = input.pageSize.toString();
+    }
+    if (input.cursor) {
+      searchParams.cursor = input.cursor;
+    }
+    const raw = await api.get(`${CODE_SUBSTRATE_RUNNER_API}/runs`, {
+      searchParams,
+      authRequired: true
+    });
+    const response = ListDurableRunsApiResponseSchema.parse(raw);
+    return {
+      data: response.results,
+      nextCursor: response.meta.next_cursor ?? void 0
+    };
+  }
+});
+var OperationTypeSchema = kitcore.openEnum(
+  ["step", "wait", "callback"],
+  "Operation kind: `step` is a journaled function call; `wait` is a time-based suspension; `callback` is a wait on an external callback."
+);
+var OperationStatusSchema = kitcore.openEnum(
+  ["pending", "completed", "failed", "exhausted", "expired"],
+  "Operation lifecycle status. `exhausted` means retries were exceeded; `expired` means a callback's deadline passed without delivery."
+);
+var OperationSchema = zod.z.object({
+  id: zod.z.string().describe("Operation ID (UUID)"),
+  execution_id: zod.z.string().describe("Parent execution ID"),
+  name: zod.z.string().describe("Operation name as declared by the workflow author"),
+  type: OperationTypeSchema,
+  status: OperationStatusSchema,
+  result: zod.z.unknown().optional().describe("Result value when the operation completed"),
+  error: zod.z.unknown().optional().describe("Error payload when the operation failed"),
+  retry_count: zod.z.number().describe("Number of retry attempts so far"),
+  max_attempts: zod.z.number().optional().describe(
+    "Cap on total attempts for this operation. Absent if no cap applies."
+  ),
+  next_retry_at: zod.z.string().nullable().optional().describe("When the next retry will be attempted (ISO-8601)"),
+  resume_at: zod.z.string().nullable().optional().describe(
+    "When a `wait` operation resumes (ISO-8601). Set only for type=wait."
+  ),
+  callback_token: zod.z.string().nullable().optional().describe(
+    "Token for delivering a callback. Set only for type=callback; null until the callback URL is materialized."
+  ),
+  payload_schema: zod.z.unknown().optional().describe("JSON Schema describing the expected callback payload"),
+  payload: zod.z.unknown().optional().describe("Payload delivered to a callback operation, when received"),
+  expires_at: zod.z.string().nullable().optional().describe("When a callback or wait operation expires (ISO-8601)"),
+  timeout_seconds: zod.z.number().nullable().optional().describe(
+    "Requested callback timeout in seconds, used to set `expires_at`. Absent or null for non-callback operations and callbacks without a timeout."
+  ),
+  completed_at: zod.z.string().nullable().optional().describe("When the operation reached a terminal state (ISO-8601)"),
+  created_at: zod.z.string().describe("When the operation was created (ISO-8601)")
+});
+var ExecutionStatusSchema = kitcore.openEnum(
+  ["running", "waiting", "completed", "failed"],
+  "Execution lifecycle status. `waiting` means blocked on a wait or callback operation."
+);
+var ExecutionSummarySchema = zod.z.object({
+  id: zod.z.string().describe("Execution ID (UUID)"),
+  name: zod.z.string().describe("Durable function name"),
+  status: ExecutionStatusSchema,
+  input: zod.z.unknown().describe("Input passed when the execution was created"),
+  output: zod.z.unknown().optional().describe("Return value when status is `completed`"),
+  error: zod.z.unknown().optional().describe("Error details when status is `failed`"),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe(
+    "Caller-supplied tags (Zap ID, Step ID, Agent ID, etc.) carried alongside the execution"
+  ),
+  created_at: zod.z.string().describe("When the execution was created (ISO-8601)"),
+  summary: zod.z.object({
+    total_attempts: zod.z.number().describe(
+      "Total ticks attempted against this execution across all retries"
+    ),
+    last_error: zod.z.object({
+      code: zod.z.string().describe("Machine-readable error category"),
+      title: zod.z.string().describe("Short error label"),
+      detail: zod.z.string().nullable().optional().describe("Longer-form error detail, when provided")
+    }).passthrough().nullable().optional().describe(
+      "The most recent error; null when the execution has not errored."
+    )
+  }).passthrough().nullable().optional().describe(
+    "Aggregate health summary. Null when no attempts have been recorded yet."
+  ),
+  operations: zod.z.array(OperationSchema).optional().describe(
+    "Operations journal \u2014 append-only record of every step/wait/callback the execution made"
+  )
+});
+var GetDurableRunOptionsSchema = zod.z.object({
+  run: zod.z.string().uuid().describe("Durable run ID")
+}).describe(
+  "Get the full state of a run-once durable run, including its operations journal"
+);
+var GetDurableRunResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Run ID (UUID)"),
+  status: RunStatusSchema,
+  input: zod.z.unknown().describe("Input data passed to the run"),
+  output: zod.z.unknown().nullable().describe("Return value, present when status is `finished`"),
+  error: RunErrorSchema.nullable().describe(
+    "Structured error details when the run failed (null otherwise)"
+  ),
+  execution: ExecutionSummarySchema.nullable().describe(
+    "Linked execution, including the operations journal. Null while the run is still in `initialized` state."
+  ),
+  is_private: zod.z.boolean().describe(
+    "When true, the run is visible only to the creating user; otherwise visible across the account."
+  ),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+
+// src/plugins/codeSubstrate/getDurableRun/index.ts
+var getDurableRunPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getDurableRun",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "DurableRun",
+  inputSchema: GetDurableRunOptionsSchema,
+  outputSchema: GetDurableRunResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { run: chunkTJXDMXEE_cjs.durableRunIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_RUNNER_API}/runs/${encodeURIComponent(input.run)}`,
+      {
+        authRequired: true,
+        resource: { type: "run", id: input.run }
+      }
+    );
+    return { data: GetDurableRunResponseSchema.parse(raw) };
+  }
+});
+var RunNotificationEventSchema = zod.z.enum(["started", "progress", "completed", "error", "cancelled"]).describe("Run lifecycle event this notification subscribes to");
+var RunNotificationSchema = zod.z.object({
+  type: zod.z.literal("webhook").optional().describe("Notification transport. Webhook is the only supported type."),
+  url: zod.z.string().url().describe(
+    "URL to POST event notifications to. Payload is `{run_id, event}`."
+  ),
+  max_retries: zod.z.number().int().min(0).max(10).optional().describe(
+    "Max delivery attempts with exponential backoff. Defaults to 3 server-side."
+  ),
+  events: zod.z.array(RunNotificationEventSchema).min(1).describe("One or more lifecycle events to subscribe this URL to.")
+}).describe(
+  "Webhook subscriber for run lifecycle events. Server POSTs `{run_id, event}` on each subscribed transition."
+);
+var RunDurableBaseSchema = zod.z.object({
+  input: JsonPayloadSchema.optional().describe(
+    "Input data passed to the run. Accepts any JSON value, or its JSON-string encoding."
+  ),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional().describe(
+    'Optional npm package dependencies. A version of "latest" is resolved by the server for @zapier/zapier-durable and @zapier/zapier-sdk only; every other value, including a "latest" on any other package, is passed to the install as written.'
+  ),
+  zapierDurableVersion: zod.z.string().optional().describe(
+    `Exact semver of @zapier/zapier-durable to use (e.g. "1.2.3"), or "latest". Defaults to the server-configured version if omitted. "latest" is resolved by the server to the newest release old enough to clear the sandbox install age gate (24h) -- this is not npm's "latest" tag, which can point at a release too new to install. Ranges (^1.2.3, ~1.2) are rejected.`
+  ),
+  /** @deprecated Use `zapierDurableVersion` instead. */
+  zapier_durable_version: zod.z.string().optional().meta({ deprecated: true }),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema).optional().describe(
+    'Named connection aliases. Maps each alias to an object holding its Zapier connection ID, e.g. `{ "slack": { "connectionId": "123" } }`.'
+  ),
+  appVersions: zod.z.record(zod.z.string(), AppVersionBindingSchema).optional().describe(
+    "Pinned app versions. Maps app keys (slugs) to implementation names and versions."
+  ),
+  /** @deprecated Use `appVersions` instead. */
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema).optional().meta({ deprecated: true }),
+  private: zod.z.boolean().optional().describe("Only the creating user can see the run (default false)"),
+  notifications: zod.z.array(RunNotificationSchema).optional().describe(
+    "Webhook subscribers for run lifecycle events. Each entry specifies a URL and the events it subscribes to."
+  )
+});
+var RunDurableDescription = "Run a workflow's complete source-files map as a run-once durable run on code-substrate-runner (no deployed workflow required). Send every file the workflow needs, not only its entry point. Returns the run ID immediately; poll via getDurableRun for terminal status.";
+var RunDurableSchema = zod.z.object({ sourceFiles: SourceFilesSchema }).merge(RunDurableBaseSchema).describe(RunDurableDescription).meta({
+  aliases: {
+    source_files: "sourceFiles",
+    zapier_durable_version: "zapierDurableVersion",
+    app_versions: "appVersions"
+  }
+});
+var RunDurableSchemaDeprecated = zod.z.object({ source_files: SourceFilesSchema }).merge(RunDurableBaseSchema);
+var RunDurableOptionsSchema = zod.z.union([RunDurableSchema, RunDurableSchemaDeprecated]).describe(RunDurableDescription);
+var RunDurableResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Run ID (UUID) \u2014 server-generated, time-sortable"),
+  status: zod.z.literal("initialized").describe(
+    "Always `initialized` on creation. Poll via getDurableRun to observe the run advancing to `started` / `finished` / `failed` / `cancelled`."
+  ),
+  is_private: zod.z.boolean().describe(
+    "When true, the run is visible only to the creating user; otherwise visible across the account."
+  ),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)")
+});
+var sourceFilesResolver = kitcore.defineResolver({
+  type: "object",
+  additionalKeys: {
+    minEntries: 1,
+    keys: kitcore.defineResolver({
+      type: "static",
+      inputType: "text",
+      placeholder: "filename (e.g. index.ts)"
+    }),
+    values: kitcore.defineResolver({
+      type: "static",
+      inputType: "text",
+      placeholder: "file contents"
+    }),
+    keyValueType: "string",
+    valueValueType: "string"
+  }
+});
+
+// src/plugins/codeSubstrate/runDurable/index.ts
+var runDurablePlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "runDurable",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "DurableRun",
+  inputSchema: RunDurableOptionsSchema,
+  outputSchema: RunDurableResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { sourceFiles: sourceFilesResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const sourceFiles = "sourceFiles" in input ? input.sourceFiles : input.source_files;
+    const zapierDurableVersion = input.zapierDurableVersion ?? input.zapier_durable_version;
+    const appVersions = input.appVersions ?? input.app_versions;
+    const body = { source_files: sourceFiles };
+    if (input.input !== void 0) {
+      body.input = input.input;
+    }
+    if (input.dependencies !== void 0) {
+      body.dependencies = input.dependencies;
+    }
+    if (zapierDurableVersion !== void 0) {
+      body.zapier_durable_version = zapierDurableVersion;
+    }
+    if (input.connections !== void 0) {
+      body.connections = toWireConnections(input.connections);
+    }
+    if (appVersions !== void 0) {
+      body.app_versions = toWireAppVersions(appVersions);
+    }
+    if (input.private !== void 0) {
+      body.is_private = input.private;
+    }
+    if (input.notifications !== void 0) {
+      body.notifications = input.notifications;
+    }
+    const raw = await api.post(`${CODE_SUBSTRATE_RUNNER_API}/runs`, body, {
+      authRequired: true
+    });
+    return { data: RunDurableResponseSchema.parse(raw) };
+  }
+});
+var CancelDurableRunOptionsSchema = zod.z.object({
+  run: zod.z.string().uuid().describe("Durable run ID")
+}).describe(
+  "Cancel a run-once durable run in initialized or started status. Returns 409 if the run is already terminal."
+);
+var CancelDurableRunResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Run ID that was targeted"),
+  status: zod.z.literal("cancelled").describe(
+    "Always `cancelled` on a successful call. Synthesized client-side \u2014 the backend returns 204; callers needing the run's full state should follow up with getDurableRun."
+  )
+});
+
+// src/plugins/codeSubstrate/cancelDurableRun/index.ts
+var cancelDurableRunPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "cancelDurableRun",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "update",
+  itemType: "DurableRun",
+  inputSchema: CancelDurableRunOptionsSchema,
+  outputSchema: CancelDurableRunResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { run: chunkTJXDMXEE_cjs.durableRunIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    await api.post(
+      `${CODE_SUBSTRATE_RUNNER_API}/runs/${encodeURIComponent(input.run)}/cancel`,
+      void 0,
+      {
+        authRequired: true,
+        resource: { type: "run", id: input.run }
+      }
+    );
+    return { data: { id: input.run, status: "cancelled" } };
+  }
+});
+var PublishWorkflowVersionDescription = "Publish a new version of a durable workflow. Enables the workflow by default.";
+var PublishWorkflowVersionBaseSchema = zod.z.object({
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional().describe(
+    'Optional npm package dependencies. A version of "latest" is resolved by the server for @zapier/zapier-durable and @zapier/zapier-sdk only; every other value, including a "latest" on any other package, is passed to the install as written.'
+  ),
+  zapierDurableVersion: zod.z.string().optional().describe(
+    `Exact semver of @zapier/zapier-durable to use (e.g. "1.2.3"), or "latest". Defaults to the server-configured version if omitted. "latest" is resolved by the server to the newest release old enough to clear the sandbox install age gate (24h) -- this is not npm's "latest" tag, which can point at a release too new to install. Ranges (^1.2.3, ~1.2) are rejected.`
+  ),
+  /** @deprecated Use `zapierDurableVersion` instead. */
+  zapier_durable_version: zod.z.string().optional().meta({ deprecated: true }),
+  enabled: zod.z.boolean().optional().describe(
+    "Enable the workflow after publishing. Defaults to true if omitted; pass false to publish without enabling."
+  ).meta({ negatable: "disabled" }),
+  ignoreOpenDrafts: zod.z.boolean().optional().describe(
+    "Publish even though the workflow has open draft(s). Without this, the API rejects a direct publish with a 409 while any draft is open, since publishing the draft later would ship its stale content over this version."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema).nullish().describe(
+    "Map of connection aliases to Zapier connections used by the workflow. Pass `null` to clear an existing binding."
+  ),
+  appVersions: zod.z.record(zod.z.string(), AppVersionBindingSchema).nullish().describe(
+    "Map of app keys to pinned app implementation/version used by the workflow. Pass `null` to clear an existing binding."
+  ),
+  /** @deprecated Use `appVersions` instead. */
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema).nullish().meta({ deprecated: true }),
+  trigger: TriggerConfigSchema.optional().describe(
+    "Trigger configuration. When provided, the workflow subscribes to a Zapier trigger; for an on-demand, triggerless workflow, omit this and pass `manual: true` instead."
+  ),
+  manual: zod.z.boolean().optional().describe(
+    "Declare this an on-demand, triggerless workflow version. Pass `manual: true` only when omitting `trigger`; passing both is a contradiction the API rejects with a 400."
+  )
+});
+var WorkflowPropertySchema = zod.z.string().uuid().describe("Durable workflow ID");
+function hasNoTriggerManualConflict(data) {
+  return !(data.trigger !== void 0 && data.manual === true);
+}
+var TRIGGER_MANUAL_CONFLICT_MESSAGE = "Provide `trigger` or `manual: true`, not both \u2014 a trigger together with manual: true is a contradiction.";
+var PublishWorkflowVersionSchema = zod.z.object({
+  workflow: WorkflowPropertySchema,
+  sourceFiles: SourceFilesSchema
+}).merge(PublishWorkflowVersionBaseSchema).refine(hasNoTriggerManualConflict, {
+  message: TRIGGER_MANUAL_CONFLICT_MESSAGE
+}).describe(PublishWorkflowVersionDescription).meta({
+  aliases: {
+    source_files: "sourceFiles",
+    zapier_durable_version: "zapierDurableVersion",
+    app_versions: "appVersions"
+  }
+});
+var PublishWorkflowVersionSchemaDeprecated = zod.z.object({
+  workflow: WorkflowPropertySchema,
+  source_files: SourceFilesSchema
+}).merge(PublishWorkflowVersionBaseSchema).refine(hasNoTriggerManualConflict, {
+  message: TRIGGER_MANUAL_CONFLICT_MESSAGE
+});
+var PublishWorkflowVersionOptionsSchema = zod.z.union([PublishWorkflowVersionSchema, PublishWorkflowVersionSchemaDeprecated]).describe(PublishWorkflowVersionDescription);
+var PublishWorkflowVersionResponseSchema = WorkflowVersionSchema;
+
+// src/plugins/codeSubstrate/publishWorkflowVersion/index.ts
+function toOpenDraftRef(draft) {
+  if (typeof draft !== "object" || draft === null) return void 0;
+  const record = draft;
+  if (typeof record.id !== "string") return void 0;
+  const ref = { id: record.id };
+  if (typeof record.slug === "string") ref.slug = record.slug;
+  const lastEditedAt = record.last_edited_at;
+  if (typeof lastEditedAt === "string" || lastEditedAt === null) {
+    ref.last_edited_at = lastEditedAt;
+  }
+  const lastEditedByUserId = record.last_edited_by_user_id;
+  if (typeof lastEditedByUserId === "string" || lastEditedByUserId === null) {
+    ref.last_edited_by_user_id = lastEditedByUserId;
+  }
+  return ref;
+}
+function extractOpenDraftConflict(data) {
+  if (typeof data !== "object" || data === null) return void 0;
+  const errors = data.errors;
+  if (!Array.isArray(errors)) return void 0;
+  for (const entry of errors) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const meta = entry.meta;
+    if (typeof meta !== "object" || meta === null) continue;
+    const drafts = meta.open_drafts;
+    if (!Array.isArray(drafts)) continue;
+    const refs = drafts.map(toOpenDraftRef).filter((ref) => ref !== void 0);
+    if (refs.length === 0) continue;
+    const detail = entry.detail;
+    return {
+      openDrafts: refs,
+      detail: typeof detail === "string" ? detail : void 0
+    };
+  }
+  return void 0;
+}
+function describeOpenDraft(draft) {
+  const label = draft.slug ? `${draft.slug} (id: ${draft.id})` : draft.id;
+  return draft.last_edited_at ? `  \u2022 ${label}, last edited ${draft.last_edited_at}` : `  \u2022 ${label}`;
+}
+var publishWorkflowVersionPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "publishWorkflowVersion",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "WorkflowVersion",
+  inputSchema: PublishWorkflowVersionOptionsSchema,
+  outputSchema: PublishWorkflowVersionResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver, sourceFiles: sourceFilesResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const sourceFiles = "sourceFiles" in input ? input.sourceFiles : input.source_files;
+    const zapierDurableVersion = input.zapierDurableVersion ?? input.zapier_durable_version;
+    const appVersions = "appVersions" in input ? input.appVersions : input.app_versions;
+    const body = { source_files: sourceFiles };
+    if (input.dependencies !== void 0) {
+      body.dependencies = input.dependencies;
+    }
+    if (zapierDurableVersion !== void 0) {
+      body.zapier_durable_version = zapierDurableVersion;
+    }
+    if (input.enabled !== void 0) {
+      body.enabled = input.enabled;
+    }
+    if (input.ignoreOpenDrafts !== void 0) {
+      body.ignore_open_drafts = input.ignoreOpenDrafts;
+    }
+    if (input.connections === null) {
+      body.connections = null;
+    } else if (input.connections !== void 0) {
+      body.connections = toWireConnections(input.connections);
+    }
+    if (appVersions === null) {
+      body.app_versions = null;
+    } else if (appVersions !== void 0) {
+      body.app_versions = toWireAppVersions(appVersions);
+    }
+    if (input.trigger !== void 0) {
+      body.trigger = toWireTrigger(input.trigger);
+    }
+    if (input.manual !== void 0) {
+      body.manual = input.manual;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/versions`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow },
+        // Every 409 from this endpoint is a conflict, so every 409 maps to
+        // ZapierConflictError — mirroring publishWorkflowDraft, and keeping
+        // isZapierConflictError(error) reliable across both publish paths.
+        // The open-draft publish guard's 409 additionally carries
+        // `meta.open_drafts`; surface that list and the remediations instead
+        // of flattening to a generic message — otherwise the caller has to
+        // pick between force-publishing and draft-publishing without seeing
+        // what they'd be forcing over. The structured list rides on the
+        // error's `meta` for programmatic use (CLI --json).
+        customErrorHandler: ({ status, data }) => {
+          if (status !== 409) return void 0;
+          const conflict = extractOpenDraftConflict(data);
+          if (!conflict) {
+            return new chunkTJXDMXEE_cjs.ZapierConflictError(
+              chunkTJXDMXEE_cjs.extractErrorDetail(data) ?? "Workflow version publish conflict.",
+              { statusCode: status, resourceType: "workflow" }
+            );
+          }
+          const detail = conflict.detail ?? "Cannot publish over open draft(s).";
+          return new chunkTJXDMXEE_cjs.ZapierConflictError(
+            [
+              `${detail} Blocking draft(s):`,
+              ...conflict.openDrafts.map(describeOpenDraft),
+              "To keep a draft's changes, publish it with publishWorkflowDraft (CLI: publish-workflow-draft); to abandon them, discard it with discardWorkflowDraft (CLI: discard-workflow-draft); or force-publish over it by retrying with ignoreOpenDrafts: true (CLI: --ignore-open-drafts)."
+            ].join("\n"),
+            {
+              statusCode: status,
+              resourceType: "workflow",
+              meta: { open_drafts: conflict.openDrafts }
+            }
+          );
+        }
+      }
+    );
+    return { data: PublishWorkflowVersionResponseSchema.parse(raw) };
+  }
+});
+var WorkflowVersionListItemSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow version ID (UUID)"),
+  workflow_id: zod.z.string().describe("Parent workflow ID (UUID)"),
+  zapier_durable_version: zod.z.string().describe(
+    "Pinned semver of @zapier/zapier-durable used by this version's runs"
+  ),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).nullable().describe("Additional npm dependencies pinned for this version (or null)"),
+  created_by_user_id: zod.z.string().describe("ID of the user who published this version"),
+  created_at: zod.z.string().describe("When the version was published (ISO-8601)"),
+  trigger: WorkflowVersionTriggerConfigSchema.nullable().describe(
+    "Trigger configuration persisted on this version, or null for webhook-only workflows."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema2).nullable().describe("Connection aliases bound on this version (or null)."),
+  app_versions: zod.z.record(zod.z.string(), AppVersionBindingSchema2).nullable().describe("App-version pins bound on this version (or null)."),
+  creation_client: WorkflowClientAttributionFieldSchema
+});
+var ListWorkflowVersionsOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  pageSize: zod.z.number().int().min(1).max(100).optional().describe("Number of versions per page (max 100)"),
+  cursor: zod.z.string().optional().describe("Pagination cursor"),
+  maxItems: zod.z.number().int().min(1).optional().describe("Maximum total versions to return across all pages")
+}).describe("List published versions for a workflow, newest first");
+var ListWorkflowVersionsApiResponseSchema = zod.z.object({
+  results: zod.z.array(WorkflowVersionListItemSchema),
+  meta: zod.z.object({
+    limit: zod.z.number(),
+    cursor: zod.z.string().nullable().optional(),
+    next_cursor: zod.z.string().nullable().optional()
+  }),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+
+// src/plugins/codeSubstrate/listWorkflowVersions/index.ts
+var listWorkflowVersionsPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "listWorkflowVersions",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "list",
+  itemType: "WorkflowVersion",
+  inputSchema: ListWorkflowVersionsOptionsSchema,
+  outputSchema: WorkflowVersionListItemSchema,
+  skipOutputValidation: true,
+  // The handler already returns a clean `{ data, nextCursor }` page, so the
+  // standard list output (no `adaptPage`) applies.
+  output: { type: "list", defaultPageSize: chunkTJXDMXEE_cjs.DEFAULT_PAGE_SIZE },
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const searchParams = {};
+    if (input.pageSize !== void 0) {
+      searchParams.limit = input.pageSize.toString();
+    }
+    if (input.cursor) {
+      searchParams.cursor = input.cursor;
+    }
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/versions`,
+      {
+        searchParams,
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    const response = ListWorkflowVersionsApiResponseSchema.parse(raw);
+    return {
+      data: response.results,
+      nextCursor: response.meta.next_cursor ?? void 0
+    };
+  }
+});
+var GetWorkflowVersionOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  version: zod.z.string().uuid().describe("Workflow version ID")
+}).describe("Get full details of a workflow version including source files");
+var GetWorkflowVersionResponseSchema = WorkflowVersionSchema;
+
+// src/plugins/codeSubstrate/getWorkflowVersion/index.ts
+var getWorkflowVersionPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getWorkflowVersion",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "WorkflowVersion",
+  inputSchema: GetWorkflowVersionOptionsSchema,
+  outputSchema: GetWorkflowVersionResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    version: chunkTJXDMXEE_cjs.workflowVersionIdResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/versions/${encodeURIComponent(input.version)}`,
+      {
+        authRequired: true,
+        resource: { type: "workflow-version", id: input.version }
+      }
+    );
+    return { data: GetWorkflowVersionResponseSchema.parse(raw) };
+  }
+});
+var WorkflowDraftSummarySchema = zod.z.object({
+  id: zod.z.string().describe("Workflow draft ID (UUID)"),
+  workflow_id: zod.z.string().describe("Parent workflow ID (UUID)"),
+  slug: zod.z.string().describe(
+    "Human-friendly display name, not an identifier: two open drafts of a workflow may share one"
+  ),
+  base_version_id: zod.z.string().nullable().describe(
+    "The version this draft was forked from (the live version at draft creation), or null when the workflow had no published version yet"
+  ),
+  status: WorkflowDraftStatusSchema,
+  last_edited_by_user_id: zod.z.string().nullable().describe("ID of the user who last saved this draft (or null)"),
+  last_edited_at: zod.z.string().nullable().describe("When the draft was last edited (ISO-8601, or null)"),
+  created_at: zod.z.string().describe("When the draft was created (ISO-8601)"),
+  creation_client: WorkflowClientAttributionFieldSchema,
+  last_edited_client: WorkflowClientAttributionFieldSchema
+});
+var ListWorkflowDraftsOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  status: WorkflowDraftStatusSchema.optional().describe(
+    "Filter by draft status (server default: open)"
+  ),
+  slug: zod.z.string().optional().describe(
+    "Filter by exact slug match. Slugs are not unique, so this returns every draft with this slug matching the selected status, ordered by most recent activity and paginated"
+  ),
+  pageSize: zod.z.number().int().min(1).max(100).optional().describe("Number of drafts per page (max 100)"),
+  cursor: zod.z.string().optional().describe("Pagination cursor"),
+  maxItems: zod.z.number().int().min(1).optional().describe("Maximum total drafts to return across all pages")
+}).describe(
+  "List drafts for a workflow, most recently edited first (open drafts by default)"
+);
+var ListWorkflowDraftsApiResponseSchema = zod.z.object({
+  results: zod.z.array(WorkflowDraftSummarySchema),
+  meta: zod.z.object({
+    limit: zod.z.number(),
+    cursor: zod.z.string().nullable().optional(),
+    next_cursor: zod.z.string().nullable().optional()
+  }),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+
+// src/plugins/codeSubstrate/listWorkflowDrafts/index.ts
+var listWorkflowDraftsPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "listWorkflowDrafts",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "list",
+  itemType: "WorkflowDraft",
+  inputSchema: ListWorkflowDraftsOptionsSchema,
+  outputSchema: WorkflowDraftSummarySchema,
+  skipOutputValidation: true,
+  // The handler already returns a clean `{ data, nextCursor }` page, so the
+  // standard list output (no `adaptPage`) applies.
+  output: { type: "list", defaultPageSize: chunkTJXDMXEE_cjs.DEFAULT_PAGE_SIZE },
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const searchParams = {};
+    if (input.status !== void 0) {
+      searchParams.status = input.status;
+    }
+    if (input.slug !== void 0) {
+      searchParams.slug = input.slug;
+    }
+    if (input.pageSize !== void 0) {
+      searchParams.limit = input.pageSize.toString();
+    }
+    if (input.cursor) {
+      searchParams.cursor = input.cursor;
+    }
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts`,
+      {
+        searchParams,
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    const response = ListWorkflowDraftsApiResponseSchema.parse(raw);
+    return {
+      data: response.results,
+      nextCursor: response.meta.next_cursor ?? void 0
+    };
+  }
+});
+var GetWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  draft: zod.z.string().uuid().describe("Workflow draft ID")
+}).describe("Get full details of a workflow draft including source files");
+var GetWorkflowDraftResponseSchema = WorkflowDraftSchema;
+
+// src/plugins/codeSubstrate/getWorkflowDraft/index.ts
+var getWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "WorkflowDraft",
+  inputSchema: GetWorkflowDraftOptionsSchema,
+  outputSchema: GetWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    draft: chunkTJXDMXEE_cjs.workflowDraftIdResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts/${encodeURIComponent(input.draft)}`,
+      {
+        authRequired: true,
+        resource: { type: "workflow-draft", id: input.draft }
+      }
+    );
+    return { data: GetWorkflowDraftResponseSchema.parse(raw) };
+  }
+});
+var CreateWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  slug: zod.z.string().min(1).max(128).optional().describe(
+    "Optional display name for the draft. When omitted, the server generates one. Need not be unique among the workflow's open drafts."
+  ),
+  ...WorkflowClientAttributionInputSchema.shape
+}).refine(hasAccessMethodForHarness, HARNESS_WITHOUT_ACCESS_METHOD_ISSUE).describe(
+  "Fork a new draft from the workflow's current live version (or a blank stub before the first publish)"
+);
+var CreateWorkflowDraftResponseSchema = WorkflowDraftSchema;
+
+// src/plugins/codeSubstrate/createWorkflowDraft/index.ts
+var createWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "createWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "WorkflowDraft",
+  inputSchema: CreateWorkflowDraftOptionsSchema,
+  outputSchema: CreateWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = {};
+    if (input.slug !== void 0) {
+      body.slug = input.slug;
+    }
+    const creationClient = toWireWorkflowClientAttribution(input);
+    if (creationClient !== void 0) {
+      body.creation_client = creationClient;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: CreateWorkflowDraftResponseSchema.parse(raw) };
+  }
+});
+var TRIGGER_MANUAL_CONFLICT_MESSAGE2 = "Provide `trigger` or `manual: true`, not both \u2014 a trigger together with manual: true is a contradiction.";
+var UpdateWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  draft: zod.z.string().uuid().describe("Workflow draft ID"),
+  sourceFiles: SourceFilesSchema,
+  zapierDurableVersion: zod.z.string().optional().describe(
+    'Exact semver of @zapier/zapier-durable to use (e.g. "1.2.3"), or "latest". Leaves the stored pin unchanged if omitted. A draft stores what you pass verbatim, so "latest" is recorded as-is and resolved to an exact version when the draft is published -- reading the draft back shows "latest", not a version. Ranges (^1.2.3, ~1.2) are rejected at publish.'
+  ),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional().describe(
+    'Optional npm package dependencies. A version of "latest" is resolved by the server for @zapier/zapier-durable and @zapier/zapier-sdk only; every other value, including a "latest" on any other package, is passed to the install as written.'
+  ),
+  draftRevision: zod.z.number().int().min(0).optional().describe(
+    "Expected draft revision for optimistic concurrency. Pass the revision from the last read; the server rejects the save with a conflict if the draft has changed since. Omit to skip the check."
+  ),
+  trigger: TriggerConfigSchema.nullish().describe(
+    "Trigger configuration. Omit to leave the stored trigger unchanged, pass null to clear it, or pass an object to replace it; for an on-demand, triggerless workflow, clear this and pass `manual: true` instead."
+  ),
+  connections: zod.z.record(zod.z.string(), ConnectionBindingSchema).nullish().describe(
+    "Map of connection aliases to Zapier connections used by the workflow. Pass `null` to clear an existing binding."
+  ),
+  appVersions: zod.z.record(zod.z.string(), AppVersionBindingSchema).nullish().describe(
+    "Map of app keys to pinned app implementation/version used by the workflow. Pass `null` to clear an existing binding."
+  ),
+  manual: zod.z.boolean().optional().describe(
+    "Declare this draft on-demand and triggerless. Pass `manual: true` only when omitting `trigger` (or clearing it with `trigger: null`); passing both is a contradiction the API rejects with a 400. Setting a `trigger` later clears a previously stored `manual: true`."
+  ),
+  ...WorkflowClientAttributionInputSchema.shape
+}).refine(({ trigger, manual }) => manual !== true || trigger == null, {
+  message: TRIGGER_MANUAL_CONFLICT_MESSAGE2
+}).refine(hasAccessMethodForHarness, HARNESS_WITHOUT_ACCESS_METHOD_ISSUE).describe("Update (autosave) an open workflow draft");
+var UpdateWorkflowDraftResponseSchema = WorkflowDraftSchema;
+
+// src/plugins/codeSubstrate/updateWorkflowDraft/index.ts
+var updateWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "updateWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "update",
+  itemType: "WorkflowDraft",
+  inputSchema: UpdateWorkflowDraftOptionsSchema,
+  outputSchema: UpdateWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    draft: chunkTJXDMXEE_cjs.workflowDraftIdResolver,
+    sourceFiles: sourceFilesResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = { source_files: input.sourceFiles };
+    if (input.zapierDurableVersion !== void 0) {
+      body.zapier_durable_version = input.zapierDurableVersion;
+    }
+    if (input.dependencies !== void 0) {
+      body.dependencies = input.dependencies;
+    }
+    if (input.draftRevision !== void 0) {
+      body.draft_revision = input.draftRevision;
+    }
+    if (input.trigger === null) {
+      body.trigger = null;
+    } else if (input.trigger !== void 0) {
+      body.trigger = toWireTrigger(input.trigger);
+    }
+    if (input.connections === null) {
+      body.connections = null;
+    } else if (input.connections !== void 0) {
+      body.connections = toWireConnections(input.connections);
+    }
+    if (input.appVersions === null) {
+      body.app_versions = null;
+    } else if (input.appVersions !== void 0) {
+      body.app_versions = toWireAppVersions(input.appVersions);
+    }
+    if (input.manual !== void 0) {
+      body.manual = input.manual;
+    }
+    const creationClient = toWireWorkflowClientAttribution(input);
+    if (creationClient !== void 0) {
+      body.creation_client = creationClient;
+    }
+    const raw = await api.put(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts/${encodeURIComponent(input.draft)}`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow-draft", id: input.draft },
+        // A 409 is the optimistic-concurrency signal: the draft's revision
+        // moved past the caller's `draftRevision` (someone else saved in
+        // between). Type it so callers can catch ZapierConflictError,
+        // re-read the draft, and retry instead of blind-overwriting.
+        customErrorHandler: ({ status, data }) => {
+          if (status === 409) {
+            const detail = chunkTJXDMXEE_cjs.extractErrorDetail(data);
+            return new chunkTJXDMXEE_cjs.ZapierConflictError(
+              `${detail ?? "Draft revision conflict"} \u2014 the draft changed since it was last read. Re-read the draft to get the current draft_revision, merge your edits, and retry.`,
+              { statusCode: status, resourceType: "workflow-draft" }
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    return { data: UpdateWorkflowDraftResponseSchema.parse(raw) };
+  }
+});
+var DiscardWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  draft: zod.z.string().uuid().describe("Workflow draft ID")
+}).describe(
+  "Discard an open workflow draft (soft delete). The draft's unpublished edits stop resolving; the published version is untouched."
+);
+var DiscardWorkflowDraftResponseSchema = WorkflowDraftSchema;
+
+// src/plugins/codeSubstrate/discardWorkflowDraft/index.ts
+var discardWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "discardWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "delete",
+  itemType: "WorkflowDraft",
+  // Soft delete returns the discarded draft, not the `{ success: boolean }`
+  // shape the docs generator assumes for delete methods.
+  returnType: "WorkflowDraftItem",
+  // Discard throws away the draft's unpublished edits, so it warrants the
+  // same interactive confirmation as deleteWorkflow.
+  confirm: "delete",
+  inputSchema: DiscardWorkflowDraftOptionsSchema,
+  outputSchema: DiscardWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    draft: chunkTJXDMXEE_cjs.workflowDraftIdResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const raw = await api.delete(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts/${encodeURIComponent(input.draft)}`,
+      void 0,
+      {
+        authRequired: true,
+        resource: { type: "workflow-draft", id: input.draft }
+      }
+    );
+    return { data: DiscardWorkflowDraftResponseSchema.parse(raw) };
+  }
+});
+var PublishWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  draft: zod.z.string().uuid().describe("Workflow draft ID"),
+  enabled: zod.z.boolean().optional().describe(
+    "Set the workflow's enabled state as part of the publish. If omitted, the current enabled state is preserved."
+  ).meta({ negatable: "disabled" }),
+  draftRevision: zod.z.number().int().min(0).optional().describe(
+    "Expected draft revision for optimistic concurrency. Pass the revision from the last read; the server rejects the publish with a conflict if the draft has changed since. Omit to skip the check."
+  ),
+  manual: zod.z.boolean().optional().describe(
+    "Declare this publish on-demand and triggerless, overriding the draft's stored intent for this publish only. Pass `manual: true` only when the draft has no trigger configured; the API rejects a draft with a trigger published as `manual: true` as a contradiction (400)."
+  ),
+  ...WorkflowClientAttributionInputSchema.shape
+}).refine(hasAccessMethodForHarness, HARNESS_WITHOUT_ACCESS_METHOD_ISSUE).describe(
+  "Publish an open draft as a new immutable workflow version. Advances the workflow's live pointer and discards the draft \u2014 publish consumes it, so an open draft always means unpublished work. Continue editing by creating a new draft, which forks from the just-published version."
+);
+var PublishWorkflowDraftResponseSchema = zod.z.object({
+  draft: WorkflowDraftSchema.describe(
+    "The consumed draft: status is 'discarded' and discarded_at is set. base_version_id still records the version the draft was forked from."
+  ),
+  version: WorkflowVersionSchema.describe(
+    "The newly published immutable workflow version, now live."
+  )
+});
+
+// src/plugins/codeSubstrate/publishWorkflowDraft/index.ts
+var publishWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "publishWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "WorkflowVersion",
+  // The response is the composite `{ draft, version }`, not the bare
+  // `WorkflowVersionItem` the docs generator derives from itemType.
+  returnType: "PublishWorkflowDraftResponse",
+  inputSchema: PublishWorkflowDraftOptionsSchema,
+  outputSchema: PublishWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    draft: chunkTJXDMXEE_cjs.workflowDraftIdResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = {};
+    if (input.enabled !== void 0) {
+      body.enabled = input.enabled;
+    }
+    if (input.draftRevision !== void 0) {
+      body.draft_revision = input.draftRevision;
+    }
+    if (input.manual !== void 0) {
+      body.manual = input.manual;
+    }
+    const creationClient = toWireWorkflowClientAttribution(input);
+    if (creationClient !== void 0) {
+      body.creation_client = creationClient;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts/${encodeURIComponent(input.draft)}/publish`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow-draft", id: input.draft },
+        // Preserve the endpoint's distinct failure modes instead of letting
+        // them flatten into a generic API error:
+        //   409 — the draft was edited concurrently (draft_revision moved past
+        //         the caller's), or a trigger subscription switchover is
+        //         already in progress. Retryable after re-reading the draft.
+        //   503 — the trigger config could not be validated against the
+        //         platform catalog; validation is fail-closed so the publish
+        //         is rejected rather than committing unvalidated config.
+        //         Retryable as-is.
+        // 400 (invalid zapier_durable_version / trigger config) already maps
+        // to ZapierValidationError via the client's default handling.
+        customErrorHandler: ({ status, data }) => {
+          if (status === 409) {
+            const detail = chunkTJXDMXEE_cjs.extractErrorDetail(data);
+            return new chunkTJXDMXEE_cjs.ZapierConflictError(
+              `${detail ?? "Draft publish conflict"} \u2014 the draft changed since it was last read, or a trigger switchover is already in progress. Re-read the draft to get the current draft_revision, then retry the publish.`,
+              { statusCode: status, resourceType: "workflow-draft" }
+            );
+          }
+          if (status === 503) {
+            const detail = chunkTJXDMXEE_cjs.extractErrorDetail(data);
+            return new chunkTJXDMXEE_cjs.ZapierApiError(
+              detail !== void 0 ? `${detail} \u2014 the trigger config could not be validated against the platform catalog, so the publish was rejected (fail-closed). This is transient; retry the publish.` : "Draft publish temporarily unavailable \u2014 trigger validation is fail-closed, or the service is briefly unavailable. This is transient; retry the publish.",
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    return { data: PublishWorkflowDraftResponseSchema.parse(raw) };
+  }
+});
+var WORKFLOW_RUN_WAIT_MAX_SECONDS = 30;
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["finished", "failed", "cancelled"]);
+var FIRST_BACKOFF_MILLISECONDS = 250;
+var MAX_BACKOFF_MILLISECONDS = 2500;
+var RunWaitSecondsSchema = zod.z.number().int().min(0).optional().describe(
+  "Wait for the run to be finished, failed or cancelled, up to this many seconds, then return it as it stands. The answer comes as soon as the run ends."
+);
+var runWaitSearchParams = (holdSeconds) => holdSeconds > 0 ? { wait_seconds: String(holdSeconds) } : void 0;
+async function readRunUntilEnded({
+  waitSeconds,
+  read,
+  pendingWhileNotFound = false
+}) {
+  const deadline = Date.now() + waitSeconds * 1e3;
+  let latest;
+  let notFound;
+  let backoffMilliseconds = FIRST_BACKOFF_MILLISECONDS;
+  do {
+    const remaining = Math.max(0, deadline - Date.now());
+    const requestWaitSeconds = Math.min(
+      WORKFLOW_RUN_WAIT_MAX_SECONDS,
+      Math.ceil(remaining / 1e3)
+    );
+    const askedAt = Date.now();
+    try {
+      latest = await read(requestWaitSeconds);
+      if (TERMINAL_RUN_STATUSES.has(latest.status)) return latest;
+    } catch (error) {
+      if (!pendingWhileNotFound || !chunkTJXDMXEE_cjs.isZapierNotFoundError(error)) throw error;
+      notFound = error;
+    }
+    if (Date.now() - askedAt < requestWaitSeconds * 1e3 / 2) {
+      await chunkTJXDMXEE_cjs.sleep(Math.min(backoffMilliseconds, deadline - Date.now()));
+      backoffMilliseconds = Math.min(
+        backoffMilliseconds * 2,
+        MAX_BACKOFF_MILLISECONDS
+      );
+    }
+  } while (Date.now() < deadline);
+  if (latest) return latest;
+  throw notFound;
+}
+var WorkflowRunStatusSchema = zod.z.union([
+  zod.z.enum(["initialized", "started", "finished", "failed", "cancelled"]),
+  zod.z.string()
+]).describe(
+  "Workflow run lifecycle status. `finished` / `failed` / `cancelled` are terminal."
+);
+var workflowRunListItemBase = zod.z.object({
+  id: zod.z.string().describe("Workflow run ID (UUIDv7). Unique across live and draft runs."),
+  durable_run_id: zod.z.string().nullable().describe(
+    "Linked code-substrate-runner run ID. Null until the durable run is created."
+  ),
+  status: WorkflowRunStatusSchema,
+  input: zod.z.unknown().describe("Input passed to the run"),
+  error: zod.z.unknown().nullable().describe("Error payload when status is `failed` (null otherwise)"),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+var LiveWorkflowRunListItemSchema = workflowRunListItemBase.extend({
+  kind: zod.z.literal("live").describe("A run of a published workflow version."),
+  trigger_id: zod.z.string().nullable().describe(
+    "ID of the trigger that fired this run. Null for runs created without a trigger."
+  ),
+  workflow_version_id: zod.z.string().nullable().describe("Workflow version the run is bound to. Null in rare edge cases.")
+});
+var DraftWorkflowRunListItemSchema = workflowRunListItemBase.extend({
+  kind: zod.z.literal("draft").describe("A run launched from a workflow draft via `runWorkflowDraft`."),
+  workflow_draft_id: zod.z.string().nullable().describe(
+    "The draft this run was launched from. Null once that draft has been deleted (the run outlives its draft)."
+  ),
+  draft_revision: zod.z.number().int().describe("The draft's revision at the moment this run was created.")
+});
+var WorkflowRunListItemSchema = zod.z.discriminatedUnion("kind", [
+  LiveWorkflowRunListItemSchema,
+  DraftWorkflowRunListItemSchema
+]);
+var ListWorkflowRunsOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  pageSize: zod.z.number().int().min(1).max(100).optional().describe("Number of runs per page (max 100)"),
+  kind: zod.z.enum(["live", "draft"]).optional().describe(
+    "Return only runs of this kind. Omit for both, interleaved by recency."
+  ),
+  cursor: zod.z.string().optional().describe("Pagination cursor"),
+  maxItems: zod.z.number().int().min(1).optional().describe("Maximum total runs to return across all pages")
+}).describe(
+  "List workflow runs for a specific workflow, newest first. Live runs (of published versions) and draft runs share the one list; pass `kind` to narrow it to one."
+);
+var ListWorkflowRunsApiResponseSchema = zod.z.object({
+  results: zod.z.array(WorkflowRunListItemSchema),
+  meta: zod.z.object({
+    limit: zod.z.number(),
+    cursor: zod.z.string().nullable().optional(),
+    next_cursor: zod.z.string().nullable().optional()
+  }),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+
+// src/plugins/codeSubstrate/getWorkflowRun/schemas.ts
+var GetWorkflowRunOptionsSchema = zod.z.object({
+  // Picker-only field — the API endpoint is /workflows/runs/:id and
+  // does not take a workflow id, but the run-id picker is scoped to a
+  // parent workflow so the user can browse runs without enumerating
+  // every run across every workflow on the account.
+  workflow: zod.z.string().uuid().optional().describe(
+    "Parent workflow ID \u2014 used only to scope the CLI run-id picker; ignored by the API call."
+  ),
+  run: zod.z.string().uuid().describe("Workflow run ID"),
+  waitSeconds: RunWaitSecondsSchema
+}).describe(
+  "Get the current state of a workflow run \u2014 a live run of a published workflow version, or a draft run launched via `runWorkflowDraft` (the `kind` field says which)"
+);
+var workflowRunBase = zod.z.object({
+  id: zod.z.string().describe("Workflow run ID (UUIDv7). Unique across live and draft runs."),
+  workflow_id: zod.z.string().describe("The workflow this run belongs to"),
+  durable_run_id: zod.z.string().nullable().describe(
+    "Linked code-substrate-runner run ID. Null until the durable run is created."
+  ),
+  status: WorkflowRunStatusSchema,
+  input: zod.z.unknown().describe("Input passed to the run"),
+  output: zod.z.unknown().nullable().describe("Return value, present when status is `finished`"),
+  error: zod.z.unknown().nullable().describe("Error payload when status is `failed` (null otherwise)"),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+var LiveWorkflowRunSchema = workflowRunBase.extend({
+  kind: zod.z.literal("live").describe("A run of a published workflow version."),
+  trigger_id: zod.z.string().nullable().describe(
+    "ID of the trigger that fired this run. Null for runs created without a trigger."
+  ),
+  workflow_version_id: zod.z.string().nullable().describe("Workflow version the run is bound to. Null in rare edge cases.")
+});
+var DraftWorkflowRunSchema = workflowRunBase.extend({
+  kind: zod.z.literal("draft").describe("A run launched from a workflow draft via `runWorkflowDraft`."),
+  workflow_draft_id: zod.z.string().nullable().describe(
+    "The draft this run was launched from. Null once that draft has been deleted (the run outlives its draft)."
+  ),
+  draft_revision: zod.z.number().int().describe(
+    "The draft's revision at the moment this run was created. Compare against the draft's current `draft_revision` to tell whether the run still reflects the draft as it now stands."
+  )
+});
+var GetWorkflowRunResponseSchema = zod.z.discriminatedUnion("kind", [
+  LiveWorkflowRunSchema,
+  DraftWorkflowRunSchema
+]);
+
+// src/plugins/codeSubstrate/getWorkflowRun/index.ts
+var getWorkflowRunPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getWorkflowRun",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "WorkflowRun",
+  inputSchema: GetWorkflowRunOptionsSchema,
+  outputSchema: GetWorkflowRunResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    run: chunkTJXDMXEE_cjs.workflowRunIdResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const read = async (holdSeconds) => GetWorkflowRunResponseSchema.parse(
+      await api.get(
+        `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/runs/${encodeURIComponent(input.run)}`,
+        {
+          authRequired: true,
+          resource: { type: "workflow-run", id: input.run },
+          searchParams: runWaitSearchParams(holdSeconds)
+        }
+      )
+    );
+    return {
+      data: await readRunUntilEnded({
+        waitSeconds: input.waitSeconds ?? 0,
+        read
+      })
+    };
+  }
+});
+var RunWorkflowDraftOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  draft: zod.z.string().uuid().describe("Workflow draft ID"),
+  draftRevision: zod.z.number().int().min(0).describe(
+    "The draft revision you intend to run, from the last read of the draft. The server rejects the run with a conflict if the draft has changed since. The upstream API treats this check as optional; the SDK requires it so a test run can never silently execute source the caller has already replaced."
+  ),
+  input: JsonPayloadSchema.optional().describe(
+    "Input data passed to the workflow. Accepts any JSON value, or its JSON-string encoding. Omit for a workflow that takes no input."
+  ),
+  waitSeconds: RunWaitSecondsSchema
+}).describe(
+  "Launch a draft test run: execute the draft's current source without publishing it. The draft's payload is snapshotted onto the run at creation, so later edits (or discarding the draft) never change what the run executed. Draft runs are free (not task-charged) and rate limited per user. Without `waitSeconds` the run comes back at once, `initialized`; follow it with `getWorkflowRun`, or list it via `listWorkflowRuns` with `kind: \"draft\"`. With `waitSeconds`, the run is returned once it ends (or as it stands when the wait runs out), with `output` set when it finished."
+);
+var RunWorkflowDraftResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow run ID (UUIDv7). Unique across live and draft runs."),
+  kind: zod.z.literal("draft").describe("A run launched from a workflow draft."),
+  workflow_id: zod.z.string().describe("The workflow this run belongs to"),
+  durable_run_id: zod.z.string().nullable().describe(
+    "Linked code-substrate-runner run ID. Usually still null in this response \u2014 the run is accepted and launched in the background."
+  ),
+  workflow_draft_id: zod.z.string().nullable().describe(
+    "The draft this run was launched from. Becomes null once that draft is deleted \u2014 the run outlives its draft."
+  ),
+  draft_revision: zod.z.number().int().describe("The draft's revision at the moment this run was created."),
+  status: WorkflowRunStatusSchema,
+  input: zod.z.unknown().describe("Input passed to the run"),
+  output: zod.z.unknown().nullable().describe("Return value, present when status is `finished`"),
+  error: zod.z.unknown().nullable().describe("Error payload when status is `failed` (null otherwise)"),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+
+// src/plugins/codeSubstrate/runWorkflowDraft/index.ts
+var runWorkflowDraftPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "runWorkflowDraft",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef, getWorkflowRunPlugin],
+  type: "create",
+  itemType: "WorkflowRun",
+  // The response is the draft variant of the run resource (`kind: "draft"`,
+  // required `workflow_draft_id` / `draft_revision`), not the mixed-kind
+  // `WorkflowRun` item the docs generator derives from itemType.
+  returnType: "RunWorkflowDraftResponse",
+  inputSchema: RunWorkflowDraftOptionsSchema,
+  outputSchema: RunWorkflowDraftResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: {
+    workflow: chunkTJXDMXEE_cjs.workflowIdResolver,
+    draft: chunkTJXDMXEE_cjs.workflowDraftIdResolver,
+    draftRevision: chunkTJXDMXEE_cjs.workflowDraftRevisionResolver
+  },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const body = {
+      draft_revision: input.draftRevision
+    };
+    if (input.input !== void 0) {
+      body.input = input.input;
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/drafts/${encodeURIComponent(input.draft)}/runs`,
+      body,
+      {
+        authRequired: true,
+        resource: { type: "workflow-draft", id: input.draft },
+        // 409 — the draft was edited concurrently (its draft_revision moved
+        // past the caller's). Retryable after re-reading the draft. 429 (the
+        // per-user draft-run rate limit) needs no handling here: the client
+        // retries with backoff and then throws ZapierRateLimitError.
+        customErrorHandler: ({ status, data }) => {
+          if (status === 409) {
+            const detail = chunkTJXDMXEE_cjs.extractErrorDetail(data);
+            return new chunkTJXDMXEE_cjs.ZapierConflictError(
+              `${detail ?? "Draft run conflict"} \u2014 the draft changed since it was last read. Re-read the draft to get the current draft_revision, then retry the run.`,
+              { statusCode: status, resourceType: "workflow-draft" }
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    const started = RunWorkflowDraftResponseSchema.parse(raw);
+    if (!input.waitSeconds) return { data: started };
+    const { data: run } = await imports.getWorkflowRun({
+      run: started.id,
+      waitSeconds: input.waitSeconds
+    });
+    return { data: RunWorkflowDraftResponseSchema.parse(run) };
+  }
+});
+var listWorkflowRunsPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "listWorkflowRuns",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "list",
+  itemType: "WorkflowRun",
+  inputSchema: ListWorkflowRunsOptionsSchema,
+  outputSchema: WorkflowRunListItemSchema,
+  skipOutputValidation: true,
+  // The handler already returns a clean `{ data, nextCursor }` page, so the
+  // standard list output (no `adaptPage`) applies.
+  output: { type: "list", defaultPageSize: chunkTJXDMXEE_cjs.DEFAULT_PAGE_SIZE },
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const searchParams = {};
+    if (input.pageSize !== void 0) {
+      searchParams.limit = input.pageSize.toString();
+    }
+    if (input.kind !== void 0) {
+      searchParams.kind = input.kind;
+    }
+    if (input.cursor) {
+      searchParams.cursor = input.cursor;
+    }
+    const raw = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}/runs`,
+      {
+        searchParams,
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    const response = ListWorkflowRunsApiResponseSchema.parse(raw);
+    return {
+      data: response.results,
+      nextCursor: response.meta.next_cursor ?? void 0
+    };
+  }
+});
+var GetTriggerRunOptionsSchema = zod.z.object({
+  trigger: zod.z.string().uuid().describe("Workflow trigger ID"),
+  waitSeconds: RunWaitSecondsSchema
+}).describe(
+  "Get the workflow run associated with a deployed workflow's trigger. Useful immediately after firing a trigger, when you have the trigger ID but not yet the run ID. With `waitSeconds`, the read also waits for the run to be created and to end."
+);
+var GetTriggerRunResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Workflow run ID (UUID)"),
+  durable_run_id: zod.z.string().nullable().describe(
+    "Linked code-substrate-runner run ID. Null until the durable run is created."
+  ),
+  workflow_version_id: zod.z.string().nullable().describe("Workflow version the run is bound to"),
+  status: WorkflowRunStatusSchema,
+  input: zod.z.unknown().describe("Input passed to the run"),
+  output: zod.z.unknown().nullable().describe("Return value, present when status is `finished`"),
+  error: zod.z.unknown().nullable().describe("Error payload when status is `failed` (null otherwise)"),
+  created_at: zod.z.string().describe("When the run was created (ISO-8601)"),
+  updated_at: zod.z.string().describe("When the run was last updated (ISO-8601)")
+});
+
+// src/plugins/codeSubstrate/getTriggerRun/index.ts
+var getTriggerRunPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "getTriggerRun",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "WorkflowRun",
+  inputSchema: GetTriggerRunOptionsSchema,
+  outputSchema: GetTriggerRunResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  // No resolver for `trigger` — users typically have the trigger id
+  // from a recent trigger fire and pass it directly. Authoring a
+  // picker would require listing triggers across all workflows,
+  // which has no clean entry point today.
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const read = async (holdSeconds) => GetTriggerRunResponseSchema.parse(
+      await api.get(
+        `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/triggers/${encodeURIComponent(input.trigger)}/run`,
+        {
+          authRequired: true,
+          resource: { type: "workflow-trigger", id: input.trigger },
+          searchParams: runWaitSearchParams(holdSeconds)
+        }
+      )
+    );
+    return {
+      data: await readRunUntilEnded({
+        waitSeconds: input.waitSeconds ?? 0,
+        read,
+        pendingWhileNotFound: true
+      })
+    };
+  }
+});
+var TriggerWorkflowLookupResponseSchema = zod.z.object({
+  trigger_url: zod.z.string()
+}).passthrough();
+var TriggerWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  input: JsonPayloadSchema.optional().describe(
+    "JSON payload delivered as the trigger body. Accepts any JSON value, or its JSON-string encoding. Sent as `application/json`; omit to fire with an empty body."
+  )
+}).describe(
+  "Look up a workflow's trigger URL and fire it manually, as the authenticated account."
+);
+var TriggerWorkflowResponseSchema = zod.z.object({
+  id: zod.z.string().describe("Trigger ID (UUID)"),
+  workflow_id: zod.z.string().describe("The workflow that was triggered (UUID)"),
+  created_at: zod.z.string().describe("When the trigger was received (ISO-8601)")
+});
+
+// src/plugins/codeSubstrate/triggerWorkflow/index.ts
+var triggerWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "triggerWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  type: "create",
+  itemType: "WorkflowRun",
+  inputSchema: TriggerWorkflowOptionsSchema,
+  outputSchema: TriggerWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const api = imports.api;
+    const rawWorkflow = await api.get(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/${encodeURIComponent(input.workflow)}`,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    const workflow = TriggerWorkflowLookupResponseSchema.parse(rawWorkflow);
+    const segments = new URL(workflow.trigger_url).pathname.split("/");
+    const triggerToken = segments[segments.length - 1];
+    if (!triggerToken) {
+      throw new chunkTJXDMXEE_cjs.ZapierApiError(
+        `Workflow ${input.workflow} returned a malformed trigger_url`,
+        { statusCode: 0, response: workflow.trigger_url }
+      );
+    }
+    const raw = await api.post(
+      `${CODE_SUBSTRATE_WORKFLOWS_API}/workflows/trigger/${encodeURIComponent(triggerToken)}`,
+      input.input,
+      {
+        authRequired: true,
+        resource: { type: "workflow", id: input.workflow }
+      }
+    );
+    return { data: TriggerWorkflowResponseSchema.parse(raw) };
+  }
+});
+var DEFAULT_RUN_WORKFLOW_WAIT_SECONDS = 60;
+var RunWorkflowOptionsSchema = zod.z.object({
+  workflow: zod.z.string().uuid().describe("Durable workflow ID"),
+  input: JsonPayloadSchema.optional().describe(
+    "JSON payload delivered as the trigger body. Accepts any JSON value, or its JSON-string encoding. Omit to run with an empty body."
+  ),
+  waitSeconds: zod.z.number().int().positive().optional().describe(
+    "How long to wait for the run to end, in seconds. A run still going after the wait is returned with its current status, not as an error."
+  )
+}).describe(
+  `Run a published workflow and wait for its result: fires the workflow's trigger as the authenticated account, then returns the run once it is finished, failed or cancelled, with \`output\` set when it finished. Waits up to ${DEFAULT_RUN_WORKFLOW_WAIT_SECONDS} seconds unless \`waitSeconds\` says otherwise. A run that has not ended after \`waitSeconds\` is returned with its current status; wait on it again with getWorkflowRun and \`waitSeconds\`.`
+);
+var RunWorkflowResponseSchema = GetTriggerRunResponseSchema.extend({
+  trigger_id: zod.z.string().describe("Trigger ID of the run (UUID)")
+});
+
+// src/plugins/codeSubstrate/runWorkflow/index.ts
+var runWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "runWorkflow",
+  imports: [triggerWorkflowPlugin, getTriggerRunPlugin],
+  type: "create",
+  itemType: "WorkflowRun",
+  inputSchema: RunWorkflowOptionsSchema,
+  outputSchema: RunWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { workflow: chunkTJXDMXEE_cjs.workflowIdResolver },
+  run: async ({ imports, input }) => {
+    const { data: trigger } = await imports.triggerWorkflow({
+      workflow: input.workflow,
+      input: input.input
+    });
+    const waitSeconds = input.waitSeconds ?? DEFAULT_RUN_WORKFLOW_WAIT_SECONDS;
+    try {
+      const { data: run } = await imports.getTriggerRun({
+        trigger: trigger.id,
+        waitSeconds
+      });
+      return { data: { ...run, trigger_id: trigger.id } };
+    } catch (error) {
+      if (!chunkTJXDMXEE_cjs.isZapierNotFoundError(error)) throw error;
+      throw new chunkTJXDMXEE_cjs.ZapierTimeoutError(
+        `The run for trigger ${trigger.id} had not started after ${waitSeconds}s. Check it later with getTriggerRun.`,
+        { cause: error }
+      );
+    }
+  }
+});
+var MAX_SOURCE_FILES_COUNT = 50;
+var MAX_SOURCE_FILE_LENGTH = 2e5;
+var DEFAULT_ENTRYPOINT_FILE = "/workflow.ts";
+var EXAMPLE_SOURCE_FILES = {
+  [DEFAULT_ENTRYPOINT_FILE]: 'import { defineDurable } from "@zapier/zapier-durable"; export default defineDurable("hello-world", async (ctx, input) => { return ctx.step("greet", async () => "Hello, world!"); });'
+};
+var WorkflowValidationSourceFilesSchema = zod.z.record(
+  zod.z.string().regex(/^\//, "source file paths must start with /"),
+  zod.z.string().max(MAX_SOURCE_FILE_LENGTH)
+).refine((files) => Object.keys(files).length > 0, {
+  message: "sourceFiles must contain at least one file"
+}).refine((files) => Object.keys(files).length <= MAX_SOURCE_FILES_COUNT, {
+  message: `sourceFiles must contain at most ${MAX_SOURCE_FILES_COUNT} files`
+}).describe("Exact TypeScript sources keyed by absolute logical path.").meta({ example: EXAMPLE_SOURCE_FILES });
+var ValidateWorkflowOptionsSchema = zod.z.object({
+  sourceFiles: WorkflowValidationSourceFilesSchema,
+  entrypointFile: zod.z.string().regex(/^\//, "entrypointFile must start with /").optional().describe(
+    "Absolute logical path of the entry file in sourceFiles. Defaults to /workflow.ts."
+  )
+}).refine(
+  ({ sourceFiles, entrypointFile }) => (entrypointFile ?? DEFAULT_ENTRYPOINT_FILE) in sourceFiles,
+  {
+    path: ["entrypointFile"],
+    message: "entrypointFile must identify a file in sourceFiles"
+  }
+).describe(
+  "Validate durable workflow source without publishing it. Returns source diagnostics; issue kinds are extensible and may be unfamiliar to the client."
+);
+var WorkflowValidationSourceLocationSchema = zod.z.object({
+  file_id: zod.z.string().describe("Source file containing the diagnostic."),
+  start_line: zod.z.number().int().positive().describe("Inclusive 1-based start line."),
+  start_column: zod.z.number().int().positive().describe("Inclusive 1-based start column."),
+  end_line: zod.z.number().int().positive().describe("Inclusive 1-based end line."),
+  end_column: zod.z.number().int().positive().describe("Inclusive 1-based end column.")
+}).describe("1-based source coordinates within a single sourceFiles entry.");
+var WorkflowValidationIssueSchema = zod.z.object({
+  kind: zod.z.string().describe(
+    "Extensible diagnostic category; clients must accept unfamiliar values."
+  ),
+  message: zod.z.string().describe("Safe human-readable explanation."),
+  // Unlike `kind`, severity is a closed vocabulary on the analyzer side: a
+  // new value requires a new API version, and every issue carries one, so
+  // callers can rank findings without a missing-severity branch.
+  severity: zod.z.enum(["error", "warning", "info", "hint"]).describe("Diagnostic severity."),
+  suggestion: zod.z.string().optional().describe("Actionable fix hint."),
+  source: WorkflowValidationSourceLocationSchema.optional().describe(
+    "Affected source location."
+  ),
+  source_excerpt: zod.z.string().optional().describe(
+    "Source text the diagnostic was raised against, truncated to 240 characters."
+  ),
+  syntax_kind: zod.z.string().optional().describe(
+    "TypeScript AST node kind the diagnostic was raised against (e.g. `CallExpression`)."
+  )
+});
+var ValidateWorkflowResponseSchema = zod.z.object({
+  issues: zod.z.array(WorkflowValidationIssueSchema).describe("Source diagnostics, or an empty array when validation passes.")
+});
+
+// src/plugins/codeSubstrate/validateWorkflow/index.ts
+var validateWorkflowPlugin = kitcore.defineMethod({
+  ...codeSubstrateDefaults,
+  name: "validateWorkflow",
+  imports: [chunkTJXDMXEE_cjs.apiPluginRef],
+  itemType: "WorkflowValidation",
+  inputSchema: ValidateWorkflowOptionsSchema,
+  outputSchema: ValidateWorkflowResponseSchema,
+  skipOutputValidation: true,
+  output: "item",
+  resolvers: { sourceFiles: sourceFilesResolver },
+  run: async ({ imports, input }) => {
+    const body = {
+      source_files: input.sourceFiles
+    };
+    if (input.entrypointFile !== void 0) {
+      body.entrypoint_file = input.entrypointFile;
+    }
+    const raw = await imports.api.post(
+      `${CODE_SUBSTRATE_ANALYZER_API}/validations`,
+      body,
+      { authRequired: true }
+    );
+    return { data: ValidateWorkflowResponseSchema.parse(raw) };
+  }
+});
+
+// src/beta.ts
+var zapierBetaSdkPlugin = kitcore.definePlugin({
+  namespace: "zapier",
+  name: "beta-sdk",
+  exports: [
+    chunkTJXDMXEE_cjs.zapierSdkPlugin,
+    // Next Gen Zaps (workflows, drafts, runs). `list*` plugins are exported
+    // before their `get*` / mutation siblings because per-row resolvers
+    // reach the listing methods.
+    listWorkflowsPlugin,
+    getWorkflowPlugin,
+    createWorkflowPlugin,
+    importWorkflowPlugin,
+    updateWorkflowPlugin,
+    enableWorkflowPlugin,
+    disableWorkflowPlugin,
+    deleteWorkflowPlugin,
+    listDurableRunsPlugin,
+    getDurableRunPlugin,
+    runDurablePlugin,
+    cancelDurableRunPlugin,
+    publishWorkflowVersionPlugin,
+    listWorkflowVersionsPlugin,
+    getWorkflowVersionPlugin,
+    listWorkflowDraftsPlugin,
+    getWorkflowDraftPlugin,
+    createWorkflowDraftPlugin,
+    updateWorkflowDraftPlugin,
+    discardWorkflowDraftPlugin,
+    publishWorkflowDraftPlugin,
+    runWorkflowDraftPlugin,
+    listWorkflowRunsPlugin,
+    getWorkflowRunPlugin,
+    getTriggerRunPlugin,
+    triggerWorkflowPlugin,
+    runWorkflowPlugin,
+    validateWorkflowPlugin
+  ]
+});
+function createZapierSdk(options = {}) {
+  return kitcore.createSdk(zapierBetaSdkPlugin, {
+    configuration: {
+      [chunkTJXDMXEE_cjs.SDK_OPTIONS_ID]: options,
+      [kitcore.CORE_OPTIONS_ID]: chunkTJXDMXEE_cjs.zapierCoreOptions
+    }
+  });
+}
+
+exports.CreateWorkflowOptionsSchema = CreateWorkflowOptionsSchema;
+exports.CreateWorkflowResponseSchema = CreateWorkflowResponseSchema;
+exports.ImportWorkflowOptionsSchema = ImportWorkflowOptionsSchema;
+exports.ImportWorkflowResponseSchema = ImportWorkflowResponseSchema;
+exports.createZapierSdk = createZapierSdk;
+exports.zapierBetaSdkPlugin = zapierBetaSdkPlugin;