@sanity/workflow-engine 0.15.0 → 0.16.0

package/dist/_chunks-cjs/invariants.cjs

@@ -20,6 +20,26 @@ function _interopNamespaceCompat(e) {
 
 var v__namespace = /* @__PURE__ */ _interopNamespaceCompat(v);
 
+function isCascadeFired(action) {
+    return action.when !== void 0;
+}
+
+function deriveActivityKind(activity) {
+    if (activity.target !== void 0) return "manual";
+    const actions = activity.actions ?? [];
+    return actions.some(a => !isCascadeFired(a)) ? "user" : actions.some(a => (a.effects ?? []).length > 0 || a.spawn !== void 0) ? "service" : actions.length > 0 ? "receive" : "script";
+}
+
+function deriveExecutorClassification(activity) {
+    if (activity.target !== void 0) return "off-system";
+    const actions = activity.actions ?? [], cascadeFired = actions.filter(isCascadeFired).length;
+    return cascadeFired === actions.length ? "autonomous" : cascadeFired === 0 ? "interactive" : "hybrid";
+}
+
+function driverKind(actor) {
+    return actor.kind === "person" || actor.kind === "agent" ? actor.kind : "service";
+}
+
 function errorMessage(err) {
     return (err instanceof Error ? err.message : String(err)).replace(/[^\P{Cc}\n\t]/gu, "");
 }
@@ -397,6 +417,596 @@ function actorFulfillsRole({actorRoles: actorRoles, required: required, aliases:
     return actorRoles.some(role => accepted.has(role));
 }
 
+function groq(strings, ...values) {
+    return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
+}
+
+function serializeGroqValue(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) throw new Error(`groq tag cannot serialize ${typeof value} — interpolate JSON-representable values only`);
+    return serialized;
+}
+
+function desugarWorkflow(authoring) {
+    const issues = [];
+    checkReservedRoleAliasKeys(authoring.roleAliases, issues);
+    const roleAliases = normalizeRoleAliases(authoring.roleAliases), ctx = {
+        issues: issues,
+        claimFields: /* @__PURE__ */ new Map,
+        claimedFields: /* @__PURE__ */ new Set,
+        roleAliases: roleAliases
+    }, workflowFields2 = desugarFieldEntries({
+        entries: authoring.fields,
+        path: [ "fields" ],
+        ctx: ctx
+    }), workflowLayer = layerOf(workflowFields2), stages = authoring.stages.map((stage, i) => {
+        const path = [ "stages", i ], stageFields2 = desugarFieldEntries({
+            entries: stage.fields,
+            path: [ ...path, "fields" ],
+            ctx: ctx
+        }), stageEnv = {
+            layers: [ {
+                scope: "stage",
+                entries: layerOf(stageFields2)
+            }, {
+                scope: "workflow",
+                entries: workflowLayer
+            } ]
+        }, activities = (stage.activities ?? []).map((activity, j) => desugarActivity({
+            activity: activity,
+            path: [ ...path, "activities", j ],
+            stageEnv: stageEnv,
+            ctx: ctx
+        })), transitions = (stage.transitions ?? []).map(transition => desugarTransition({
+            transition: transition
+        })), editable = desugarStageEditable({
+            overrides: stage.editable,
+            inScope: editableFieldNames({
+                workflowFields: workflowFields2,
+                stageFields: stageFields2,
+                activities: activities
+            }),
+            path: [ ...path, "editable" ],
+            ctx: ctx
+        });
+        return {
+            ...stripUndefined({
+                name: stage.name,
+                title: stage.title,
+                description: stage.description,
+                groups: stage.groups,
+                guards: stage.guards?.map(desugarGuard)
+            }),
+            ...stageFields2 ? {
+                fields: stageFields2
+            } : {},
+            ...activities.length > 0 ? {
+                activities: activities
+            } : {},
+            ...transitions.length > 0 ? {
+                transitions: transitions
+            } : {},
+            ...editable ? {
+                editable: editable
+            } : {}
+        };
+    });
+    return checkUnclaimedClaimFields(ctx), {
+        definition: {
+            ...stripUndefined({
+                name: authoring.name,
+                title: authoring.title,
+                description: authoring.description,
+                groups: authoring.groups,
+                lifecycle: authoring.lifecycle,
+                start: desugarStart(authoring.start),
+                initialStage: authoring.initialStage,
+                predicates: authoring.predicates,
+                roleAliases: roleAliases
+            }),
+            ...workflowFields2 ? {
+                fields: workflowFields2
+            } : {},
+            stages: stages
+        },
+        issues: ctx.issues
+    };
+}
+
+function desugarStart(start) {
+    if (start !== void 0) return {
+        kind: start.kind ?? "interactive",
+        ...start.filter !== void 0 ? {
+            filter: start.filter
+        } : {}
+    };
+}
+
+function checkReservedRoleAliasKeys(aliases, issues) {
+    for (const key of Object.keys(aliases ?? {})) key.startsWith("$") && issues.push({
+        path: [ "roleAliases", key ],
+        message: `role alias key "${key}" uses the reserved "$" prefix — that namespace is the engine's stored spelling for the universal fulfiller. Use "*" to mean "fulfills any gate", or rename the role.`
+    });
+}
+
+const TODOLIST_OF = [ {
+    type: "string",
+    name: "label",
+    title: "Label"
+}, {
+    type: "string",
+    name: "status",
+    title: "Status"
+}, {
+    type: "assignee",
+    name: "assignee",
+    title: "Assignee"
+}, {
+    type: "date",
+    name: "dueDate",
+    title: "Due date"
+} ], NOTES_OF = [ {
+    type: "text",
+    name: "body",
+    title: "Body"
+}, {
+    type: "actor",
+    name: "actor",
+    title: "Actor"
+}, {
+    type: "datetime",
+    name: "at",
+    title: "At"
+} ];
+
+function desugarFieldEntries({entries: entries, path: path, ctx: ctx}) {
+    return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => desugarFieldEntry({
+        entry: entry,
+        path: [ ...path, i ],
+        ctx: ctx
+    }));
+}
+
+function desugarFieldEntry({entry: entry, path: path, ctx: ctx}) {
+    if (entry.type === "claim") return desugarClaimField({
+        entry: entry,
+        path: path,
+        ctx: ctx
+    });
+    if (entry.type === "todoList" || entry.type === "notes") return desugarListField({
+        entry: entry,
+        path: path,
+        ctx: ctx
+    });
+    const editable = normalizeEditable({
+        editable: entry.editable,
+        path: [ ...path, "editable" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            type: entry.type,
+            name: entry.name,
+            title: entry.title,
+            description: entry.description,
+            group: normalizeGroup(entry.group),
+            required: entry.required,
+            initialValue: entry.initialValue,
+            editable: editable,
+            types: entry.types,
+            fields: entry.fields,
+            of: entry.of
+        })
+    };
+}
+
+function desugarClaimField({entry: entry, path: path, ctx: ctx}) {
+    const desugared = {
+        ...stripUndefined({
+            name: entry.name,
+            title: entry.title,
+            description: entry.description,
+            group: normalizeGroup(entry.group)
+        }),
+        type: "actor"
+    };
+    return ctx.claimFields.set(desugared, {
+        name: entry.name,
+        path: path
+    }), desugared;
+}
+
+function desugarListField({entry: entry, path: path, ctx: ctx}) {
+    const editable = normalizeEditable({
+        editable: entry.editable,
+        path: [ ...path, "editable" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            name: entry.name,
+            title: entry.title,
+            description: entry.description,
+            group: normalizeGroup(entry.group),
+            required: entry.required,
+            initialValue: entry.initialValue,
+            editable: editable
+        }),
+        type: "array",
+        of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
+    };
+}
+
+function normalizeEditable({editable: editable, path: path, ctx: ctx}) {
+    if (editable === void 0 || editable === !0) return editable;
+    if (Array.isArray(editable)) {
+        const condition = rolesCondition(editable, ctx.roleAliases);
+        if (condition === void 0) {
+            ctx.issues.push({
+                path: path,
+                message: "editable: [] names no roles — use `true` to open the field to anyone in its scope, or list at least one role"
+            });
+            return;
+        }
+        return condition;
+    }
+    return editable;
+}
+
+function editableFieldNames({workflowFields: workflowFields2, stageFields: stageFields2, activities: activities}) {
+    const names = /* @__PURE__ */ new Set, collect = entries => {
+        for (const entry of entries ?? []) entry.editable !== void 0 && names.add(entry.name);
+    };
+    collect(workflowFields2), collect(stageFields2);
+    for (const activity of activities) collect(activity.fields);
+    return names;
+}
+
+function desugarStageEditable({overrides: overrides, inScope: inScope, path: path, ctx: ctx}) {
+    if (overrides === void 0) return;
+    const out = {};
+    for (const [name, value] of Object.entries(overrides)) {
+        if (!inScope.has(name)) {
+            ctx.issues.push({
+                path: [ ...path, name ],
+                message: `stage editable override "${name}" does not narrow an editable field in scope — name a workflow/stage/activity field of this stage that declares \`editable\``
+            });
+            continue;
+        }
+        const normalized = normalizeEditable({
+            editable: value,
+            path: [ ...path, name ],
+            ctx: ctx
+        });
+        normalized !== void 0 && (out[name] = normalized);
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+}
+
+function layerOf(entries) {
+    return new Map((entries ?? []).map(entry => [ entry.name, entry ]));
+}
+
+function normalizeGroup(group) {
+    return group === void 0 || Array.isArray(group) ? group : [ group ];
+}
+
+function desugarActivity({activity: activity, path: path, stageEnv: stageEnv, ctx: ctx}) {
+    const activityFields2 = desugarFieldEntries({
+        entries: activity.fields,
+        path: [ ...path, "fields" ],
+        ctx: ctx
+    }), env = {
+        layers: [ {
+            scope: "activity",
+            entries: layerOf(activityFields2)
+        }, ...stageEnv.layers ]
+    }, actions = (activity.actions ?? []).map((action, a) => desugarAction({
+        action: action,
+        path: [ ...path, "actions", a ],
+        env: env,
+        activityName: activity.name,
+        ctx: ctx
+    })), target = desugarTarget({
+        target: activity.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            name: activity.name,
+            title: activity.title,
+            description: activity.description,
+            groups: activity.groups,
+            group: normalizeGroup(activity.group),
+            filter: activity.filter,
+            requirements: activity.requirements
+        }),
+        ...target ? {
+            target: target
+        } : {},
+        ...activityFields2 ? {
+            fields: activityFields2
+        } : {},
+        ...actions.length > 0 ? {
+            actions: actions
+        } : {}
+    };
+}
+
+const TARGET_DOC_KINDS = [ "doc.ref", "doc.refs", "release.ref" ];
+
+function desugarTarget({target: target, env: env, path: path, ctx: ctx}) {
+    if (target === void 0 || target.type === "url") return target;
+    const ref = typeof target.field == "string" ? {
+        field: target.field
+    } : target.field, field = resolveRef({
+        ref: ref,
+        env: env,
+        path: [ ...path, "field" ],
+        ctx: ctx
+    }) ?? fallbackRef(ref), entry = entryAt(env, field);
+    return entry && !TARGET_DOC_KINDS.includes(entry.type) && ctx.issues.push({
+        path: [ ...path, "field" ],
+        message: `manual activity target references "${field.field}" of kind "${entry.type}" — a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
+    }), {
+        type: "field",
+        field: field
+    };
+}
+
+function desugarAction({action: action, path: path, env: env, activityName: activityName, ctx: ctx}) {
+    if ("type" in action) return desugarClaimAction({
+        action: action,
+        path: path,
+        env: env,
+        ctx: ctx
+    });
+    action.roles !== void 0 && action.roles.length === 0 && ctx.issues.push({
+        path: [ ...path, "roles" ],
+        message: "roles: [] names no roles — omit it to allow any identity, or list at least one role"
+    });
+    const cascadeFired = isCascadeFired(action), filter = cascadeFired ? action.filter : andConditions([ rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = desugarOps({
+        ops: action.ops,
+        path: [ ...path, "ops" ],
+        env: env,
+        firingActivity: activityName,
+        ctx: ctx
+    }) ?? [];
+    return action.status !== void 0 && ops.push({
+        type: "status.set",
+        activity: activityName,
+        status: action.status
+    }), {
+        ...stripUndefined({
+            name: action.name,
+            title: action.title,
+            description: action.description,
+            group: normalizeGroup(action.group),
+            when: action.when,
+            params: action.params,
+            effects: action.effects,
+            spawn: action.spawn
+        }),
+        ...cascadeFired && action.roles !== void 0 && action.roles.length > 0 ? {
+            roles: action.roles
+        } : {},
+        ...filter ? {
+            filter: filter
+        } : {},
+        ...ops.length > 0 ? {
+            ops: ops
+        } : {}
+    };
+}
+
+function desugarClaimAction({action: action, path: path, env: env, ctx: ctx}) {
+    const ref = typeof action.field == "string" ? {
+        field: action.field
+    } : action.field, resolved = resolveRef({
+        ref: ref,
+        env: env,
+        path: [ ...path, "field" ],
+        ctx: ctx
+    });
+    if (resolved) {
+        const entry = entryAt(env, resolved);
+        entry && entry.type !== "actor" && ctx.issues.push({
+            path: [ ...path, "field" ],
+            message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" — a claim pair needs an actor-valued entry (a "claim" or "actor" field declaration)`
+        }), checkShadowedClaimTarget({
+            actionName: action.name,
+            field: ref.field,
+            resolved: resolved,
+            env: env,
+            path: [ ...path, "field" ],
+            ctx: ctx
+        }), entry && ctx.claimedFields.add(entry);
+    }
+    const noSteal = `!defined($fields.${ref.field})`, filter = andConditions([ noSteal, rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = resolved ? [ {
+        type: "field.set",
+        target: resolved,
+        value: {
+            type: "actor"
+        }
+    } ] : [];
+    return {
+        ...stripUndefined({
+            name: action.name,
+            title: action.title,
+            description: action.description,
+            group: normalizeGroup(action.group),
+            params: action.params,
+            effects: action.effects
+        }),
+        filter: filter,
+        ...ops.length > 0 ? {
+            ops: ops
+        } : {}
+    };
+}
+
+function checkShadowedClaimTarget({actionName: actionName, field: field, resolved: resolved, env: env, path: path, ctx: ctx}) {
+    const nearest = env.layers.find(l => l.entries.has(field));
+    nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
+        path: path,
+        message: `claim action "${actionName}" targets "${field}" at scope "${resolved.scope}", but a nearer ${nearest.scope}-scope entry of the same name shadows it in $fields — the no-steal filter would read the shadowing entry while the claim writes the "${resolved.scope}" one. Rename one of the entries or claim the nearer one`
+    });
+}
+
+function checkUnclaimedClaimFields(ctx) {
+    for (const [entry, {name: name, path: path}] of ctx.claimFields) ctx.claimedFields.has(entry) || ctx.issues.push({
+        path: path,
+        message: `claim field "${name}" is never referenced by a claim action — you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw actor entry`
+    });
+}
+
+const DEFAULT_TRANSITION_WHEN = "$allActivitiesDone";
+
+function desugarTransition({transition: transition}) {
+    return {
+        ...stripUndefined({
+            name: transition.name,
+            title: transition.title,
+            description: transition.description,
+            to: transition.to
+        }),
+        when: transition.when ?? DEFAULT_TRANSITION_WHEN
+    };
+}
+
+function desugarGuard(guard) {
+    const {match: match, metadata: metadata, ...rest} = guard, {idRefs: idRefs, ...matchRest} = match;
+    return {
+        ...rest,
+        match: {
+            ...matchRest,
+            ...idRefs !== void 0 ? {
+                idRefs: idRefs.map(printGuardRead)
+            } : {}
+        },
+        ...metadata !== void 0 ? {
+            metadata: Object.fromEntries(Object.entries(metadata).map(([key, read]) => [ key, printGuardRead(read) ]))
+        } : {}
+    };
+}
+
+function desugarOps({ops: ops, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
+    if (ops) return ops.map((op, i) => desugarOp({
+        op: op,
+        path: [ ...path, i ],
+        env: env,
+        firingActivity: firingActivity,
+        ctx: ctx
+    }));
+}
+
+function desugarOp({op: op, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
+    if (op.type === "status.set") return {
+        type: "status.set",
+        activity: op.activity ?? firingActivity,
+        status: op.status
+    };
+    if (op.type === "audit") return desugarAuditOp({
+        op: op,
+        path: path,
+        env: env,
+        ctx: ctx
+    });
+    const target = resolveRef({
+        ref: op.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    }) ?? fallbackRef(op.target);
+    return {
+        ...op,
+        target: target
+    };
+}
+
+const AUDIT_STAMPS = {
+    actor: {
+        type: "actor"
+    },
+    at: {
+        type: "now"
+    }
+};
+
+function desugarAuditOp({op: op, path: path, env: env, ctx: ctx}) {
+    const target = resolveRef({
+        ref: op.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    }) ?? fallbackRef(op.target);
+    if (op.value.type !== "object") return ctx.issues.push({
+        path: [ ...path, "value" ],
+        message: `audit value must be an object source carrying the domain fields (got "${op.value.type}")`
+    }), {
+        type: "field.append",
+        target: target,
+        value: op.value
+    };
+    const actorField = op.stampFields?.actor ?? "actor", atField = op.stampFields?.at ?? "at", fields = {
+        ...op.value.fields
+    };
+    for (const [stamp, source] of [ [ actorField, AUDIT_STAMPS.actor ], [ atField, AUDIT_STAMPS.at ] ]) {
+        if (stamp in fields) {
+            ctx.issues.push({
+                path: [ ...path, "value", "fields", stamp ],
+                message: `audit stamp field "${stamp}" collides with an authored domain field — rename yours or remap the stamp via stampFields`
+            });
+            continue;
+        }
+        fields[stamp] = source;
+    }
+    return {
+        type: "field.append",
+        target: target,
+        value: {
+            type: "object",
+            fields: fields
+        }
+    };
+}
+
+function resolveRef({ref: ref, env: env, path: path, ctx: ctx}) {
+    const layers = ref.scope === void 0 ? env.layers : env.layers.filter(l => l.scope === ref.scope);
+    for (const layer of layers) if (layer.entries.has(ref.field)) return {
+        scope: layer.scope,
+        field: ref.field
+    };
+    const reachable = env.layers.flatMap(l => [ ...l.entries.keys() ].map(n => `${l.scope}:${n}`));
+    ctx.issues.push({
+        path: path,
+        message: `field reference "${ref.field}"${ref.scope ? ` (scope "${ref.scope}")` : ""} does not resolve to a declared entry. Reachable: ${reachable.join(", ") || "(none)"}`
+    });
+}
+
+function entryAt(env, ref) {
+    return env.layers.find(l => l.scope === ref.scope)?.entries.get(ref.field);
+}
+
+function fallbackRef(ref) {
+    return {
+        scope: ref.scope ?? "workflow",
+        field: ref.field
+    };
+}
+
+function rolesCondition(roles, aliases) {
+    if (!(!roles || roles.length === 0)) return groq`count($actor.roles[@ in ${expandRequiredRoles(roles, aliases)}]) > 0`;
+}
+
+function stripUndefined(obj) {
+    const out = {};
+    for (const [k, value] of Object.entries(obj)) value !== void 0 && (out[k] = value);
+    return out;
+}
+
 function isUnevaluable(result) {
     return result == null;
 }
@@ -416,9 +1026,9 @@ async function evaluateCondition(args) {
 
 async function evaluatePredicates(args) {
     const out = {};
-    for (const [name, groq] of Object.entries(args.predicates ?? {})) {
+    for (const [name, groq2] of Object.entries(args.predicates ?? {})) {
         const result = await runGroq({
-            groq: groq,
+            groq: groq2,
             params: args.params,
             snapshot: args.snapshot
         }), outcome = groqConditionDescribe.conditionOutcome(result);
@@ -427,46 +1037,46 @@ async function evaluatePredicates(args) {
     return out;
 }
 
-async function runGroq({groq: groq, params: params, snapshot: snapshot}) {
+async function runGroq({groq: groq2, params: params, snapshot: snapshot}) {
     return groqConditionDescribe.runGroq({
-        groq: groq,
+        groq: groq2,
         params: params,
         dataset: snapshot.docs
     });
 }
 
-function conditionSyntaxIssues(groq, boundVars) {
+function conditionSyntaxIssues(groq2, boundVars) {
     const issues = [];
     let tree;
     try {
-        tree = groqJs.parse(groq);
+        tree = groqJs.parse(groq2);
     } catch (err) {
         issues.push(errorMessage(err));
     }
-    if (/\*\s*\[\s*_type\b/.test(groq) && issues.push('condition scans by `_type` — that\'s a discovery query, not a predicate. Conditions evaluate against the in-memory snapshot (instance + ancestors + field-declared docs). To bring extra docs in scope, declare a `doc.ref` (or `doc.refs`) field entry on the workflow or this stage. For lake scans like "all articles in this release", use `subworkflows.forEach` instead.'), 
-    boundVars !== void 0 && tree !== void 0) for (const name of conditionParameterNames(groq)) boundVars.includes(name) || issues.push(`reads $${name}, which this scope does not bind — an unbound variable evaluates to GROQ null, so the condition silently never matches. Bound here: ` + boundVars.map(n => `$${n}`).join(", "));
+    if (/\*\s*\[\s*_type\b/.test(groq2) && issues.push("condition scans by `_type` — that's a discovery query, not a predicate. Conditions evaluate against the in-memory snapshot (instance + ancestors + field-declared docs). To bring extra docs in scope, declare a `doc.ref` (or `doc.refs`) field entry on the workflow or this stage. For lake scans like \"all articles in this release\", use a spawn action's `forEach` instead."), 
+    boundVars !== void 0 && tree !== void 0) for (const name of conditionParameterNames(groq2)) boundVars.includes(name) || issues.push(`reads $${name}, which this scope does not bind — an unbound variable evaluates to GROQ null, so the condition silently never matches. Bound here: ` + boundVars.map(n => `$${n}`).join(", "));
     return issues;
 }
 
-function conditionParameterNames(groq) {
+function conditionParameterNames(groq2) {
     const read = /* @__PURE__ */ new Set;
-    return walkAstNodes(tryParseGroq(groq), node => {
+    return walkAstNodes(tryParseGroq(groq2), node => {
         node.type === "Parameter" && typeof node.name == "string" && read.add(node.name);
     }), read;
 }
 
-function conditionFieldReadNames(groq) {
+function conditionFieldReadNames(groq2) {
     const read = /* @__PURE__ */ new Set;
-    return walkAstNodes(tryParseGroq(groq), node => {
+    return walkAstNodes(tryParseGroq(groq2), node => {
         if (node.type !== "AccessAttribute" || typeof node.name != "string") return;
         const base = node.base;
         base?.type === "Parameter" && base.name === "fields" && read.add(node.name);
     }), read;
 }
 
-function conditionEffectReads(groq) {
+function conditionEffectReads(groq2) {
     const reads = [];
-    return walkAstNodes(tryParseGroq(groq), node => {
+    return walkAstNodes(tryParseGroq(groq2), node => {
         if (node.type !== "AccessAttribute" || typeof node.name != "string") return;
         const base = node.base;
         base?.type !== "AccessAttribute" || typeof base.name != "string" || base.base?.type === "Parameter" && base.base.name === "effects" && reads.push({
@@ -476,9 +1086,34 @@ function conditionEffectReads(groq) {
     }), reads;
 }
 
-function tryParseGroq(groq) {
+function readsRootDocument(groq2) {
+    return nodeReadsRoot(tryParseGroq(groq2), 0);
+}
+
+const SCOPED_CHILD = {
+    Filter: "expr",
+    Projection: "expr",
+    Map: "expr",
+    FlatMap: "expr",
+    PipeFuncCall: "args"
+};
+
+function nodeReadsRoot(node, depth) {
+    if (Array.isArray(node)) return node.some(item => nodeReadsRoot(item, depth));
+    if (typeof node != "object" || node === null) return !1;
+    const typed = node;
+    if (depth === 0 && typed.type === "This" || depth === 0 && typed.type === "AccessAttribute" && typed.base === void 0) return !0;
+    if (typed.type === "Parent") {
+        const climb = typeof typed.n == "number" ? typed.n : 1;
+        return depth - climb <= 0;
+    }
+    const scopedChild = typeof typed.type == "string" ? SCOPED_CHILD[typed.type] : void 0;
+    return scopedChild !== void 0 ? Object.entries(node).some(([key, value]) => nodeReadsRoot(value, key === scopedChild ? depth + 1 : depth)) : Object.values(node).some(value => nodeReadsRoot(value, depth));
+}
+
+function tryParseGroq(groq2) {
     try {
-        return groqJs.parse(groq);
+        return groqJs.parse(groq2);
     } catch {
         return;
     }
@@ -495,7 +1130,13 @@ function walkAstNodes(node, visit) {
     }
 }
 
-const CONDITION_VARS = [ {
+const ACTIVITY_STATUSES = [ "active", "done", "skipped", "failed" ], TERMINAL_ACTIVITY_STATUSES = [ "done", "skipped", "failed" ];
+
+function isTerminalActivityStatus(status) {
+    return TERMINAL_ACTIVITY_STATUSES.includes(status);
+}
+
+const FIELD_SCOPES = [ "workflow", "stage", "activity" ], DOCUMENT_VALUE_PERMISSIONS = [ "create", "read", "update" ], MUTATION_GUARD_ACTIONS = [ "create", "update", "delete", "publish", "unpublish" ], ACTIVITY_KINDS = [ "user", "service", "script", "manual", "receive" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ], CONDITION_VARS = [ {
     name: "self",
     binding: "always",
     label: "this workflow instance",
@@ -525,11 +1166,16 @@ const CONDITION_VARS = [ {
     binding: "always",
     label: "the current time",
     description: "The ISO clock reading shared by every condition in one evaluation pass, so they agree on the time."
+}, {
+    name: "context",
+    binding: "always",
+    label: "start-time context",
+    description: "The instance's `context` bag: values seeded at `startInstance` plus a parent's `spawn.context` handoff, by entry name. Written only at start — never mutated afterwards."
 }, {
     name: "effects",
     binding: "always",
     label: "automation outputs",
-    description: "The `effectsContext` map: stable handler params seeded at start plus completed effects' outputs namespaced by effect name (`$effects['<effect>'].<output>`). Handler fuel — transition filters should read instance/lake state (or $effectStatus) instead."
+    description: "Completed effects' outputs, namespaced by effect name (`$effects['<effect>'].<output>`) — each effect's latest completed run wins. Handler fuel — transition triggers should read instance/lake state (or $effectStatus) instead."
 }, {
     name: "effectStatus",
     binding: "always",
@@ -564,23 +1210,35 @@ const CONDITION_VARS = [ {
     name: "can",
     binding: "caller",
     label: "your permissions",
-    description: "Advisory per-permission booleans computed from the caller's grants; `undefined` without grants. Bound wherever grants ride the evaluation: the projection's rendered scope (action filters, activity requirements, editability predicates) and the fireAction/editField commit gates. Deploy rejects it at every site that evaluates without grants: transition filters, activity `filter`/`completeWhen`/`failWhen`, effect bindings, where-op `where`s, and the subworkflow `forEach`/`with`/`context` sites."
+    description: "Advisory per-permission booleans computed from the caller's grants; `undefined` without grants. Bound wherever grants ride the evaluation: the projection's rendered scope (fireAction-action filters, activity requirements, editability predicates) and the fireAction/editField commit gates. Deploy rejects it at every site that evaluates without grants: transition `when`s, activity filters, cascade-fired actions' `when`/`filter`, effect bindings, where-op `where`s, and the spawn `forEach`/`with`/`context` sites."
 }, {
     name: "row",
     binding: "spawn",
     label: "the spawned row",
-    description: "One `subworkflows.forEach` result row, bound while its `with` map evaluates — and the row under test while a where-op `where` evaluates (per row)."
+    description: "One `spawn.forEach` result row, bound while its `with` map evaluates — and the row under test while a where-op `where` evaluates (per row)."
 }, {
     name: "params",
     binding: "caller",
     label: "the action's arguments",
-    description: "The firing action's args — they hold values only while that action's effect bindings and where-op `where`s evaluate (activity/transition boundaries bind `{}`; subworkflow sites don't bind it at all). Deploy rejects a read in the cascade gates and in the caller-bound projection (action filters, requirements, editable predicates): args exist only once the caller fires the action, after those sites have evaluated."
+    description: "The firing action's args — they hold values only while a fireAction-fired action's effect bindings and where-op `where`s evaluate (spawn sites don't bind it at all, and a cascade-fired action has no caller to supply args). Deploy rejects a read in the cascade gates, in a cascade-fired action's payload, and in the caller-bound projection (action filters, requirements, editable predicates): args exist only once the caller fires the action, after those sites have evaluated."
 }, {
     name: "subworkflows",
     binding: "always",
     label: "the spawned subworkflows",
-    description: "Every row of the instance's subworkflow registry, faceted by `activity`/`definition`/`rowKey`/`status` (`'active'|'done'|'aborted'`) with `current` marking the open stage entry's cohort and `stage` the child's current stage. Usable anywhere — transition filters, requirements, any stage's gates; the implicit spawn gate is `count($subworkflows[activity == <name> && current && status == 'active']) == 0`."
-} ], RESERVED_CONDITION_VARS = CONDITION_VARS.map(v2 => v2.name), FILTER_SCOPE_VARS = CONDITION_VARS.filter(v2 => v2.binding === "always").map(v2 => v2.name), CALLER_BOUND_VARS = CONDITION_VARS.filter(v2 => v2.binding === "caller").map(v2 => v2.name), GUARD_PREDICATE_VARS = [ {
+    description: "Every row of the instance's subworkflow registry, faceted by `activity`/`action`/`definition`/`rowKey`/`status` (`'active'|'done'|'aborted'`) with `current` marking the open stage entry's cohort and `stage` the child's current stage. Usable anywhere — transition `when`s, requirements, any stage's gates; the settled gate is `count($subworkflows[activity == <name> && current && status == 'active']) == 0`."
+} ], RESERVED_CONDITION_VARS = CONDITION_VARS.map(v2 => v2.name), FILTER_SCOPE_VARS = CONDITION_VARS.filter(v2 => v2.binding === "always").map(v2 => v2.name), CALLER_BOUND_VARS = CONDITION_VARS.filter(v2 => v2.binding === "caller").map(v2 => v2.name), START_FILTER_VARS = [ {
+    name: "tag",
+    description: "The engine's tag partition — scope `*[...]` instance scans with `tag == $tag`."
+}, {
+    name: "definition",
+    description: "The `name` of the definition under evaluation (its own start.filter binds it)."
+}, {
+    name: "now",
+    description: "The ISO clock reading of the evaluating engine."
+}, {
+    name: "fields",
+    description: "The candidate initialFields by entry name, when the read surface has them (the Studio start control: yes; a per-doc picker: no). Document references bind as GDR envelopes — `$fields.<entry>.id` is the GDR URI, never a string authors assemble."
+} ], GUARD_PREDICATE_VARS = [ {
     name: "guard",
     description: "The guard document itself (its `metadata` carries deploy-time resolved values)."
 }, {
@@ -803,13 +1461,7 @@ function formatIssues(issues) {
     });
 }
 
-const ACTIVITY_STATUSES = [ "pending", "active", "done", "skipped", "failed" ], TERMINAL_ACTIVITY_STATUSES = [ "done", "skipped", "failed" ];
-
-function isTerminalActivityStatus(status) {
-    return TERMINAL_ACTIVITY_STATUSES.includes(status);
-}
-
-const FIELD_SCOPES = [ "workflow", "stage", "activity" ], DOCUMENT_VALUE_PERMISSIONS = [ "create", "read", "update" ], MUTATION_GUARD_ACTIONS = [ "create", "update", "delete", "publish", "unpublish" ], ACTIVITY_KINDS = [ "user", "service", "script", "manual", "receive" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 function groqIdentifier(referencedAs) {
     return v__namespace.pipe(v__namespace.string(), v__namespace.regex(GROQ_IDENTIFIER, `must be a GROQ-safe identifier (letters, digits, underscore; not starting with a digit) because it is referenced as ${referencedAs} in GROQ conditions`));
@@ -908,7 +1560,7 @@ const StoredFieldOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFi
     type: v__namespace.literal("status.set"),
     activity: NonEmpty,
     status: picklist(ACTIVITY_STATUSES)
-}) ]), StoredTransitionOpSchema = StoredFieldOpSchema, AuditOpSchema = v__namespace.strictObject({
+}) ]), AuditOpSchema = v__namespace.strictObject({
     type: v__namespace.literal("audit"),
     target: AuthoringFieldRefSchema,
     value: ValueExprSchema,
@@ -1036,6 +1688,15 @@ const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("
     bindings: v__namespace.optional(v__namespace.record(v__namespace.string(), ConditionSchema)),
     input: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown())),
     outputs: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+}), DefinitionRefSchema = v__namespace.strictObject({
+    name: NonEmpty,
+    version: v__namespace.optional(v__namespace.union([ PositiveInt, v__namespace.literal("latest") ]))
+}), SubworkflowsSchema = v__namespace.strictObject({
+    forEach: NonEmpty,
+    definition: DefinitionRefSchema,
+    with: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
+    context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
+    onExit: v__namespace.optional(picklist([ "detach", "abort" ]))
 }), ActionParamSchema = v__namespace.strictObject({
     type: picklist([ "string", "number", "boolean", "url", "dateTime", "actor", "doc.ref", "doc.refs", "json" ]),
     name: NonEmpty,
@@ -1050,14 +1711,19 @@ function actionFields(op, group) {
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         group: v__namespace.optional(group),
+        when: v__namespace.optional(ConditionSchema),
         filter: v__namespace.optional(ConditionSchema),
         params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
         ops: v__namespace.optional(v__namespace.array(op)),
-        effects: v__namespace.optional(v__namespace.array(EffectSchema))
+        effects: v__namespace.optional(v__namespace.array(EffectSchema)),
+        spawn: v__namespace.optional(SubworkflowsSchema)
     };
 }
 
-const StoredActionSchema = pinned()(v__namespace.strictObject(actionFields(StoredOpSchema, StoredGroupMembershipSchema))), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(v__namespace.strictObject({
+const StoredActionSchema = pinned()(v__namespace.strictObject({
+    ...actionFields(StoredOpSchema, StoredGroupMembershipSchema),
+    roles: v__namespace.optional(v__namespace.array(NonEmpty))
+})), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(v__namespace.strictObject({
     ...actionFields(AuthoringOpSchema, AuthoringGroupMembershipSchema),
     roles: v__namespace.optional(v__namespace.array(NonEmpty)),
     status: v__namespace.optional(TerminalActivityStatus)
@@ -1072,35 +1738,19 @@ const StoredActionSchema = pinned()(v__namespace.strictObject(actionFields(Store
     filter: v__namespace.optional(ConditionSchema),
     params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
     effects: v__namespace.optional(v__namespace.array(EffectSchema))
-})), AuthoringActionSchema = pinned()(v__namespace.union([ RawAuthoringActionSchema, ClaimActionSchema ])), DefinitionRefSchema = v__namespace.strictObject({
-    name: NonEmpty,
-    version: v__namespace.optional(v__namespace.union([ PositiveInt, v__namespace.literal("latest") ]))
-}), SubworkflowsSchema = v__namespace.strictObject({
-    forEach: NonEmpty,
-    definition: DefinitionRefSchema,
-    with: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
-    context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
-    onExit: v__namespace.optional(picklist([ "detach", "abort" ]))
-});
+})), AuthoringActionSchema = pinned()(v__namespace.lazy(input => typeof input == "object" && input !== null && "type" in input ? ClaimActionSchema : RawAuthoringActionSchema));
 
-function activityFields({field: field, action: action, op: op, target: target, group: group}) {
+function activityFields({field: field, action: action, target: target, group: group}) {
     return {
         name: NonEmpty,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         groups: v__namespace.optional(v__namespace.array(GroupSchema)),
         group: v__namespace.optional(group),
-        kind: v__namespace.optional(picklist(ACTIVITY_KINDS)),
         target: v__namespace.optional(target),
-        activation: v__namespace.optional(picklist([ "auto", "manual" ])),
         filter: v__namespace.optional(ConditionSchema),
         requirements: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
-        completeWhen: v__namespace.optional(ConditionSchema),
-        failWhen: v__namespace.optional(ConditionSchema),
-        ops: v__namespace.optional(v__namespace.array(op)),
-        effects: v__namespace.optional(v__namespace.array(EffectSchema)),
         actions: v__namespace.optional(v__namespace.array(action)),
-        subworkflows: v__namespace.optional(SubworkflowsSchema),
         fields: v__namespace.optional(v__namespace.array(field))
     };
 }
@@ -1108,30 +1758,26 @@ function activityFields({field: field, action: action, op: op, target: target, g
 const StoredActivitySchema = pinned()(v__namespace.strictObject(activityFields({
     field: FieldEntrySchema,
     action: StoredActionSchema,
-    op: StoredOpSchema,
     target: StoredManualTargetSchema,
     group: StoredGroupMembershipSchema
 }))), AuthoringActivitySchema = pinned()(v__namespace.strictObject(activityFields({
     field: AuthoringFieldEntrySchema,
     action: AuthoringActionSchema,
-    op: AuthoringOpSchema,
     target: AuthoringManualTargetSchema,
     group: AuthoringGroupMembershipSchema
 })));
 
-function transitionFields(op, filter) {
+function transitionFields(when) {
     return {
         name: NonEmpty,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         to: NonEmpty,
-        filter: filter,
-        ops: v__namespace.optional(v__namespace.array(op)),
-        effects: v__namespace.optional(v__namespace.array(EffectSchema))
+        when: when
     };
 }
 
-const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(StoredTransitionOpSchema, ConditionSchema))), AuthoringTransitionOpSchema = v__namespace.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), AuditOpSchema ]), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(AuthoringTransitionOpSchema, v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = v__namespace.variant("type", [ v__namespace.strictObject({
+const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = v__namespace.variant("type", [ v__namespace.strictObject({
     type: v__namespace.literal("self")
 }), v__namespace.strictObject({
     type: v__namespace.literal("now")
@@ -1193,16 +1839,25 @@ const StoredStageSchema = pinned()(v__namespace.strictObject(stageFields({
     transition: AuthoringTransitionSchema,
     guard: AuthoringGuardSchema,
     editable: AuthoringEditableSchema
-}))), RoleAliasesSchema = v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))), WORKFLOW_LIFECYCLES = [ "standalone", "child" ];
+}))), RoleAliasesSchema = v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))), WORKFLOW_LIFECYCLES = [ "standalone", "child" ], START_KINDS = [ "interactive", "autonomous" ];
+
+function startFields(kind) {
+    return {
+        kind: kind,
+        filter: v__namespace.optional(ConditionSchema)
+    };
+}
+
+const StoredStartSchema = pinned()(v__namespace.strictObject(startFields(picklist(START_KINDS)))), AuthoringStartSchema = pinned()(v__namespace.strictObject(startFields(v__namespace.optional(picklist(START_KINDS)))));
 
-function workflowFields(field, stage) {
+function workflowFields({field: field, stage: stage, start: start}) {
     return {
         name: NonEmpty,
         title: NonEmpty,
         description: v__namespace.optional(v__namespace.string()),
         groups: v__namespace.optional(v__namespace.array(GroupSchema)),
         lifecycle: v__namespace.optional(picklist(WORKFLOW_LIFECYCLES)),
-        applicableWhen: v__namespace.optional(ConditionSchema),
+        start: v__namespace.optional(start),
         initialStage: NonEmpty,
         fields: v__namespace.optional(v__namespace.array(field)),
         stages: v__namespace.pipe(v__namespace.array(stage), v__namespace.minLength(1, "must declare at least one stage")),
@@ -1211,7 +1866,11 @@ function workflowFields(field, stage) {
     };
 }
 
-const WorkflowDefinitionSchema = pinned()(v__namespace.strictObject(workflowFields(FieldEntrySchema, StoredStageSchema)));
+const WorkflowDefinitionSchema = pinned()(v__namespace.strictObject(workflowFields({
+    field: FieldEntrySchema,
+    stage: StoredStageSchema,
+    start: StoredStartSchema
+})));
 
 function parseStoredDefinition(input, label) {
     return parseOrThrow({
@@ -1221,12 +1880,28 @@ function parseStoredDefinition(input, label) {
     });
 }
 
-const AuthoringWorkflowSchema = pinned()(v__namespace.strictObject(workflowFields(AuthoringFieldEntrySchema, AuthoringStageSchema))), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
+const AuthoringWorkflowSchema = pinned()(v__namespace.strictObject(workflowFields({
+    field: AuthoringFieldEntrySchema,
+    stage: AuthoringStageSchema,
+    start: AuthoringStartSchema
+}))), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
 
 function isStartableDefinition(definition) {
     return definition.lifecycle !== "child";
 }
 
+function startKindOf(definition) {
+    return definition.start?.kind ?? "interactive";
+}
+
+function isSubjectEntry(entry) {
+    return entry.required === !0 && (entry.type === "doc.ref" || entry.type === "doc.refs");
+}
+
+function isInputSourced(entry) {
+    return entry.initialValue?.type === "input";
+}
+
 function formatValidationError(label, issues) {
     const lines = issues.map(issue => `  - ${issue.path.length === 0 ? "(root)" : formatIssuePath(issue.path)}: ${issue.message}`);
     return `${label} failed validation (${issues.length} issue${issues.length === 1 ? "" : "s"}):\n${lines.join(`\n`)}`;
@@ -1329,12 +2004,6 @@ function checkActivities({def: def, i: i, activityNames: activityNames, issues:
 }
 
 function checkStatusSetTargets({activity: activity, activityNames: activityNames, path: path, issues: issues}) {
-    checkStatusSetOps({
-        ops: activity.ops,
-        activityNames: activityNames,
-        path: [ ...path, "ops" ],
-        issues: issues
-    });
     for (const [a, action] of (activity.actions ?? []).entries()) checkStatusSetOps({
         ops: action.ops,
         activityNames: activityNames,
@@ -1382,25 +2051,11 @@ function checkStageReachability({def: def, stageNames: stageNames, issues: issue
 
 function effectNameSites(def) {
     const sites = [];
-    for (const [i, stage] of def.stages.entries()) {
-        for (const [j, activity] of (stage.activities ?? []).entries()) {
-            collectEffects({
-                effects: activity.effects,
-                path: [ "stages", i, "activities", j, "effects" ],
-                sites: sites
-            });
-            for (const [a, action] of (activity.actions ?? []).entries()) collectEffects({
-                effects: action.effects,
-                path: [ "stages", i, "activities", j, "actions", a, "effects" ],
-                sites: sites
-            });
-        }
-        for (const [k, t] of (stage.transitions ?? []).entries()) collectEffects({
-            effects: t.effects,
-            path: [ "stages", i, "transitions", k, "effects" ],
-            sites: sites
-        });
-    }
+    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) collectEffects({
+        effects: action.effects,
+        path: [ "stages", i, "activities", j, "actions", a, "effects" ],
+        sites: sites
+    });
     return sites;
 }
 
@@ -1487,16 +2142,16 @@ function checkPredicates(def, issues) {
         path: [ "predicates", name ],
         message: `predicate "${name}" shadows the built-in $${name} — pick another name`
     });
-    for (const [name, groq] of Object.entries(def.predicates ?? {})) checkPredicateBody({
+    for (const [name, groq2] of Object.entries(def.predicates ?? {})) checkPredicateBody({
         name: name,
-        groq: groq,
+        groq: groq2,
         names: names,
         issues: issues
     });
 }
 
-function checkPredicateBody({name: name, groq: groq, names: names, issues: issues}) {
-    const reads = conditionParameterNames(groq);
+function checkPredicateBody({name: name, groq: groq2, names: names, issues: issues}) {
+    const reads = conditionParameterNames(groq2);
     for (const caller of CALLER_BOUND_VARS) reads.has(caller) && issues.push({
         path: [ "predicates", name ],
         message: `predicate "${name}" reads $${caller} — predicates are instance-level (pre-evaluated once, without a caller); compose caller gates at the condition site instead`
@@ -1522,11 +2177,11 @@ function checkUnboundCallerVars(def, issues) {
 }
 
 function unboundCallerVars(policy) {
-    return policy === "cascade" ? CALLER_BOUND_VARS : policy === "caller-bound" ? [ "params" ] : [ "can" ];
+    return policy === "cascade" ? CALLER_BOUND_VARS : policy === "caller-bound" ? [ "params" ] : policy === "triggered-payload" ? [ "can", "params" ] : [ "can" ];
 }
 
 function callerVarMessage(site, name) {
-    return site.policy === "cascade" ? `${site.label} reads $${name} — the cascade evaluates transition filters and activity gates (filter/completeWhen/failWhen) with no caller bound ($assigned is constant false, the other caller vars hold no value); gate on instance state (e.g. a field an action wrote) instead` : site.policy === "caller-bound" ? `${site.label} reads $${name} — $params (the firing action's args) is bound only while the action's effect bindings and where-op \`where\`s evaluate; this site never binds it, so the condition could never pass. Bind $params in an effect binding or a where-op instead, or gate on a field an action wrote` : `${site.label} reads $can — $can (the caller's grants) is bound only in the caller-bound projection (action filters, requirements, editable predicates) and never holds a value in cascade conditions; move the check to one of those sites or drop $can`;
+    return site.policy === "cascade" ? `${site.label} reads $${name} — cascade gates (transition \`when\`s, activity \`filter\`s, a cascade-fired action's \`when\`/\`filter\`) must resolve identically no matter whose token drives the cascade ($assigned is constant false, the other caller vars hold no value); gate on instance state (e.g. a field an action wrote), or pin executing identities with \`roles\`` : site.policy === "caller-bound" ? `${site.label} reads $${name} — $params (the firing action's args) is bound only while the action's effect bindings and where-op \`where\`s evaluate; this site never binds it, so the condition could never pass. Bind $params in an effect binding or a where-op instead, or gate on a field an action wrote` : site.policy === "triggered-payload" && name === "params" ? `${site.label} reads $params — a cascade-fired action has no caller to supply args, so $params never holds a value in its payload; read fields or effect outputs instead` : `${site.label} reads $can — $can (the caller's grants) is bound only in the caller-bound projection (action filters, requirements, editable predicates) and never holds a value in cascade conditions; move the check to one of those sites or drop $can`;
 }
 
 function conditionSites(def) {
@@ -1559,23 +2214,11 @@ function collectStageConditionSites({stage: stage, i: i, workflowLayer: workflow
         names: entryNames(activity.fields)
     })) ];
     for (const [k, t] of (stage.transitions ?? []).entries()) sites.push({
-        groq: t.filter,
-        path: [ "stages", i, "transitions", k, "filter" ],
-        label: `transition "${t.name}" filter`,
+        groq: t.when,
+        path: [ "stages", i, "transitions", k, "when" ],
+        label: `transition "${t.name}" when`,
         policy: "cascade",
         fields: stageFields2
-    }), collectBindingSites({
-        effects: t.effects,
-        path: [ "stages", i, "transitions", k, "effects" ],
-        label: `transition "${t.name}"`,
-        fields: stageFields2,
-        sites: sites
-    }), collectOpWhereSites({
-        ops: t.ops,
-        path: [ "stages", i, "transitions", k, "ops" ],
-        label: `transition "${t.name}"`,
-        fields: stageFields2,
-        sites: sites
     });
     collectEditableSites({
         entries: stage.fields,
@@ -1609,11 +2252,14 @@ function collectEditableSites({entries: entries, path: path, labelPrefix: labelP
     });
 }
 
-function collectOpWhereSites({ops: ops, path: path, label: label, fields: fields, sites: sites}) {
+function collectOpWhereSites({ops: ops, path: path, label: label, policy: policy, fields: fields, sites: sites}) {
     for (const [o, op] of (ops ?? []).entries()) op.where !== void 0 && sites.push({
         groq: op.where,
         path: [ ...path, o, "where" ],
         label: `${label} ${op.type} where`,
+        ...policy !== void 0 ? {
+            policy: policy
+        } : {},
         fields: fields
     });
 }
@@ -1623,36 +2269,21 @@ function collectActivityConditionSites({activity: activity, path: path, stageFie
         scope: "activity",
         names: entryNames(activity.fields)
     }, ...stageFields2 ];
-    for (const gate of [ "filter", "completeWhen", "failWhen" ]) {
-        const groq = activity[gate];
-        groq !== void 0 && sites.push({
-            groq: groq,
-            path: [ ...path, gate ],
-            label: `activity "${activity.name}".${gate}`,
-            policy: "cascade",
-            fields: fields
-        });
-    }
-    for (const [name, groq] of Object.entries(activity.requirements ?? {})) sites.push({
-        groq: groq,
+    activity.filter !== void 0 && sites.push({
+        groq: activity.filter,
+        path: [ ...path, "filter" ],
+        label: `activity "${activity.name}".filter`,
+        policy: "cascade",
+        fields: fields
+    });
+    for (const [name, groq2] of Object.entries(activity.requirements ?? {})) sites.push({
+        groq: groq2,
         path: [ ...path, "requirements", name ],
         label: `activity "${activity.name}" requirement "${name}"`,
         policy: "caller-bound",
         fields: fields
     });
-    collectBindingSites({
-        effects: activity.effects,
-        path: [ ...path, "effects" ],
-        label: `activity "${activity.name}"`,
-        fields: fields,
-        sites: sites
-    }), collectOpWhereSites({
-        ops: activity.ops,
-        path: [ ...path, "ops" ],
-        label: `activity "${activity.name}"`,
-        fields: fields,
-        sites: sites
-    }), collectEditableSites({
+    collectEditableSites({
         entries: activity.fields,
         path: [ ...path, "fields" ],
         labelPrefix: `activity "${activity.name}"`,
@@ -1663,59 +2294,77 @@ function collectActivityConditionSites({activity: activity, path: path, stageFie
         path: path,
         fields: fields,
         sites: sites
-    }), collectSubworkflowSites({
-        activity: activity,
-        path: path,
-        fields: fields,
-        sites: sites
     });
 }
 
 function collectActionConditionSites({activity: activity, path: path, fields: fields, sites: sites}) {
-    for (const [a, action] of (activity.actions ?? []).entries()) action.filter !== void 0 && sites.push({
-        groq: action.filter,
-        path: [ ...path, "actions", a, "filter" ],
-        label: `action "${action.name}" filter`,
-        policy: "caller-bound",
-        fields: fields
-    }), collectBindingSites({
-        effects: action.effects,
-        path: [ ...path, "actions", a, "effects" ],
-        label: `action "${action.name}"`,
-        fields: fields,
-        sites: sites
-    }), collectOpWhereSites({
-        ops: action.ops,
-        path: [ ...path, "actions", a, "ops" ],
-        label: `action "${action.name}"`,
-        fields: fields,
-        sites: sites
-    });
+    for (const [a, action] of (activity.actions ?? []).entries()) {
+        const actionPath = [ ...path, "actions", a ], cascadeFired = action.when !== void 0;
+        action.when !== void 0 && sites.push({
+            groq: action.when,
+            path: [ ...actionPath, "when" ],
+            label: `action "${action.name}" when`,
+            policy: "cascade",
+            fields: fields
+        }), action.filter !== void 0 && sites.push({
+            groq: action.filter,
+            path: [ ...actionPath, "filter" ],
+            label: `action "${action.name}" filter`,
+            policy: cascadeFired ? "cascade" : "caller-bound",
+            fields: fields
+        });
+        const payloadPolicy = cascadeFired ? "triggered-payload" : void 0;
+        collectBindingSites({
+            effects: action.effects,
+            path: [ ...actionPath, "effects" ],
+            label: `action "${action.name}"`,
+            policy: payloadPolicy,
+            fields: fields,
+            sites: sites
+        }), collectOpWhereSites({
+            ops: action.ops,
+            path: [ ...actionPath, "ops" ],
+            label: `action "${action.name}"`,
+            policy: payloadPolicy,
+            fields: fields,
+            sites: sites
+        }), collectSpawnSites({
+            action: action,
+            path: actionPath,
+            fields: fields,
+            sites: sites
+        });
+    }
 }
 
-function collectSubworkflowSites({activity: activity, path: path, fields: fields, sites: sites}) {
-    const sub = activity.subworkflows;
-    if (sub === void 0) return;
-    const subPath = [ ...path, "subworkflows" ];
+function collectSpawnSites({action: action, path: path, fields: fields, sites: sites}) {
+    const spawn = action.spawn;
+    if (spawn === void 0) return;
+    const spawnPath = [ ...path, "spawn" ];
     sites.push({
-        groq: sub.forEach,
-        path: [ ...subPath, "forEach" ],
-        label: `activity "${activity.name}".subworkflows.forEach`,
+        groq: spawn.forEach,
+        path: [ ...spawnPath, "forEach" ],
+        label: `action "${action.name}".spawn.forEach`,
+        policy: "cascade",
         fields: fields
     });
-    for (const [group, record] of [ [ "with", sub.with ], [ "context", sub.context ] ]) for (const [key, groq] of Object.entries(record ?? {})) sites.push({
-        groq: groq,
-        path: [ ...subPath, group, key ],
-        label: `activity "${activity.name}".subworkflows.${group} "${key}"`,
+    for (const [group, record] of [ [ "with", spawn.with ], [ "context", spawn.context ] ]) for (const [key, groq2] of Object.entries(record ?? {})) sites.push({
+        groq: groq2,
+        path: [ ...spawnPath, group, key ],
+        label: `action "${action.name}".spawn.${group} "${key}"`,
+        policy: "triggered-payload",
         fields: fields
     });
 }
 
-function collectBindingSites({effects: effects, path: path, label: label, fields: fields, sites: sites}) {
-    for (const [e, effect] of (effects ?? []).entries()) for (const [key, groq] of Object.entries(effect.bindings ?? {})) sites.push({
-        groq: groq,
+function collectBindingSites({effects: effects, path: path, label: label, policy: policy, fields: fields, sites: sites}) {
+    for (const [e, effect] of (effects ?? []).entries()) for (const [key, groq2] of Object.entries(effect.bindings ?? {})) sites.push({
+        groq: groq2,
         path: [ ...path, e, "bindings", key ],
         label: `${label} effect "${effect.name}" binding "${key}"`,
+        ...policy !== void 0 ? {
+            policy: policy
+        } : {},
         fields: fields
     });
 }
@@ -1727,36 +2376,76 @@ function checkAssigneesEntries(def, issues) {
     });
 }
 
-function activityShape(activity) {
-    return {
-        hasActions: (activity.actions ?? []).length > 0,
-        hasEffects: (activity.effects ?? []).length > 0,
-        hasCompleteWhen: activity.completeWhen !== void 0,
-        hasSubworkflows: activity.subworkflows !== void 0
-    };
+function checkActivityTerminalPaths(def, issues) {
+    for (const [i, stage] of def.stages.entries()) {
+        const resolvable = terminallyResolvableActivities(stage);
+        for (const [j, activity] of (stage.activities ?? []).entries()) resolvable.has(activity.name) || issues.push({
+            path: [ "stages", i, "activities", j ],
+            message: `activity "${activity.name}" has no path to a terminal status — no action in stage "${stage.name}" resolves it (\`status: 'done'\` on one of its actions, a \`{when: <condition>, status: 'done'}\` trigger, or a sibling's \`status.set\`), so it can never finish and the stage's \`$allActivitiesDone\` gate would wedge`
+        });
+    }
 }
 
-const KIND_SHAPE_RULES = {
-    user: s => s.hasActions ? [] : [ "needs at least one action for a person to fire" ],
-    service: s => s.hasEffects ? [] : [ "needs at least one effect — the automated work it performs" ],
-    manual: s => [ s.hasActions || s.hasCompleteWhen ? void 0 : "needs a way to complete — an action to acknowledge it, or a `completeWhen` predicate to verify it (otherwise it auto-resolves on activation)", s.hasSubworkflows ? "is off-system work, not a fan-out — drop `subworkflows` or move it to its own activity" : void 0 ].filter(m => m !== void 0),
-    receive: s => [ s.hasCompleteWhen || s.hasSubworkflows ? void 0 : "needs a `completeWhen` (or `subworkflows`) condition to wait on", s.hasActions ? "has no actor, so it cannot carry actions" : void 0 ].filter(m => m !== void 0),
-    script: s => [ s.hasActions ? "runs inline with no actor, so it cannot carry actions" : void 0, s.hasCompleteWhen ? "resolves on activation, so it cannot carry a `completeWhen` (that is a `receive`/`service` wait)" : void 0, s.hasSubworkflows ? "resolves on activation, so it cannot fan out with `subworkflows`" : void 0 ].filter(m => m !== void 0)
-};
+function terminallyResolvableActivities(stage) {
+    const terminalSets = (stage.activities ?? []).flatMap(activity => activity.actions ?? []).flatMap(action => action.ops ?? []).filter(op => op.type === "status.set").filter(op => TERMINAL_ACTIVITY_STATUSES.includes(op.status));
+    return new Set(terminalSets.map(op => op.activity));
+}
 
-function checkActivityKinds(def, issues) {
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) {
-        const path = [ "stages", i, "activities", j ];
-        if (activity.target !== void 0 && activity.kind !== "manual" && issues.push({
-            path: [ ...path, "target" ],
-            message: `activity "${activity.name}" has a \`target\` but is not \`kind: "manual"\` — a target is the deep-link for off-system manual work`
-        }), activity.kind !== void 0) for (const fault of KIND_SHAPE_RULES[activity.kind](activityShape(activity))) issues.push({
-            path: [ ...path, "kind" ],
-            message: `activity "${activity.name}" declares kind "${activity.kind}" but ${fault}`
+function checkTerminalStageActivities(def, issues) {
+    for (const [i, stage] of def.stages.entries()) (stage.transitions ?? []).length > 0 || (stage.activities ?? []).length === 0 || issues.push({
+        path: [ "stages", i, "activities" ],
+        message: `stage "${stage.name}" is terminal (no transitions) but declares activities — entering a terminal stage completes the instance, so they can never run. Move the work to a \`when\` action in the source stage (it commits in the hop that moves here), or give the stage a transition out`
+    });
+}
+
+function storedRolesIssue(action) {
+    if (action.roles !== void 0) {
+        if (action.roles.length === 0) return `action "${action.name}" stores \`roles: []\`, which names no roles — the runtime reads an empty pin as "anyone may execute", the opposite of a pin. Omit \`roles\` to allow any identity, or list at least one role`;
+        if (action.when === void 0) return `action "${action.name}" stores \`roles\` but is fireAction-fired (no \`when\`) — the stored pin is only read on cascade fires. Author \`roles\` normally (it desugars into the action's \`filter\`), or add \`when\` to make it a trigger`;
+    }
+}
+
+function checkStoredRolesPlacement(def, issues) {
+    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) {
+        const message = storedRolesIssue(action);
+        message !== void 0 && issues.push({
+            path: [ "stages", i, "activities", j, "actions", a, "roles" ],
+            message: message
         });
     }
 }
 
+function checkTriggeredActionParams(def, issues) {
+    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) action.when === void 0 || (action.params ?? []).length === 0 || issues.push({
+        path: [ "stages", i, "activities", j, "actions", a, "params" ],
+        message: `action "${action.name}" declares params but is cascade-fired (\`when\`) — no caller ever supplies args to a trigger. Drop the params, or drop \`when\` to make it a fireAction-fired action`
+    });
+}
+
+function checkStart(def, issues) {
+    if (def.start !== void 0 && (def.lifecycle === "child" && issues.push({
+        path: [ "start" ],
+        message: "a spawn-only (lifecycle 'child') definition declares `start` — children are instantiated by a parent's `spawn`, never started standalone, so the block would never apply. Remove `start`, or drop `lifecycle: 'child'`"
+    }), checkStartFilterReads(def, issues), def.start.kind === "autonomous")) for (const [n, entry] of (def.fields ?? []).entries()) entry.required !== !0 || isSubjectEntry(entry) || issues.push({
+        path: [ "fields", n, "required" ],
+        message: `start.kind 'autonomous' means runs are initiated by a system reacting to a document, so every required input must be derivable from that triggering document — required entry "${entry.name}" (kind "${entry.type}") is not a document reference. Make it optional, seed it another way (query/literal), or declare it doc.ref / doc.refs`
+    });
+}
+
+function checkStartFilterReads(def, issues) {
+    const filter = def.start?.filter;
+    if (filter === void 0) return;
+    const bindable = new Set((def.fields ?? []).filter(isInputSourced).map(entry => entry.name)), declared = new Set((def.fields ?? []).map(entry => entry.name));
+    for (const name of conditionFieldReadNames(filter)) bindable.has(name) || issues.push({
+        path: [ "start", "filter" ],
+        message: declared.has(name) ? `start.filter reads $fields.${name}, but "${name}" is not an \`input\`-sourced entry — $fields binds only the caller's input entries (query/literal/fieldRead entries resolve at materialisation, after any read-side evaluation), so the read is GROQ null and the filter silently never passes. Bindable (input) fields: ${knownList(bindable)}` : `start.filter reads $fields.${name}, but no workflow-scope field entry named "${name}" is declared — $fields binds only the caller's input entries, so the read is GROQ null and the filter silently never passes. Bindable (input) fields: ${knownList(bindable)}`
+    });
+    readsRootDocument(filter) && !(def.fields ?? []).some(isSubjectEntry) && issues.push({
+        path: [ "start", "filter" ],
+        message: "start.filter reads the candidate document (its root), but the definition declares no required subject entry (a required doc.ref / doc.refs input) — a read surface would never have a document to bind as root, so the filter could never pass. Declare a required subject entry, or gate on $fields / the dataset instead"
+    });
+}
+
 function checkGroups(def, issues) {
     const workflowGroups = checkGroupDeclarations({
         groups: def.groups,
@@ -1873,7 +2562,7 @@ function checkConditionFieldReads(def, issues) {
         path: site.path,
         message: undeclaredFieldReadMessage(site, name)
     });
-    for (const [name, groq] of Object.entries(def.predicates ?? {})) for (const read of conditionFieldReadNames(groq)) everywhere.has(read) || issues.push({
+    for (const [name, groq2] of Object.entries(def.predicates ?? {})) for (const read of conditionFieldReadNames(groq2)) everywhere.has(read) || issues.push({
         path: [ "predicates", name ],
         message: noFieldAnywhereMessage(`predicate "${name}"`, read)
     });
@@ -1977,38 +2666,29 @@ function seedEarlierSiblingTarget(args) {
     });
 }
 
+function opSites(def) {
+    const sites = [];
+    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) sites.push({
+        ops: action.ops,
+        path: [ "stages", i, "activities", j, "actions", a, "ops" ],
+        label: `action "${action.name}"`,
+        stage: stage,
+        activity: activity
+    });
+    return sites;
+}
+
 function checkFieldReadOpValues(def, issues) {
     const workflowEntries = def.fields ?? [];
-    for (const [i, stage] of def.stages.entries()) {
-        const shared = {
-            workflowEntries: workflowEntries,
-            stageEntries: stage.fields ?? [],
-            issues: issues
-        };
-        for (const [k, t] of (stage.transitions ?? []).entries()) checkOpsFieldReads({
-            ...shared,
-            ops: t.ops,
-            path: [ "stages", i, "transitions", k, "ops" ],
-            label: `transition "${t.name}"`
-        });
-        for (const [j, activity] of (stage.activities ?? []).entries()) {
-            const activityNames = entryNames(activity.fields), activityPath = [ "stages", i, "activities", j ];
-            checkOpsFieldReads({
-                ...shared,
-                ops: activity.ops,
-                path: [ ...activityPath, "ops" ],
-                label: `activity "${activity.name}"`,
-                activityNames: activityNames
-            });
-            for (const [a, action] of (activity.actions ?? []).entries()) checkOpsFieldReads({
-                ...shared,
-                ops: action.ops,
-                path: [ ...activityPath, "actions", a, "ops" ],
-                label: `action "${action.name}"`,
-                activityNames: activityNames
-            });
-        }
-    }
+    for (const site of opSites(def)) checkOpsFieldReads({
+        workflowEntries: workflowEntries,
+        stageEntries: site.stage.fields ?? [],
+        issues: issues,
+        ops: site.ops,
+        path: site.path,
+        label: site.label,
+        activityNames: entryNames(site.activity.fields)
+    });
 }
 
 function checkOpsFieldReads({ops: ops, path: path, label: label, ...ctx}) {
@@ -2061,6 +2741,49 @@ function opFieldReadMissMessage({read: read, where: where, hosts: hosts, activit
     return `${where} reads field "${read.field}", which is not declared at ${searched} — the read resolves to undefined at op time, so the write silently lands empty.${activityHint} Known: ${known.join(", ") || "(none)"}`;
 }
 
+function checkUpdateWhereOps(def, issues) {
+    const workflow = def.fields ?? [];
+    for (const site of opSites(def)) for (const [o, op] of (site.ops ?? []).entries()) {
+        if (op.type !== "field.updateWhere") continue;
+        const scopes = {
+            workflow: workflow,
+            stage: site.stage.fields ?? [],
+            activity: site.activity.fields ?? []
+        };
+        checkUpdateWhereTargetKind({
+            op: op,
+            path: [ ...site.path, o ],
+            label: site.label,
+            scopes: scopes,
+            issues: issues
+        }), checkUpdateWhereMergeKeys({
+            op: op,
+            path: [ ...site.path, o ],
+            label: site.label,
+            issues: issues
+        });
+    }
+}
+
+function checkUpdateWhereTargetKind({op: op, path: path, label: label, scopes: scopes, issues: issues}) {
+    const target = scopes[op.target.scope]?.find(entry => entry.name === op.target.field);
+    target === void 0 || target.type === "array" || issues.push({
+        path: [ ...path, "target" ],
+        message: `${label} field.updateWhere targets ${op.target.scope}-scope "${op.target.field}" (${target.type}) — updateWhere merges declared row sub-fields, so its target must be an \`array\` entry${rowOpsHint(target.type)}`
+    });
+}
+
+function rowOpsHint(type) {
+    return type === "doc.refs" || type === "assignees" ? `; to add or drop ${type} rows use field.append / field.removeWhere` : "";
+}
+
+function checkUpdateWhereMergeKeys({op: op, path: path, label: label, issues: issues}) {
+    if (op.value.type === "object") for (const key of Object.keys(op.value.fields)) key !== "_key" && key !== "_type" || issues.push({
+        path: [ ...path, "value", "fields", key ],
+        message: `${label} field.updateWhere merge writes the reserved row key "${key}" — row identity and bookkeeping are engine-stamped, and a merge would restamp every matched row with the same literal`
+    });
+}
+
 function checkGuardFieldReads(def, issues) {
     const reads = {
         workflowEntries: def.fields ?? [],
@@ -2258,9 +2981,11 @@ function checkWorkflowInvariants(def) {
         stageNames: stageNames,
         issues: issues
     }), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), 
-    checkRequiredField(def, issues), checkPredicates(def, issues), checkUnboundCallerVars(def, issues), 
-    checkConditionFieldReads(def, issues), checkFieldReadSeeds(def, issues), checkFieldReadOpValues(def, issues), 
-    checkGuardFieldReads(def, issues), checkAssigneesEntries(def, issues), checkActivityKinds(def, issues), 
+    checkRequiredField(def, issues), checkStart(def, issues), checkPredicates(def, issues), 
+    checkUnboundCallerVars(def, issues), checkConditionFieldReads(def, issues), checkFieldReadSeeds(def, issues), 
+    checkFieldReadOpValues(def, issues), checkUpdateWhereOps(def, issues), checkGuardFieldReads(def, issues), 
+    checkAssigneesEntries(def, issues), checkActivityTerminalPaths(def, issues), checkTerminalStageActivities(def, issues), 
+    checkTriggeredActionParams(def, issues), checkStoredRolesPlacement(def, issues), 
     checkGroups(def, issues), issues;
 }
 
@@ -2290,6 +3015,8 @@ exports.CONDITION_VARS = CONDITION_VARS;
 
 exports.ContractViolationError = ContractViolationError;
 
+exports.DEFAULT_TRANSITION_WHEN = DEFAULT_TRANSITION_WHEN;
+
 exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
 
 exports.DRIVER_KINDS = DRIVER_KINDS;
@@ -2300,6 +3027,8 @@ exports.DefinitionNotFoundError = DefinitionNotFoundError;
 
 exports.EFFECTS_READ = EFFECTS_READ;
 
+exports.EXECUTOR_CLASSIFICATIONS = EXECUTOR_CLASSIFICATIONS;
+
 exports.EffectNotFoundError = EffectNotFoundError;
 
 exports.EffectSchema = EffectSchema;
@@ -2322,6 +3051,8 @@ exports.RESERVED_CONDITION_VARS = RESERVED_CONDITION_VARS;
 
 exports.RESOURCE_ALIAS_NAME_SOURCE = RESOURCE_ALIAS_NAME_SOURCE;
 
+exports.START_FILTER_VARS = START_FILTER_VARS;
+
 exports.StoredFieldOpSchema = StoredFieldOpSchema;
 
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
@@ -2342,6 +3073,8 @@ exports.clientConfigFromResource = clientConfigFromResource;
 
 exports.conditionEffectReads = conditionEffectReads;
 
+exports.conditionFieldReadNames = conditionFieldReadNames;
+
 exports.conditionParameterNames = conditionParameterNames;
 
 exports.conditionSyntaxIssues = conditionSyntaxIssues;
@@ -2350,6 +3083,14 @@ exports.datasetResourceParts = datasetResourceParts;
 
 exports.definitionDocId = definitionDocId;
 
+exports.deriveActivityKind = deriveActivityKind;
+
+exports.deriveExecutorClassification = deriveExecutorClassification;
+
+exports.desugarWorkflow = desugarWorkflow;
+
+exports.driverKind = driverKind;
+
 exports.errorMessage = errorMessage;
 
 exports.evaluateCondition = evaluateCondition;
@@ -2358,8 +3099,6 @@ exports.evaluateConditionOutcome = evaluateConditionOutcome;
 
 exports.evaluatePredicates = evaluatePredicates;
 
-exports.expandRequiredRoles = expandRequiredRoles;
-
 exports.extractDocumentId = extractDocumentId;
 
 exports.formatIssuePath = formatIssuePath;
@@ -2376,20 +3115,28 @@ exports.gdrResourcePrefix = gdrResourcePrefix;
 
 exports.gdrUri = gdrUri;
 
+exports.groq = groq;
+
 exports.groupMembershipNames = groupMembershipNames;
 
 exports.isBareSeedId = isBareSeedId;
 
+exports.isCascadeFired = isCascadeFired;
+
 exports.isGdr = isGdr;
 
 exports.isGdrUri = isGdrUri;
 
 exports.isGuardReadExpr = isGuardReadExpr;
 
+exports.isInputSourced = isInputSourced;
+
 exports.isNotesEntry = isNotesEntry;
 
 exports.isStartableDefinition = isStartableDefinition;
 
+exports.isSubjectEntry = isSubjectEntry;
+
 exports.isTerminalActivityStatus = isTerminalActivityStatus;
 
 exports.isTodoListEntry = isTodoListEntry;
@@ -2400,8 +3147,6 @@ exports.isUnevaluable = isUnevaluable;
 
 exports.labelFor = labelFor;
 
-exports.normalizeRoleAliases = normalizeRoleAliases;
-
 exports.parseGdr = parseGdr;
 
 exports.parseOrThrow = parseOrThrow;
@@ -2410,7 +3155,7 @@ exports.parseResourceGdr = parseResourceGdr;
 
 exports.parseStoredDefinition = parseStoredDefinition;
 
-exports.printGuardRead = printGuardRead;
+exports.readsRootDocument = readsRootDocument;
 
 exports.refCanvas = refCanvas;
 
@@ -2444,6 +3189,8 @@ exports.sameResource = sameResource;
 
 exports.selfGdr = selfGdr;
 
+exports.startKindOf = startKindOf;
+
 exports.tagScopeFilter = tagScopeFilter;
 
 exports.toBareId = toBareId;