@sanity/workflow-engine 0.3.0 → 0.4.0

package/dist/_chunks-es/schema.js

@@ -1,193 +1,168 @@
 import * as v from "valibot";
-const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], STATE_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
+const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMINAL_TASK_STATUSES = ["done", "skipped", "failed"];
+function isTerminalTaskStatus(status) {
+  return TERMINAL_TASK_STATUSES.includes(status);
+}
+const STATE_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
   "create",
   "update",
   "delete",
   "publish",
   "unpublish"
-], NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1));
+], NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function groqIdentifier(referencedAs) {
+  return v.pipe(
+    v.string(),
+    v.regex(
+      GROQ_IDENTIFIER,
+      `must be a GROQ-safe identifier (letters, digits, underscore; not starting with a digit) because it is referenced as ${referencedAs} in GROQ conditions`
+    )
+  );
+}
 function picklist(options) {
   return v.picklist(
     options,
     `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
   );
 }
-const GdrSchema = v.strictObject({
-  id: v.pipe(
-    v.string(),
-    v.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
-}), SourceSchema = v.lazy(
+const SourceSchema = v.lazy(
   () => v.union([
+    // State-entry origins: who fills the entry, and when.
+    v.strictObject({ type: v.literal("init") }),
+    v.strictObject({ type: v.literal("write") }),
     v.strictObject({
-      source: v.literal("literal"),
-      value: v.union([v.string(), v.number(), v.boolean(), v.null()])
-    }),
-    v.strictObject({ source: v.literal("param"), paramId: NonEmpty }),
-    v.strictObject({ source: v.literal("actor") }),
-    v.strictObject({ source: v.literal("now") }),
-    v.strictObject({ source: v.literal("self") }),
-    v.strictObject({ source: v.literal("stageId") }),
-    v.strictObject({
-      source: v.literal("stateRead"),
-      scope: picklist(STATE_SCOPES),
-      slotId: NonEmpty,
-      path: v.optional(v.string())
+      type: v.literal("query"),
+      query: NonEmpty
     }),
-    // effectsContext lookup — reads from `instance.effectsContext[id === ID].value`.
-    // Used by chained effects where one handler's output feeds another's binding.
+    // Value sources: resolved to concrete JSON when an op or seed applies.
+    v.strictObject({ type: v.literal("literal"), value: v.unknown() }),
+    v.strictObject({ type: v.literal("param"), param: NonEmpty }),
+    v.strictObject({ type: v.literal("actor") }),
+    v.strictObject({ type: v.literal("now") }),
+    v.strictObject({ type: v.literal("self") }),
+    v.strictObject({ type: v.literal("stage") }),
     v.strictObject({
-      source: v.literal("effectOutput"),
-      contextId: NonEmpty,
+      type: v.literal("stateRead"),
+      scope: v.optional(v.union([v.literal("workflow"), v.literal("stage")])),
+      state: NonEmpty,
       path: v.optional(v.string())
     }),
-    v.strictObject({ source: v.literal("row"), path: v.optional(v.string()) }),
     v.strictObject({
-      source: v.literal("parentState"),
-      slotId: NonEmpty,
-      path: v.optional(v.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" } } }`.
-    v.strictObject({
-      source: v.literal("object"),
+      type: v.literal("object"),
       fields: v.record(NonEmpty, SourceSchema)
     })
   ])
