@sanity/workflow-engine 0.31.0 → 0.33.0

package/dist/define.d.ts

@@ -14,14 +14,15 @@ 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[]> & {
+declare type Action = ActionFields<Op, string[], Effect> & {
   roles?: string[] | undefined;
 };
 
-/** Type-mirror of {@link actionFields}, parameterised over the op and
- *  group-membership grammars. */
-declare type ActionFields<TOp, TGroup> = {
+/** @inline */
+declare type ActionFields<TOp, TGroup, TEffect> = {
   name: string;
   semantics?: ActionSemantic[] | undefined;
   title?: string | undefined;
@@ -31,7 +32,7 @@ declare type ActionFields<TOp, TGroup> = {
   filter?: string | undefined;
   params?: ActionParam[] | undefined;
   ops?: TOp[] | undefined;
-  effects?: Effect[] | undefined;
+  effects?: TEffect[] | undefined;
   spawn?: Subworkflows | 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,45 @@ 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 type AuthoringEditable = true | string[] | string;
 
-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
->;
+/**
+ * An {@link Effect} whose `retry` block may omit its `kind`, plus the
+ * authoring-only `runtime` block that says where the generated runtime hosts
+ * this handler. `retry` is stored; `runtime` is stripped before the deploy
+ * writes the definition.
+ *
+ * @interface
+ */
+declare type AuthoringEffect = EffectFields<AuthoringEffectRetry> & {
+  runtime?: EffectRuntimeBlock | undefined;
+};
+
+/** An {@link EffectRetry} whose omitted `kind` defaults to `engine`. */
+declare type AuthoringEffectRetry = EffectRetryFields & {
+  kind?: EffectRetryKind | undefined;
+};
 
+/**
+ * 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.
+ * See {@link FieldEntry} for scope, required-input, and field-type constraints.
+ */
 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 +305,26 @@ 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. */
+/**
+ * A stage's content mutation guard. Its name must be unique across the whole
+ * definition and use lowercase letters, digits, and dashes, starting with a
+ * letter or digit. `match.actions` must contain at least one action.
+ *
+ * `match.types` intersects the ID criteria. Within the ID criteria, matching
+ * either `idRefs` or `idPatterns` is sufficient. Omitted or empty optional
+ * criteria do not constrain the match. `idRefs` uses typed {@link GuardRead}s.
+ * Patterns use resource-local document-ID characters and `*` wildcards.
+ * A release-version pattern is rejected if translating it for a lifecycle
+ * action would broaden it to every document.
+ *
+ * `predicate` is delta-mode GROQ over `document`, `guard`, and `mutation`;
+ * see {@link GUARD_PREDICATE_VARS}. Only a strict `true` allows a matching
+ * mutation. An omitted or empty predicate denies it. `metadata` resolves
+ * {@link GuardRead}s into values available as `guard.metadata` in the predicate.
+ * Engine evaluations are advisory; the Content Lake is the enforcement point.
+ *
+ * @interface
+ */
 declare type AuthoringGuard = v.InferOutput<typeof AuthoringGuardSchema>;
 
 declare const AuthoringGuardSchema: v.StrictObjectSchema<
@@ -314,105 +352,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 +395,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 +406,61 @@ 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;
+    };
 
-declare type AuthoringRawAction = ActionFields<AuthoringOp, GroupMembership> & {
+/** @inline */
+declare type AuthoringRawAction = ActionFields<
+  AuthoringOp,
+  GroupMembership,
+  AuthoringEffect
+> & {
   roles?: string[] | undefined;
   status?: TerminalActivityStatus | undefined;
 };
 
+/** @inline */
 declare type AuthoringRawFieldEntry = FieldEntryFields<
   AuthoringEditable,
   GroupMembership
 >;
 
+/**
+ * A {@link Stage} accepting authoring fields, activities, transitions, guards,
+ * and role-list editability. The same terminal-stage constraints apply.
+ *
+ * @interface
+ */
 declare type AuthoringStage = StageFields<
   AuthoringFieldEntry,
   AuthoringActivity,
@@ -933,61 +469,65 @@ declare type AuthoringStage = StageFields<
   AuthoringEditable
 >;
 
+/** A {@link StartBlock} whose omitted `kind` defaults to `interactive`. */
 declare type AuthoringStartBlock = StartFields & {
   kind?: StartKind | undefined;
 };
 
 /**
- * Authoring transitions may omit `when`; desugar fills the safe,
- * overwhelmingly-common trigger `"$allActivitiesDone"`. "Fire unconditionally"
- * stays spellable as an explicit `when: "true"`.
+ * A {@link Transition} whose `when` may be omitted, defaulting to
+ * `$allActivitiesDone`. Use `when: 'true'` for an unconditional route.
  */
 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. `runtime`
+ * says where the generated unattended runtime hosts this workflow, overriding
+ * its deployment's kind; an effect node overrides it in turn.
+ *
+ * @interface
+ */
 declare type AuthoringWorkflow = WorkflowFields<
   AuthoringFieldEntry,
   AuthoringStage,
   AuthoringStartBlock
->;
+> & {
+  runtime?: RuntimeBlock | undefined;
+};
 
 declare interface ChoiceOption {
   title: string;
   value: ChoiceValue;
 }
 
+/**
+ * A closed list of allowed non-null scalar values. The list must be nonempty,
+ * with unique values and nonempty titles. Each value must satisfy the
+ * receiving type and its validation bounds.
+ *
+ * Fields accept choices on `string`, `text`, `number`, `url`, `date`,
+ * `dueDate`, `datetime`, and `dueDatetime`. Action parameters accept choices
+ * on `string`, `number`, `url`, and `dateTime`.
+ */
 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;
-};
-
-/** 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;
-};
+/**
+ * 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
@@ -1048,11 +588,21 @@ export declare function defineActivity(
   activity: AuthoringActivity,
 ): AuthoringActivity;
 
+/**
+ * What `defineWorkflow` returns: the stored definition, plus `runtime` when the
+ * workflow or one of its effects declared a hosting kind. Generation and the
+ * blueprint tooling read `runtime`; the deploy drops it, so it never reaches the
+ * Content Lake and never affects a definition's content fingerprint.
+ */
+declare type DefinedWorkflow = WorkflowDefinition & {
+  runtime?: DefinitionRuntime | undefined;
+};
+
 /**
  * Validate and return an effect declaration — the registry model: `name` is
  * the effect's only identity; the host app registers a handler against it.
  */
-export declare function defineEffect(effect: Effect): Effect;
+export declare function defineEffect(effect: AuthoringEffect): AuthoringEffect;
 
 export declare function defineEffectDescriptor(
   descriptor: EffectDescriptor,
@@ -1081,8 +631,9 @@ export declare function defineTransition(
 ): AuthoringTransition;
 
 /**
- * Validate, desugar, and return a workflow definition in its stored shape.
- * Throws with a formatted, path-prefixed error message if validation fails.
+ * Validate, desugar, and return a workflow definition in its stored shape, plus
+ * the `runtime` hosting the workflow or its effects declared. Throws with a
+ * formatted, path-prefixed error message if validation fails.
  *
  * Example error:
  *
@@ -1094,13 +645,13 @@ export declare function defineTransition(
  */
 export declare function defineWorkflow(
   definition: AuthoringWorkflow,
-): WorkflowDefinition;
+): DefinedWorkflow;
 
 /**
  * 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
@@ -1116,6 +667,17 @@ export declare function defineWorkflowConfig(
   config: WorkflowConfigInput,
 ): WorkflowConfig;
 
+/**
+ * The hosting declarations {@link DefinedWorkflow} carries for the generator,
+ * collected out of the authored tree. `kind` is present only when the workflow
+ * declared one, so an absent `kind` inherits the deployment's. `effects` holds
+ * one entry per effect that declared a block, keyed by effect name.
+ */
+declare interface DefinitionRuntime {
+  kind?: RuntimeKind | undefined;
+  effects?: Record<string, EffectRuntimeBlock> | undefined;
+}
+
 /**
  * Declared editability of a field — the generic edit seam's gate. Default
  * (absent) is NOT editable: a field is op-only engine working memory unless the
@@ -1125,21 +687,27 @@ 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,
- * read downstream as `$effects.<name>`) — the host app registers a handler
- * against it 1:1, and the stored definition never references code.
- * `bindings` are GROQ reads over the rendered scope, resolved to concrete
- * JSON at queue time; `input` is static config passed through verbatim.
- * `outputs` (typed {@link FieldShape}s) is a STRICT allowlist: at completion
- * an undeclared output key, or a value that doesn't fit its shape, fails the
- * 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.
+ * External work queued for the handler registered under `name`. Names are
+ * unique within a definition; completed outputs are read as `$effects['<name>']`.
+ *
+ * `bindings` resolves GROQ expressions against the action's rendered scope
+ * when the effect is queued. The handler receives one parameter bag combining
+ * those values with static `input`. An `input` key overrides a same-named
+ * binding, including when its value is null.
+ *
+ * `outputs` declares the allowed result keys and their {@link FieldShape}s.
+ * An undeclared key or invalid value rejects the completion without storing
+ * it. Omitting `outputs` allows no output keys.
+ *
+ * `retry` ({@link EffectRetry}) bounds how many times a failing handler is
+ * attempted. Omitting it completes the effect as failed on the first failure.
+ *
+ * @interface
  */
-declare type Effect = v.InferOutput<typeof EffectSchema>;
+declare type Effect = EffectFields<EffectRetry>;
 
 /**
  * Effect handler descriptor, registered by the runtime against an effect
@@ -1160,43 +728,96 @@ export declare interface EffectDescriptorParam {
   description?: string;
 }
 
-declare const EffectSchema: v.StrictObjectSchema<
-  {
-    readonly name: v.SchemaWithPipe<
-      readonly [
-        v.StringSchema<undefined>,
-        v.MinLengthAction<string, 1, "must be a non-empty string">,
-      ]
-    >;
-    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly description: v.OptionalSchema<
-      v.StringSchema<undefined>,
-      undefined
-    >;
-    readonly bindings: v.OptionalSchema<
-      v.RecordSchema<
-        v.StringSchema<undefined>,
-        v.SchemaWithPipe<
-          readonly [
-            v.StringSchema<undefined>,
-            v.MinLengthAction<string, 1, "must be a non-empty string">,
-          ]
-        >,
-        undefined
-      >,
-      undefined
-    >;
-    readonly input: v.OptionalSchema<
-      v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>,
-      undefined
-    >;
-    readonly outputs: v.OptionalSchema<
-      v.ArraySchema<v.GenericSchema<FieldShape>, undefined>,
-      undefined
-    >;
-  },
-  undefined
->;
+/** @inline */
+declare type EffectFields<TRetry> = {
+  name: string;
+  title?: string | undefined;
+  description?: string | undefined;
+  bindings?: Record<string, string> | undefined;
+  input?: Record<string, unknown> | undefined;
+  outputs?: FieldShape[] | undefined;
+  retry?: TRetry | undefined;
+};
+
+/**
+ * A bounded retry policy for one effect. Both bounds govern one drain's run of
+ * the policy, not the effect's lifetime: a drainer that dies mid-run leaves the
+ * entry for the next drain, which starts a fresh run with the full budget, so
+ * an effect can see more handler calls in total than `attempts`.
+ *
+ * `attempts` is the total number of attempts in a run, the first included, so
+ * `1` means "never retry".
+ *
+ * `expiryMs` and the backoff a policy accumulates are each capped at 366 days
+ * (`31_622_400_000` ms), inclusive. Deploy refuses a policy declaring more,
+ * and one whose accumulated backoff reaches its own `expiryMs` before its
+ * `attempts` are spent. Those checks weigh the declared waits alone. At
+ * runtime every elapsed millisecond counts against `expiryMs`, handler time
+ * included, so a slow handler can leave attempts unused. `backoff` paces
+ * them; omitting it retries with no wait. Every duration is a whole number of
+ * milliseconds above zero, and `attempts` a whole count above zero; deploy
+ * rejects anything else.
+ *
+ * `expiryMs` decides whether a further attempt may start, measured from the
+ * moment this run dispatched its first attempt. The window closes
+ * on reaching it, so an attempt is admitted only while less than `expiryMs`
+ * has elapsed. It is not a handler timeout. An attempt already running is
+ * never interrupted, so a run can finish after the window, and a success then
+ * still counts. Omitting it leaves `attempts` as the only bound.
+ *
+ * A policy that runs out of attempts, or that `expiryMs` stops, completes the
+ * effect as failed, and `$effectStatus['<name>'] == 'failed'` routes the
+ * instance. A successful attempt completes it as done, whichever attempt
+ * succeeded. An effect with no `retry` completes as failed on its handler's
+ * first failure.
+ */
+declare type EffectRetry = EffectRetryFields & {
+  kind: EffectRetryKind;
+};
+
+/**
+ * How long the engine waits between two attempts. `delayMs` is that wait in
+ * milliseconds: `'fixed'` waits it every time, `'exponential'` doubles it per
+ * attempt already made (`delayMs`, then `2 × delayMs`, then `4 × delayMs`).
+ */
+declare type EffectRetryBackoff = {
+  kind: "fixed" | "exponential";
+  delayMs: number;
+};
+
+/** @inline */
+declare type EffectRetryFields = {
+  attempts: number;
+  backoff?: EffectRetryBackoff | undefined;
+  expiryMs?: number | undefined;
+};
+
+/**
+ * Who runs a retry policy. `'engine'` is the only member: the engine loops
+ * inside the `drainEffects` call that picked the effect up, holding the claim
+ * across the waits.
+ */
+declare type EffectRetryKind = "engine";
+
+/**
+ * The `runtime` block on an effect node, overriding its workflow's kind.
+ * `timeout` is seconds and `memory` megabytes of the function that runs this
+ * handler, and an effect declaring either gets its own drain function instead of
+ * sharing the deployment's. Both are the function budget, so both are accepted
+ * only under `'function'`.
+ */
+declare type EffectRuntimeBlock =
+  | {
+      kind: "function";
+      timeout?: number | undefined;
+      memory?: number | undefined;
+    }
+  | {
+      kind: "durableFunction";
+    }
+  | {
+      kind: "selfHosted";
+    };
 
 /**
  * The kinds a VALUE can take — scalars aligned to Sanity's names, the
@@ -1232,8 +853,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 +864,33 @@ 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. */
+/**
+ * A field declaration whose location determines its scope and lifetime.
+ * Workflow fields initialize at start; stage and activity fields initialize
+ * on each stage visit. {@link FieldSource} controls initialization;
+ * {@link Editable} controls direct edits independently.
+ *
+ * `required: true` is valid only on workflow-scope fields with an `input`
+ * source. It requires a non-null value at start or spawn. On `subject`,
+ * `doc.ref`, and `doc.refs`, selected targets must also remain readable in the
+ * workflow perspective after initialization. Missing targets block normal
+ * actions, triggered actions, and transitions. Abort and permitted field edits remain available.
+ * `subject` is also
+ * workflow-scope-only, with at most one subject per definition. Each scope
+ * may declare at most one `dueDate` or `dueDatetime` field, always top-level.
+ *
+ * `types` is a nonempty list of accepted document types on `subject`,
+ * `doc.ref`, or `doc.refs`; omit it to accept any document type. `roles`
+ * constrains assignment eligibility only on `assignee` and `assignees`.
+ * {@link FieldShape}, {@link ChoiceOptions}, and {@link ScalarValidation}
+ * define the nested-shape and scalar constraints. Authoring conveniences are
+ * accepted by {@link AuthoringFieldEntry}.
+ *
+ * @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 +905,76 @@ declare type FieldEntryFields<TEditable, TGroup> = FieldBase<
   of?: FieldShape[] | undefined;
 };
 
+/**
+ * A field mutation targeting a declared field. Resolved values must satisfy
+ * that field's shape, choices, validation, and assignment constraints.
+ *
+ * `field.setIfMissing` supports nullable fields only. If a value exists, it
+ * leaves the value unchanged and records no `opApplied` history event.
+ * `field.inc` and `field.dec` require an initialized `number` field; their
+ * delta defaults to `1`. Both the delta and resulting value must be finite,
+ * and the result must satisfy the field's validation bounds.
+ *
+ * `field.append` adds one valid list member. `field.updateWhere` accepts only
+ * `array` fields and merges an object into matching rows. The merge cannot
+ * write `_key` or `_type`, and each resulting row must satisfy its declared
+ * shape. `field.removeWhere` supports list fields. See {@link Op} for row
+ * selection and history behavior.
+ */
+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 {@link FieldMutationOp} whose target scope is explicit. Actions can write
+ * fields in their activity, stage, or workflow. Effect completions accept only
+ * workflow- or stage-scoped field operations, never activity status changes.
+ */
+declare type FieldOp = FieldMutationOp<StoredFieldRef>;
+
+/** @inline */
 declare type FieldReadExpr = {
   type: "fieldRead";
   scope?: "workflow" | "stage" | undefined;
@@ -1271,12 +983,16 @@ declare type FieldReadExpr = {
 };
 
 /**
- * A sub-field shape used inside an `object`'s `fields` or an `array`'s `of` —
- * lighter than {@link FieldEntry}: no `initialValue`/`editable`/`required`,
- * since a sub-field's value comes from the parent. An `object` kind requires
- * non-empty `fields` and no `of`; an `array` kind requires non-empty `of` and
- * no `fields`; every other kind requires neither — enforced at parse, not
- * visible in this type.
+ * A nested field shape inside an object's `fields`, an array's `of`, or an
+ * effect's `outputs`. It has no initialization, direct editability, or required
+ * setting; those belong to {@link FieldEntry}.
+ *
+ * An `object` requires nonempty `fields` and no `of`. An `array` requires
+ * nonempty `of` and no `fields`. Other types accept neither. Sibling names
+ * must be unique. Use ordinary `date` and `datetime` here; `dueDate` and
+ * `dueDatetime` are not valid nested fields or effect outputs.
+ * {@link ChoiceOptions} and {@link ScalarValidation} constrain supported
+ * scalar types. `roles` is valid only on `assignee` and `assignees` shapes.
  */
 declare interface FieldShape {
   type: FieldValueKind;
@@ -1292,14 +1008,32 @@ declare interface FieldShape {
 }
 
 /**
- * How a field seeds its `initialValue`, once at materialisation (advisory
- * after — the field stays freely editable). Absent means working memory: the
- * field starts empty and an op fills it later, spelled by omission rather
- * than an arm. Distinct from {@link ValueExpr}, an op's write payload; they
- * overlap only on the literal and field-read arms.
+ * Supplies a field's `initialValue` once, when the field is initialized.
+ * Omitting the source starts the field empty; an operation can fill it later.
+ * The source does not grant permission to edit. Direct editing requires an
+ * {@link Editable | editable} declaration.
+ *
+ * Distinct from {@link ValueExpr}, which supplies an operation's write value.
+ * Only the literal and field-read forms are shared.
+ *
+ * `input` reads workflow inputs supplied at start or spawn. Stage and activity
+ * input seeds receive no caller value; activity input seeds produce a deploy
+ * warning. `literal` supplies a fixed value. `query` runs against the Content
+ * Lake with earlier fields in the same scope available as `$fields`.
+ * Reference normalization can omit unrecognized values without recording
+ * `fieldQueryDiscarded`. A result that fails validation after normalization
+ * uses the field's empty value (`null` or `[]`) and records that event.
+ * A failed query throws.
+ *
+ * A `fieldRead` seed reads earlier fields in its own scope when `scope` is
+ * omitted. A stage or activity seed can read workflow fields with
+ * `scope: 'workflow'`. An activity seed cannot read stage fields. At workflow
+ * scope, omit `scope` to read an earlier workflow field. `path` selects a
+ * nested value; these reads do not load referenced documents.
  */
 declare type FieldSource = FieldSourceInternal;
 
+/** @inline */
 declare type FieldSourceInternal =
   | {
       type: "input";
@@ -1340,8 +1074,13 @@ export declare function groq(
   ...values: unknown[]
 ): string;
 
-/** A named readiness condition. Activities accept only `'groq'`; workflow
- *  `start.requirements` also accepts `'singleSubject'` — see {@link StartRequirement}. */
+/**
+ * A named GROQ readiness condition. Its name must be unique in the containing
+ * requirements array. Activity requirements use instance and caller variables;
+ * workflow requirements use the input and projected dataset in {@link StartBlock}.
+ * Every requirement must pass before the corresponding caller action or fresh
+ * standalone start can commit.
+ */
 declare type GroqRequirement = RequirementBase & {
   type: "groq";
   query: string;
@@ -1388,25 +1127,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 +1139,41 @@ 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 value read for a guard's `match.idRefs` or `metadata`, resolved when the
+ * guard is created or refreshed. `fieldRead` reads workflow fields only;
+ * stage and activity fields are unavailable. `effectsRead` reads a completed
+ * effect's output. `self` supplies the instance's GDR URI and `now` its ISO
+ * clock value.
+ * Paths cannot contain line breaks, and effect names cannot contain `'`.
+ * Stored {@link Guard} declarations carry string forms of these reads.
+ */
+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 +1222,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 +1255,7 @@ declare const GuardSchema: v.StrictObjectSchema<
   undefined
 >;
 
+/** @inline */
 declare type LiteralExpr = {
   type: "literal";
   value: unknown;
@@ -1523,18 +1267,39 @@ 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>;
+/**
+ * An action operation: a {@link FieldOp} or a status change on an activity in
+ * the current stage.
+ *
+ * For `field.updateWhere` and `field.removeWhere`, `where` evaluates each row
+ * as `$row`. Caller-fired actions also supply `$params`. Referenced document
+ * content is not loaded for row selection, and an unevaluable row never
+ * matches. An operation matching no rows still records `opApplied` history.
+ */
+declare type Op =
+  | FieldOp
+  | {
+      type: "status.set";
+      activity: string;
+      status: ActivityStatus;
+    };
 
+/** @inline */
 declare type RequirementBase = {
   name: string;
   title?: string | undefined;
@@ -1556,38 +1321,40 @@ 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[]>;
+
+/**
+ * The `runtime` block on a deployment and on `defineWorkflow`. A workflow that
+ * declares none inherits its deployment's kind, and a deployment that declares
+ * none hosts on `'function'`. Authoring-only: the deploy strips it and stores
+ * nothing.
+ *
+ * It is a hint to the generator and to callers, never a rule the engine
+ * enforces. The engine never sees it: any engine built anywhere with a handler
+ * for an effect drains that effect when it calls `drainEffects`, whatever kind
+ * the node declares, so a `'selfHosted'` effect is drained by whoever registers
+ * its handler, the Studio included.
+ */
+declare interface RuntimeBlock {
+  kind: RuntimeKind;
+}
+
+/**
+ * Where the generated unattended runtime hosts a workflow or an effect.
+ * `'function'` is a plain Sanity Function, `'durableFunction'` a durable one,
+ * and `'selfHosted'` a process you run yourself.
+ */
+declare type RuntimeKind = "function" | "durableFunction" | "selfHosted";
 
-/** Inclusive scalar bounds. String/text bounds measure character length;
- * number bounds measure the numeric value. */
+/**
+ * Inclusive bounds for `string`, `text`, `number`, or `progress` values.
+ * String/text bounds count characters and must be non-negative integers.
+ * Number bounds are finite numeric values. Progress bounds may only narrow
+ * its inclusive 0–100 range.
+ *
+ * Supply at least one bound. When both are present, `min` must not exceed
+ * `max`. Null values remain allowed unless an input is required separately.
+ */
 declare interface ScalarValidation {
   min?: number | undefined;
   max?: number | undefined;
@@ -1603,21 +1370,30 @@ declare const SIGNAL_SEMANTICS: readonly [
 
 declare type SignalSemantic = (typeof SIGNAL_SEMANTICS)[number];
 
+/**
+ * A start requirement that rejects a fresh start when an unfinished run of
+ * this definition holds the same subject, across deployed versions.
+ * The workflow must declare an input-sourced `subject` field. Names are unique
+ * within the requirements array. Like other engine checks, this is advisory;
+ * it is not Content Lake enforcement.
+ */
 declare type SingleSubjectRequirement = RequirementBase & {
   type: "singleSubject";
 };
 
 /**
- * A pure container — name, fields, guards, activities, transitions, no
- * behaviour of its own. Activities own enter, transitions own exit and
- * arrival; a stage with no transitions IS terminal (structural, nothing to
- * declare or mis-declare). `guards` are lake mutation guards active while
- * the stage holds, each compiling to a persisted guard document deployed on
- * stage entry and retracted on exit. `editable` is a tighten-only override
- * for the time the stage holds, keyed by an in-scope field name: the field's
- * 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.
+ * The fields, activities, guards, and outgoing routes for one stage visit.
+ * A stage with no transitions is terminal: entering it completes the instance,
+ * and it cannot declare activities. Put completion work in the source stage
+ * or give the working stage an outgoing transition.
+ *
+ * Guards are registered on entry and retracted on exit. `editable` overrides
+ * are keyed by in-scope field name and apply while the stage is current.
+ * Each combines with the field's own edit condition using AND, so an override
+ * can restrict editing but cannot open a field whose baseline is closed.
+ * An unlisted field inherits its baseline.
+ *
+ * @interface
  */
 declare type Stage = StageFields<
   FieldEntry,
@@ -1627,7 +1403,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,25 +1417,31 @@ 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
- * this document?" — evaluated by `definitionsForDocument`/applicability in
- * the browse-time-pure start-filter context (`$tag`/`$definition`/`$now`
- * bound; `$fields` cannot exist before inputs do, so a `$fields` read here
- * is deploy-rejected). It is NOT a `startInstance` gate; the verb never
- * reads it. `requirements` are named readiness checks evaluated in author
- * order in the start-time context (GROQ nodes add `$fields`; `singleSubject`
- * is the one-in-flight-run-per-subject rule) — every node must pass before
- * `startInstance` commits. Both are advisory like every engine-side check;
- * the Content Lake remains the only enforcement point.
+ * Discovery and readiness rules for standalone starts.
+ * `filter` evaluates against a candidate document with `$tag`, `$definition`,
+ * and `$now`. It controls discovery and never gates `startInstance`.
+ * It cannot read `$fields` or caller variables.
+ *
+ * `requirements` evaluates named checks in declaration order before a fresh
+ * standalone start. All must pass. Resuming an existing start and spawning
+ * children do not rerun these checks. A GROQ requirement binds `$tag`,
+ * `$definition`, `$now`, and `$fields`, with no candidate document root.
+ * `$fields` contains supplied input values, including GDR reference envelopes;
+ * it excludes computed defaults and hydrated document content.
+ *
+ * At both sites, `*` scans projected instances in the engine's tag. Each row
+ * contains only `definition` (name), `subject` (GDR URI or null), and
+ * `completedAt` (ISO timestamp or null). Completed and aborted runs are
+ * included. Raw fields such as `_type`, `tag`, and `fields` are unavailable.
+ * Use {@link SingleSubjectRequirement} for one unfinished run per subject.
+ * These checks are advisory; the Content Lake remains the enforcement point.
  */
 declare type StartBlock = StartFields & {
   kind: StartKind;
 };
 
+/** @inline */
 declare type StartFields = {
   filter?: string | undefined;
   requirements?: StartRequirement[] | undefined;
@@ -1674,292 +1456,58 @@ 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
 >;
 
 /**
- * Fan-out declared as an action's `spawn`, read back as `$subworkflows`.
- * `forEach` is GROQ producing one row per subworkflow (bound as `$row`); each
- * row needs an identity the engine can adopt on re-entry (`_key` ?? `_id` ??
- * GDR `id`, or the value itself for a scalar row) or the spawn fails.
- * `definition` resolves by stable `name`, ordered `version desc` unless
- * pinned. `with` seeds each child's initial fields; `context` delivers extra
- * parent-scope values into the child's `$context`. `onExit` governs only
- * still-live children when the cohort's scope stops applying: `'detach'`
- * (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`.
+ * Child workflows created by an action's `spawn`, exposed as `$subworkflows`.
+ * `definition` selects the highest deployed version unless a version is pinned.
+ *
+ * `forEach` evaluates with workflow fields only and no caller variables, even
+ * for a caller-fired action. Rows need unique identities: a nonempty `_key`,
+ * then `_id`, then a GDR's `id`, or a scalar's string representation.
+ * Missing or duplicate identities reject the spawn. Re-entry adopts matching
+ * live children from the same activity, action, and definition instead of
+ * duplicating them.
+ *
+ * `with` maps child input-field names to expressions evaluated with `$row`.
+ * `context` evaluates once without `$row` and supplies the child's `$context`.
+ * Both use the parent activity's field scope and the acting identity when
+ * available. Neither binds `$can`, `$attributes`, or `$params`.
+ * Context results must be strings, numbers, booleans, or full GDRs; null and
+ * undefined omit the entry. Other objects and arrays reject the spawn.
+ *
+ * `onExit` governs live children when their cohort leaves scope: `detach`
+ * (the default) leaves them running; `abort` stops them recursively. Aborting
+ * the parent always stops its children. Parent transitions must separately
+ * declare whether they wait for the cohort to settle.
+ *
+ * @interface
  */
 declare type Subworkflows = v.InferOutput<typeof SubworkflowsSchema>;
 
@@ -2050,37 +1598,28 @@ 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 = "done" | "skipped" | "failed";
 
-declare type TerminalActivityStatus =
-  (typeof TERMINAL_ACTIVITY_STATUSES)[number];
-
-/** 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";
 };
 
 /**
- * A pure edge — `{name, when, to}` plus presentation, no ops or effects
- * (structure never does; only actions do). Every transition is evaluated on
- * every commit and cascade; the first truthy `when` in declaration order
- * fires. No action coupling: a routing difference is written into fields by
- * an action and read by the trigger — arrival work is a `when: 'true'`
- * action in the destination stage, and exit work is an action in the source
- * stage whose `when` repeats this transition's condition (the hop rule
- * guarantees it commits before the move).
+ * A one-way route to another stage, without operations or effects. Selection
+ * checks `when` conditions in declaration order. The first satisfied condition
+ * fires; an earlier unevaluable condition, such as GROQ null, stops selection
+ * without considering later routes. A false condition permits the next route.
+ *
+ * Actions write routing decisions into fields; transitions read that state.
+ * Source-stage triggered actions run before transition selection. Arrival work
+ * belongs to a triggered action in a nonterminal destination stage.
  */
 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 +1627,23 @@ declare type TransitionFields = {
   to: string;
 };
 
+/**
+ * An operation's write value, resolved when the operation applies.
+ * `param` reads a caller-supplied action argument; `actor` records the acting
+ * identity. `now` supplies the operation's ISO timestamp, `self` its instance's
+ * GDR URI, and `stage` the current stage name. `object` resolves its fields
+ * recursively.
+ *
+ * A `fieldRead` with no scope searches activity, stage, then workflow fields.
+ * An explicit scope searches only that scope. A pathless read from a subject
+ * or `doc.ref` into another subject or `doc.ref` preserves the stored reference.
+ * Other reads use the referenced snapshot document, or only its `_id` and
+ * `_type` when it is not loaded. No additional documents are fetched.
+ * Initialization uses {@link FieldSource}, whose field-read scope rules differ.
+ */
+declare type ValueExpr = ValueExprInternal;
+
+/** @inline */
 declare type ValueExprInternal =
   | LiteralExpr
   | FieldReadExpr
@@ -2112,8 +1668,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 +1677,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>;
 
@@ -2396,44 +1952,22 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                 readonly [
                   v.ArraySchema<
                     v.CustomSchema<
-                      {
-                        name: string;
-                        semantics?: Semantic[] | undefined;
-                        title: string;
-                        description?: string | undefined;
-                        groups?: Group[] | undefined;
-                        lifecycle?: WorkflowLifecycle | undefined;
-                        start?: StartBlock | undefined;
-                        initialStage: string;
-                        fields?: FieldEntry[] | undefined;
-                        stages: Stage[];
-                        predicates?: Record<string, string> | undefined;
-                        roleAliases?: RoleAliases | undefined;
-                      },
+                      DefinedWorkflow,
                       v.ErrorMessage<v.CustomIssue> | undefined
                     >,
                     undefined
                   >,
                   v.MinLengthAction<
-                    {
-                      name: string;
-                      semantics?: Semantic[] | undefined;
-                      title: string;
-                      description?: string | undefined;
-                      groups?: Group[] | undefined;
-                      lifecycle?: WorkflowLifecycle | undefined;
-                      start?: StartBlock | undefined;
-                      initialStage: string;
-                      fields?: FieldEntry[] | undefined;
-                      stages: Stage[];
-                      predicates?: Record<string, string> | undefined;
-                      roleAliases?: RoleAliases | undefined;
-                    }[],
+                    DefinedWorkflow[],
                     1,
                     "a deployment needs at least one definition"
                   >,
                 ]
               >;
+              readonly runtime: v.OptionalSchema<
+                v.GenericSchema<RuntimeBlock>,
+                undefined
+              >;
             },
             undefined
           >,
@@ -2483,20 +2017,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                       };
                 }[]
               | undefined;
-            definitions: {
-              name: string;
-              semantics?: Semantic[] | undefined;
-              title: string;
-              description?: string | undefined;
-              groups?: Group[] | undefined;
-              lifecycle?: WorkflowLifecycle | undefined;
-              start?: StartBlock | undefined;
-              initialStage: string;
-              fields?: FieldEntry[] | undefined;
-              stages: Stage[];
-              predicates?: Record<string, string> | undefined;
-              roleAliases?: RoleAliases | undefined;
-            }[];
+            definitions: DefinedWorkflow[];
+            runtime?: RuntimeBlock | undefined;
           }[],
           1,
           "a config needs at least one deployment"
@@ -2545,20 +2067,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                       };
                 }[]
               | undefined;
-            definitions: {
-              name: string;
-              semantics?: Semantic[] | undefined;
-              title: string;
-              description?: string | undefined;
-              groups?: Group[] | undefined;
-              lifecycle?: WorkflowLifecycle | undefined;
-              start?: StartBlock | undefined;
-              initialStage: string;
-              fields?: FieldEntry[] | undefined;
-              stages: Stage[];
-              predicates?: Record<string, string> | undefined;
-              roleAliases?: RoleAliases | undefined;
-            }[];
+            definitions: DefinedWorkflow[];
+            runtime?: RuntimeBlock | undefined;
           }[],
           (
             issue: v.CheckIssue<
@@ -2605,20 +2115,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                           };
                     }[]
                   | undefined;
-                definitions: {
-                  name: string;
-                  semantics?: Semantic[] | undefined;
-                  title: string;
-                  description?: string | undefined;
-                  groups?: Group[] | undefined;
-                  lifecycle?: WorkflowLifecycle | undefined;
-                  start?: StartBlock | undefined;
-                  initialStage: string;
-                  fields?: FieldEntry[] | undefined;
-                  stages: Stage[];
-                  predicates?: Record<string, string> | undefined;
-                  roleAliases?: RoleAliases | undefined;
-                }[];
+                definitions: DefinedWorkflow[];
+                runtime?: RuntimeBlock | undefined;
               }[]
             >,
           ) => string
@@ -2667,20 +2165,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                       };
                 }[]
               | undefined;
