@sanity/workflow-engine 0.1.0 → 0.2.0

package/dist/define.cjs

@@ -1,69 +1,71 @@
 "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"
-];
+var v = require("valibot");
+function _interopNamespaceCompat(e) {
+  if (e && typeof e == "object" && "default" in e) return e;
+  var n = /* @__PURE__ */ Object.create(null);
+  return e && Object.keys(e).forEach(function(k) {
+    if (k !== "default") {
+      var d = Object.getOwnPropertyDescriptor(e, k);
+      Object.defineProperty(n, k, d.get ? d : {
+        enumerable: !0,
+        get: function() {
+          return e[k];
+        }
+      });
+    }
+  }), n.default = e, Object.freeze(n);
+}
+var v__namespace = /* @__PURE__ */ _interopNamespaceCompat(v);
 function knownList(ids) {
   return [...ids].map((s) => `"${s}"`).join(", ");
 }
-function checkStagesAndTasks(def, ctx) {
+function checkStagesAndTasks(def, issues) {
   const stageIds = /* @__PURE__ */ new Set();
   for (const [i, stage] of def.stages.entries())
-    stageIds.has(stage.id) && ctx.addIssue({
-      code: "custom",
+    stageIds.has(stage.id) && issues.push({
       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",
+    }), stageIds.add(stage.id), stage.kind === "terminal" && stage.transitions && stage.transitions.length > 0 && issues.push({
       path: ["stages", i, "transitions"],
       message: `terminal stage "${stage.id}" must not declare transitions`
-    }), checkDuplicateTaskIds(stage, i, ctx);
+    }), checkDuplicateTaskIds(stage, i, issues);
   return stageIds;
 }
-function checkDuplicateTaskIds(stage, i, ctx) {
+function checkDuplicateTaskIds(stage, i, issues) {
   const taskIds = /* @__PURE__ */ new Set();
   for (const [j, task] of (stage.tasks ?? []).entries())
-    taskIds.has(task.id) && ctx.addIssue({
-      code: "custom",
+    taskIds.has(task.id) && issues.push({
       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",
+function checkInitialStage(def, stageIds, issues) {
+  stageIds.has(def.initialStageId) || issues.push({
     path: ["initialStageId"],
     message: `initialStageId "${def.initialStageId}" is not a declared stage. Known stages: ${knownList(stageIds)}`
   });
 }
-function checkTransitionTargets(def, stageIds, ctx) {
+function checkTransitionTargets(def, stageIds, issues) {
   for (const [i, stage] of def.stages.entries())
     for (const [k, t] of (stage.transitions ?? []).entries())
-      stageIds.has(t.to) || ctx.addIssue({
-        code: "custom",
+      stageIds.has(t.to) || issues.push({
         path: ["stages", i, "transitions", k, "to"],
         message: `transition target "${t.to}" is not a declared stage. Known stages: ${knownList(stageIds)}`
       });
 }
-function collectPredicateIds(def, ctx) {
+function collectPredicateIds(def, issues) {
   const predicateIds = /* @__PURE__ */ new Set();
   for (const [i, p] of (def.predicates ?? []).entries())
-    predicateIds.has(p.id) && ctx.addIssue({
-      code: "custom",
+    predicateIds.has(p.id) && issues.push({
       path: ["predicates", i, "id"],
       message: `duplicate predicate id "${p.id}"`
     }), predicateIds.add(p.id);
   return predicateIds;
 }
-function checkFilterRefs(def, predicateIds, ctx) {
+function checkFilterRefs(def, predicateIds, issues) {
   const visit = (g, path) => {
-    g === void 0 || typeof g == "string" || predicateIds.has(g.ref) || ctx.addIssue({
-      code: "custom",
+    g === void 0 || typeof g == "string" || predicateIds.has(g.ref) || issues.push({
       path: [...path, "ref"],
       message: `Filter references predicate "${g.ref}" which is not declared. Known predicates: ${knownList(predicateIds) || "(none)"}`
     });
@@ -79,112 +81,127 @@ function checkFilterRefs(def, predicateIds, ctx) {
       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);
+function checkWorkflowInvariants(def) {
+  const issues = [], stageIds = checkStagesAndTasks(def, issues);
+  checkInitialStage(def, stageIds, issues), checkTransitionTargets(def, stageIds, issues);
+  const predicateIds = collectPredicateIds(def, issues);
+  return checkFilterRefs(def, predicateIds, issues), issues;
+}
+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"
+], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1));
+function picklist(options) {
+  return v__namespace.picklist(
+    options,
+    `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
+  );
 }
-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"
+const GdrSchema = v__namespace.strictObject({
+  id: v__namespace.pipe(
+    v__namespace.string(),
+    v__namespace.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),
+}), SourceSchema = v__namespace.lazy(
+  () => v__namespace.union([
+    v__namespace.strictObject({
+      source: v__namespace.literal("literal"),
+      value: v__namespace.union([v__namespace.string(), v__namespace.number(), v__namespace.boolean(), v__namespace.null()])
+    }),
+    v__namespace.strictObject({ source: v__namespace.literal("param"), paramId: NonEmpty }),
+    v__namespace.strictObject({ source: v__namespace.literal("actor") }),
+    v__namespace.strictObject({ source: v__namespace.literal("now") }),
+    v__namespace.strictObject({ source: v__namespace.literal("self") }),
+    v__namespace.strictObject({ source: v__namespace.literal("stageId") }),
+    v__namespace.strictObject({
+      source: v__namespace.literal("stateRead"),
+      scope: picklist(STATE_SCOPES),
       slotId: NonEmpty,
-      path: zod.z.string().optional()
-    }).strict(),
+      path: v__namespace.optional(v__namespace.string())
+    }),
     // 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"),
+    v__namespace.strictObject({
+      source: v__namespace.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"),
+      path: v__namespace.optional(v__namespace.string())
+    }),
+    v__namespace.strictObject({ source: v__namespace.literal("row"), path: v__namespace.optional(v__namespace.string()) }),
+    v__namespace.strictObject({
+      source: v__namespace.literal("parentState"),
       slotId: NonEmpty,
-      path: zod.z.string().optional()
-    }).strict(),
+      path: v__namespace.optional(v__namespace.string())
+    }),
     // 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()
+    v__namespace.strictObject({
+      source: v__namespace.literal("object"),
+      fields: v__namespace.record(NonEmpty, SourceSchema)
+    })
   ])
-), ScopeKeySchema = zod.z.object({
-  scope: zod.z.enum(STATE_SCOPES),
+), ScopeKeySchema = v__namespace.strictObject({
+  scope: picklist(STATE_SCOPES),
   slotId: NonEmpty
-}).strict(), OpPredicateSchema = zod.z.lazy(
-  () => zod.z.union([
-    zod.z.object({
+}), OpPredicateSchema = v__namespace.lazy(
+  () => v__namespace.union([
+    v__namespace.strictObject({
       field: NonEmpty,
       equals: SourceSchema
-    }).strict(),
-    zod.z.object({ all: zod.z.array(OpPredicateSchema) }).strict(),
-    zod.z.object({ any: zod.z.array(OpPredicateSchema) }).strict()
+    }),
+    v__namespace.strictObject({ all: v__namespace.array(OpPredicateSchema) }),
+    v__namespace.strictObject({ any: v__namespace.array(OpPredicateSchema) })
   ])
-), OpSchema = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    type: zod.z.literal("workflow.op.state.set"),
+), OpSchema = v__namespace.variant("type", [
+  v__namespace.strictObject({
+    type: v__namespace.literal("workflow.op.state.set"),
     target: ScopeKeySchema,
     value: SourceSchema
-  }).strict(),
-  zod.z.object({
-    type: zod.z.literal("workflow.op.state.append"),
+  }),
+  v__namespace.strictObject({
+    type: v__namespace.literal("workflow.op.state.append"),
     target: ScopeKeySchema,
     item: SourceSchema
-  }).strict(),
-  zod.z.object({
-    type: zod.z.literal("workflow.op.state.updateWhere"),
+  }),
+  v__namespace.strictObject({
+    type: v__namespace.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"),
+    merge: v__namespace.record(NonEmpty, SourceSchema)
+  }),
+  v__namespace.strictObject({
+    type: v__namespace.literal("workflow.op.state.removeWhere"),
     target: ScopeKeySchema,
     where: OpPredicateSchema
-  }).strict(),
-  zod.z.object({
-    type: zod.z.literal("workflow.op.status.set"),
+  }),
+  v__namespace.strictObject({
+    type: v__namespace.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"),
+    status: picklist(TASK_STATUSES)
+  })
+]), StateSlotSourceSchema = v__namespace.union([
+  v__namespace.strictObject({ kind: v__namespace.literal("init") }),
+  v__namespace.strictObject({
+    kind: v__namespace.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(),
+    resource: v__namespace.optional(v__namespace.union([v__namespace.literal("workflow"), v__namespace.literal("subject"), GdrSchema]))
+  }),
+  v__namespace.strictObject({ kind: v__namespace.literal("write") }),
   /**
    * 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(),
+  v__namespace.strictObject({ kind: v__namespace.literal("literal"), value: v__namespace.unknown() }),
   /**
    * Pre-populate by reading another already-resolved slot. `scope:
    * "workflow"` reads from the workflow-scope `state[]` (resolved at
@@ -193,18 +210,13 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
    * 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")]),
+  v__namespace.strictObject({
+    kind: v__namespace.literal("stateRead"),
+    scope: v__namespace.union([v__namespace.literal("workflow"), v__namespace.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([
+    path: v__namespace.optional(v__namespace.string())
+  })
+]), StateSlotKindSchema = picklist([
   "workflow.state.doc.ref",
   "workflow.state.doc.refs",
   // Release reference. A workflow declares this slot to say "I target a
@@ -222,47 +234,48 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
   "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([
+]), StateSlotSchema = v__namespace.strictObject({
+  type: StateSlotKindSchema,
+  id: NonEmpty,
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  source: StateSlotSourceSchema
+}), FilterSchema = v__namespace.union([
   // Inline GROQ — only reserved params allowed at runtime.
   NonEmpty,
   // Reference to a named predicate, optionally with named args.
-  zod.z.object({
+  v__namespace.strictObject({
     ref: NonEmpty,
-    args: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-  }).strict()
-]), PredicateParamSchema = zod.z.object({
+    args: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown()))
+  })
+]), PredicateParamSchema = v__namespace.strictObject({
   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(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  type: picklist(["string", "number", "boolean", "string[]", "reference"]),
+  enum: v__namespace.optional(v__namespace.array(v__namespace.string()))
+}), PredicateSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.predicate")),
   id: NonEmpty,
-  title: zod.z.string().optional(),
-  description: zod.z.string().optional(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
   groq: NonEmpty,
-  params: zod.z.array(PredicateParamSchema).optional()
-}).strict(), EffectSchema = zod.z.object({
-  type: zod.z.literal("workflow.effect").optional(),
+  params: v__namespace.optional(v__namespace.array(PredicateParamSchema))
+}), EffectSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.effect")),
   id: NonEmpty,
-  title: zod.z.string().optional(),
-  description: zod.z.string().optional(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
   // 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(),
+  bindings: v__namespace.optional(v__namespace.record(v__namespace.string(), SourceSchema)),
+  input: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown()))
+}), TerminalTaskStatus = picklist(["done", "skipped", "failed"]), PermissionSchema = picklist(DOCUMENT_VALUE_PERMISSIONS), ActionParamSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.action.param")),
   id: NonEmpty,
-  title: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  paramType: zod.z.enum([
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  paramType: picklist([
     "string",
     "number",
     "boolean",
@@ -273,15 +286,15 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
     "doc.refs",
     "json"
   ]),
-  required: zod.z.boolean().optional()
-}).strict(), ActionSchema = zod.z.object({
-  type: zod.z.literal("workflow.action").optional(),
+  required: v__namespace.optional(v__namespace.boolean())
+}), ActionSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.action")),
   id: NonEmpty,
-  title: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  filter: FilterSchema.optional(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  filter: v__namespace.optional(FilterSchema),
   /** Caller-supplied params, validated before ops/effects run. */
-  params: zod.z.array(ActionParamSchema).optional(),
+  params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
   /**
    * Status the task flips to when this action fires. Omit to leave
    * the task status unchanged — used by intermediate `claim` /
@@ -291,7 +304,7 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
    * mid-flip back to `active` outside of the `workflow.op.status.set`
    * op explicit path.
    */
-  setStatus: TerminalTaskStatus.optional(),
+  setStatus: v__namespace.optional(TerminalTaskStatus),
   /**
    * Inline state-mutation primitives executed during the action commit.
    * Each op runs against the in-memory mutation (deterministic, no
@@ -299,72 +312,74 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
    * 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(),
+  ops: v__namespace.optional(v__namespace.array(OpSchema)),
+  effects: v__namespace.optional(v__namespace.array(EffectSchema)),
   /**
    * 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(),
+  roles: v__namespace.optional(v__namespace.array(NonEmpty)),
   /**
    * 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(),
+  requireAssignment: v__namespace.optional(v__namespace.boolean()),
   /**
    * 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({
+  requiredPermission: v__namespace.optional(PermissionSchema)
+}), CompletionPolicySchema = v__namespace.union([
+  v__namespace.strictObject({ kind: v__namespace.literal("all") }),
+  v__namespace.strictObject({ kind: v__namespace.literal("any") }),
+  v__namespace.strictObject({
+    kind: v__namespace.literal("count"),
+    n: PositiveInt
+  })
+]), LogicalDefinitionRefSchema = v__namespace.strictObject({
   workflowId: NonEmpty,
-  version: zod.z.union([zod.z.number().int().positive(), zod.z.literal("latest")]).optional()
-}).strict(), SpawnForEachSchema = zod.z.object({
+  version: v__namespace.optional(v__namespace.union([PositiveInt, v__namespace.literal("latest")]))
+}), SpawnForEachSchema = v__namespace.strictObject({
   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(),
+  as: v__namespace.strictObject({
+    initialState: v__namespace.optional(
+      v__namespace.array(
+        v__namespace.strictObject({
+          type: StateSlotKindSchema,
+          id: NonEmpty,
+          value: SourceSchema
+        })
+      )
+    ),
+    effectsContext: v__namespace.optional(v__namespace.record(v__namespace.string(), SourceSchema))
+  })
+}), SpawnSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.spawn")),
+  id: v__namespace.optional(v__namespace.string()),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
   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(),
+  completionPolicy: v__namespace.optional(CompletionPolicySchema)
+}), AssigneeSchema = v__namespace.variant("kind", [
+  v__namespace.strictObject({ kind: v__namespace.literal("user"), id: NonEmpty }),
+  v__namespace.strictObject({ kind: v__namespace.literal("role"), role: NonEmpty })
+]), TaskSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.task")),
   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(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  assignees: v__namespace.optional(v__namespace.array(AssigneeSchema)),
+  filter: v__namespace.optional(FilterSchema),
+  invokeOn: v__namespace.optional(picklist(["stageEnter", "manual"])),
   /**
    * 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(),
+  completeWhen: v__namespace.optional(FilterSchema),
   /**
    * Auto-failure predicate — symmetric to `completeWhen`. Same shape,
    * same evaluation cadence (activation + every cascade), but flips
@@ -374,72 +389,75 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
    * 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(),
+  failWhen: v__namespace.optional(FilterSchema),
+  effects: v__namespace.optional(v__namespace.array(EffectSchema)),
+  actions: v__namespace.optional(v__namespace.array(ActionSchema)),
+  spawns: v__namespace.optional(SpawnSchema),
+  contentRefs: v__namespace.optional(v__namespace.array(v__namespace.unknown())),
   /** 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(),
+  state: v__namespace.optional(v__namespace.array(StateSlotSchema))
+}), TransitionSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.transition")),
   id: NonEmpty,
-  title: zod.z.string().optional(),
-  description: zod.z.string().optional(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
   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({
+  on: v__namespace.optional(v__namespace.string()),
+  filter: v__namespace.optional(FilterSchema),
+  effects: v__namespace.optional(v__namespace.array(EffectSchema))
+}), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v__namespace.strictObject({
   /** Subject `_type`(s); empty matches any type. */
-  types: zod.z.array(NonEmpty).optional(),
+  types: v__namespace.optional(v__namespace.array(NonEmpty)),
   /** Target docs as `Source`s resolved at deploy to bare ids + the resource. */
-  idRefs: zod.z.array(SourceSchema).optional(),
+  idRefs: v__namespace.optional(v__namespace.array(SourceSchema)),
   /** 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(),
+  idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
+  actions: v__namespace.pipe(
+    v__namespace.array(GuardActionSchema),
+    v__namespace.minLength(1, "a guard must match at least one action")
+  )
+}), GuardSchema = v__namespace.strictObject({
+  name: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
   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(),
+  predicate: v__namespace.optional(v__namespace.string()),
   /**
    * 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(),
+  metadata: v__namespace.optional(v__namespace.record(NonEmpty, SourceSchema))
+}), StageKindSchema = picklist(["initial", "intermediate", "terminal", "waiting"]), StageSchema = v__namespace.strictObject({
+  type: v__namespace.optional(v__namespace.literal("workflow.stage")),
   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(),
+  title: v__namespace.optional(v__namespace.string()),
+  description: v__namespace.optional(v__namespace.string()),
+  kind: v__namespace.optional(StageKindSchema),
+  tasks: v__namespace.optional(v__namespace.array(TaskSchema)),
+  transitions: v__namespace.optional(v__namespace.array(TransitionSchema)),
+  completion: v__namespace.optional(FilterSchema),
+  onEnter: v__namespace.optional(v__namespace.array(EffectSchema)),
+  onExit: v__namespace.optional(v__namespace.array(EffectSchema)),
   /**
    * 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(),
+  guards: v__namespace.optional(v__namespace.array(GuardSchema)),
+  contentRefs: v__namespace.optional(v__namespace.array(v__namespace.unknown())),
   /** Stage-scoped state slots. Resolved at stage entry and persisted on
    *  the StageEntry. */
-  state: zod.z.array(StateSlotSchema).optional()
-}).strict(), WorkflowDefinitionShape = zod.z.object({
+  state: v__namespace.optional(v__namespace.array(StateSlotSchema))
+}), WorkflowDefinitionSchema = v__namespace.strictObject({
   workflowId: NonEmpty,
-  version: zod.z.number().int().positive(),
+  version: PositiveInt,
   title: NonEmpty,
-  description: zod.z.string().optional(),
+  description: v__namespace.optional(v__namespace.string()),
   initialStageId: NonEmpty,
   /**
    * Workflow-level state slots. Persist for the instance lifetime.
@@ -447,16 +465,22 @@ const NonEmpty = zod.z.string().min(1, "must be a non-empty string"), GdrSchema
    * `*[_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"}):
+  state: v__namespace.optional(v__namespace.array(StateSlotSchema)),
+  stages: v__namespace.pipe(v__namespace.array(StageSchema), v__namespace.minLength(1, "must declare at least one stage")),
+  predicates: v__namespace.optional(v__namespace.array(PredicateSchema))
+});
+function formatValidationError(label, issues) {
+  const lines = issues.map((issue) => `  - ${issue.path.length === 0 ? "(root)" : formatPath(issue.path)}: ${issue.message}`);
+  return `${label} failed validation (${issues.length} issue${issues.length === 1 ? "" : "s"}):
 ${lines.join(`
 `)}`;
 }
+function issuesFromValibot(issues) {
+  return issues.map((issue) => ({
+    path: issue.path ? issue.path.map((item) => item.key) : [],
+    message: issue.message
+  }));
+}
 function formatPath(path) {
   let out = "";
   for (const seg of path)
@@ -464,11 +488,9 @@ function formatPath(path) {
   return out;
 }
 function defineWorkflow(definition) {
-  return parseOrThrow(
-    WorkflowDefinitionSchema,
-    definition,
-    typeof definition.workflowId == "string" ? `defineWorkflow("${definition.workflowId}")` : "defineWorkflow"
-  );
+  const workflowId = definition.workflowId, label = typeof workflowId == "string" ? `defineWorkflow("${workflowId}")` : "defineWorkflow", parsed = parseOrThrow(WorkflowDefinitionSchema, definition, label), issues = checkWorkflowInvariants(parsed);
+  if (issues.length > 0) throw new Error(formatValidationError(label, issues));
+  return parsed;
 }
 function defineStage(stage) {
   return parseOrThrow(StageSchema, stage, labelFor("defineStage", stage, "id"));
@@ -503,15 +525,15 @@ function defineEffectDescriptor(descriptor) {
   return descriptor;
 }
 function parseOrThrow(schema, input, label) {
-  const result = schema.safeParse(input);
+  const result = v__namespace.safeParse(schema, input);
   if (!result.success)
-    throw new Error(formatZodError(result.error, label));
-  return result.data;
+    throw new Error(formatValidationError(label, issuesFromValibot(result.issues)));
+  return result.output;
 }
 function labelFor(fn, value, key) {
   if (value && typeof value == "object" && key in value) {
-    const v = value[key];
-    if (typeof v == "string") return `${fn}("${v}")`;
+    const raw = value[key];
+    if (typeof raw == "string") return `${fn}("${raw}")`;
   }
   return fn;
 }