@sanity/workflow-engine 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sanity, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @sanity/workflow-engine
+
+Workflow / BPM engine for Sanity content. Define workflows as data, run them as
+instances against a Sanity client, gate transitions on GROQ filters, and queue
+effects for runtimes to drain.
+
+> **Status:** 0.x, internal. Restricted-access package; the API may change
+> between minor versions.
+
+## Installation
+
+```bash
+npm install @sanity/workflow-engine
+```
+
+## License
+
+[MIT](./LICENSE)

package/dist/define.cjs

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var zod = require("zod");
+const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], STATE_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
+  "create",
+  "update",
+  "delete",
+  "publish",
+  "unpublish"
+];
+function knownList(ids) {
+  return [...ids].map((s) => `"${s}"`).join(", ");
+}
+function checkStagesAndTasks(def, ctx) {
+  const stageIds = /* @__PURE__ */ new Set();
+  for (const [i, stage] of def.stages.entries())
+    stageIds.has(stage.id) && ctx.addIssue({
+      code: "custom",
+      path: ["stages", i, "id"],
+      message: `duplicate stage id "${stage.id}" (already declared earlier)`
+    }), stageIds.add(stage.id), stage.kind === "terminal" && stage.transitions && stage.transitions.length > 0 && ctx.addIssue({
+      code: "custom",
+      path: ["stages", i, "transitions"],
+      message: `terminal stage "${stage.id}" must not declare transitions`
+    }), checkDuplicateTaskIds(stage, i, ctx);
+  return stageIds;
+}
+function checkDuplicateTaskIds(stage, i, ctx) {
+  const taskIds = /* @__PURE__ */ new Set();
+  for (const [j, task] of (stage.tasks ?? []).entries())
+    taskIds.has(task.id) && ctx.addIssue({
+      code: "custom",
+      path: ["stages", i, "tasks", j, "id"],
+      message: `duplicate task id "${task.id}" in stage "${stage.id}"`
+    }), taskIds.add(task.id);
+}
+function checkInitialStage(def, stageIds, ctx) {
+  stageIds.has(def.initialStageId) || ctx.addIssue({
+    code: "custom",
+    path: ["initialStageId"],
+    message: `initialStageId "${def.initialStageId}" is not a declared stage. Known stages: ${knownList(stageIds)}`
+  });
+}
+function checkTransitionTargets(def, stageIds, ctx) {
+  for (const [i, stage] of def.stages.entries())
+    for (const [k, t] of (stage.transitions ?? []).entries())
+      stageIds.has(t.to) || ctx.addIssue({
+        code: "custom",
+        path: ["stages", i, "transitions", k, "to"],
+        message: `transition target "${t.to}" is not a declared stage. Known stages: ${knownList(stageIds)}`
+      });
+}
+function collectPredicateIds(def, ctx) {
+  const predicateIds = /* @__PURE__ */ new Set();
+  for (const [i, p] of (def.predicates ?? []).entries())
+    predicateIds.has(p.id) && ctx.addIssue({
+      code: "custom",
+      path: ["predicates", i, "id"],
+      message: `duplicate predicate id "${p.id}"`
+    }), predicateIds.add(p.id);
+  return predicateIds;
+}
+function checkFilterRefs(def, predicateIds, ctx) {
+  const visit = (g, path) => {
+    g === void 0 || typeof g == "string" || predicateIds.has(g.ref) || ctx.addIssue({
+      code: "custom",
+      path: [...path, "ref"],
+      message: `Filter references predicate "${g.ref}" which is not declared. Known predicates: ${knownList(predicateIds) || "(none)"}`
+    });
+  };
+  for (const [i, stage] of def.stages.entries()) {
+    visit(stage.completion, ["stages", i, "completion"]);
+    for (const [j, task] of (stage.tasks ?? []).entries()) {
+      visit(task.filter, ["stages", i, "tasks", j, "filter"]), visit(task.completeWhen, ["stages", i, "tasks", j, "completeWhen"]), visit(task.failWhen, ["stages", i, "tasks", j, "failWhen"]);
+      for (const [a, action] of (task.actions ?? []).entries())
+        visit(action.filter, ["stages", i, "tasks", j, "actions", a, "filter"]);
+    }
+    for (const [k, t] of (stage.transitions ?? []).entries())
+      visit(t.filter, ["stages", i, "transitions", k, "filter"]);
+  }
+}
+function checkWorkflowInvariants(def, ctx) {
+  const stageIds = checkStagesAndTasks(def, ctx);
+  checkInitialStage(def, stageIds, ctx), checkTransitionTargets(def, stageIds, ctx);
+  const predicateIds = collectPredicateIds(def, ctx);
+  checkFilterRefs(def, predicateIds, ctx);
+}
+const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema = zod.z.object({
+  id: zod.z.string().regex(
+    /^(dataset|canvas|media-library|dashboard):/,
+    "must be a GDR URI of form '<scheme>:<...id-parts>' where scheme is one of: dataset, canvas, media-library, dashboard"
+  ),
+  type: NonEmpty
+}).strict(), SourceSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.object({
+      source: zod.z.literal("literal"),
+      value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()])
+    }).strict(),
+    zod.z.object({ source: zod.z.literal("param"), paramId: NonEmpty }).strict(),
+    zod.z.object({ source: zod.z.literal("actor") }).strict(),
+    zod.z.object({ source: zod.z.literal("now") }).strict(),
+    zod.z.object({ source: zod.z.literal("self") }).strict(),
+    zod.z.object({ source: zod.z.literal("stageId") }).strict(),
+    zod.z.object({
+      source: zod.z.literal("stateRead"),
+      scope: zod.z.enum(STATE_SCOPES),
+      slotId: NonEmpty,
+      path: zod.z.string().optional()
+    }).strict(),
+    // effectsContext lookup — reads from `instance.effectsContext[id === ID].value`.
+    // Used by chained effects where one handler's output feeds another's binding.
+    zod.z.object({
+      source: zod.z.literal("effectOutput"),
+      contextId: NonEmpty,
+      path: zod.z.string().optional()
+    }).strict(),
+    zod.z.object({ source: zod.z.literal("row"), path: zod.z.string().optional() }).strict(),
+    zod.z.object({
+      source: zod.z.literal("parentState"),
+      slotId: NonEmpty,
+      path: zod.z.string().optional()
+    }).strict(),
+    // Compound object source — resolves each field's Source recursively
+    // and packages the result into a JSON object. Lets ops append rich
+    // rows to `checklist` / `notes` / `assignees` slots, e.g.
+    // `{ source: "object", fields: { signer: { source: "actor" },
+    //   at: { source: "now" } } }`.
+    zod.z.object({
+      source: zod.z.literal("object"),
+      fields: zod.z.record(NonEmpty, SourceSchema)
+    }).strict()
+  ])
+), ScopeKeySchema = zod.z.object({
+  scope: zod.z.enum(STATE_SCOPES),
+  slotId: NonEmpty
+}).strict(), OpPredicateSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.object({
+      field: NonEmpty,
+      equals: SourceSchema
+    }).strict(),
+    zod.z.object({ all: zod.z.array(OpPredicateSchema) }).strict(),
+    zod.z.object({ any: zod.z.array(OpPredicateSchema) }).strict()
+  ])
+), OpSchema = zod.z.discriminatedUnion("type", [
+  zod.z.object({
+    type: zod.z.literal("workflow.op.state.set"),
+    target: ScopeKeySchema,
+    value: SourceSchema
+  }).strict(),
+  zod.z.object({
+    type: zod.z.literal("workflow.op.state.append"),
+    target: ScopeKeySchema,
+    item: SourceSchema
+  }).strict(),
+  zod.z.object({
+    type: zod.z.literal("workflow.op.state.updateWhere"),
+    target: ScopeKeySchema,
+    where: OpPredicateSchema,
+    merge: zod.z.record(NonEmpty, SourceSchema)
+  }).strict(),
+  zod.z.object({
+    type: zod.z.literal("workflow.op.state.removeWhere"),
+    target: ScopeKeySchema,
+    where: OpPredicateSchema
+  }).strict(),
+  zod.z.object({
+    type: zod.z.literal("workflow.op.status.set"),
+    taskId: NonEmpty,
+    status: zod.z.enum(TASK_STATUSES)
+  }).strict()
+]), StateSlotSourceSchema = zod.z.union([
+  zod.z.object({ kind: zod.z.literal("init") }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("query"),
+    query: NonEmpty,
+    resource: zod.z.union([zod.z.literal("workflow"), zod.z.literal("subject"), GdrSchema]).optional()
+  }).strict(),
+  zod.z.object({ kind: zod.z.literal("write") }).strict(),
+  zod.z.object({ kind: zod.z.literal("computed"), compute: NonEmpty }).strict(),
+  /**
+   * Pre-populate the slot at resolution time with a constant value.
+   * Useful for stage- or task-scope slots that should start non-empty
+   * (e.g. a default headline, a starting tally).
+   */
+  zod.z.object({ kind: zod.z.literal("literal"), value: zod.z.unknown() }).strict(),
+  /**
+   * Pre-populate by reading another already-resolved slot. `scope:
+   * "workflow"` reads from the workflow-scope `state[]` (resolved at
+   * startInstance). `scope: "stage"` reads from an earlier slot in
+   * this same stage entry's `state[]` (sequential resolution).
+   * Optional `path` selects a nested field (e.g. `path: "id"` on a
+   * doc.ref slot).
+   */
+  zod.z.object({
+    kind: zod.z.literal("stateRead"),
+    scope: zod.z.union([zod.z.literal("workflow"), zod.z.literal("stage")]),
+    slotId: NonEmpty,
+    path: zod.z.string().optional()
+  }).strict()
+]), StateSlotBase = {
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  source: StateSlotSourceSchema
+}, StateSlotKindSchema = zod.z.enum([
+  "workflow.state.doc.ref",
+  "workflow.state.doc.refs",
+  // Release reference. A workflow declares this slot to say "I target a
+  // Content Release"; the runtime fills it with a specific release at
+  // start time, and the engine auto-derives the instance's read
+  // perspective from it.
+  "workflow.state.release.ref",
+  "workflow.state.query",
+  "workflow.state.value.string",
+  "workflow.state.value.url",
+  "workflow.state.value.number",
+  "workflow.state.value.boolean",
+  "workflow.state.value.dateTime",
+  "workflow.state.value.actor",
+  "workflow.state.checklist",
+  "workflow.state.notes",
+  "workflow.state.assignees"
+]), StateSlotSchema = zod.z.discriminatedUnion(
+  "type",
+  StateSlotKindSchema.options.map(
+    (kind) => zod.z.object({ type: zod.z.literal(kind), ...StateSlotBase }).strict()
+  )
+), FilterSchema = zod.z.union([
+  // Inline GROQ — only reserved params allowed at runtime.
+  NonEmpty,
+  // Reference to a named predicate, optionally with named args.
+  zod.z.object({
+    ref: NonEmpty,
+    args: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  }).strict()
+]), PredicateParamSchema = zod.z.object({
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  type: zod.z.enum(["string", "number", "boolean", "string[]", "reference"]),
+  enum: zod.z.array(zod.z.string()).optional()
+}).strict(), PredicateSchema = zod.z.object({
+  type: zod.z.literal("workflow.predicate").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  groq: NonEmpty,
+  params: zod.z.array(PredicateParamSchema).optional()
+}).strict(), EffectSchema = zod.z.object({
+  type: zod.z.literal("workflow.effect").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  // Bindings resolve typed Source values at commit time, producing
+  // concrete JSON in the queued effect's `params`. NO GROQ.
+  bindings: zod.z.record(zod.z.string(), SourceSchema).optional(),
+  input: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+}).strict(), TerminalTaskStatus = zod.z.enum(["done", "skipped", "failed"]), PermissionSchema = zod.z.enum(DOCUMENT_VALUE_PERMISSIONS), ActionParamSchema = zod.z.object({
+  type: zod.z.literal("workflow.action.param").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  paramType: zod.z.enum([
+    "string",
+    "number",
+    "boolean",
+    "url",
+    "dateTime",
+    "actor",
+    "doc.ref",
+    "doc.refs",
+    "json"
+  ]),
+  required: zod.z.boolean().optional()
+}).strict(), ActionSchema = zod.z.object({
+  type: zod.z.literal("workflow.action").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  filter: FilterSchema.optional(),
+  /** Caller-supplied params, validated before ops/effects run. */
+  params: zod.z.array(ActionParamSchema).optional(),
+  /**
+   * Status the task flips to when this action fires. Omit to leave
+   * the task status unchanged — used by intermediate `claim` /
+   * `assign` / partial-update actions where the task should stay
+   * active so a later action can fire on it. Declared values must
+   * be terminal (`done` / `skipped` / `failed`); the engine never
+   * mid-flip back to `active` outside of the `workflow.op.status.set`
+   * op explicit path.
+   */
+  setStatus: TerminalTaskStatus.optional(),
+  /**
+   * Inline state-mutation primitives executed during the action commit.
+   * Each op runs against the in-memory mutation (deterministic, no
+   * external I/O). Resolved Sources turn into concrete JSON before the
+   * op applies. Logged on `history[]` as `workflow.history.opApplied`
+   * and surfaced on the `ActionResult.ranOps`.
+   */
+  ops: zod.z.array(OpSchema).optional(),
+  effects: zod.z.array(EffectSchema).optional(),
+  /**
+   * Role gating — OR-match against `Actor.roles[]`. If omitted, no role
+   * gate. `"*"` in Actor.roles always matches (bench / all-access).
+   */
+  roles: zod.z.array(NonEmpty).optional(),
+  /**
+   * When true, the actor must appear in the task's `assignees[]` (as a
+   * user-kind assignee matching by id) for the action to be allowed.
+   */
+  requireAssignment: zod.z.boolean().optional(),
+  /**
+   * Which permission on the workflow.instance document the actor must
+   * hold (per supplied `grants`). Defaults to "update". Only checked
+   * when grants are supplied at evaluate/fireAction time.
+   */
+  requiredPermission: PermissionSchema.optional()
+}).strict(), CompletionPolicySchema = zod.z.union([
+  zod.z.object({ kind: zod.z.literal("all") }).strict(),
+  zod.z.object({ kind: zod.z.literal("any") }).strict(),
+  zod.z.object({
+    kind: zod.z.literal("count"),
+    n: zod.z.number().int().positive()
+  }).strict()
+]), LogicalDefinitionRefSchema = zod.z.object({
+  workflowId: NonEmpty,
+  version: zod.z.union([zod.z.number().int().positive(), zod.z.literal("latest")]).optional()
+}).strict(), SpawnForEachSchema = zod.z.object({
+  groq: NonEmpty,
+  as: zod.z.object({
+    initialState: zod.z.array(
+      zod.z.object({
+        type: StateSlotKindSchema,
+        id: NonEmpty,
+        value: SourceSchema
+      }).strict()
+    ).optional(),
+    effectsContext: zod.z.record(zod.z.string(), SourceSchema).optional()
+  }).strict()
+}).strict(), SpawnSchema = zod.z.object({
+  type: zod.z.literal("workflow.spawn").optional(),
+  id: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  definitionRef: LogicalDefinitionRefSchema,
+  forEach: SpawnForEachSchema,
+  completionPolicy: CompletionPolicySchema.optional()
+}).strict(), AssigneeSchema = zod.z.discriminatedUnion("kind", [
+  zod.z.object({ kind: zod.z.literal("user"), id: NonEmpty }).strict(),
+  zod.z.object({ kind: zod.z.literal("role"), role: NonEmpty }).strict()
+]), TaskSchema = zod.z.object({
+  type: zod.z.literal("workflow.task").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  assignees: zod.z.array(AssigneeSchema).optional(),
+  filter: FilterSchema.optional(),
+  invokeOn: zod.z.enum(["stageEnter", "manual"]).optional(),
+  /**
+   * Auto-completion predicate — same shape as `transition.filter`. When
+   * truthy at activation or on any subsequent cascade, the engine
+   * flips the task to `done` with a `{ kind: "system", id: "engine.completeWhen" }`
+   * actor. A full filter, not just a wall-clock deadline.
+   */
+  completeWhen: FilterSchema.optional(),
+  /**
+   * Auto-failure predicate — symmetric to `completeWhen`. Same shape,
+   * same evaluation cadence (activation + every cascade), but flips
+   * the task to `failed` (not `done`) with a `{ kind: "system",
+   * id: "engine.failWhen" }` actor. When both `completeWhen` and
+   * `failWhen` resolve truthy on the same evaluation, `failWhen`
+   * wins — failure is the more notable signal and should not be
+   * silently swallowed.
+   */
+  failWhen: FilterSchema.optional(),
+  effects: zod.z.array(EffectSchema).optional(),
+  actions: zod.z.array(ActionSchema).optional(),
+  spawns: SpawnSchema.optional(),
+  contentRefs: zod.z.array(zod.z.unknown()).optional(),
+  /** Task-scoped state slots. Resolved at task activation time. */
+  state: zod.z.array(StateSlotSchema).optional()
+}).strict(), TransitionSchema = zod.z.object({
+  type: zod.z.literal("workflow.transition").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  to: NonEmpty,
+  on: zod.z.string().optional(),
+  filter: FilterSchema.optional(),
+  effects: zod.z.array(EffectSchema).optional()
+}).strict(), GuardActionSchema = zod.z.enum(MUTATION_GUARD_ACTIONS), GuardMatchSchema = zod.z.object({
+  /** Subject `_type`(s); empty matches any type. */
+  types: zod.z.array(NonEmpty).optional(),
+  /** Target docs as `Source`s resolved at deploy to bare ids + the resource. */
+  idRefs: zod.z.array(SourceSchema).optional(),
+  /** Glob id patterns (bare, resource-local). */
+  idPatterns: zod.z.array(NonEmpty).optional(),
+  actions: zod.z.array(GuardActionSchema).min(1, "a guard must match at least one action")
+}).strict(), GuardSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  match: GuardMatchSchema,
+  /**
+   * Lake GROQ predicate. Reads `document.before`/`document.after`, `mutation`,
+   * `guard`, and `identity()`. Bare ids/fields only — no GDRs. Omitted or
+   * empty means UNCONDITIONAL DENY.
+   */
+  predicate: zod.z.string().optional(),
+  /**
+   * Projected workflow state the predicate reads as `guard.metadata.*`. Values
+   * are `Source`s resolved at deploy and re-synced by the engine. Copied data,
+   * never a cross-resource pointer.
+   */
+  metadata: zod.z.record(NonEmpty, SourceSchema).optional()
+}).strict(), StageKindSchema = zod.z.enum(["initial", "intermediate", "terminal", "waiting"]), StageSchema = zod.z.object({
+  type: zod.z.literal("workflow.stage").optional(),
+  id: NonEmpty,
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  kind: StageKindSchema.optional(),
+  tasks: zod.z.array(TaskSchema).optional(),
+  transitions: zod.z.array(TransitionSchema).optional(),
+  completion: FilterSchema.optional(),
+  onEnter: zod.z.array(EffectSchema).optional(),
+  onExit: zod.z.array(EffectSchema).optional(),
+  /**
+   * Lake mutation guards active while this stage holds. Each compiles to a
+   * `temp.system.guard` doc deployed on stage entry and retracted on exit.
+   * Plural because one stage's intent may span resources (one guard each).
+   */
+  guards: zod.z.array(GuardSchema).optional(),
+  contentRefs: zod.z.array(zod.z.unknown()).optional(),
+  /** Stage-scoped state slots. Resolved at stage entry and persisted on
+   *  the StageEntry. */
+  state: zod.z.array(StateSlotSchema).optional()
+}).strict(), WorkflowDefinitionShape = zod.z.object({
+  workflowId: NonEmpty,
+  version: zod.z.number().int().positive(),
+  title: NonEmpty,
+  description: zod.z.string().optional(),
+  initialStageId: NonEmpty,
+  /**
+   * Workflow-level state slots. Persist for the instance lifetime.
+   * Every stage's filters/ops can read them via
+   * `*[_id == $self][0].state[key == "<key>"][0].value`. Init-sourced
+   * slots are supplied at `startInstance` via `initialState`.
+   */
+  state: zod.z.array(StateSlotSchema).optional(),
+  stages: zod.z.array(StageSchema).min(1, "must declare at least one stage"),
+  predicates: zod.z.array(PredicateSchema).optional()
+}).strict(), WorkflowDefinitionSchema = WorkflowDefinitionShape.superRefine(checkWorkflowInvariants);
+function formatZodError(error, label) {
+  const lines = error.issues.map((issue) => `  - ${issue.path.length === 0 ? "(root)" : formatPath(issue.path)}: ${issue.message}`);
+  return `${label} failed validation (${error.issues.length} issue${error.issues.length === 1 ? "" : "s"}):
+${lines.join(`
+`)}`;
+}
+function formatPath(path) {
+  let out = "";
+  for (const seg of path)
+    typeof seg == "number" ? out += `[${seg}]` : out += out.length === 0 ? String(seg) : `.${String(seg)}`;
+  return out;
+}
+function defineWorkflow(definition) {
+  return parseOrThrow(
+    WorkflowDefinitionSchema,
+    definition,
+    typeof definition.workflowId == "string" ? `defineWorkflow("${definition.workflowId}")` : "defineWorkflow"
+  );
+}
+function defineStage(stage) {
+  return parseOrThrow(StageSchema, stage, labelFor("defineStage", stage, "id"));
+}
+function defineTask(task) {
+  return parseOrThrow(TaskSchema, task, labelFor("defineTask", task, "id"));
+}
+function defineAction(action) {
+  return parseOrThrow(ActionSchema, action, labelFor("defineAction", action, "id"));
+}
+function defineTransition(transition) {
+  return parseOrThrow(
+    TransitionSchema,
+    transition,
+    typeof transition.id == "string" ? `defineTransition("${transition.id}")` : typeof transition.to == "string" ? `defineTransition(\u2192 "${transition.to}")` : "defineTransition"
+  );
+}
+function defineFilter(filter) {
+  return parseOrThrow(FilterSchema, filter, "defineFilter");
+}
+function defineAssignee(assignee) {
+  return parseOrThrow(AssigneeSchema, assignee, "defineAssignee");
+}
+function definePredicate(predicate) {
+  return parseOrThrow(PredicateSchema, predicate, labelFor("definePredicate", predicate, "id"));
+}
+function defineEffect(effect) {
+  return parseOrThrow(EffectSchema, effect, labelFor("defineEffect", effect, "id"));
+}
+function defineEffectDescriptor(descriptor) {
+  if (!descriptor.name) throw new Error("EffectDescriptor missing name");
+  return descriptor;
+}
+function parseOrThrow(schema, input, label) {
+  const result = schema.safeParse(input);
+  if (!result.success)
+    throw new Error(formatZodError(result.error, label));
+  return result.data;
+}
+function labelFor(fn, value, key) {
+  if (value && typeof value == "object" && key in value) {
+    const v = value[key];
+    if (typeof v == "string") return `${fn}("${v}")`;
+  }
+  return fn;
+}
+exports.defineAction = defineAction;
+exports.defineAssignee = defineAssignee;
+exports.defineEffect = defineEffect;
+exports.defineEffectDescriptor = defineEffectDescriptor;
+exports.defineFilter = defineFilter;
+exports.definePredicate = definePredicate;
+exports.defineStage = defineStage;
+exports.defineTask = defineTask;
+exports.defineTransition = defineTransition;
+exports.defineWorkflow = defineWorkflow;
+//# sourceMappingURL=define.cjs.map