-            definitions: {
-              name: string;
-              semantics?: Semantic[] | undefined;
-              title: string;
-              description?: string | undefined;
-              groups?: Group[] | undefined;
-              lifecycle?: WorkflowLifecycle | undefined;
-              start?: StartBlock | undefined;
-              initialStage: string;
-              fields?: FieldEntry[] | undefined;
-              stages: Stage[];
-              predicates?: Record<string, string> | undefined;
-              roleAliases?: RoleAliases | undefined;
-            }[];
+            definitions: DefinedWorkflow[];
+            runtime?: RuntimeBlock | undefined;
           }[],
           (
             issue: v.CheckIssue<
@@ -2727,20 +2213,8 @@ declare const WorkflowConfigSchema: v.ObjectSchema<
                           };
                     }[]
                   | undefined;
-                definitions: {
-                  name: string;
-                  semantics?: Semantic[] | undefined;
-                  title: string;
-                  description?: string | undefined;
-                  groups?: Group[] | undefined;
-                  lifecycle?: WorkflowLifecycle | undefined;
-                  start?: StartBlock | undefined;
-                  initialStage: string;
-                  fields?: FieldEntry[] | undefined;
-                  stages: Stage[];
-                  predicates?: Record<string, string> | undefined;
-                  roleAliases?: RoleAliases | undefined;
-                }[];
+                definitions: DefinedWorkflow[];
+                runtime?: RuntimeBlock | undefined;
               }[]
             >,
           ) => string
