@sanity/workflow-engine 0.31.0 → 0.32.0

package/dist/define.d.ts

@@ -14,13 +14,14 @@ import * as v from "valibot";
  * only when cascade-fired (the pin on which identities may execute the
  * trigger); a fireAction-fired action's `roles` folds into `filter` at
  * desugar instead.
+ *
+ * @interface
  */
 declare type Action = ActionFields<Op, string[]> & {
   roles?: string[] | undefined;
 };
 
-/** Type-mirror of {@link actionFields}, parameterised over the op and
- *  group-membership grammars. */
+/** @inline */
 declare type ActionFields<TOp, TGroup> = {
   name: string;
   semantics?: ActionSemantic[] | undefined;
@@ -40,6 +41,8 @@ declare type ActionFields<TOp, TGroup> = {
  * or queuing effects: a missing required param throws
  * `ActionParamsInvalidError` and the action does not commit. Resolved values
  * feed `ValueExpr.param` lookups.
+ *
+ * @interface
  */
 declare type ActionParam = v.InferOutput<typeof ActionParamSchema>;
 
@@ -185,6 +188,8 @@ declare type ActionSemantic = DecisionSemantic | Semantic;
  * `requirements` are readiness gates orthogonal to `filter` — an unmet one
  * keeps the activity visible but disables its actions with a
  * `requirements-unmet` verdict; distinct from ACL and guards.
+ *
+ * @interface
  */
 declare type Activity = ActivityFields<
   FieldEntry,
@@ -193,7 +198,7 @@ declare type Activity = ActivityFields<
   string[]
 >;
 
-/** Type-mirror of {@link activityFields}, parameterised over field/action/target/group. */
+/** @inline */
 declare type ActivityFields<TField, TAction, TTarget, TGroup> = {
   name: string;
   semantics?: Semantic[] | undefined;
@@ -209,8 +214,15 @@ declare type ActivityFields<TField, TAction, TTarget, TGroup> = {
 };
 
 /**
- * The stored action fields plus two authoring sugars, or the
- * {@link ClaimAction} pair-half. `roles`: on a fireAction-fired action (no
+ * An activity is `active` from stage entry (or `skipped` when its `filter`
+ * excluded it) until a terminal status resolves it — there is no pre-active
+ * state. The authored action `status:` sugar (and the `status.set` op it
+ * desugars to) is constrained to {@link TerminalActivityStatus}.
+ */
+declare type ActivityStatus = "active" | "done" | "skipped" | "failed";
+
+/**
+ * The stored action fields plus authoring sugar. `roles`: on a fireAction-fired action (no
  * `when`) it desugars into a `count($actor.roles[@ in [...]]) > 0` condition
  * ANDed with `filter`; on a CASCADE-FIRED action it stores VERBATIM instead —
  * the pin on which identities may execute the trigger, since folding it into
@@ -220,8 +232,9 @@ declare type ActivityFields<TField, TAction, TTarget, TGroup> = {
  * deliberately never implied, so a forgotten `status` is a visible stall
  * rather than a silently completed action.
  */
-declare type AuthoringAction = AuthoringRawAction | ClaimAction;
+declare type AuthoringAction = AuthoringRawAction;
 
+/** @interface */
 declare type AuthoringActivity = ActivityFields<
   AuthoringFieldEntry,
   AuthoringAction,
@@ -235,38 +248,27 @@ declare type AuthoringActivity = ActivityFields<
  * predicate `action.roles` produces. `true` opens the field to anyone in its
  * window; a bare string is a raw predicate.
  */
-declare type AuthoringEditable = v.InferOutput<typeof AuthoringEditableSchema>;
-
-declare const AuthoringEditableSchema: v.UnionSchema<
-  [
-    v.LiteralSchema<true, undefined>,
-    v.ArraySchema<
-      v.SchemaWithPipe<
-        readonly [
-          v.StringSchema<undefined>,
-          v.MinLengthAction<string, 1, "must be a non-empty string">,
-        ]
-      >,
-      undefined
-    >,
-    v.SchemaWithPipe<
-      readonly [
-        v.StringSchema<undefined>,
-        v.MinLengthAction<string, 1, "must be a non-empty string">,
-      ]
-    >,
-  ],
-  undefined
->;
+declare type AuthoringEditable = true | string[] | string;
 
+/**
+ * A raw field entry or one of the authoring-only field sugars. `todoList`
+ * expands to an array of objects with `label`, `status`, optional `assignee`,
+ * and optional `dueDate`; that due date remains an ordinary date field.
+ * `notes` expands to an array of audit-shaped objects with `body`, `actor`,
+ * and `at` fields. Sugar type names are compiled away and never become stored
+ * field kinds.
+ */
 declare type AuthoringFieldEntry =
   | AuthoringRawFieldEntry
-  | ClaimField
   | TodoListField
   | NotesField;
 
-/** A field reference with `scope` optional; desugar resolves it lexically
- *  (activity → stage → workflow) into {@link StoredFieldRef}. */
+/**
+ * A field reference with `scope` optional; desugar resolves it lexically
+ * (activity → stage → workflow) into {@link StoredFieldRef}.
+ *
+ * @interface
+ */
 declare type AuthoringFieldRef = v.InferOutput<typeof AuthoringFieldRefSchema>;
 
 declare const AuthoringFieldRefSchema: v.StrictObjectSchema<
@@ -285,8 +287,12 @@ declare const AuthoringFieldRefSchema: v.StrictObjectSchema<
   undefined
 >;
 
-/** {@link Guard}'s contract as authored: `match.idRefs` and `metadata` carry
- *  typed {@link GuardRead} values that deploy resolves to bare ones. */
+/**
+ * {@link Guard}'s contract as authored: `match.idRefs` and `metadata` carry
+ * typed {@link GuardRead} values that deploy resolves to bare ones.
+ *
+ * @interface
+ */
 declare type AuthoringGuard = v.InferOutput<typeof AuthoringGuardSchema>;
 
 declare const AuthoringGuardSchema: v.StrictObjectSchema<
@@ -314,105 +320,7 @@ declare const AuthoringGuardSchema: v.StrictObjectSchema<
           undefined
         >;
         idRefs: v.OptionalSchema<
-          v.ArraySchema<
-            v.VariantSchema<
-              "type",
-              [
-                v.StrictObjectSchema<
-                  {
-                    readonly type: v.LiteralSchema<"self", undefined>;
-                  },
-                  undefined
-                >,
-                v.StrictObjectSchema<
-                  {
-                    readonly type: v.LiteralSchema<"now", undefined>;
-                  },
-                  undefined
-                >,
-                v.StrictObjectSchema<
-                  {
-                    readonly type: v.LiteralSchema<"fieldRead", undefined>;
-                    readonly field: v.SchemaWithPipe<
-                      readonly [
-                        v.StringSchema<undefined>,
-                        v.RegexAction<string, string>,
-                      ]
-                    >;
-                    readonly path: v.OptionalSchema<
-                      v.SchemaWithPipe<
-                        readonly [
-                          v.SchemaWithPipe<
-                            readonly [
-                              v.StringSchema<undefined>,
-                              v.MinLengthAction<
-                                string,
-                                1,
-                                "must be a non-empty string"
-                              >,
-                            ]
-                          >,
-                          v.CheckAction<
-                            string,
-                            "a guard read path cannot contain a line break"
-                          >,
-                        ]
-                      >,
-                      undefined
-                    >;
-                  },
-                  undefined
-                >,
-                v.StrictObjectSchema<
-                  {
-                    readonly type: v.LiteralSchema<"effectsRead", undefined>;
-                    readonly effect: v.SchemaWithPipe<
-                      readonly [
-                        v.SchemaWithPipe<
-                          readonly [
-                            v.StringSchema<undefined>,
-                            v.MinLengthAction<
-                              string,
-                              1,
-                              "must be a non-empty string"
-                            >,
-                          ]
-                        >,
-                        v.CheckAction<
-                          string,
-                          "an effect name cannot contain `'`"
-                        >,
-                      ]
-                    >;
-                    readonly path: v.OptionalSchema<
-                      v.SchemaWithPipe<
-                        readonly [
-                          v.SchemaWithPipe<
-                            readonly [
-                              v.StringSchema<undefined>,
-                              v.MinLengthAction<
-                                string,
-                                1,
-                                "must be a non-empty string"
-                              >,
-                            ]
-                          >,
-                          v.CheckAction<
-                            string,
-                            "a guard read path cannot contain a line break"
-                          >,
-                        ]
-                      >,
-                      undefined
-                    >;
-                  },
-                  undefined
-                >,
-              ],
-              undefined
-            >,
-            undefined
-          >,
+          v.ArraySchema<v.GenericSchema<GuardRead>, undefined>,
           undefined
         >;
         idPatterns: v.OptionalSchema<
@@ -455,99 +363,7 @@ declare const AuthoringGuardSchema: v.StrictObjectSchema<
             v.MinLengthAction<string, 1, "must be a non-empty string">,
           ]
         >,
-        v.VariantSchema<
-          "type",
-          [
-            v.StrictObjectSchema<
-              {
-                readonly type: v.LiteralSchema<"self", undefined>;
-              },
-              undefined
-            >,
-            v.StrictObjectSchema<
-              {
-                readonly type: v.LiteralSchema<"now", undefined>;
-              },
-              undefined
-            >,
-            v.StrictObjectSchema<
-              {
-                readonly type: v.LiteralSchema<"fieldRead", undefined>;
-                readonly field: v.SchemaWithPipe<
-                  readonly [
-                    v.StringSchema<undefined>,
-                    v.RegexAction<string, string>,
-                  ]
-                >;
-                readonly path: v.OptionalSchema<
-                  v.SchemaWithPipe<
-                    readonly [
-                      v.SchemaWithPipe<
-                        readonly [
-                          v.StringSchema<undefined>,
-                          v.MinLengthAction<
-                            string,
-                            1,
-                            "must be a non-empty string"
-                          >,
-                        ]
-                      >,
-                      v.CheckAction<
-                        string,
-                        "a guard read path cannot contain a line break"
-                      >,
-                    ]
-                  >,
-                  undefined
-                >;
-              },
-              undefined
-            >,
-            v.StrictObjectSchema<
-              {
-                readonly type: v.LiteralSchema<"effectsRead", undefined>;
-                readonly effect: v.SchemaWithPipe<
-                  readonly [
-                    v.SchemaWithPipe<
-                      readonly [
-                        v.StringSchema<undefined>,
-                        v.MinLengthAction<
-                          string,
-                          1,
-                          "must be a non-empty string"
-                        >,
-                      ]
-                    >,
-                    v.CheckAction<string, "an effect name cannot contain `'`">,
-                  ]
-                >;
-                readonly path: v.OptionalSchema<
-                  v.SchemaWithPipe<
-                    readonly [
-                      v.SchemaWithPipe<
-                        readonly [
-                          v.StringSchema<undefined>,
-                          v.MinLengthAction<
-                            string,
-                            1,
-                            "must be a non-empty string"
-                          >,
-                        ]
-                      >,
-                      v.CheckAction<
-                        string,
-                        "a guard read path cannot contain a line break"
-                      >,
-                    ]
-                  >,
-                  undefined
-                >;
-              },
-              undefined
-            >,
-          ],
-          undefined
-        >,
+        v.GenericSchema<GuardRead>,
         undefined
       >,
       undefined
@@ -558,373 +374,52 @@ declare const AuthoringGuardSchema: v.StrictObjectSchema<
 
 /** Like {@link ManualTarget}, but the `field` variant also accepts a bare
  *  field name; desugar normalises it into {@link AuthoringFieldRef}. */
-declare type AuthoringManualTarget = v.InferOutput<
-  typeof AuthoringManualTargetSchema
->;
-
-declare const AuthoringManualTargetSchema: v.VariantSchema<
-  "type",
-  [
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"url", undefined>;
-        readonly url: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.UrlAction<string, "must be a valid URL">,
-            v.CheckAction<string, "must be an http(s) URL">,
-          ]
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field", undefined>;
-        readonly field: v.UnionSchema<
-          [
-            v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >,
-            v.StrictObjectSchema<
-              {
-                readonly scope: v.OptionalSchema<
-                  v.PicklistSchema<
-                    readonly ["workflow", "stage", "activity"],
-                    string
-                  >,
-                  undefined
-                >;
-                readonly field: v.SchemaWithPipe<
-                  readonly [
-                    v.StringSchema<undefined>,
-                    v.MinLengthAction<string, 1, "must be a non-empty string">,
-                  ]
-                >;
-              },
-              undefined
-            >,
-          ],
-          undefined
-        >;
-      },
-      undefined
-    >,
-  ],
-  undefined
->;
+declare type AuthoringManualTarget =
+  | {
+      type: "url";
+      url: string;
+    }
+  | {
+      type: "field";
+      field: string | AuthoringFieldRef;
+    };
 
 /** Like {@link Op}, plus: `status.set`'s `activity` is optional (desugar fills
  *  the firing activity), and the `audit` sugar — a stamped append merging
- *  `actor`/`at` {@link ValueExpr} fields into its own value. */
-declare type AuthoringOp = v.InferOutput<typeof AuthoringOpSchema>;
-
-declare const AuthoringOpSchema: v.VariantSchema<
-  "type",
-  [
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.set", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.setIfMissing", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.unset", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.append", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.inc", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.OptionalSchema<
-          v.GenericSchema<ValueExprInternal>,
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.dec", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.OptionalSchema<
-          v.GenericSchema<ValueExprInternal>,
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.updateWhere", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly where: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.removeWhere", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly where: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"status.set", undefined>;
-        readonly activity: v.OptionalSchema<
-          v.SchemaWithPipe<
-            readonly [
-              v.StringSchema<undefined>,
-              v.MinLengthAction<string, 1, "must be a non-empty string">,
-            ]
-          >,
-          undefined
-        >;
-        readonly status: v.PicklistSchema<
-          readonly ["active", "done", "skipped", "failed"],
-          string
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"audit", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.OptionalSchema<
-              v.PicklistSchema<
-                readonly ["workflow", "stage", "activity"],
-                string
-              >,
-              undefined
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-        readonly stampFields: v.OptionalSchema<
-          v.StrictObjectSchema<
-            {
-              readonly actor: v.OptionalSchema<
-                v.SchemaWithPipe<
-                  readonly [
-                    v.StringSchema<undefined>,
-                    v.MinLengthAction<string, 1, "must be a non-empty string">,
-                  ]
-                >,
-                undefined
-              >;
-              readonly at: v.OptionalSchema<
-                v.SchemaWithPipe<
-                  readonly [
-                    v.StringSchema<undefined>,
-                    v.MinLengthAction<string, 1, "must be a non-empty string">,
-                  ]
-                >,
-                undefined
-              >;
-            },
-            undefined
-          >,
-          undefined
-        >;
-      },
-      undefined
-    >,
-  ],
-  undefined
->;
+ *  `actor`/`at` {@link ValueExpr} fields into its own value.
+ */
+declare type AuthoringOp =
+  | FieldMutationOp<AuthoringFieldRef>
+  | {
+      type: "status.set";
+      activity?: string | undefined;
+      status: ActivityStatus;
+    }
+  | {
+      type: "audit";
+      target: AuthoringFieldRef;
+      value: ValueExpr;
+      stampFields?:
+        | {
+            actor?: string | undefined;
+            at?: string | undefined;
+          }
+        | undefined;
+    };
 