-), ScopeKeySchema = v.strictObject({
+), StoredStateRefSchema = v.strictObject({
   scope: picklist(STATE_SCOPES),
-  slotId: NonEmpty
+  state: NonEmpty
+}), AuthoringStateRefSchema = v.strictObject({
+  scope: v.optional(picklist(STATE_SCOPES)),
+  state: NonEmpty
 }), OpPredicateSchema = v.lazy(
   () => v.union([
     v.strictObject({
+      type: v.literal("field"),
       field: NonEmpty,
       equals: SourceSchema
     }),
-    v.strictObject({ all: v.array(OpPredicateSchema) }),
-    v.strictObject({ any: v.array(OpPredicateSchema) })
+    v.strictObject({ type: v.literal("all"), of: v.array(OpPredicateSchema) }),
+    v.strictObject({ type: v.literal("any"), of: v.array(OpPredicateSchema) })
   ])
-), OpSchema = v.variant("type", [
-  v.strictObject({
-    type: v.literal("workflow.op.state.set"),
-    target: ScopeKeySchema,
-    value: SourceSchema
-  }),
-  v.strictObject({
-    type: v.literal("workflow.op.state.append"),
-    target: ScopeKeySchema,
-    item: SourceSchema
-  }),
-  v.strictObject({
-    type: v.literal("workflow.op.state.updateWhere"),
-    target: ScopeKeySchema,
-    where: OpPredicateSchema,
-    merge: v.record(NonEmpty, SourceSchema)
-  }),
-  v.strictObject({
-    type: v.literal("workflow.op.state.removeWhere"),
-    target: ScopeKeySchema,
-    where: OpPredicateSchema
-  }),
+);
+function opSchemas(targetSchema) {
+  return [
+    v.strictObject({
+      type: v.literal("state.set"),
+      target: targetSchema,
+      value: SourceSchema
+    }),
+    v.strictObject({
+      type: v.literal("state.unset"),
+      target: targetSchema
+    }),
+    v.strictObject({
+      type: v.literal("state.append"),
+      target: targetSchema,
+      value: SourceSchema
+    }),
+    v.strictObject({
+      type: v.literal("state.updateWhere"),
+      target: targetSchema,
+      where: OpPredicateSchema,
+      value: SourceSchema
+    }),
+    v.strictObject({
+      type: v.literal("state.removeWhere"),
+      target: targetSchema,
+      where: OpPredicateSchema
+    })
+  ];
+}
+const StoredOpSchema = v.variant("type", [
+  ...opSchemas(StoredStateRefSchema),
   v.strictObject({
-    type: v.literal("workflow.op.status.set"),
-    taskId: NonEmpty,
+    type: v.literal("status.set"),
+    task: NonEmpty,
     status: picklist(TASK_STATUSES)
   })
-]), StateSlotSourceSchema = v.union([
-  v.strictObject({ kind: v.literal("init") }),
+]), StoredTransitionOpSchema = v.variant("type", [...opSchemas(StoredStateRefSchema)]), AuditOpSchema = v.strictObject({
+  type: v.literal("audit"),
+  target: AuthoringStateRefSchema,
+  value: SourceSchema,
+  stampFields: v.optional(
+    v.strictObject({
+      actor: v.optional(NonEmpty),
+      at: v.optional(NonEmpty)
+    })
+  )
+}), AuthoringOpSchema = v.variant("type", [
+  ...opSchemas(AuthoringStateRefSchema),
   v.strictObject({
-    kind: v.literal("query"),
-    query: NonEmpty,
-    resource: v.optional(v.union([v.literal("workflow"), v.literal("subject"), GdrSchema]))
+    type: v.literal("status.set"),
+    task: v.optional(NonEmpty),
+    status: picklist(TASK_STATUSES)
   }),
-  v.strictObject({ kind: v.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).
-   */
-  v.strictObject({ kind: v.literal("literal"), value: v.unknown() }),
-  /**
-   * 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).
-   */
-  v.strictObject({
-    kind: v.literal("stateRead"),
-    scope: v.union([v.literal("workflow"), v.literal("stage")]),
-    slotId: NonEmpty,
-    path: v.optional(v.string())
-  })
-]), StateSlotKindSchema = picklist([
-  "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 = v.strictObject({
-  type: StateSlotKindSchema,
-  id: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  source: StateSlotSourceSchema
-}), FilterSchema = v.union([
-  // Inline GROQ — only reserved params allowed at runtime.
-  NonEmpty,
-  // Reference to a named predicate, optionally with named args.
-  v.strictObject({
-    ref: NonEmpty,
-    args: v.optional(v.record(v.string(), v.unknown()))
-  })
-]), PredicateParamSchema = v.strictObject({
-  id: NonEmpty,
+  AuditOpSchema
+]), StateKindSchema = picklist([
+  "doc.ref",
+  "doc.refs",
+  // Release reference. A workflow declares this entry to say "I target a
+  // Content Release"; the runtime fills it at start time and auto-derives
+  // the instance's read perspective from it.
+  "release.ref",
+  "query",
+  "value.string",
+  "value.url",
+  "value.number",
+  "value.boolean",
+  "value.dateTime",
+  "value.actor",
+  "checklist",
+  "notes",
+  // The WHO-FOR entry: the inbox reverse-query reads it by kind, and the
+  // rendered `$assigned` gate matches the caller against it.
+  "assignees"
+]), StateEntryName = groqIdentifier("`$state.<name>`"), StateEntrySchema = v.strictObject({
+  type: StateKindSchema,
+  name: StateEntryName,
   title: v.optional(v.string()),
   description: v.optional(v.string()),
-  type: picklist(["string", "number", "boolean", "string[]", "reference"]),
-  enum: v.optional(v.array(v.string()))
-}), PredicateSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.predicate")),
-  id: NonEmpty,
+  source: SourceSchema
+}), ClaimStateSchema = v.strictObject({
+  type: v.literal("claim"),
+  name: StateEntryName,
   title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  groq: NonEmpty,
-  params: v.optional(v.array(PredicateParamSchema))
-}), EffectSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.effect")),
-  id: NonEmpty,
+  description: v.optional(v.string())
+}), AuthoringStateEntrySchema = v.union([StateEntrySchema, ClaimStateSchema]), ConditionSchema = NonEmpty, EffectSchema = v.strictObject({
+  name: NonEmpty,
   title: v.optional(v.string()),
   description: v.optional(v.string()),
-  // Bindings resolve typed Source values at commit time, producing
-  // concrete JSON in the queued effect's `params`. NO GROQ.
-  bindings: v.optional(v.record(v.string(), SourceSchema)),
+  /** GROQ reads over the rendered scope, resolved to concrete JSON at queue time. */
+  bindings: v.optional(v.record(v.string(), ConditionSchema)),
+  /** Static config, passed through to the handler verbatim. */
   input: v.optional(v.record(v.string(), v.unknown()))
-}), TerminalTaskStatus = picklist(["done", "skipped", "failed"]), PermissionSchema = picklist(DOCUMENT_VALUE_PERMISSIONS), ActionParamSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.action.param")),
-  id: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  paramType: picklist([
+}), ActionParamSchema = v.strictObject({
+  type: picklist([
     "string",
     "number",
     "boolean",
@@ -198,130 +173,113 @@ const GdrSchema = v.strictObject({
     "doc.refs",
     "json"
   ]),
-  required: v.optional(v.boolean())
-}), ActionSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.action")),
-  id: NonEmpty,
+  name: NonEmpty,
   title: v.optional(v.string()),
   description: v.optional(v.string()),
-  filter: v.optional(FilterSchema),
-  /** Caller-supplied params, validated before ops/effects run. */
-  params: v.optional(v.array(ActionParamSchema)),
-  /**
-   * 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: v.optional(TerminalTaskStatus),
-  /**
-   * 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: v.optional(v.array(OpSchema)),
-  effects: v.optional(v.array(EffectSchema)),
-  /**
-   * Role gating — OR-match against `Actor.roles[]`. If omitted, no role
-   * gate. `"*"` in Actor.roles always matches (bench / all-access).
-   */
+  required: v.optional(v.boolean())
+});
+function actionFields(op) {
+  return {
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    /**
+     * The one gate mechanism: a condition over the rendered scope. Hard
+     * enforcement lives outside the engine entirely (the lake ACL on the
+     * documents, and guards) — every engine-evaluated gate is authoring/UX.
+     */
+    filter: v.optional(ConditionSchema),
+    params: v.optional(v.array(ActionParamSchema)),
+    ops: v.optional(v.array(op)),
+    effects: v.optional(v.array(EffectSchema))
+  };
+}
+const StoredActionSchema = v.strictObject(actionFields(StoredOpSchema)), TerminalTaskStatus = picklist(TERMINAL_TASK_STATUSES), RawAuthoringActionSchema = v.strictObject({
+  ...actionFields(AuthoringOpSchema),
   roles: v.optional(v.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: v.optional(v.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: v.optional(PermissionSchema)
-}), CompletionPolicySchema = v.union([
-  v.strictObject({ kind: v.literal("all") }),
-  v.strictObject({ kind: v.literal("any") }),
-  v.strictObject({
-    kind: v.literal("count"),
-    n: PositiveInt
-  })
-]), LogicalDefinitionRefSchema = v.strictObject({
-  workflowId: NonEmpty,
-  version: v.optional(v.union([PositiveInt, v.literal("latest")]))
-}), SpawnForEachSchema = v.strictObject({
-  groq: NonEmpty,
-  as: v.strictObject({
-    initialState: v.optional(
-      v.array(
-        v.strictObject({
-          type: StateSlotKindSchema,
-          id: NonEmpty,
-          value: SourceSchema
-        })
-      )
-    ),
-    effectsContext: v.optional(v.record(v.string(), SourceSchema))
-  })
-}), SpawnSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.spawn")),
-  id: v.optional(v.string()),
+  status: v.optional(TerminalTaskStatus)
+}), ClaimActionSchema = v.strictObject({
+  type: v.literal("claim"),
+  name: NonEmpty,
   title: v.optional(v.string()),
   description: v.optional(v.string()),
-  definitionRef: LogicalDefinitionRefSchema,
-  forEach: SpawnForEachSchema,
-  completionPolicy: v.optional(CompletionPolicySchema)
-}), AssigneeSchema = v.variant("kind", [
-  v.strictObject({ kind: v.literal("user"), id: NonEmpty }),
-  v.strictObject({ kind: v.literal("role"), role: NonEmpty })
-]), TaskSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.task")),
-  id: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  assignees: v.optional(v.array(AssigneeSchema)),
-  filter: v.optional(FilterSchema),
-  invokeOn: v.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: v.optional(FilterSchema),
+  state: v.union([NonEmpty, AuthoringStateRefSchema]),
+  roles: v.optional(v.array(NonEmpty)),
+  filter: v.optional(ConditionSchema),
+  params: v.optional(v.array(ActionParamSchema)),
+  effects: v.optional(v.array(EffectSchema))
+}), AuthoringActionSchema = v.union([RawAuthoringActionSchema, ClaimActionSchema]), DefinitionRefSchema = v.strictObject({
+  name: NonEmpty,
+  version: v.optional(v.union([PositiveInt, v.literal("latest")]))
+}), SubworkflowsSchema = v.strictObject({
+  /** GROQ producing one row per subworkflow; each row binds as `$row`. */
+  forEach: NonEmpty,
+  definition: DefinitionRefSchema,
+  /** Initial state for each subworkflow — entry name → GROQ over `$row` + the parent scope. */
+  with: v.optional(v.record(NonEmpty, ConditionSchema)),
   /**
-   * 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.
+   * Extra values evaluated in the parent's rendered scope at spawn time and
+   * delivered into each subworkflow's `$effects` bag — the parent→child
+   * handoff, read exactly like an effect output.
    */
-  failWhen: v.optional(FilterSchema),
-  effects: v.optional(v.array(EffectSchema)),
-  actions: v.optional(v.array(ActionSchema)),
-  spawns: v.optional(SpawnSchema),
-  contentRefs: v.optional(v.array(v.unknown())),
-  /** Task-scoped state slots. Resolved at task activation time. */
-  state: v.optional(v.array(StateSlotSchema))
-}), TransitionSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.transition")),
-  id: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  to: NonEmpty,
-  on: v.optional(v.string()),
-  filter: v.optional(FilterSchema),
-  effects: v.optional(v.array(EffectSchema))
-}), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v.strictObject({
+  context: v.optional(v.record(NonEmpty, ConditionSchema))
+});
+function taskFields(state, action, op) {
+  return {
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    activation: v.optional(picklist(["auto", "manual"])),
+    filter: v.optional(ConditionSchema),
+    /**
+     * Auto-completion condition — evaluated at activation and on every
+     * cascade; truthy flips the task to `done` with a system actor. On a
+     * spawning task it typically reads `$subworkflows`.
+     */
+    completeWhen: v.optional(ConditionSchema),
+    /**
+     * Auto-failure condition — symmetric to `completeWhen`, flips to
+     * `failed`. When both are truthy on the same evaluation, `failWhen`
+     * wins — failure is the more notable signal.
+     */
+    failWhen: v.optional(ConditionSchema),
+    ops: v.optional(v.array(op)),
+    effects: v.optional(v.array(EffectSchema)),
+    actions: v.optional(v.array(action)),
+    subworkflows: v.optional(SubworkflowsSchema),
+    /** Task-scoped state entries. Resolved at task activation time. */
+    state: v.optional(v.array(state))
+  };
+}
+const StoredTaskSchema = v.strictObject(
+  taskFields(StateEntrySchema, StoredActionSchema, StoredOpSchema)
+), AuthoringTaskSchema = v.strictObject(
+  taskFields(AuthoringStateEntrySchema, AuthoringActionSchema, AuthoringOpSchema)
+);
+function transitionFields(op, filter) {
+  return {
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    to: NonEmpty,
+    filter,
+    /** The `state.*` subset — state-write-on-move, the stage's EXIT/ARRIVAL payload. */
+    ops: v.optional(v.array(op)),
+    effects: v.optional(v.array(EffectSchema))
+  };
+}
+const StoredTransitionSchema = v.strictObject(
+  transitionFields(StoredTransitionOpSchema, ConditionSchema)
+), AuthoringTransitionOpSchema = v.variant("type", [
+  ...opSchemas(AuthoringStateRefSchema),
+  AuditOpSchema
+]), AuthoringTransitionSchema = v.strictObject(
+  transitionFields(AuthoringTransitionOpSchema, v.optional(ConditionSchema))
+), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v.strictObject({
   /** Subject `_type`(s); empty matches any type. */
   types: v.optional(v.array(NonEmpty)),
-  /** Target docs as `Source`s resolved at deploy to bare ids + the resource. */
-  idRefs: v.optional(v.array(SourceSchema)),
+  /** Target docs as `$state` reads (or `"$self"`), resolved at deploy to bare ids + the resource. */
+  idRefs: v.optional(v.array(NonEmpty)),
   /** Glob id patterns (bare, resource-local). */
   idPatterns: v.optional(v.array(NonEmpty)),
   actions: v.pipe(
@@ -329,58 +287,71 @@ const GdrSchema = v.strictObject({
     v.minLength(1, "a guard must match at least one action")
   )
 }), GuardSchema = v.strictObject({
-  name: v.optional(v.string()),
+  name: NonEmpty,
+  title: v.optional(v.string()),
   description: v.optional(v.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.
+   * Lake GROQ predicate — a distinct eval context reading
+   * `document.before`/`document.after`, `mutation`, `guard`, and
+   * `identity()`. Bare ids/fields only. Omitted or empty means
+   * UNCONDITIONAL DENY.
    */
   predicate: v.optional(v.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: v.optional(v.record(NonEmpty, SourceSchema))
-}), StageKindSchema = picklist(["initial", "intermediate", "terminal", "waiting"]), StageSchema = v.strictObject({
-  type: v.optional(v.literal("workflow.stage")),
-  id: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  kind: v.optional(StageKindSchema),
-  tasks: v.optional(v.array(TaskSchema)),
-  transitions: v.optional(v.array(TransitionSchema)),
-  completion: v.optional(FilterSchema),
-  onEnter: v.optional(v.array(EffectSchema)),
-  onExit: v.optional(v.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).
+   * Projected workflow state the predicate reads as `guard.metadata.*` —
+   * the only bridge from the lake eval context (which cannot see `$state`)
+   * to workflow state. Values are NOT GROQ: each is a deploy-time read in
+   * the guard mini-language — `"$self"`, `"$now"`, or
+   * `"$state.<name>[.path]"` — resolved into a bare value at deploy and
+   * re-synced by the post-state-op guard refresh.
    */
-  guards: v.optional(v.array(GuardSchema)),
-  contentRefs: v.optional(v.array(v.unknown())),
-  /** Stage-scoped state slots. Resolved at stage entry and persisted on
-   *  the StageEntry. */
-  state: v.optional(v.array(StateSlotSchema))
-}), WorkflowDefinitionSchema = v.strictObject({
-  workflowId: NonEmpty,
-  version: PositiveInt,
-  title: NonEmpty,
-  description: v.optional(v.string()),
-  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: v.optional(v.array(StateSlotSchema)),
-  stages: v.pipe(v.array(StageSchema), v.minLength(1, "must declare at least one stage")),
-  predicates: v.optional(v.array(PredicateSchema))
-}), WORKFLOW_DEFINITION_TYPE = "workflow.definition";
+  metadata: v.optional(v.record(NonEmpty, NonEmpty))
+});
+function stageFields(state, task, transition) {
+  return {
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    tasks: v.optional(v.array(task)),
+    transitions: v.optional(v.array(transition)),
+    /**
+     * Lake mutation guards active while this stage holds. Each compiles to a
+     * `temp.system.guard` doc deployed on stage entry and retracted on exit.
+     */
+    guards: v.optional(v.array(GuardSchema)),
+    /** Stage-scoped state entries. Resolved at stage entry. */
+    state: v.optional(v.array(state))
+  };
+}
+const StoredStageSchema = v.strictObject(
+  stageFields(StateEntrySchema, StoredTaskSchema, StoredTransitionSchema)
+), AuthoringStageSchema = v.strictObject(
+  stageFields(AuthoringStateEntrySchema, AuthoringTaskSchema, AuthoringTransitionSchema)
+);
+function workflowFields(state, stage) {
+  return {
+    name: NonEmpty,
+    version: PositiveInt,
+    title: NonEmpty,
+    description: v.optional(v.string()),
+    /** Reference field: named for the target, holds the stage's `name`. */
+    initialStage: NonEmpty,
+    /** Workflow-scope state entries. Persist for the instance lifetime. */
+    state: v.optional(v.array(state)),
+    stages: v.pipe(v.array(stage), v.minLength(1, "must declare at least one stage")),
+    /**
+     * Nullary named conditions — each `name: groq` entry is pre-evaluated
+     * and bound as the boolean `$name` var, composable with native GROQ.
+     * Redefining a built-in var is a deploy error (never silently shadow).
+     */
+    predicates: v.optional(v.record(groqIdentifier("`$<name>`"), ConditionSchema))
+  };
+}
+v.strictObject(workflowFields(StateEntrySchema, StoredStageSchema));
+const AuthoringWorkflowSchema = v.strictObject(
+  workflowFields(AuthoringStateEntrySchema, AuthoringStageSchema)
+), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
 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"}):
@@ -400,17 +371,20 @@ function formatPath(path) {
   return out;
 }
 export {
-  ActionSchema,
-  AssigneeSchema,
+  AuthoringActionSchema,
+  AuthoringOpSchema,
+  AuthoringStageSchema,
+  AuthoringStateEntrySchema,
+  AuthoringTaskSchema,
+  AuthoringTransitionSchema,
+  AuthoringWorkflowSchema,
+  DOCUMENT_VALUE_PERMISSIONS,
   EffectSchema,
-  FilterSchema,
-  PredicateSchema,
-  StageSchema,
-  TaskSchema,
-  TransitionSchema,
+  GROQ_IDENTIFIER,
+  GuardSchema,
   WORKFLOW_DEFINITION_TYPE,
-  WorkflowDefinitionSchema,
   formatValidationError,
+  isTerminalTaskStatus,
   issuesFromValibot
 };
 //# sourceMappingURL=schema.js.map