@@ -2772,26 +2246,13 @@ 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
 >;
 
-/**
- * Structural schema for a STORED workflow definition — primitives only,
- * every reference scope resolved. Cross-field invariants (unique names,
- * transition targets, effect-name uniqueness, predicate shadowing) are
- * checked by `checkWorkflowInvariants` after desugar — see `defineWorkflow`.
- * Carries NO `version`: a definition's version and content fingerprint are
- * stamped onto the deployed document at deploy time, derived from the
- * content itself, so redeploying identical content is a no-op and any
- * change mints the next version.
- *
- * Exported (module-level, not package API) for the model-surface gate's
- * coverage test and for `parseStoredDefinition` — the boundary parse for a
- * definition that did not come out of `defineWorkflow` in-process; trusted
- * in-process desugar output is never re-parsed.
- */
 declare const WorkflowDefinitionSchema: v.GenericSchema<
   WorkflowFields<FieldEntry, Stage, StartBlock>
 >;
@@ -2803,10 +2264,22 @@ declare const WorkflowDefinitionSchema: v.GenericSchema<
 declare type WorkflowDeployment = WorkflowConfig["deployments"][number];
 
 /**
- * What an author writes for one deployment: the highest reader model verified
- * across runtimes sharing its workflow resource. Runtime validation compares
- * it with the submitted definitions, so a dependency upgrade alone does not
- * require changing the literal.
+ * Author one deployment with a nonempty `definitions` array and a
+ * {@link WorkflowResource}. Dataset resource IDs use `<projectId>.<dataset>`.
+ *
+ * `name` and `tag` must contain only ASCII lowercase letters, digits, and dashes,
+ * starting with a letter or digit. Deployment names and `(workflowResource, tag)`
+ * pairs must be unique across the config. Optional `resourceAliases` use the same
+ * name grammar, with unique names within this deployment.
+ *
+ * `expectedMinReaderModel` is the highest reader model you have verified across
+ * runtimes sharing the workflow resource. Supply a reviewed numeric literal.
+ * Definition submission checks it against the required reader floor; upgrading
+ * a dependency alone does not require changing it.
+ *
+ * `runtime` is the default hosting kind for this deployment's workflows, which
+ * each workflow and effect may override. Omitted, its workflows host on
+ * `'function'`.
  */
 declare type WorkflowDeploymentInput = Omit<
   WorkflowDeployment,
@@ -2815,7 +2288,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 +2307,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