+/** @inline */
 declare type AuthoringRawAction = ActionFields<AuthoringOp, GroupMembership> & {
   roles?: string[] | undefined;
   status?: TerminalActivityStatus | undefined;
 };
 
+/** @inline */
 declare type AuthoringRawFieldEntry = FieldEntryFields<
   AuthoringEditable,
   GroupMembership
 >;
 
+/** @interface */
 declare type AuthoringStage = StageFields<
   AuthoringFieldEntry,
   AuthoringActivity,
@@ -946,7 +441,11 @@ declare type AuthoringTransition = TransitionFields & {
   when?: string | undefined;
 };
 
-/** The authoring surface: stored primitives plus the define-time sugar. */
+/**
+ * The authoring surface: stored primitives plus the define-time sugar.
+ *
+ * @interface
+ */
 declare type AuthoringWorkflow = WorkflowFields<
   AuthoringFieldEntry,
   AuthoringStage,
@@ -959,35 +458,22 @@ declare interface ChoiceOption {
 }
 
 declare interface ChoiceOptions {
-  list: ChoiceOption[];
-}
-
-declare type ChoiceValue = string | number;
-
-/** The action half of the mirrored claim pair: `field` names the actor-valued entry this action claims, resolved lexically, and the expansion
- *  adds a no-steal `!defined($fields.<field>)` filter ANDed with `roles`/`filter` plus a `field.set` ← actor op. `ops`/`status` are reserved (strictObject rejects them). */
-declare type ClaimAction = {
-  type: "claim";
-  name: string;
-  title?: string | undefined;
-  description?: string | undefined;
-  group?: GroupMembership | undefined;
-  field: string | AuthoringFieldRef;
-  roles?: string[] | undefined;
-  filter?: string | undefined;
-  params?: ActionParam[] | undefined;
-  effects?: Effect[] | undefined;
-};
+  list: ChoiceOption[];
+}
 
-/** The field half of the mirrored claim pair, expanding strictly within this entry: an `actor`
- *  working-memory field with no `initialValue` — the paired {@link ClaimAction}'s op fills it. */
-declare type ClaimField = {
-  type: "claim";
-  name: string;
-  title?: string | undefined;
-  description?: string | undefined;
-  group?: GroupMembership | undefined;
-};
+declare type ChoiceValue = string | number;
+
+/**
+ * A raw GROQ string evaluated over the rendered scope: the engine-bound
+ * variables inventoried in {@link CONDITION_VARS} (each annotated with the
+ * context that binds it) plus the author's nullary `predicates` as `$<name>`
+ * booleans. Evaluation runs against the instance's in-memory snapshot —
+ * never a `_type` scan over the lake (rejected at deploy).
+ *
+ * There is no `{ref, args}` wrapper: parameterized reuse is a define-time
+ * TypeScript function producing a condition string (see the {@link define.groq | groq} tag).
+ */
+declare type Condition = string;
 
 /**
  * Every variable the engine binds for the RENDERED condition scope (every
@@ -1100,7 +586,7 @@ export declare function defineWorkflow(
  * Validate a deploy config — the binding of each definition's logical resource
  * handles to physical resources, per environment (tag). Throws a formatted,
  * path-prefixed error if the shape is invalid. The CLI collapses the selected
- * deployment's bindings via {@link resourceAliasesToMap} into the
+ * deployment's bindings via {@link index.resourceAliasesToMap | resourceAliasesToMap} into the
  * `resourceAliases` map `deployDefinitions` expands against.
  *
  * Validates shape only; reader-floor acknowledgement belongs to paths that
@@ -1125,7 +611,7 @@ export declare function defineWorkflowConfig(
  * to decide who-may-edit. ADVISORY like every engine gate — it disables the
  * inline field and explains; a {@link Guard} declares the intended write-lock.
  */
-declare type Editable = v.InferOutput<typeof StoredEditableSchema>;
+declare type Editable = true | string;
 
 /**
  * A registered effect: `name` is its only identity (unique per definition,
@@ -1138,6 +624,8 @@ declare type Editable = v.InferOutput<typeof StoredEditableSchema>;
  * completion and nothing is stored. Omitting `outputs` is an EMPTY allowlist,
  * so ANY returned output is rejected and fails the completion — the bound is
  * universal, not opt-in.
+ *
+ * @interface
  */
 declare type Effect = v.InferOutput<typeof EffectSchema>;
 
@@ -1232,8 +720,7 @@ declare const FIELD_VALUE_KINDS: readonly [
   "array",
 ];
 
-/** Type-mirror of {@link fieldBase}, parameterised over the `editable` and
- *  `group` grammars (stored membership is the canonical list form). */
+/** @inline */
 declare type FieldBase<TEditable, TGroup> = {
   name: string;
   title?: string | undefined;
@@ -1244,11 +731,14 @@ declare type FieldBase<TEditable, TGroup> = {
   editable?: TEditable | undefined;
 };
 
-/** One declared field entry as authored and stored: name, value kind, and its scope's sourcing and editability. */
+/**
+ * One declared field entry as authored and stored: name, value kind, and its scope's sourcing and editability.
+ *
+ * @interface
+ */
 declare type FieldEntry = FieldEntryFields<Editable, string[]>;
 
-/** Type-mirror of {@link fieldEntryFields}: a raw field entry of the given
- *  editability and group-membership grammars. */
+/** @inline */
 declare type FieldEntryFields<TEditable, TGroup> = FieldBase<
   TEditable,
   TGroup
@@ -1263,6 +753,60 @@ declare type FieldEntryFields<TEditable, TGroup> = FieldBase<
   of?: FieldShape[] | undefined;
 };
 
+/** A field mutation targeting the supplied field-reference shape. */
+declare type FieldMutationOp<
+  TTarget extends {
+    field: string;
+  },
+> =
+  | {
+      type: "field.set";
+      target: TTarget;
+      value: ValueExpr;
+    }
+  | {
+      type: "field.setIfMissing";
+      target: TTarget;
+      value: ValueExpr;
+    }
+  | {
+      type: "field.unset";
+      target: TTarget;
+    }
+  | {
+      type: "field.append";
+      target: TTarget;
+      value: ValueExpr;
+    }
+  | {
+      type: "field.inc";
+      target: TTarget;
+      value?: ValueExpr | undefined;
+    }
+  | {
+      type: "field.dec";
+      target: TTarget;
+      value?: ValueExpr | undefined;
+    }
+  | {
+      type: "field.updateWhere";
+      target: TTarget;
+      where: Condition;
+      value: ValueExpr;
+    }
+  | {
+      type: "field.removeWhere";
+      target: TTarget;
+      where: Condition;
+    };
+
+/**
+ * A stored field mutation. `field.inc` and `field.dec` use the same names as
+ * `@sanity/client` patches and default an omitted `value` to a delta of `1`.
+ */
+declare type FieldOp = FieldMutationOp<StoredFieldRef>;
+
+/** @inline */
 declare type FieldReadExpr = {
   type: "fieldRead";
   scope?: "workflow" | "stage" | undefined;
@@ -1300,6 +844,7 @@ declare interface FieldShape {
  */
 declare type FieldSource = FieldSourceInternal;
 
+/** @inline */
 declare type FieldSourceInternal =
   | {
       type: "input";
@@ -1388,25 +933,11 @@ declare type GroupKind = (typeof GROUP_KINDS)[number];
 declare type GroupMembership = string | string[];
 
 /**
- * A lake mutation guard. A FOREIGN CONTRACT mirrored 1:1: `match`,
- * `predicate`, and `metadata` are the content lake's persisted guard-document
- * API, not engine-invented surface — the stored form keeps the lake's
- * vocabulary verbatim. The engine adds exactly two things: `name` (a
- * lake-id-segment, `^[a-z0-9][a-z0-9-]*$`, unique per definition — the lake
- * `_id` derives from `(instanceId, name)` at stage entry) and the deploy-time
- * read VALUES on `match.idRefs` / `metadata` (a typed {@link GuardRead} when
- * authoring, resolved to bare values at deploy). `match` selects mutations by
- * `types` (empty matches any), `idRefs` (field reads resolved to bare ids),
- * `idPatterns` (bare glob ids), and `actions` (at least one). `predicate` is
- * lake GROQ in a distinct delta-mode eval context (`before()`/`after()`,
- * `mutation`, `guard`, `identity()`, bare ids/fields only): strictly `true`
- * ALLOWS the mutation; anything else — false, null, an evaluation error, or
- * an omitted/empty predicate — DENIES. `metadata` is the only bridge from
- * that eval context (which cannot see `$fields`) to workflow fields, read as
- * `guard.metadata.*` and re-synced by the post-field-op guard refresh. The
- * lake does not enforce the guard document type yet: a deployed guard denies
- * optimistically engine-side, and the lake ACL is the only hard gate until
- * guard enforcement ships.
+ * A stored workflow guard. Its string reads and authored lifecycle actions
+ * remain unresolved until stage entry produces the Lake-shaped documents
+ * deployed for that stage.
+ *
+ * @interface
  */
 declare type Guard = v.InferOutput<typeof GuardSchema>;
 
@@ -1414,14 +945,43 @@ declare type Guard = v.InferOutput<typeof GuardSchema>;
  * The identifiers a lake mutation guard's `predicate` reads — the wire
  * dialect, not the condition scope (so no {@link ConditionVarBinding}: these
  * bind only when a guard evaluates a mutation). `before()`/`after()`/
- * `identity()` are groq-js delta-mode natives on top of these. Bound in one
- * place: `guardPredicateParams` in the guard evaluator.
+ * `identity()` are groq-js delta-mode natives on top of these. The guard
+ * evaluator must bind every entry here at the predicate root.
  */
 export declare const GUARD_PREDICATE_VARS: readonly {
   name: string;
   description: string;
 }[];
 
+/**
+ * A deploy-time value read on a guard's `match.idRefs` / `metadata`, typed
+ * like {@link ValueExpr} (`self`/`now`/`fieldRead`, plus the guard-only
+ * `effectsRead` for a completed effect's output). Workflow-scope only — a
+ * guard outlives any activity, so `fieldRead` here carries no `scope`.
+ * Desugar prints the STORED string spelling the deploy resolver and guard
+ * refresh parse (`"$self"`, `"$now"`, `"$fields.<name>[.path]"`,
+ * `"$effects['<name>'][.path]"`); those spellings are single-line strings
+ * matched by anchored regexes, so a line break in a path would print an
+ * unparseable read.
+ */
+declare type GuardRead =
+  | {
+      type: "self";
+    }
+  | {
+      type: "now";
+    }
+  | {
+      type: "fieldRead";
+      field: string;
+      path?: string | undefined;
+    }
+  | {
+      type: "effectsRead";
+      effect: string;
+      path?: string | undefined;
+    };
+
 declare const GuardSchema: v.StrictObjectSchema<
   {
     name: v.SchemaWithPipe<
@@ -1470,21 +1030,12 @@ declare const GuardSchema: v.StrictObjectSchema<
           >,
           undefined
         >;
-        actions: v.SchemaWithPipe<
-          readonly [
-            v.ArraySchema<
-              v.PicklistSchema<
-                readonly ["create", "update", "delete", "publish", "unpublish"],
-                string
-              >,
-              undefined
-            >,
-            v.MinLengthAction<
-              ("create" | "update" | "delete" | "publish" | "unpublish")[],
-              1,
-              "a guard must match at least one action"
-            >,
-          ]
+        actions: v.ArraySchema<
+          v.PicklistSchema<
+            readonly ["create", "update", "delete", "publish", "unpublish"],
+            string
+          >,
+          undefined
         >;
       },
       undefined
@@ -1512,6 +1063,7 @@ declare const GuardSchema: v.StrictObjectSchema<
   undefined
 >;
 
+/** @inline */
 declare type LiteralExpr = {
   type: "literal";
   value: unknown;
@@ -1523,18 +1075,32 @@ declare type LiteralExpr = {
  * reference whose resolved document the consumer opens; deploy checks the
  * `field` variant points at a doc-valued entry.
  */
-declare type ManualTarget = v.InferOutput<typeof StoredManualTargetSchema>;
+declare type ManualTarget =
+  | {
+      type: "url";
+      url: string;
+    }
+  | {
+      type: "field";
+      field: StoredFieldRef;
+    };
 
-/** An append-only audit/comment log: sugar over `array of object {body, actor, at}` — the `actor`/`at`
- *  names match the `audit` op's stamp fields, so it pairs with it. Never a stored kind. */
+/** @inline */
 declare type NotesField = FieldBase<AuthoringEditable, GroupMembership> & {
   type: "notes";
 };
 
 /** A `field.updateWhere` / `field.removeWhere` op's `where` selects rows to
  *  mutate with rendered-scope GROQ (`$row`, `$params` bound) — row selection, not a gate; an unevaluable row never matches. */
-declare type Op = v.InferOutput<typeof StoredOpSchema>;
+declare type Op =
+  | FieldOp
+  | {
+      type: "status.set";
+      activity: string;
+      status: ActivityStatus;
+    };
 
+/** @inline */
 declare type RequirementBase = {
   name: string;
   title?: string | undefined;
@@ -1556,35 +1122,7 @@ export declare const RESERVED_CONDITION_VARS: readonly string[];
  * literal ownership values and are not widened by this map. The authored `"*"`
  * key lists universal fulfillers and is normalized before persistence.
  */
-declare type RoleAliases = v.InferOutput<typeof RoleAliasesSchema>;
-
-declare const RoleAliasesSchema: v.RecordSchema<
-  v.SchemaWithPipe<
-    readonly [
-      v.StringSchema<undefined>,
-      v.MinLengthAction<string, 1, "must be a non-empty string">,
-    ]
-  >,
-  v.SchemaWithPipe<
-    readonly [
-      v.ArraySchema<
-        v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >,
-        undefined
-      >,
-      v.MinLengthAction<
-        string[],
-        1,
-        "a role alias must list at least one fulfilling role"
-      >,
-    ]
-  >,
-  undefined
->;
+declare type RoleAliases = Record<string, string[]>;
 
 /** Inclusive scalar bounds. String/text bounds measure character length;
  * number bounds measure the numeric value. */
@@ -1618,6 +1156,8 @@ declare type SingleSubjectRequirement = RequirementBase & {
  * own `editable` is the ceiling, ANDed with the stage value at runtime, so an
  * override can only NARROW — never open a field the baseline left closed. An
  * unlisted field inherits its baseline.
+ *
+ * @interface
  */
 declare type Stage = StageFields<
   FieldEntry,
@@ -1627,7 +1167,7 @@ declare type Stage = StageFields<
   Editable
 >;
 
-/** Type-mirror of {@link stageFields}, parameterised over field/activity/transition/guard/editable. */
+/** @inline */
 declare type StageFields<TField, TActivity, TTransition, TGuard, TEditable> = {
   name: string;
   semantics?: Semantic[] | undefined;
@@ -1641,8 +1181,6 @@ declare type StageFields<TField, TActivity, TTransition, TGuard, TEditable> = {
   editable?: Record<string, TEditable> | undefined;
 };
 
-declare const START_KINDS: readonly ["interactive", "autonomous"];
-
 /**
  * How standalone runs of this workflow begin. `filter` is a READ-SIDE
  * visibility predicate — "should a start surface offer this workflow for
@@ -1660,6 +1198,7 @@ declare type StartBlock = StartFields & {
   kind: StartKind;
 };
 
+/** @inline */
 declare type StartFields = {
   filter?: string | undefined;
   requirements?: StartRequirement[] | undefined;
@@ -1674,277 +1213,31 @@ declare type StartFields = {
  * path for every kind, and an interactive start of an autonomous workflow is
  * legal.
  */
-declare type StartKind = (typeof START_KINDS)[number];
+declare type StartKind = "interactive" | "autonomous";
 
 /** Every named readiness requirement accepted by workflow `start.requirements`. */
 declare type StartRequirement = GroqRequirement | SingleSubjectRequirement;
 
-declare const StoredEditableSchema: v.UnionSchema<
-  [
-    v.LiteralSchema<true, undefined>,
-    v.SchemaWithPipe<
+/**
+ * A field reference with `scope` already resolved — the form every op target carries.
+ *
+ * @interface
+ */
+declare type StoredFieldRef = v.InferOutput<typeof StoredFieldRefSchema>;
+
+declare const StoredFieldRefSchema: v.StrictObjectSchema<
+  {
+    readonly scope: v.PicklistSchema<
+      readonly ["workflow", "stage", "activity"],
+      string
+    >;
+    readonly field: v.SchemaWithPipe<
       readonly [
         v.StringSchema<undefined>,
         v.MinLengthAction<string, 1, "must be a non-empty string">,
       ]
-    >,
-  ],
-  undefined
->;
-
-declare const StoredManualTargetSchema: v.VariantSchema<
-  "type",
-  [
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"url", undefined>;
-        readonly url: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.UrlAction<string, "must be a valid URL">,
-            v.CheckAction<string, "must be an http(s) URL">,
-          ]
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field", undefined>;
-        readonly field: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-      },
-      undefined
-    >,
-  ],
-  undefined
->;
-
-declare const StoredOpSchema: v.VariantSchema<
-  "type",
-  [
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.set", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.setIfMissing", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.unset", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.append", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.inc", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.OptionalSchema<
-          v.GenericSchema<ValueExprInternal>,
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.dec", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly value: v.OptionalSchema<
-          v.GenericSchema<ValueExprInternal>,
-          undefined
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.updateWhere", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly where: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >;
-        readonly value: v.GenericSchema<ValueExprInternal>;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"field.removeWhere", undefined>;
-        readonly target: v.StrictObjectSchema<
-          {
-            readonly scope: v.PicklistSchema<
-              readonly ["workflow", "stage", "activity"],
-              string
-            >;
-            readonly field: v.SchemaWithPipe<
-              readonly [
-                v.StringSchema<undefined>,
-                v.MinLengthAction<string, 1, "must be a non-empty string">,
-              ]
-            >;
-          },
-          undefined
-        >;
-        readonly where: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >;
-      },
-      undefined
-    >,
-    v.StrictObjectSchema<
-      {
-        readonly type: v.LiteralSchema<"status.set", undefined>;
-        readonly activity: v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >;
-        readonly status: v.PicklistSchema<
-          readonly ["active", "done", "skipped", "failed"],
-          string
-        >;
-      },
-      undefined
-    >,
-  ],
+    >;
+  },
   undefined
 >;
 
@@ -1960,6 +1253,8 @@ declare const StoredOpSchema: v.VariantSchema<
  * (default) lets them run to completion, `'abort'` kills them recursively —
  * always an authored choice, never automatic. Whether the PARENT may move at
  * all is a separate gate over `$subworkflows`.
+ *
+ * @interface
  */
 declare type Subworkflows = v.InferOutput<typeof SubworkflowsSchema>;
 
@@ -2050,17 +1345,9 @@ declare const SubworkflowsSchema: v.StrictObjectSchema<
  * `$allActivitiesDone` — a `failed` activity blocks it permanently, surfacing
  * via `$anyActivityFailed`.
  */
-declare const TERMINAL_ACTIVITY_STATUSES: readonly [
-  "done",
-  "skipped",
-  "failed",
-];
-
-declare type TerminalActivityStatus =
-  (typeof TERMINAL_ACTIVITY_STATUSES)[number];
+declare type TerminalActivityStatus = "done" | "skipped" | "failed";
 
-/** Ad-hoc, status-tracked work items: sugar over `array of object {label, status, assignee?, dueDate?}`; a plain checklist is that with `{label, status}` alone.
- *  Its `dueDate` is a `date` column named `dueDate`, not the elevated `dueDate` kind, which reserves one deadline slot per level. Never a stored kind. */
+/** @inline */
 declare type TodoListField = FieldBase<AuthoringEditable, GroupMembership> & {
   type: "todoList";
 };
@@ -2079,8 +1366,7 @@ declare type Transition = TransitionFields & {
   when: string;
 };
 
-/** Type-mirror of {@link transitionFields} minus `when` — stored requires it,
- *  authoring omits it (desugar fills the default), so each variant declares it. */
+/** @inline */
 declare type TransitionFields = {
   name: string;
   title?: string | undefined;
@@ -2088,6 +1374,15 @@ declare type TransitionFields = {
   to: string;
 };
 
+/**
+ * An op's write payload, resolved to concrete JSON when the op applies. Each
+ * context-bound arm has a rendered `$`-twin in conditions (`actor` ↔
+ * `$actor`, `now` ↔ `$now`, `self` ↔ `$self`), so learning one side teaches
+ * the other. Distinct from {@link FieldSource}, a field's seed recipe.
+ */
+declare type ValueExpr = ValueExprInternal;
+
+/** @inline */
 declare type ValueExprInternal =
   | LiteralExpr
   | FieldReadExpr
@@ -2112,8 +1407,6 @@ declare type ValueExprInternal =
       fields: Record<string, ValueExprInternal>;
     };
 
-declare const WORKFLOW_LIFECYCLES: readonly ["standalone", "child"];
-
 /**
  * `deployments` names must be unique (the selector deployment-targeted
  * commands resolve by), and each `(workflowResource, tag)` pair must be
@@ -2123,6 +1416,8 @@ declare const WORKFLOW_LIFECYCLES: readonly ["standalone", "child"];
  * logger unconditionally (CI and `DO_NOT_TRACK` included), and consent,
  * environment suppression, and transport become this implementation's
  * business.
+ *
+ * @interface
  */
 declare type WorkflowConfig = v.InferOutput<typeof WorkflowConfigSchema>;
 
@@ -2772,6 +2067,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
  * conditions — each `name: groq` entry is pre-evaluated and bound as the
  * boolean `$name` var; redefining a built-in var is a deploy error, never a
  * silent shadow.
+ *
+ * @interface
  */
 declare type WorkflowDefinition = v.InferOutput<
   typeof WorkflowDefinitionSchema
@@ -2815,7 +2112,7 @@ declare type WorkflowDeploymentInput = Omit<
   expectedMinReaderModel: number;
 };
 
-/** Type-mirror of {@link workflowFields}, parameterised over field/stage/start. */
+/** @inline */
 declare type WorkflowFields<TField, TStage, TStart> = {
   name: string;
   semantics?: Semantic[] | undefined;
@@ -2834,7 +2131,7 @@ declare type WorkflowFields<TField, TStage, TStart> = {
 /** How instances of a definition come to exist: started standalone (the
  *  default) or spawned by a parent. `'child'` is spawn-only — see
  *  {@link isStartableDefinition}. */
-declare type WorkflowLifecycle = (typeof WORKFLOW_LIFECYCLES)[number];
+declare type WorkflowLifecycle = "standalone" | "child";
 
 /**
  * A telemetry event descriptor — a structural mirror of `@sanity/telemetry`'s