@sanity/workflow-engine 0.15.0 → 0.16.0

package/dist/index.cjs

@@ -24,20 +24,8 @@ function _interopNamespaceCompat(e) {
 
 var v__namespace = /* @__PURE__ */ _interopNamespaceCompat(v);
 
-function hasItems(arr) {
-    return arr !== void 0 && arr.length > 0;
-}
-
-function deriveActivityKind(activity) {
-    return hasItems(activity.actions) ? "user" : hasItems(activity.effects) ? "service" : activity.completeWhen !== void 0 || activity.subworkflows !== void 0 ? "receive" : "script";
-}
-
-function activityKind(activity) {
-    return activity.kind ?? deriveActivityKind(activity);
-}
-
-function driverKind(actor) {
-    return actor.kind === "person" || actor.kind === "agent" ? actor.kind : "service";
+function isFilterScopedOut(entry) {
+    return entry.status === "skipped" && entry.startedAt === void 0;
 }
 
 function liveSubworkflows(host) {
@@ -302,7 +290,7 @@ const HIGH_FREQUENCY_SAMPLE_MS = 6e4, WorkflowDefinitionDeployed = defineWorkflo
 });
 
 function definitionDeployedData(definition, outcome) {
-    const stages = definition.stages, activities = stages.flatMap(stage => stage.activities ?? []), actions = activities.flatMap(activity => activity.actions ?? []), transitions = stages.flatMap(stage => stage.transitions ?? []), fieldEntries2 = [ ...definition.fields ?? [], ...stages.flatMap(stage => stage.fields ?? []), ...activities.flatMap(activity => activity.fields ?? []) ], effectCarriers = [ ...activities, ...actions, ...transitions ];
+    const stages = definition.stages, activities = stages.flatMap(stage => stage.activities ?? []), actions = activities.flatMap(activity => activity.actions ?? []), transitions = stages.flatMap(stage => stage.transitions ?? []), fieldEntries2 = [ ...definition.fields ?? [], ...stages.flatMap(stage => stage.fields ?? []), ...activities.flatMap(activity => activity.fields ?? []) ];
     return {
         contentHash: outcome.contentHash,
         status: outcome.status,
@@ -312,11 +300,11 @@ function definitionDeployedData(definition, outcome) {
         actionCount: actions.length,
         transitionCount: transitions.length,
         fieldCount: fieldEntries2.length,
-        activityKinds: [ ...new Set(activities.map(activityKind)) ].sort(),
+        activityKinds: [ ...new Set(activities.map(invariants.deriveActivityKind)) ].sort(),
         fieldKinds: [ ...new Set(fieldEntries2.map(entry => entry.type)) ].sort(),
         guardCount: stages.reduce((n, stage) => n + (stage.guards ?? []).length, 0),
-        effectCount: effectCarriers.reduce((n, node) => n + (node.effects ?? []).length, 0),
-        subworkflowCount: activities.filter(activity => activity.subworkflows !== void 0).length,
+        effectCount: actions.reduce((n, action) => n + (action.effects ?? []).length, 0),
+        subworkflowCount: actions.filter(action => action.spawn !== void 0).length,
         lifecycle: definition.lifecycle ?? "standalone"
     };
 }
@@ -363,7 +351,7 @@ function openStage$1(instance) {
 
 function firedActivityKind(instance, activity) {
     const node = openStage$1(instance).stage?.activities?.find(a => a.name === activity);
-    return node === void 0 ? void 0 : activityKind(node);
+    return node === void 0 ? void 0 : invariants.deriveActivityKind(node);
 }
 
 function editedFieldKind(instance, target) {
@@ -401,20 +389,11 @@ function fieldEditedData(args) {
 }
 
 function effectSites(def) {
-    const sites = [], collect = (effects, location) => {
-        for (const effect of effects ?? []) sites.push({
-            effect: effect,
-            location: location
-        });
-    };
-    for (const stage of def.stages ?? []) {
-        for (const activity of stage.activities ?? []) {
-            const at = `stage[${stage.name}].activity[${activity.name}]`;
-            collect(activity.effects, `${at}.effects`);
-            for (const action of activity.actions ?? []) collect(action.effects, `${at}.action[${action.name}].effects`);
-        }
-        for (const transition of stage.transitions ?? []) collect(transition.effects, `stage[${stage.name}].transition[${transition.name}].effects`);
-    }
+    const sites = [];
+    for (const stage of def.stages ?? []) for (const activity of stage.activities ?? []) for (const action of activity.actions ?? []) for (const effect of action.effects ?? []) sites.push({
+        effect: effect,
+        location: `stage[${stage.name}].activity[${activity.name}].action[${action.name}].effects`
+    });
     return sites;
 }
 
@@ -640,25 +619,15 @@ function describeSiteHeading(address, ctx) {
             });
         }
 
-      case "complete-when":
-        {
-            const activity = activityTitle(address.activity, ctx);
-            return groqConditionDescribe.phrase(id, {
-                params: {
-                    activity: activity
-                },
-                text: `${groqConditionDescribe.quoted(activity)} completes automatically when:`
-            });
-        }
-
-      case "fail-when":
+      case "action-when":
         {
-            const activity = activityTitle(address.activity, ctx);
+            const title = actionTitle(address, ctx), activity = activityTitle(address.activity, ctx);
             return groqConditionDescribe.phrase(id, {
                 params: {
+                    title: title,
                     activity: activity
                 },
-                text: `${groqConditionDescribe.quoted(activity)} fails automatically when:`
+                text: `action ${groqConditionDescribe.quoted(title)} on ${groqConditionDescribe.quoted(activity)} fires automatically when:`
             });
         }
 
@@ -728,20 +697,26 @@ function describeSite(site, ctx) {
             });
         }
 
+      case "action-when":
+        {
+            const title = actionTitle(site, ctx), activity = activityTitle(site.activity, ctx);
+            return groqConditionDescribe.phrase(id, {
+                params: {
+                    title: title,
+                    activity: activity
+                },
+                text: `the ${groqConditionDescribe.quoted(title)} trigger on ${groqConditionDescribe.quoted(activity)}`
+            });
+        }
+
       case "activity-filter":
-      case "complete-when":
-      case "fail-when":
         {
-            const activity = activityTitle(site.activity, ctx), verb = {
-                "activity-filter": "visibility of",
-                "complete-when": "auto-completion of",
-                "fail-when": "auto-failure of"
-            }[site.kind];
+            const activity = activityTitle(site.activity, ctx);
             return groqConditionDescribe.phrase(id, {
                 params: {
                     activity: activity
                 },
-                text: `${verb} ${groqConditionDescribe.quoted(activity)}`
+                text: `existence of ${groqConditionDescribe.quoted(activity)}`
             });
         }
 
@@ -790,7 +765,7 @@ function unsatisfiedTransitionSummaries(evaluation) {
     const ctx = {
         definition: evaluation.definition
     };
-    return evaluation.currentStage.transitions.filter(t => !t.filterSatisfied).flatMap(t => {
+    return evaluation.currentStage.transitions.filter(t => !t.whenSatisfied).flatMap(t => {
         const summary = describeCondition(t.insight, ctx).summary;
         return summary !== void 0 ? [ {
             transition: t.transition.name,
@@ -804,7 +779,12 @@ function describeNode(node, ctx) {
 }
 
 function dispatchDescribe(node, ctx) {
-    return "involvedIn" in node ? describeFieldInsight(node, ctx) : "actions" in node ? describeActivity(node, ctx) : "transition" in node ? describeCondition(node.insight, ctx) : "analysis" in node ? describeCondition(node, ctx) : node.insight !== void 0 ? describeCondition(node.insight, ctx) : void 0;
+    if ("involvedIn" in node) return describeFieldInsight(node, ctx);
+    if ("actions" in node) return describeActivity(node, ctx);
+    if ("transition" in node) return describeCondition(node.insight, ctx);
+    if ("analysis" in node) return describeCondition(node, ctx);
+    const gate = "whenInsight" in node ? node.whenInsight ?? node.insight : node.insight;
+    return gate !== void 0 ? describeCondition(gate, ctx) : void 0;
 }
 
 function describeActivity(node, ctx) {
@@ -815,12 +795,6 @@ function describeActivity(node, ctx) {
         } : {},
         ...node.filterInsight !== void 0 ? {
             filter: describeCondition(node.filterInsight, ctx)
-        } : {},
-        ...node.completeWhenInsight !== void 0 ? {
-            completeWhen: describeCondition(node.completeWhenInsight, ctx)
-        } : {},
-        ...node.failWhenInsight !== void 0 ? {
-            failWhen: describeCondition(node.failWhenInsight, ctx)
         } : {}
     };
 }
@@ -867,7 +841,7 @@ function stageSites(stage, definition) {
             kind: "transition",
             transition: transition.name
         },
-        condition: transition.filter
+        condition: transition.when
     });
     for (const activity of stage.activities ?? []) sites.push(...activitySites(activity, stage.name));
     for (const site of editableFieldsInStage(definition, stage)) typeof site.effective == "string" && sites.push({
@@ -894,15 +868,14 @@ function stageSites(stage, definition) {
 }
 
 function activitySites(activity, stage) {
-    const named = (kind, condition) => condition !== void 0 ? [ {
+    return [ ...activity.filter !== void 0 ? [ {
         stage: stage,
         address: {
-            kind: kind,
+            kind: "activity-filter",
             activity: activity.name
         },
-        condition: condition
-    } ] : [];
-    return [ ...named("activity-filter", activity.filter), ...Object.entries(activity.requirements ?? {}).map(([requirement, condition]) => ({
+        condition: activity.filter
+    } ] : [], ...Object.entries(activity.requirements ?? {}).map(([requirement, condition]) => ({
         stage: stage,
         address: {
             kind: "requirement",
@@ -910,7 +883,7 @@ function activitySites(activity, stage) {
             requirement: requirement
         },
         condition: condition
-    })), ...named("complete-when", activity.completeWhen), ...named("fail-when", activity.failWhen), ...(activity.actions ?? []).flatMap(action => action.filter !== void 0 ? [ {
+    })), ...(activity.actions ?? []).flatMap(action => [ ...action.filter !== void 0 ? [ {
         stage: stage,
         address: {
             kind: "action",
@@ -918,7 +891,15 @@ function activitySites(activity, stage) {
             action: action.name
         },
         condition: action.filter
-    } ] : []) ];
+    } ] : [], ...action.when !== void 0 ? [ {
+        stage: stage,
+        address: {
+            kind: "action-when",
+            activity: activity.name,
+            action: action.name
+        },
+        condition: action.when
+    } ] : [] ]) ];
 }
 
 async function describeDefinition(definition) {
@@ -940,58 +921,111 @@ async function describeDefinition(definition) {
 }
 
 function acceptsDocumentType(definition, documentType) {
-    return (definition.fields ?? []).some(entry => entry.required === !0 && (entry.type === "doc.ref" || entry.type === "doc.refs") && (entry.types === void 0 || entry.types.includes(documentType)));
+    return (definition.fields ?? []).some(entry => invariants.isSubjectEntry(entry) && (entry.types === void 0 || entry.types.includes(documentType)));
 }
 
 async function isDefinitionApplicable(args) {
-    const {definition: definition, document: document} = args;
-    return assertCandidateDocument(document), !invariants.isStartableDefinition(definition) || !acceptsDocumentType(definition, document._type) ? !1 : evaluateApplicableWhen(definition, document);
+    const {definition: definition, document: document, scope: scope} = args;
+    return assertCandidateDocument(document), !invariants.isStartableDefinition(definition) || !acceptsDocumentType(definition, document._type) ? !1 : evaluateDeclaredStartFilter({
+        definition: definition,
+        document: document,
+        scope: scope
+    });
 }
 
 async function applicableDefinitions(args) {
-    const {definitions: definitions, document: document} = args;
+    const {definitions: definitions, document: document, scope: scope} = args;
     assertCandidateDocument(document);
     const verdicts = await Promise.all(definitions.map(definition => isDefinitionApplicable({
         definition: definition,
-        document: document
+        document: document,
+        ...scope !== void 0 ? {
+            scope: scope
+        } : {}
     })));
     return definitions.filter((_, i) => verdicts[i]);
 }
 
-async function evaluateApplicableWhen(definition, document) {
-    const groq = definition.applicableWhen;
-    if (groq === void 0) return !0;
+async function evaluateStartFilter(args) {
+    const {filter: filter, definition: definition, document: document, scope: scope} = args;
+    let parsed;
+    try {
+        parsed = {
+            tree: groqJs.parse(filter),
+            needsDataset: groqConditionDescribe.analyzeCondition(filter).readsDataset
+        };
+    } catch (err) {
+        rethrowNamingDefinition(err, definition);
+    }
+    let dataset = [];
+    if (parsed.needsDataset) {
+        if (scope?.fetchDataset === void 0) return !1;
+        dataset = await scope.fetchDataset();
+    }
     try {
-        const tree = groqJs.parse(groq), result = await (await groqJs.evaluate(tree, {
-            root: document,
-            dataset: [ document ]
+        const result = await (await groqJs.evaluate(parsed.tree, {
+            ...document !== void 0 ? {
+                root: document
+            } : {},
+            dataset: dataset,
+            params: startFilterParams({
+                definition: definition,
+                scope: scope
+            })
         })).get();
         return invariants.isUnevaluable(result) ? !1 : !!result;
     } catch (err) {
-        invariants.rethrowWithContext(err, `applicableWhen on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (deploy validation rejects this — was the definition written around it?)`);
+        rethrowNamingDefinition(err, definition);
     }
 }
 
+function rethrowNamingDefinition(err, definition) {
+    invariants.rethrowWithContext(err, `start.filter on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (deploy validation rejects this — was the definition written around it?)`);
+}
+
+function startFilterParams({definition: definition, scope: scope}) {
+    return {
+        ...definition.name !== void 0 ? {
+            definition: definition.name
+        } : {},
+        ...scope?.tag !== void 0 ? {
+            tag: scope.tag
+        } : {},
+        ...scope?.now !== void 0 ? {
+            now: scope.now
+        } : {},
+        ...scope?.fields !== void 0 ? {
+            fields: scope.fields
+        } : {}
+    };
+}
+
+async function evaluateDeclaredStartFilter(args) {
+    const {definition: definition, document: document, scope: scope} = args, filter = definition.start?.filter;
+    return filter === void 0 ? !0 : evaluateStartFilter({
+        filter: filter,
+        definition: definition,
+        document: document,
+        ...scope !== void 0 ? {
+            scope: scope
+        } : {}
+    });
+}
+
 function assertCandidateDocument(document) {
     const docType = document._type;
     if (typeof docType != "string" || docType.length === 0) throw new invariants.ContractViolationError("Applicability: the candidate document must carry a non-empty `_type` — pass the loaded document, not a reference or bare id.");
 }
 
-function applicabilitySyntaxIssues(groq) {
-    let tree;
+const START_FILTER_VAR_NAMES = new Set(invariants.START_FILTER_VARS.map(v2 => v2.name));
+
+function startFilterSyntaxIssues(groq) {
     try {
-        tree = groqJs.parse(groq);
+        groqJs.parse(groq);
     } catch (err) {
         return [ err instanceof Error ? err.message : String(err) ];
     }
-    const issues = [];
-    hasEverythingNode(tree) && issues.push("scans the dataset with `*` — `applicableWhen` evaluates against the candidate document alone (there is no lake in this context), so a scan reads a phantom dataset and silently misleads. Read the document's own attributes instead (e.g. `_type == 'article' && articleType == 'finance'`)");
-    for (const name of invariants.conditionParameterNames(groq)) issues.push(`reads $${name} — \`applicableWhen\` evaluates against the candidate document alone; no \`$\` vars are bound (an unbound variable is GROQ null, so the predicate would silently never match)`);
-    return issues;
-}
-
-function hasEverythingNode(node) {
-    return Array.isArray(node) ? node.some(hasEverythingNode) : typeof node != "object" || node === null ? !1 : node.type === "Everything" ? !0 : Object.values(node).some(hasEverythingNode);
+    return [ ...invariants.conditionParameterNames(groq) ].filter(name => !START_FILTER_VAR_NAMES.has(name)).map(name => `reads $${name}, which the start-filter context does not bind (an unbound variable is GROQ null, so the predicate would silently never match). Bound here: ` + invariants.START_FILTER_VARS.map(v2 => `$${v2.name}`).join(", "));
 }
 
 function getPath(value, path) {
@@ -1069,10 +1103,25 @@ function rewriteRefsRecursive(value, resource) {
     return mapJsonStrings(value, (str, key) => key === "_ref" && !str.includes(":") ? invariants.gdrFromResource(resource, str) : str);
 }
 
+function overlayInstanceInSnapshot(snapshot, instance) {
+    const uri = invariants.selfGdr(instance), restamped = {
+        ...instance,
+        _id: uri
+    };
+    return snapshot.knownIds.has(uri) ? {
+        docs: snapshot.docs.map(doc => doc._id === uri ? restamped : doc),
+        knownIds: snapshot.knownIds
+    } : {
+        docs: [ ...snapshot.docs, restamped ],
+        knownIds: /* @__PURE__ */ new Set([ ...snapshot.knownIds, uri ])
+    };
+}
+
 function resolveFieldRead(args) {
-    const {kind: kind, value: value, path: path, snapshot: snapshot} = args;
+    const {kind: kind, value: value, path: path, snapshot: snapshot, targetKind: targetKind} = args;
     if (kind === "doc.ref") {
         if (!invariants.isGdr(value)) return null;
+        if (path === void 0 && targetKind === "doc.ref") return value;
         const base = derefBase(value, snapshot);
         return path === void 0 ? base : walkDocPath(base, path);
     }
@@ -1095,7 +1144,8 @@ function buildParams(args) {
         ancestors: instance.ancestors.map(a => a.id),
         stage: instance.currentStage,
         now: now,
-        effects: effectsContextMap(instance),
+        context: contextMap(instance),
+        effects: effectOutputsMap(instance),
         effectStatus: effectStatusMap(instance),
         activities: currentActivities2,
         subworkflows: subworkflowVarRows(instance, snapshot),
@@ -1110,6 +1160,7 @@ function subworkflowVarRows(instance, snapshot) {
         _id: invariants.toBareId(row.ref.id),
         rowKey: row.rowKey,
         activity: row.activity,
+        action: row.action,
         definition: row.definition,
         current: row.stageEntry === openKey,
         ...childState(row, snapshot),
@@ -1182,9 +1233,15 @@ function effectStatusMap(instance) {
     return out;
 }
 
-function effectsContextMap(instance) {
+function contextMap(instance) {
+    const out = {};
+    for (const entry of instance.context) out[entry.name] = entry._type === "context.json" ? parseJsonContextEntry(entry) : entry.value;
+    return out;
+}
+
+function effectOutputsMap(instance) {
     const out = {};
-    for (const entry of instance.effectsContext) out[entry.name] = entry._type === "effectsContext.json" ? parseJsonContextEntry(entry) : entry.value;
+    for (const run of instance.effectHistory) run.outputs !== void 0 && (out[run.name] = run.outputs);
     return out;
 }
 
@@ -1192,7 +1249,7 @@ function parseJsonContextEntry(entry) {
     try {
         return JSON.parse(entry.value);
     } catch (err) {
-        invariants.rethrowWithContext(err, `effectsContext entry "${entry.name}" holds unparseable JSON`);
+        invariants.rethrowWithContext(err, `context entry "${entry.name}" holds unparseable JSON`);
     }
 }
 
@@ -1257,8 +1314,9 @@ function recordFieldDiscards({target: target, scope: scope, at: at}) {
 
 function applyActivityStatusChange(args) {
     const {entry: entry, history: history, stage: stage, to: to, at: at, actor: actor} = args, from = entry.status;
-    entry.status = to, invariants.isTerminalActivityStatus(to) && (entry.completedAt = at, 
-    actor !== void 0 && (entry.completedBy = actor.id)), history.push({
+    entry.status = to, invariants.isTerminalActivityStatus(to) ? (entry.completedAt = at, 
+    actor !== void 0 && (entry.completedBy = actor.id)) : (delete entry.completedAt, 
+    delete entry.completedBy), history.push({
         _key: randomKey(),
         _type: "activityStatusChanged",
         at: at,
@@ -1346,7 +1404,7 @@ class RequiredFieldNotProvidedError extends invariants.WorkflowError {
     missing;
     constructor(args) {
         const lines = args.missing.map(m => `  - ${m.name} (${m.type})`).join(`\n`), where = args.definition !== void 0 ? ` for workflow "${args.definition}"` : "";
-        super("required-field-not-provided", `Required input fields${where} were not provided:\n${lines}\nProvide each via \`initialFields\` when starting standalone, or via the parent's \`subworkflows.with\` when spawned.`), 
+        super("required-field-not-provided", `Required input fields${where} were not provided:\n${lines}\nProvide each via \`initialFields\` when starting standalone, or via the parent's \`spawn.with\` when spawned.`), 
         this.name = "RequiredFieldNotProvidedError", args.definition !== void 0 && (this.definition = args.definition), 
         this.missing = args.missing;
     }
@@ -1374,7 +1432,11 @@ class PartialGuardDeployError extends invariants.WorkflowError {
     }
 }
 
-const CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS = 3;
+const CONCURRENT_COMMIT_MAX_ATTEMPTS = 3;
+
+function lostRaceMessage(args) {
+    return `${args.what} (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running — a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`;
+}
 
 class ConcurrentFireActionError extends invariants.WorkflowError {
     instanceId;
@@ -1382,9 +1444,12 @@ class ConcurrentFireActionError extends invariants.WorkflowError {
     action;
     attempts;
     constructor(args) {
-        super("concurrent-fire-action", `Action "${args.action}" on activity "${args.activity}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running — a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`), 
-        this.name = "ConcurrentFireActionError", this.instanceId = args.instanceId, this.activity = args.activity, 
-        this.action = args.action, this.attempts = args.attempts;
+        super("concurrent-fire-action", lostRaceMessage({
+            what: `Action "${args.action}" on activity "${args.activity}"`,
+            instanceId: args.instanceId,
+            attempts: args.attempts
+        })), this.name = "ConcurrentFireActionError", this.instanceId = args.instanceId, 
+        this.activity = args.activity, this.action = args.action, this.attempts = args.attempts;
     }
 }
 
@@ -1400,9 +1465,26 @@ class ConcurrentEditFieldError extends invariants.WorkflowError {
     attempts;
     constructor(args) {
         const where = args.target.activity !== void 0 ? `${args.target.activity}.${args.target.field}` : args.target.field;
-        super("concurrent-edit-field", `Edit of "${args.target.scope}:${where}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running — a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`), 
-        this.name = "ConcurrentEditFieldError", this.instanceId = args.instanceId, this.target = args.target, 
-        this.attempts = args.attempts;
+        super("concurrent-edit-field", lostRaceMessage({
+            what: `Edit of "${args.target.scope}:${where}"`,
+            instanceId: args.instanceId,
+            attempts: args.attempts
+        })), this.name = "ConcurrentEditFieldError", this.instanceId = args.instanceId, 
+        this.target = args.target, this.attempts = args.attempts;
+    }
+}
+
+class ConcurrentCompleteEffectError extends invariants.WorkflowError {
+    instanceId;
+    effectKey;
+    attempts;
+    constructor(args) {
+        super("concurrent-complete-effect", lostRaceMessage({
+            what: `Completion of effect entry "${args.effectKey}"`,
+            instanceId: args.instanceId,
+            attempts: args.attempts
+        })), this.name = "ConcurrentCompleteEffectError", this.instanceId = args.instanceId, 
+        this.effectKey = args.effectKey, this.attempts = args.attempts;
     }
 }
 
@@ -1410,7 +1492,7 @@ class CascadeLimitError extends invariants.WorkflowError {
     instanceId;
     limit;
     constructor(args) {
-        super("cascade-limit", `Cascade did not stabilise after ${args.limit} auto-transitions on ${args.instanceId} — likely a runaway loop (transition guards that stay mutually satisfied). Check that each transition's filter eventually goes false.`), 
+        super("cascade-limit", `Cascade did not stabilise after ${args.limit} hops on ${args.instanceId} — likely a runaway loop (transition \`when\`s that stay mutually satisfied). Check that each transition's \`when\` eventually goes false.`), 
         this.name = "CascadeLimitError", this.instanceId = args.instanceId, this.limit = args.limit;
     }
 }
@@ -1520,9 +1602,6 @@ function opAppliedEntry(args) {
         ...origin.action !== void 0 ? {
             action: origin.action
         } : {},
-        ...origin.transition !== void 0 ? {
-            transition: origin.transition
-        } : {},
         ...origin.edit === !0 ? {
             edit: !0
         } : {},
@@ -1584,7 +1663,11 @@ async function applyOp(op, ctx) {
 }
 
 function applyFieldSet(op, ctx) {
-    const value = resolveOpValue(op.value, ctx), entry = locateEntry(ctx, op.target);
+    const entry = locateEntry(ctx, op.target), value = resolveOpValue({
+        src: op.value,
+        ctx: ctx,
+        target: entrySlot(entry)
+    });
     return invariants.validateFieldValue({
         entryType: entry._type,
         entryName: entry.name,
@@ -1609,6 +1692,24 @@ function entryShape(entry) {
     } : {} : {};
 }
 
+function entrySlot(entry) {
+    return entry._type === "object" ? {
+        kind: entry._type,
+        fields: entry.fields
+    } : {
+        kind: entry._type
+    };
+}
+
+function appendItemSlot(entry) {
+    if (entry._type === "doc.refs") return {
+        kind: "doc.ref"
+    };
+    if (entry._type === "array") return {
+        fields: entry.of
+    };
+}
+
 const EMPTY_BY_KIND = {
     "doc.refs": [],
     array: [],
@@ -1624,7 +1725,13 @@ function applyFieldUnset(op, ctx) {
 }
 
 function applyFieldAppend(op, ctx) {
-    const item = resolveOpValue(op.value, ctx), entry = locateEntry(ctx, op.target);
+    const entry = locateEntry(ctx, op.target), slot = appendItemSlot(entry), item = resolveOpValue({
+        src: op.value,
+        ctx: ctx,
+        ...slot !== void 0 ? {
+            target: slot
+        } : {}
+    });
     invariants.validateFieldAppendItem({
         entryType: entry._type,
         entryName: entry.name,
@@ -1650,17 +1757,31 @@ function withRowKey(item) {
 }
 
 async function applyFieldUpdateWhere(op, ctx) {
-    const entry = locateEntry(ctx, op.target), rows = requireArrayValue(entry, op), merge = resolveOpValue(op.value, ctx);
+    const entry = locateEntry(ctx, op.target);
+    requireMergeableRows(entry, op);
+    const rows = requireArrayValue(entry, op), merge = resolveOpValue({
+        src: op.value,
+        ctx: ctx,
+        target: {
+            fields: entry.of
+        }
+    });
     if (merge === null || typeof merge != "object" || Array.isArray(merge)) throw new Error(`field.updateWhere value must resolve to an object of fields to merge (target "${op.target.field}")`);
+    requireNoReservedMergeKeys(merge, op);
     const matches = await rowMatches({
         where: op.where,
         rows: rows,
         ctx: ctx
-    });
-    return setEntryValue(entry, rows.map((row, index) => matches[index] ? {
+    }), next = rows.map((row, index) => matches[index] ? {
         ...row,
         ...merge
-    } : row)), {
+    } : row);
+    return invariants.validateFieldValue({
+        entryType: entry._type,
+        entryName: entry.name,
+        value: next,
+        of: entry.of
+    }), setEntryValue(entry, next), {
         opType: op.type,
         target: op.target,
         resolved: {
@@ -1681,8 +1802,17 @@ async function applyFieldRemoveWhere(op, ctx) {
     };
 }
 
+function requireMergeableRows(entry, op) {
+    if (entry._type !== "array") throw new Error(`${op.type} target ${op.target.scope}:"${op.target.field}" is a ${entry._type} entry — updateWhere merges declared row sub-fields, so it targets \`array\` entries only`);
+}
+
+function requireNoReservedMergeKeys(merge, op) {
+    const reserved = [ "_key", "_type" ].filter(key => key in merge);
+    if (reserved.length !== 0) throw new Error(`field.updateWhere merge writes the reserved row key${reserved.length === 1 ? "" : "s"} ${reserved.map(k => `"${k}"`).join(", ")} (target "${op.target.field}") — row identity and bookkeeping are engine-stamped, never merged`);
+}
+
 function requireArrayValue(entry, op) {
-    if (!Array.isArray(entry.value)) throw new Error(`${op.type} target ${op.target.scope}:"${op.target.field}" holds a non-array ${entry._type} value — where-ops operate on array entries`);
+    if (!Array.isArray(entry.value)) throw new Error(`${op.type} target ${op.target.scope}:"${op.target.field}" (${entry._type}) holds a non-array value — where-ops operate on array entries`);
     return entry.value;
 }
 
@@ -1726,7 +1856,18 @@ function fieldHost(ctx, scope) {
     activity?.fields;
 }
 
-function resolveOpValue(src, ctx) {
+function subSlot(target, field) {
+    const shape = target?.fields?.find(f => f.name === field);
+    if (shape !== void 0) return {
+        kind: shape.type,
+        ...shape.fields !== void 0 ? {
+            fields: shape.fields
+        } : {}
+    };
+}
+
+function resolveOpValue(args) {
+    const {src: src, ctx: ctx, target: target} = args;
     switch (src.type) {
       case "literal":
       case "param":
@@ -1747,14 +1888,26 @@ function resolveOpValue(src, ctx) {
                 kind: entry._type,
                 value: entry.value,
                 path: src.path,
-                snapshot: ctx.snapshot
+                snapshot: ctx.snapshot,
+                ...target?.kind !== void 0 ? {
+                    targetKind: target.kind
+                } : {}
             });
         }
 
       case "object":
         {
             const out = {};
-            for (const [field, fieldSrc] of Object.entries(src.fields)) out[field] = resolveOpValue(fieldSrc, ctx);
+            for (const [field, fieldSrc] of Object.entries(src.fields)) {
+                const slot = subSlot(target, field);
+                out[field] = resolveOpValue({
+                    src: fieldSrc,
+                    ctx: ctx,
+                    ...slot !== void 0 ? {
+                        target: slot
+                    } : {}
+                });
+            }
             return out;
         }
     }
@@ -1782,7 +1935,7 @@ async function rowMatches({where: where, rows: rows, ctx: ctx}) {
     })));
 }
 
-const WHERE_SCOPE_PARAM_NAMES = [ "row", "params", "actor", "now", "self", "stage", "fields", "effects", "effectStatus", "activities", "allActivitiesDone", "anyActivityFailed" ];
+const WHERE_SCOPE_PARAM_NAMES = [ "row", "params", "actor", "now", "self", "stage", "fields", "context", "effects", "effectStatus", "activities", "allActivitiesDone", "anyActivityFailed" ];
 
 function whereParams(ctx) {
     const activities = findOpenStageEntry(ctx.mutation)?.activities ?? [];
@@ -1800,7 +1953,8 @@ function whereParams(ctx) {
                 activityName: ctx.activityName
             })
         },
-        effects: effectsContextMap(ctx.mutation),
+        context: contextMap(ctx.mutation),
+        effects: effectOutputsMap(ctx.mutation),
         effectStatus: effectStatusMap(ctx.mutation),
         activities: activities,
         ...activityGateParams(activities)
@@ -1816,7 +1970,7 @@ function validateDefinition(definition) {
             address: address
         }));
     }
-    definition.applicableWhen !== void 0 && v2.report("applicableWhen", applicabilitySyntaxIssues(definition.applicableWhen));
+    definition.start?.filter !== void 0 && v2.report("start.filter", startFilterSyntaxIssues(definition.start.filter));
     for (const entry of definition.fields ?? []) v2.checkEntry(entry, `workflow.fields "${entry.name}"`);
     for (const stage of definition.stages) validateStage(v2, stage);
     for (const issue of invariants.checkWorkflowInvariants(definition)) v2.errors.push(`  · ${invariants.formatIssuePath(issue.path)}: ${issue.message}`);
@@ -1856,23 +2010,20 @@ function conditionSiteLabel({stage: stage, address: address}) {
         return `predicate "${address.predicate}"`;
 
       case "transition":
-        return `${at} transition "${address.transition}" filter`;
+        return `${at} transition "${address.transition}" when`;
 
       case "activity-filter":
         return `${at} activity "${address.activity}".filter`;
 
-      case "complete-when":
-        return `${at} activity "${address.activity}".completeWhen`;
-
-      case "fail-when":
-        return `${at} activity "${address.activity}".failWhen`;
-
       case "requirement":
         return `${at} activity "${address.activity}".requirements "${address.requirement}"`;
 
       case "action":
         return `${at} activity "${address.activity}" action "${address.action}".filter`;
 
+      case "action-when":
+        return `${at} activity "${address.activity}" action "${address.action}".when`;
+
       case "editable-override":
         return `${at}.editable "${address.name}"`;
     }
@@ -1885,15 +2036,6 @@ function validateStage(v2, stage) {
         stageName: stage.name,
         guard: guard
     });
-    for (const t of stage.transitions ?? []) {
-        const where = `stage "${stage.name}" transition "${t.name}"`;
-        checkOpWheres({
-            v: v2,
-            ops: t.ops,
-            label: where
-        });
-        for (const [key, groq] of effectBindings(t.effects)) v2.tryParse(groq, `${where} effect binding "${key}"`);
-    }
     for (const activity of stage.activities ?? []) validateActivity({
         v: v2,
         stageName: stage.name,
@@ -1910,20 +2052,10 @@ function validateGuardReads({v: v2, stageName: stageName, guard: guard}) {
 function validateActivity({v: v2, stageName: stageName, activity: activity}) {
     const where = `stage "${stageName}" activity "${activity.name}"`;
     for (const entry of activity.fields ?? []) v2.checkEntry(entry, `${where}.fields "${entry.name}"`);
-    checkOpWheres({
-        v: v2,
-        ops: activity.ops,
-        label: where
-    });
-    for (const [key, groq] of effectBindings(activity.effects)) v2.tryParse(groq, `${where} effect binding "${key}"`);
     validateActivityActions({
         v: v2,
         where: where,
         activity: activity
-    }), activity.subworkflows !== void 0 && validateSubworkflows({
-        v: v2,
-        where: where,
-        sub: activity.subworkflows
     });
 }
 
@@ -1936,6 +2068,11 @@ function validateActivityActions({v: v2, where: where, activity: activity}) {
             label: label
         });
         for (const [key, groq] of effectBindings(a.effects)) v2.tryParse(groq, `${label} effect binding "${key}"`);
+        a.spawn !== void 0 && validateSpawn({
+            v: v2,
+            where: label,
+            sub: a.spawn
+        });
     }
 }
 
@@ -1943,10 +2080,10 @@ function checkOpWheres({v: v2, ops: ops, label: label}) {
     for (const op of ops ?? []) (op.type === "field.updateWhere" || op.type === "field.removeWhere") && v2.checkWhere(op.where, `${label} ${op.type} where`);
 }
 
-function validateSubworkflows({v: v2, where: where, sub: sub}) {
-    v2.tryParse(sub.forEach, `${where}.subworkflows.forEach`);
-    for (const [key, groq] of Object.entries(sub.with ?? {})) v2.tryParse(groq, `${where}.subworkflows.with "${key}"`);
-    for (const [key, groq] of Object.entries(sub.context ?? {})) v2.tryParse(groq, `${where}.subworkflows.context "${key}"`);
+function validateSpawn({v: v2, where: where, sub: sub}) {
+    v2.tryParse(sub.forEach, `${where}.spawn.forEach`);
+    for (const [key, groq] of Object.entries(sub.with ?? {})) v2.tryParse(groq, `${where}.spawn.with "${key}"`);
+    for (const [key, groq] of Object.entries(sub.context ?? {})) v2.tryParse(groq, `${where}.spawn.context "${key}"`);
 }
 
 function effectBindings(effects) {
@@ -1958,7 +2095,11 @@ function lintEffectOutputs(definition) {
     for (const {effect: effect} of effectSites(definition)) declared.set(effect.name, effect.outputs?.map(shape => shape.name) ?? []);
     const warnings = /* @__PURE__ */ new Set, check = ({effect: effect, key: key}) => {
         const outputs = declared.get(effect);
-        outputs === void 0 || outputs.includes(key) || warnings.add(`effect "${effect}" is read as \`$effects['${effect}'].${key}\` but declares outputs [${outputs.join(", ")}] — no declared producer for "${key}"`);
+        if (outputs === void 0) {
+            warnings.add(`\`$effects['${effect}'].${key}\` reads an effect this definition never declares — $effects carries completed effects' outputs only (a start seed or spawn handoff is read via $context)`);
+            return;
+        }
+        outputs.includes(key) || warnings.add(`effect "${effect}" is read as \`$effects['${effect}'].${key}\` but declares outputs [${outputs.join(", ")}] — no declared producer for "${key}"`);
     };
     for (const groq of effectReadGroq(definition)) invariants.conditionEffectReads(groq).forEach(check);
     return guardEffectReads(definition).forEach(check), [ ...warnings ];
@@ -1997,7 +2138,7 @@ function actionVerdict(activity, action) {
 }
 
 function availableActions(activities) {
-    return activities.flatMap(t => t.actions.map(a => actionVerdict(t, a)));
+    return activities.filter(t => !t.scopedOut).flatMap(t => t.actions.map(a => actionVerdict(t, a)));
 }
 
 function buildClientForGdr(args) {
@@ -2222,7 +2363,13 @@ const DATA_MODEL_VERSION = 1, DATA_MODEL_MIN_READER = 0, MODEL_STAMP = {
 };
 
 function fieldTreeShape(value) {
-    return Array.isArray(value) ? value.map(fieldTreeShape) : value === null ? "null" : typeof value == "object" ? Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [ key, fieldTreeShape(entry) ])) : typeof value;
+    if (Array.isArray(value)) return value.map(fieldTreeShape);
+    if (value === null) return "null";
+    if (typeof value == "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).toSorted().map(key => [ key, fieldTreeShape(record[key]) ]));
+    }
+    return typeof value;
 }
 
 function modelVersionOf(doc) {
@@ -2309,7 +2456,7 @@ function isResolved(status) {
 }
 
 function failedEffectCause(input) {
-    const stalled = new Set(input.activities.filter(t => !isResolved(t.status)).map(t => t.activity.name)), effect = [ ...input.instance.effectHistory ].reverse().find(e => e.status === "failed" && e.origin.kind === "activity" && stalled.has(e.origin.name));
+    const stalledEffectNames = new Set(input.activities.filter(t => !isResolved(t.status)).flatMap(t => (t.activity.actions ?? []).flatMap(action => action.effects ?? [])).map(effect2 => effect2.name)), effect = [ ...input.instance.effectHistory ].reverse().find(e => e.status === "failed" && stalledEffectNames.has(e.name));
     return effect ? {
         kind: "failed-effect",
         effect: effect
@@ -2338,7 +2485,7 @@ function waitingState(input) {
         state: "waiting",
         activity: active.activity.name,
         assignees: input.assignees[active.activity.name] ?? [],
-        actions: (active.activity.actions ?? []).map(a => a.name)
+        actions: (active.activity.actions ?? []).filter(a => !invariants.isCascadeFired(a)).map(a => a.name)
     };
 }
 
@@ -2353,7 +2500,7 @@ function blockedState(input) {
 }
 
 function noTransitionFiresCause(input) {
-    if (input.transitions.length === 0 || input.transitions.some(t => t.filterSatisfied) || !input.activities.every(t => isResolved(t.status))) return;
+    if (input.transitions.length === 0 || input.transitions.some(t => t.whenSatisfied) || !input.activities.every(t => isResolved(t.status))) return;
     const undecidable = input.transitions.filter(t => t.unevaluable);
     return undecidable.length > 0 ? {
         kind: "transition-unevaluable",
@@ -2390,7 +2537,7 @@ function diagnoseInstance(input) {
     };
 }
 
-const RUNNABLE_VERBS = /* @__PURE__ */ new Set([ "set-stage", "abort" ]);
+const RUNNABLE_VERBS = /* @__PURE__ */ new Set([ "set-stage", "abort", "drain-effects" ]);
 
 function remediationsForCause(cause) {
     switch (cause.kind) {
@@ -2406,7 +2553,7 @@ function remediationsForCause(cause) {
       case "hung-effect":
         return [ {
             verb: "drain-effects",
-            rationale: "Re-run the effect drainer to re-pick the claimed effect."
+            rationale: "Re-run the effect drainer — the runtime that registered the effect handlers — to re-pick the claimed effect."
         }, {
             verb: "abort",
             rationale: "Abort the instance if the effect never drains."
@@ -2499,7 +2646,7 @@ function resolveGuardRead(args) {
     }
     const effectsRead = invariants.EFFECTS_READ.exec(expr);
     if (effectsRead !== null) {
-        const outputs = effectsContextMap(ctx.instance)[effectsRead[1]];
+        const outputs = effectOutputsMap(ctx.instance)[effectsRead[1]];
         return effectsRead[2] !== void 0 ? getPath(outputs, effectsRead[2]) : outputs;
     }
     throw new Error(`Guard read "${expr}" is not a supported deploy-time value — use "$self", "$now", "$fields.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $fields or $effects)`);
@@ -2751,6 +2898,40 @@ function contentReleaseName(args) {
     if (!readsRaw(ref) && Array.isArray(perspective)) return perspective.find(entry => entry !== "drafts" && entry !== "published" && entry !== "raw");
 }
 
+function contentDraftFallback(args) {
+    if (readsRaw(args.ref)) return !0;
+    const effective = args.perspective ?? DEFAULT_CONTENT_PERSPECTIVE;
+    return Array.isArray(effective) ? effective.includes("drafts") : effective === "drafts";
+}
+
+function contentDocQuery(documentId) {
+    return {
+        query: "*[_id == $id][0]",
+        params: {
+            id: documentId
+        }
+    };
+}
+
+function watchRefRepresentations(args) {
+    const {ref: ref} = args;
+    if (readsRaw(ref)) return [ ref.documentId ];
+    const release = contentReleaseName(args);
+    return [ ref.documentId, ...contentDraftFallback(args) ? [ `drafts.${ref.documentId}` ] : [], ...release !== void 0 ? [ `versions.${release}.${ref.documentId}` ] : [] ];
+}
+
+function projectToWatchRef(args) {
+    const {doc: doc, ref: ref} = args;
+    if (doc._id === ref.documentId) return doc;
+    const accepted = watchRefRepresentations(args);
+    if (!accepted.includes(doc._id)) throw new Error(`projectToWatchRef: the store resolved "${doc._id}" for watch ref "${ref.globalDocumentId}" — not a representation of "${ref.documentId}" under the instance's perspective (accepted: ${accepted.map(id => `"${id}"`).join(", ")}). The consumer is feeding the wrong document.`);
+    return {
+        ...doc,
+        _id: ref.documentId,
+        _originalId: doc._id
+    };
+}
+
 function subscriptionDocument(ref) {
     return {
         ...invariants.parseGdr(ref.id),
@@ -2847,9 +3028,8 @@ async function readDoc({client: client, id: id, perspective: perspective}) {
         const doc2 = await client.getDocument(id) ?? null;
         return doc2 ? assertReadableModel(doc2) : null;
     }
-    return await client.fetch("*[_id == $id][0]", {
-        id: id
-    }, {
+    const {query: query, params: params} = contentDocQuery(id);
+    return await client.fetch(query, params, {
         perspective: perspective
     }) ?? null;
 }
@@ -3002,35 +3182,35 @@ async function reload({client: client, instanceId: instanceId, tag: tag}) {
     return doc;
 }
 
-function effectsContextEntry(name, value) {
+function contextEntry(name, value) {
     const _key = randomKey();
     return typeof value == "string" ? {
         _key: _key,
-        _type: "effectsContext.string",
+        _type: "context.string",
         name: name,
         value: value
     } : typeof value == "number" ? {
         _key: _key,
-        _type: "effectsContext.number",
+        _type: "context.number",
         name: name,
         value: value
     } : typeof value == "boolean" ? {
         _key: _key,
-        _type: "effectsContext.boolean",
+        _type: "context.boolean",
         name: name,
         value: value
     } : {
         _key: _key,
-        _type: "effectsContext.ref",
+        _type: "context.ref",
         name: name,
         value: value
     };
 }
 
-function effectsContextJsonEntry(name, value) {
+function contextJsonEntry(name, value) {
     return {
         _key: randomKey(),
-        _type: "effectsContext.json",
+        _type: "context.json",
         name: name,
         value: serializeContextValue(name, value)
     };
@@ -3041,9 +3221,9 @@ function serializeContextValue(name, value) {
     try {
         json = JSON.stringify(value);
     } catch (err) {
-        invariants.rethrowWithContext(err, `effectsContext entry "${name}" holds unserializable JSON`);
+        invariants.rethrowWithContext(err, `context entry "${name}" holds unserializable JSON`);
     }
-    if (json === void 0) throw new Error(`effectsContext entry "${name}" holds a non-JSON value (undefined, a function, or a symbol)`);
+    if (json === void 0) throw new Error(`context entry "${name}" holds a non-JSON value (undefined, a function, or a symbol)`);
     return json;
 }
 
@@ -3073,7 +3253,7 @@ function buildInstanceBase(args) {
         } : {},
         definitionSnapshot: JSON.stringify(args.definition),
         fields: args.fields,
-        effectsContext: args.effectsContext,
+        context: args.context,
         ancestors: args.ancestors,
         ...perspective !== void 0 ? {
             perspective: perspective
@@ -3252,14 +3432,19 @@ async function deleteOrphanedDefinitionGuards(args) {
 }
 
 function derivePerspectiveFromFields(entries) {
-    if (entries !== void 0) {
-        for (const entry of entries) if (entry._type === "release.ref" && entry.value !== null) {
-            const releaseName = entry.value.releaseName;
-            if (typeof releaseName == "string" && releaseName.length > 0) return [ releaseName ];
-        }
+    for (const entry of entries ?? []) {
+        if (entry._type !== "release.ref") continue;
+        const perspective = perspectiveFromReleaseValue(entry.value);
+        if (perspective !== void 0) return perspective;
     }
 }
 
+function perspectiveFromReleaseValue(value) {
+    if (typeof value != "object" || value === null) return;
+    const releaseName = value.releaseName;
+    return typeof releaseName == "string" && releaseName.length > 0 ? [ releaseName ] : void 0;
+}
+
 async function resolveDeclaredFields(args) {
     const {entryDefs: entryDefs, initialFields: initialFields, ctx: ctx, randomKey: randomKey2} = args;
     if (entryDefs === void 0 || entryDefs.length === 0) return [];
@@ -3285,8 +3470,8 @@ async function resolveDeclaredFields(args) {
 }
 
 function missingRequiredInputs(args) {
-    return args.entryDefs.filter(entry => entry.required === !0 && entry.initialValue?.type === "input").filter(entry => {
-        const match = args.initialFields.find(s => s.name === entry.name && s.type === entry.type);
+    return args.entryDefs.filter(entry => entry.required === !0 && invariants.isInputSourced(entry)).filter(entry => {
+        const match = suppliedFieldFor(entry, args.initialFields);
         return match === void 0 || match.value === void 0 || match.value === null;
     }).map(entry => ({
         name: entry.name,
@@ -3294,6 +3479,10 @@ function missingRequiredInputs(args) {
     }));
 }
 
+function suppliedFieldFor(entry, initialFields) {
+    return initialFields.find(field => field.name === entry.name && field.type === entry.type);
+}
+
 function assertRequiredInputProvided({entryDefs: entryDefs, initialFields: initialFields, definitionName: definitionName}) {
     const missing = missingRequiredInputs({
         entryDefs: entryDefs,
@@ -3314,18 +3503,19 @@ function defaultEntryValue(entryType) {
 }
 
 function resolveInputValue({entry: entry, initialFields: initialFields, defaultValue: defaultValue}) {
-    const initMatch = initialFields.find(s => s.name === entry.name && s.type === entry.type);
+    const initMatch = suppliedFieldFor(entry, initialFields);
     return initMatch === void 0 ? defaultValue : (assertInputValueShape(entry, initMatch.value), 
     initMatch.value);
 }
 
-function resolveFieldReadValue({source: source, ctx: ctx, defaultValue: defaultValue}) {
-    const target = (source.scope === "workflow" ? ctx.workflowFields ?? [] : ctx.resolvedFields ?? []).find(s => s.name === source.field);
-    return target === void 0 ? defaultValue : resolveFieldRead({
-        kind: target._type,
-        value: target.value,
+function resolveFieldReadValue({entry: entry, source: source, ctx: ctx, defaultValue: defaultValue}) {
+    const sourceEntry = (source.scope === "workflow" ? ctx.workflowFields ?? [] : ctx.resolvedFields ?? []).find(s => s.name === source.field);
+    return sourceEntry === void 0 ? defaultValue : resolveFieldRead({
+        kind: sourceEntry._type,
+        value: sourceEntry.value,
         path: source.path,
-        snapshot: void 0
+        snapshot: void 0,
+        targetKind: entry.type
     }) ?? defaultValue;
 }
 
@@ -3364,6 +3554,7 @@ async function resolveEntryValue({entry: entry, initialFields: initialFields, ct
         ctx: ctx,
         defaultValue: defaultValue
     }) : source.type === "fieldRead" ? resolveFieldReadValue({
+        entry: entry,
         source: source,
         ctx: ctx,
         defaultValue: defaultValue
@@ -3581,7 +3772,7 @@ function loadCallContext({client: client, instanceId: instanceId, options: optio
 
 async function retryOnRevisionConflict(args) {
     const {client: client, instanceId: instanceId, options: options, commit: commit, onExhausted: onExhausted} = args;
-    for (let attempt = 1; attempt <= CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS; attempt++) {
+    for (let attempt = 1; attempt <= CONCURRENT_COMMIT_MAX_ATTEMPTS; attempt++) {
         const ctx = await loadCallContext({
             client: client,
             instanceId: instanceId,
@@ -3849,7 +4040,7 @@ function startMutation(instance) {
         })),
         pendingEffects: [ ...instance.pendingEffects ],
         effectHistory: [ ...instance.effectHistory ],
-        effectsContext: [ ...instance.effectsContext ],
+        context: [ ...instance.context ],
         history: [ ...instance.history ],
         processedRequests: [ ...instance.processedRequests ?? [] ],
         lastChangedAt: instance.lastChangedAt,
@@ -3873,7 +4064,7 @@ function instanceStateFields(src) {
         subworkflows: src.subworkflows ?? [],
         pendingEffects: src.pendingEffects,
         effectHistory: src.effectHistory,
-        effectsContext: src.effectsContext,
+        context: src.context,
         history: src.history,
         processedRequests: src.processedRequests ?? []
     };
@@ -3881,6 +4072,15 @@ function instanceStateFields(src) {
     fields;
 }
 
+function liveViewContext(ctx, mutation) {
+    const materialized = materializeInstance(ctx.instance, mutation);
+    return {
+        ...ctx,
+        instance: materialized,
+        snapshot: overlayInstanceInSnapshot(ctx.snapshot, materialized)
+    };
+}
+
 function materializeInstance(base, mutation) {
     return {
         ...base,
@@ -3888,7 +4088,9 @@ function materializeInstance(base, mutation) {
         fields: mutation.fields,
         stages: mutation.stages,
         subworkflows: mutation.subworkflows,
-        effectsContext: mutation.effectsContext
+        context: mutation.context,
+        pendingEffects: mutation.pendingEffects,
+        effectHistory: mutation.effectHistory
     };
 }
 
@@ -4053,22 +4255,27 @@ async function refreshStageGuards({ctx: ctx, mutation: mutation, stageName: stag
 async function completeEffect(args) {
     const {client: client, instanceId: instanceId, effectKey: effectKey, status: status, outputs: outputs, ops: ops, detail: detail, error: error, durationMs: durationMs, requestRecord: requestRecord, options: options} = args;
     if (status !== "done" && status !== "failed") throw new invariants.ContractViolationError(`completeEffect: status must be "done" or "failed", got ${JSON.stringify(status)} — "cancelled" is engine-stamped by abort, never reportable`);
-    const ctx = await loadCallContext({
+    return retryOnRevisionConflict({
         client: client,
         instanceId: instanceId,
-        options: options
-    });
-    return commitCompleteEffect({
-        ctx: ctx,
-        effectKey: effectKey,
-        status: status,
-        outputs: outputs,
-        ops: ops,
-        detail: detail,
-        error: error,
-        durationMs: durationMs,
-        requestRecord: requestRecord,
-        actor: options?.actor
+        options: options,
+        commit: ctx => commitCompleteEffect({
+            ctx: ctx,
+            effectKey: effectKey,
+            status: status,
+            outputs: outputs,
+            ops: ops,
+            detail: detail,
+            error: error,
+            durationMs: durationMs,
+            requestRecord: requestRecord,
+            actor: options.actor
+        }),
+        onExhausted: () => new ConcurrentCompleteEffectError({
+            instanceId: instanceId,
+            effectKey: effectKey,
+            attempts: CONCURRENT_COMMIT_MAX_ATTEMPTS
+        })
     });
 }
 
@@ -4158,11 +4365,6 @@ function validateEffectOutputs(args) {
     });
 }
 
-function upsertEffectsContext({mutation: mutation, effectName: effectName, outputs: outputs}) {
-    const existingIndex = mutation.effectsContext.findIndex(e => e.name === effectName), entry = effectsContextJsonEntry(effectName, outputs);
-    existingIndex >= 0 ? mutation.effectsContext[existingIndex] = entry : mutation.effectsContext.push(entry);
-}
-
 function requirePendingEffect(instance, effectKey) {
     const pending = instance.pendingEffects.find(e => e._key === effectKey);
     if (pending !== void 0) return pending;
@@ -4230,12 +4432,8 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         outputs: outputs
     });
     mutation.effectHistory.push(settlement.run);
-    const wroteEffectsContext = status === "done" && outputs !== void 0;
-    wroteEffectsContext && upsertEffectsContext({
-        mutation: mutation,
-        effectName: pending.name,
-        outputs: outputs
-    }), mutation.history.push(settlement.event);
+    const wroteEffectOutputs = status === "done" && outputs !== void 0;
+    mutation.history.push(settlement.event);
     const ranOps = await runOps({
         ops: validatedOps,
         mutation: mutation,
@@ -4248,7 +4446,7 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         self: invariants.selfGdr(ctx.instance),
         now: ranAt,
         snapshot: ctx.snapshot
-    }), needsGuardRefresh = wroteEffectsContext || ranOps.some(isFieldOp);
+    }), needsGuardRefresh = wroteEffectOutputs || ranOps.some(isFieldOp);
     return await persistThenMaybeRefresh({
         ctx: ctx,
         mutation: mutation,
@@ -4418,6 +4616,60 @@ async function commitAbort({ctx: ctx, reason: reason, requestRecord: requestReco
     };
 }
 
+async function buildStageActivities({ctx: ctx, stage: stage, recordDiscard: recordDiscard}) {
+    const entries = [];
+    for (const activity of stage.activities ?? []) entries.push(await buildActivityEntry({
+        ctx: ctx,
+        stage: stage,
+        activity: activity,
+        recordDiscard: recordDiscard
+    }));
+    return entries;
+}
+
+async function buildActivityEntry({ctx: ctx, stage: stage, activity: activity, recordDiscard: recordDiscard}) {
+    const outcome = await ctxEvaluateConditionOutcome({
+        ctx: ctx,
+        condition: activity.filter,
+        opts: {
+            activityName: activity.name
+        }
+    }), inScope = outcome !== "unsatisfied", entry = {
+        _key: randomKey(),
+        name: activity.name,
+        status: inScope ? "active" : "skipped",
+        ...activity.filter !== void 0 ? {
+            filterEvaluation: buildFilterEvaluation({
+                at: ctx.now,
+                filter: activity.filter,
+                outcome: outcome
+            })
+        } : {}
+    };
+    return inScope && (entry.startedAt = ctx.now, activity.fields !== void 0 && activity.fields.length > 0 && (entry.fields = await resolveActivityFieldEntries({
+        client: ctx.client,
+        instance: ctx.instance,
+        stage: stage,
+        activity: activity,
+        now: ctx.now,
+        ...recordDiscard !== void 0 ? {
+            recordDiscard: recordDiscard
+        } : {}
+    }))), entry;
+}
+
+function buildFilterEvaluation({at: at, filter: filter, outcome: outcome}) {
+    return outcome === "unevaluable" ? {
+        at: at,
+        truthy: !1,
+        unevaluable: !0,
+        detail: `Filter "${filter}" could not be evaluated (GROQ null — a referenced operand was missing or incomparable). Activity kept in scope so the gate is not silently skipped.`
+    } : {
+        at: at,
+        truthy: outcome === "satisfied"
+    };
+}
+
 async function discoverItems(args) {
     const {client: client, groq: groq, params: params, perspective: perspective} = args;
     return client.fetch(groq, paramsForLake(params), {
@@ -4436,65 +4688,28 @@ function clientForDiscovery({defaultClient: defaultClient, clientForGdr: clientF
 
 const MAX_SPAWN_DEPTH = 6;
 
-function subworkflowsSettledGate(activityName) {
-    return `count($subworkflows[activity == ${JSON.stringify(activityName)} && current && status == 'active']) == 0`;
-}
-
 function subworkflowsOnExit(sub) {
     return sub.onExit ?? "detach";
 }
 
-function applyGateOutcome(args) {
-    applyActivityStatusChange({
-        entry: args.entry,
-        history: args.history,
-        stage: args.stage,
-        to: args.outcome,
-        at: args.at,
-        ...args.actor !== void 0 ? {
-            actor: args.actor
-        } : {}
-    });
-}
-
-function effectiveCompleteWhen(activity) {
-    return activity.completeWhen ?? (activity.subworkflows !== void 0 ? subworkflowsSettledGate(activity.name) : void 0);
-}
-
-async function evaluateResolutionGate({ctx: ctx, activity: activity}) {
-    const scope = {
-        activityName: activity.name
-    };
-    if (activity.failWhen !== void 0 && await ctxEvaluateCondition({
-        ctx: ctx,
-        condition: activity.failWhen,
-        opts: scope
-    })) return "failed";
-    const completeWhen = effectiveCompleteWhen(activity);
-    if (completeWhen !== void 0 && await ctxEvaluateCondition({
-        ctx: ctx,
-        condition: completeWhen,
-        opts: scope
-    })) return "done";
-}
-
-async function spawnSubworkflows({ctx: ctx, mutation: mutation, activity: activity, sub: sub, actor: actor}) {
-    assertSpawnDepth(ctx, activity);
-    const openEntry = findOpenStageEntry(mutation);
-    if (openEntry === void 0) throw new Error(`Mutation invariant broken: no open StageEntry while spawning on activity "${activity.name}" of ${ctx.instance._id}`);
-    const definition = await requireChildDefinition({
-        ctx: ctx,
-        activity: activity,
-        sub: sub
-    }), parentScope = await ctxConditionParams(ctx, {
-        activityName: activity.name,
-        ...actor ? {
-            actor: actor
+async function spawnSubworkflows({ctx: ctx, mutation: mutation, activity: activity, action: action, sub: sub, actor: actor}) {
+    assertSpawnDepth(ctx, activity);
+    const openEntry = findOpenStageEntry(mutation);
+    if (openEntry === void 0) throw new Error(`Mutation invariant broken: no open StageEntry while spawning on activity "${activity.name}" of ${ctx.instance._id}`);
+    const definition = await requireChildDefinition({
+        ctx: ctx,
+        activity: activity,
+        sub: sub
+    }), parentScope = await ctxConditionParams(ctx, {
+        activityName: activity.name,
+        ...actor ? {
+            actor: actor
         } : {}
     }), {rows: rows, discoveryResource: discoveryResource} = await resolveSpawnRows(ctx, sub), keyedRows = keyRows(rows, {
         activity: activity.name,
+        action: action.name,
         instanceId: ctx.instance._id
-    }), live = liveSubworkflows(mutation).filter(r => r.activity === activity.name && r.definition === sub.definition.name && r.abortPending === void 0);
+    }), live = liveSubworkflows(mutation).filter(r => r.activity === activity.name && r.action === action.name && r.definition === sub.definition.name && r.abortPending === void 0);
     adoptRediscoveredRows({
         mutation: mutation,
         live: live,
@@ -4503,7 +4718,7 @@ async function spawnSubworkflows({ctx: ctx, mutation: mutation, activity: activi
         activity: activity,
         now: ctx.now
     });
-    const effectsContext = await resolveContextHandoff({
+    const context = await resolveContextHandoff({
         ctx: ctx,
         sub: sub,
         parentScope: parentScope
@@ -4512,10 +4727,11 @@ async function spawnSubworkflows({ctx: ctx, mutation: mutation, activity: activi
         ctx: ctx,
         mutation: mutation,
         activity: activity,
+        action: action,
         sub: sub,
         definition: definition,
         parentScope: parentScope,
-        effectsContext: effectsContext,
+        context: context,
         discoveryResource: discoveryResource,
         openEntry: openEntry,
         keyed: keyed,
@@ -4553,7 +4769,7 @@ function adoptRediscoveredRows({mutation: mutation, live: live, keyedRows: keyed
     }));
 }
 
-async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, sub: sub, definition: definition, parentScope: parentScope, effectsContext: effectsContext, discoveryResource: discoveryResource, openEntry: openEntry, keyed: keyed, actor: actor}) {
+async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, action: action, sub: sub, definition: definition, parentScope: parentScope, context: context, discoveryResource: discoveryResource, openEntry: openEntry, keyed: keyed, actor: actor}) {
     const now = ctx.now, initialFields = await projectRowFields({
         ctx: ctx,
         sub: sub,
@@ -4566,7 +4782,7 @@ async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, sub:
         parent: ctx.instance,
         definition: definition,
         initialFields: initialFields,
-        effectsContext: effectsContext,
+        context: context,
         actor: actor,
         now: now
     });
@@ -4581,6 +4797,7 @@ async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, sub:
     }), mutation.subworkflows.push({
         _key: randomKey(),
         activity: activity.name,
+        action: action.name,
         definition: sub.definition.name,
         stageEntry: openEntry._key,
         cohortStage: openEntry.name,
@@ -4606,7 +4823,7 @@ function keyRows(rows, cx) {
         rowKey: spawnRowKey(row, cx)
     })), seen = /* @__PURE__ */ new Set;
     for (const {rowKey: rowKey} of keyed) {
-        if (seen.has(rowKey)) throw new Error(`subworkflows.forEach on activity "${cx.activity}" of ${cx.instanceId} produced two rows with the same identity "${rowKey}" — adopt-matching cannot tell them apart. Make each row's identity unique: distinct \`_key\`/\`_id\`/GDR \`id\` values for object rows, distinct values for scalar rows.`);
+        if (seen.has(rowKey)) throw new Error(`spawn.forEach on action "${cx.action}" (activity "${cx.activity}") of ${cx.instanceId} produced two rows with the same identity "${rowKey}" — adopt-matching cannot tell them apart. Make each row's identity unique: distinct \`_key\`/\`_id\`/GDR \`id\` values for object rows, distinct values for scalar rows.`);
         seen.add(rowKey);
     }
     return keyed;
@@ -4620,15 +4837,19 @@ function spawnRowKey(row, cx) {
         if (typeof _id == "string" && _id.length > 0) return _id;
         if (invariants.isGdr(row) && invariants.isGdrUri(row.id)) return row.id;
     }
-    throw new Error(`subworkflows.forEach on activity "${cx.activity}" of ${cx.instanceId} produced a row without an identity, so re-entering the stage could not tell "same row" from "new row". Project \`_id\` (document rows) or \`_key\` (array items), keep GDR rows whole (a \`{id, type}\` row with a GDR-URI \`id\` — the shape a \`doc.refs\` field stores — keys on its \`id\`), or mint a \`_key\` for synthetic rows (e.g. \`{"_key": lang + "-" + market, ...}\`); scalar rows key on their value. Row: ${JSON.stringify(row)}`);
+    throw new Error(`spawn.forEach on action "${cx.action}" (activity "${cx.activity}") of ${cx.instanceId} produced a row without an identity, so re-entering the stage could not tell "same row" from "new row". Project \`_id\` (document rows) or \`_key\` (array items), keep GDR rows whole (a \`{id, type}\` row with a GDR-URI \`id\` — the shape a \`doc.refs\` field stores — keys on its \`id\`), or mint a \`_key\` for synthetic rows (e.g. \`{"_key": lang + "-" + market, ...}\`); scalar rows key on their value. Row: ${JSON.stringify(row)}`);
 }
 
 function condemnOnExitCohorts({mutation: mutation, stage: stage, exitedEntry: exitedEntry, at: at}) {
-    for (const activity of stage.activities ?? []) {
-        const sub = activity.subworkflows;
-        if (!(sub === void 0 || subworkflowsOnExit(sub) !== "abort")) for (const row of liveSubworkflows(mutation)) row.activity !== activity.name || row.stageEntry !== exitedEntry._key || condemnSubworkflow(row, {
+    const abortCohorts = (stage.activities ?? []).flatMap(activity => (activity.actions ?? []).filter(action => action.spawn !== void 0 && subworkflowsOnExit(action.spawn) === "abort").map(action => ({
+        activity: activity.name,
+        action: action.name
+    })));
+    for (const cohort of abortCohorts) {
+        const owed = liveSubworkflows(mutation).filter(row => row.activity === cohort.activity && row.action === cohort.action && row.stageEntry === exitedEntry._key);
+        for (const row of owed) condemnSubworkflow(row, {
             at: at,
-            reason: `stage "${stage.name}" exited with the child still live (onExit: "abort" on activity "${activity.name}")`
+            reason: `stage "${stage.name}" exited with the child still live (onExit: "abort" on action "${cohort.action}" of activity "${cohort.activity}")`
         });
     }
 }
@@ -4679,7 +4900,7 @@ async function projectRowFields({ctx: ctx, sub: sub, childDefinition: childDefin
     const out = [];
     for (const [name, groq] of Object.entries(sub.with ?? {})) {
         const declared = (childDefinition.fields ?? []).find(e => e.name === name);
-        if (declared === void 0) throw new Error(`subworkflows.with["${name}"]: subworkflow "${childDefinition.name}" declares no field entry "${name}"`);
+        if (declared === void 0) throw new Error(`spawn.with["${name}"]: subworkflow "${childDefinition.name}" declares no field entry "${name}"`);
         const raw = await invariants.runGroq({
             groq: groq,
             params: {
@@ -4709,7 +4930,7 @@ async function projectRowFields({ctx: ctx, sub: sub, childDefinition: childDefin
                 types: declared.types,
                 value: value
             }).includes("document") ? ' A projected bare id or `_ref` canonicalises with the generic type "document" — project the target\'s schema type alongside its id (e.g. {"id": _id, "type": _type}).' : "";
-            throw new Error(`subworkflows.with["${name}"] on subworkflow "${childDefinition.name}": ${typeIssues.join("; ")}.${hint}`);
+            throw new Error(`spawn.with["${name}"] on subworkflow "${childDefinition.name}": ${typeIssues.join("; ")}.${hint}`);
         }
         out.push({
             type: declared.type,
@@ -4740,7 +4961,7 @@ async function resolveContextHandoff({ctx: ctx, sub: sub, parentScope: parentSco
                 };
                 continue;
             }
-            throw new Error(`subworkflows.context["${name}"] evaluated to ${JSON.stringify(v2)}, which the handoff cannot carry. A context entry seeds the child's $effects bag with a string, number, boolean, or a document reference — a full GDR \`{id, type}\` whose \`id\` is a "<scheme>:..." URI (parent-scope ids are already canonical).`);
+            throw new Error(`spawn.context["${name}"] evaluated to ${JSON.stringify(v2)}, which the handoff cannot carry. A context entry seeds the child's $context bag with a string, number, boolean, or a document reference — a full GDR \`{id, type}\` whose \`id\` is a "<scheme>:..." URI (parent-scope ids are already canonical).`);
         }
     }
     return out;
@@ -4751,7 +4972,7 @@ function canonicaliseSpawnValue({kind: kind, value: value, cx: cx}) {
 }
 
 function assertBareIdRootsCorrectly(id, cx) {
-    if (!(cx.discoveryResource === void 0 || invariants.sameResource(cx.discoveryResource, cx.parentResource))) throw new Error(`subworkflows.with["${cx.entryName}"]: subworkflow "${cx.childName}" projected the bare id "${id}", which roots at the parent resource "${cx.parentResource.id}", but spawn discovery ran against "${cx.discoveryResource.id}". The child would reference a document that doesn't exist in the parent resource. Project an explicit GDR URI in the with-GROQ (e.g. "dataset:<projectId>:<dataset>:" + _id) so the child's subject points at the resource the discovered rows came from.`);
+    if (!(cx.discoveryResource === void 0 || invariants.sameResource(cx.discoveryResource, cx.parentResource))) throw new Error(`spawn.with["${cx.entryName}"]: subworkflow "${cx.childName}" projected the bare id "${id}", which roots at the parent resource "${cx.parentResource.id}", but spawn discovery ran against "${cx.discoveryResource.id}". The child would reference a document that doesn't exist in the parent resource. Project an explicit GDR URI in the with-GROQ (e.g. "dataset:<projectId>:<dataset>:" + _id) so the child's subject points at the resource the discovered rows came from.`);
 }
 
 function coerceSpawnGdr(raw, cx) {
@@ -4786,7 +5007,7 @@ async function resolveDefinitionRef({client: client, ref: ref, tag: tag}) {
 }
 
 async function prepareChildInstance(args) {
-    const {client: client, parent: parent, definition: definition, initialFields: initialFields, effectsContext: effectsContext, actor: actor, now: now} = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = instanceDocId(childTag), childRef = {
+    const {client: client, parent: parent, definition: definition, initialFields: initialFields, context: context, actor: actor, now: now} = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = instanceDocId(childTag), childRef = {
         id: invariants.gdrFromResource(workflowResource, childDocId),
         type: WORKFLOW_INSTANCE_TYPE
     }, ancestors = [ ...parent.ancestors, {
@@ -4812,7 +5033,7 @@ async function prepareChildInstance(args) {
             })
         },
         randomKey: randomKey
-    }), childPerspective = derivePerspectiveFromFields(childFields) ?? inheritedPerspective, effectsContextEntries = Object.entries(effectsContext).map(([key, value]) => effectsContextEntry(key, value)), base = buildInstanceBase({
+    }), childPerspective = derivePerspectiveFromFields(childFields) ?? inheritedPerspective, contextEntries = Object.entries(context).map(([key, value]) => contextEntry(key, value)), base = buildInstanceBase({
         id: childDocId,
         now: now,
         tag: childTag,
@@ -4822,7 +5043,7 @@ async function prepareChildInstance(args) {
         pinnedContentHash: definition.contentHash,
         definition: definition,
         fields: childFields,
-        effectsContext: effectsContextEntries,
+        context: contextEntries,
         ancestors: ancestors,
         perspective: childPerspective,
         initialStage: definition.initialStage,
@@ -4837,182 +5058,6 @@ async function prepareChildInstance(args) {
     };
 }
 
-async function invokeActivity(args) {
-    const {client: client, instanceId: instanceId, activity: activityName, options: options} = args, ctx = await loadCallContext({
-        client: client,
-        instanceId: instanceId,
-        options: options
-    });
-    return commitInvoke({
-        ctx: ctx,
-        activityName: activityName,
-        actor: options?.actor
-    });
-}
-
-async function commitInvoke({ctx: ctx, activityName: activityName, actor: actor}) {
-    const {activity: activity} = findActivityInCurrentStage(ctx, activityName), entry = findCurrentActivities(ctx.instance).find(t => t.name === activityName);
-    if (entry === void 0) throw new Error(`Activity "${activityName}" has no status entry on instance ${ctx.instance._id}`);
-    if (entry.status !== "pending") return {
-        invoked: !1,
-        activity: activityName
-    };
-    const mutation = startMutation(ctx.instance), mutEntry = requireMutationActivityEntry(mutation, activityName);
-    return await activateActivity({
-        ctx: ctx,
-        mutation: mutation,
-        activity: activity,
-        entry: mutEntry,
-        actor: actor
-    }), await persist(ctx, mutation), {
-        invoked: !0,
-        activity: activityName
-    };
-}
-
-async function activateActivity({ctx: ctx, mutation: mutation, activity: activity, entry: entry, actor: actor}) {
-    const now = ctx.now;
-    if (entry.status = "active", entry.startedAt = now, activity.fields !== void 0 && activity.fields.length > 0) {
-        const stage = findStage(ctx.definition, mutation.currentStage);
-        entry.fields = await resolveActivityFieldEntries({
-            client: ctx.client,
-            instance: ctx.instance,
-            stage: stage,
-            activity: activity,
-            now: now,
-            recordDiscard: recordFieldDiscards({
-                target: mutation.history,
-                scope: "activity",
-                at: now
-            })
-        });
-    }
-    await runOps({
-        ops: activity.ops,
-        mutation: mutation,
-        stage: mutation.currentStage,
-        origin: {
-            activity: activity.name
-        },
-        params: {},
-        actor: actor,
-        self: invariants.selfGdr(ctx.instance),
-        now: now,
-        snapshot: ctx.snapshot
-    }), mutation.history.push({
-        _key: randomKey(),
-        _type: "activityActivated",
-        at: now,
-        stage: mutation.currentStage,
-        activity: activity.name,
-        ...actor !== void 0 ? {
-            actor: actor
-        } : {}
-    }), await queueEffects({
-        ctx: ctx,
-        mutation: mutation,
-        effects: activity.effects,
-        origin: {
-            kind: "activity",
-            name: activity.name
-        },
-        actor: actor,
-        opts: {
-            activityName: activity.name
-        }
-    }), activity.subworkflows !== void 0 && await spawnSubworkflows({
-        ctx: ctx,
-        mutation: mutation,
-        activity: activity,
-        sub: activity.subworkflows,
-        actor: actor
-    }), !await autoResolveOnActivate({
-        ctx: ctx,
-        mutation: mutation,
-        activity: activity,
-        entry: entry,
-        now: now,
-        actor: actor
-    }) && resolveMachineStep({
-        mutation: mutation,
-        activity: activity,
-        entry: entry,
-        now: now,
-        actor: actor
-    });
-}
-
-async function autoResolveOnActivate({ctx: ctx, mutation: mutation, activity: activity, entry: entry, now: now, actor: actor}) {
-    if (activity.failWhen === void 0 && effectiveCompleteWhen(activity) === void 0) return !1;
-    const gateCtx = {
-        ...ctx,
-        instance: materializeInstance(ctx.instance, mutation)
-    }, outcome = await evaluateResolutionGate({
-        ctx: gateCtx,
-        activity: activity
-    });
-    return outcome === void 0 ? !1 : (applyGateOutcome({
-        entry: entry,
-        history: mutation.history,
-        stage: mutation.currentStage,
-        at: now,
-        outcome: outcome,
-        actor: actor
-    }), !0);
-}
-
-function resolveMachineStep({mutation: mutation, activity: activity, entry: entry, now: now, actor: actor}) {
-    const waitsForActor = activity.actions !== void 0 && activity.actions.length > 0, waitsForCondition = activity.completeWhen !== void 0 || activity.subworkflows !== void 0;
-    waitsForActor || waitsForCondition || applyActivityStatusChange({
-        entry: entry,
-        history: mutation.history,
-        stage: mutation.currentStage,
-        to: "done",
-        at: now,
-        ...actor !== void 0 ? {
-            actor: actor
-        } : {}
-    });
-}
-
-async function buildStageActivities(ctx, stage) {
-    const entries = [];
-    for (const activity of stage.activities ?? []) {
-        const outcome = await ctxEvaluateConditionOutcome({
-            ctx: ctx,
-            condition: activity.filter,
-            opts: {
-                activityName: activity.name
-            }
-        }), inScope = outcome !== "unsatisfied";
-        entries.push({
-            _key: randomKey(),
-            name: activity.name,
-            status: inScope ? "pending" : "skipped",
-            ...activity.filter !== void 0 ? {
-                filterEvaluation: buildFilterEvaluation({
-                    at: ctx.now,
-                    filter: activity.filter,
-                    outcome: outcome
-                })
-            } : {}
-        });
-    }
-    return entries;
-}
-
-function buildFilterEvaluation({at: at, filter: filter, outcome: outcome}) {
-    return outcome === "unevaluable" ? {
-        at: at,
-        truthy: !1,
-        unevaluable: !0,
-        detail: `Filter "${filter}" could not be evaluated (GROQ null — a referenced operand was missing or incomparable). Activity kept in scope so the gate is not silently skipped.`
-    } : {
-        at: at,
-        truthy: outcome === "satisfied"
-    };
-}
-
 function isTerminalStage(stage) {
     return (stage.transitions ?? []).length === 0;
 }
@@ -5032,13 +5077,13 @@ async function setStage(args) {
     });
 }
 
-async function enterStage({ctx: ctx, mutation: mutation, nextStage: nextStage, actor: actor, at: at, entryKey: entryKey}) {
+async function enterStage({ctx: ctx, mutation: mutation, nextStage: nextStage, at: at}) {
     mutation.currentStage = nextStage.name;
     const entryCtx = {
         ...ctx,
         instance: materializeInstance(ctx.instance, mutation)
     }, nextStageEntry = {
-        _key: entryKey ?? randomKey(),
+        _key: randomKey(),
         name: nextStage.name,
         enteredAt: at,
         fields: await resolveStageFieldEntries({
@@ -5054,19 +5099,15 @@ async function enterStage({ctx: ctx, mutation: mutation, nextStage: nextStage, a
         }),
         activities: []
     };
-    mutation.stages.push(nextStageEntry), nextStageEntry.activities = await buildStageActivities(entryCtx, nextStage);
-    for (const activity of nextStage.activities ?? []) {
-        if (activity.activation !== "auto") continue;
-        const entry = nextStageEntry.activities.find(t => t.name === activity.name);
-        entry && entry.status === "pending" && await activateActivity({
-            ctx: entryCtx,
-            mutation: mutation,
-            activity: activity,
-            entry: entry,
-            actor: actor
-        });
-    }
-    isTerminalStage(nextStage) && (mutation.completedAt = at);
+    mutation.stages.push(nextStageEntry), nextStageEntry.activities = await buildStageActivities({
+        ctx: entryCtx,
+        stage: nextStage,
+        recordDiscard: recordFieldDiscards({
+            target: mutation.history,
+            scope: "activity",
+            at: at
+        })
+    }), isTerminalStage(nextStage) && (mutation.completedAt = at);
 }
 
 function isTerminal(ctx) {
@@ -5091,13 +5132,34 @@ async function commitSetStage({ctx: ctx, targetStage: targetStage, reason: reaso
         record: requestRecord,
         now: ctx.now
     });
-    const at = ctx.now, transitionName = `setStage:${currentStage.name}->${nextStage.name}`;
-    return mutation.history.push(...stageTransitionHistory({
+    const transitionName = `setStage:${currentStage.name}->${nextStage.name}`;
+    return await commitStageMove({
+        ctx: ctx,
+        mutation: mutation,
+        fromStage: currentStage,
+        toStage: nextStage,
+        transition: transitionName,
+        via: "setStage",
+        actor: actor,
+        reason: reason
+    }), {
+        fired: !0,
         fromStage: currentStage.name,
         toStage: nextStage.name,
+        transition: transitionName
+    };
+}
+
+async function commitStageMove({ctx: ctx, mutation: mutation, fromStage: fromStage, toStage: toStage, transition: transition, via: via, actor: actor, reason: reason}) {
+    const at = ctx.now;
+    mutation.history.push(...stageTransitionHistory({
+        fromStage: fromStage.name,
+        toStage: toStage.name,
         at: at,
-        transition: transitionName,
-        via: "setStage",
+        transition: transition,
+        ...via === "setStage" ? {
+            via: via
+        } : {},
         ...actor !== void 0 ? {
             actor: actor
         } : {},
@@ -5106,30 +5168,24 @@ async function commitSetStage({ctx: ctx, targetStage: targetStage, reason: reaso
         } : {}
     })), exitOpenStage({
         mutation: mutation,
-        stage: currentStage,
+        stage: fromStage,
         at: at
     }), await enterStage({
         ctx: ctx,
         mutation: mutation,
-        nextStage: nextStage,
-        actor: actor,
+        nextStage: toStage,
         at: at
     }), await persistStageMove({
         ctx: ctx,
         mutation: mutation,
-        exitedStage: currentStage.name,
-        enteredStage: nextStage.name
+        exitedStage: fromStage.name,
+        enteredStage: toStage.name
     }), emitStageTransitioned({
         ctx: ctx,
-        nextStage: nextStage,
+        nextStage: toStage,
         at: at,
-        via: "setStage"
-    }), {
-        fired: !0,
-        fromStage: currentStage.name,
-        toStage: nextStage.name,
-        transition: transitionName
-    };
+        via: via
+    });
 }
 
 function emitStageTransitioned({ctx: ctx, nextStage: nextStage, at: at, via: via}) {
@@ -5177,893 +5233,321 @@ async function persistStageMove({ctx: ctx, mutation: mutation, exitedStage: exit
     });
 }
 
-async function commitTransition(ctx, actor) {
-    if (isTerminal(ctx)) return {
-        fired: !1
-    };
-    const currentStage = findStage(ctx.definition, ctx.instance.currentStage), transition = await pickTransition(ctx, currentStage);
-    if (transition === void 0) return {
-        fired: !1
-    };
-    const mutation = startMutation(ctx.instance), at = ctx.now;
-    await runOps({
-        ops: transition.ops,
-        mutation: mutation,
-        stage: currentStage.name,
-        origin: {
-            transition: transition.name
-        },
-        params: {},
-        actor: actor,
-        self: invariants.selfGdr(ctx.instance),
-        now: at,
-        snapshot: ctx.snapshot
-    });
-    const nextEntryKey = randomKey();
-    await queueEffects({
-        ctx: ctx,
-        mutation: mutation,
-        effects: transition.effects,
-        origin: {
-            kind: "transition",
-            name: transition.name
-        },
-        actor: actor,
-        opts: {
-            stageEntryKey: nextEntryKey
-        }
-    }), mutation.history.push(...stageTransitionHistory({
-        fromStage: currentStage.name,
-        toStage: transition.to,
-        at: at,
-        transition: transition.name,
-        ...actor !== void 0 ? {
-            actor: actor
-        } : {}
-    })), exitOpenStage({
-        mutation: mutation,
-        stage: currentStage,
-        at: at
-    });
-    const nextStage = findStage(ctx.definition, transition.to);
-    return await enterStage({
-        ctx: ctx,
-        mutation: mutation,
-        nextStage: nextStage,
-        actor: actor,
-        at: at,
-        entryKey: nextEntryKey
-    }), await persistStageMove({
-        ctx: ctx,
-        mutation: mutation,
-        exitedStage: currentStage.name,
-        enteredStage: nextStage.name
-    }), emitStageTransitioned({
-        ctx: ctx,
-        nextStage: nextStage,
-        at: at,
-        via: "transition"
-    }), {
-        fired: !0,
-        fromStage: currentStage.name,
-        toStage: transition.to,
-        transition: transition.name
-    };
-}
-
 async function pickTransition(ctx, stage) {
     for (const candidate of stage.transitions ?? []) {
         const outcome = await ctxEvaluateConditionOutcome({
             ctx: ctx,
-            condition: candidate.filter
+            condition: candidate.when
         });
         if (outcome === "satisfied") return candidate;
         if (outcome === "unevaluable") return;
     }
 }
 
-async function evaluateAutoTransitions(args) {
-    const {client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay} = args, ctx = await loadContext({
-        client: client,
-        instanceId: instanceId,
-        options: {
-            clientForGdr: clientForGdr,
-            ...actor ? {
-                actor: actor
-            } : {},
-            ...clock ? {
-                clock: clock
-            } : {},
-            ...executionContext ? {
-                executionContext: executionContext
-            } : {},
-            ...telemetry ? {
-                telemetry: telemetry
-            } : {},
-            ...overlay ? {
-                overlay: overlay
-            } : {}
-        }
-    });
-    return commitTransition(ctx, actor);
-}
+const parsedFilters = /* @__PURE__ */ new Map;
 
-async function primeInitialStage({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    const instance = await getInstanceDocument(client, instanceId);
-    if (!instance || instance.stages.length > 0) return;
-    const definition = parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
-    if (stage === void 0) return;
-    const ctx = await buildEngineContext({
-        client: client,
-        clientForGdr: clientForGdr,
-        instance: instance,
-        definition: definition,
-        ...clock ? {
-            clock: clock
-        } : {},
-        ...actor ? {
-            actor: actor
-        } : {},
-        ...executionContext ? {
-            executionContext: executionContext
-        } : {},
-        ...telemetry ? {
-            telemetry: telemetry
+async function matchesFilter(args) {
+    const {document: document, filter: filter, userId: userId} = args;
+    parsedFilters.has(filter) || parsedFilters.set(filter, groqJs.parse(`*[${filter}]`));
+    const ast = parsedFilters.get(filter), data = await (await groqJs.evaluate(ast, {
+        dataset: [ document ],
+        ...userId !== void 0 ? {
+            identity: userId
         } : {}
-    }), now = ctx.now, discards = [], initialStageEntry = {
-        _key: randomKey(),
-        name: stage.name,
-        enteredAt: now,
-        fields: await resolveStageFieldEntries({
-            client: client,
-            instance: instance,
-            stage: stage,
-            now: now,
-            recordDiscard: recordFieldDiscards({
-                target: discards,
-                scope: "stage",
-                at: now
-            })
-        }),
-        activities: []
-    }, primedCtx = {
-        ...ctx,
-        instance: {
-            ...instance,
-            stages: [ initialStageEntry ]
-        }
-    };
-    initialStageEntry.activities = await buildStageActivities(primedCtx, stage);
-    const committed = await client.patch(instance._id).set({
-        stages: [ initialStageEntry ],
-        lastChangedAt: now,
-        ...discards.length > 0 ? {
-            history: [ ...instance.history, ...stampHistoryEntries(discards, ctx.executionContext) ]
+    })).get();
+    return Array.isArray(data) && data.length === 1;
+}
+
+async function grantsPermissionOn(args) {
+    const {document: document, grants: grants, permission: permission, userId: userId} = args;
+    if (!document || grants.length === 0) return !1;
+    for (const grant of grants) if (grant.permissions.includes(permission) && await matchesFilter({
+        document: document,
+        filter: grant.filter,
+        ...userId !== void 0 ? {
+            userId: userId
+        } : {}
+    })) return !0;
+    return !1;
+}
+
+function aclPathForResource(res) {
+    if (res.type === "dataset") {
+        const {projectId: projectId, dataset: dataset} = invariants.datasetResourceParts(res.id);
+        return `/projects/${projectId}/datasets/${dataset}/acl`;
+    }
+    if (res.type === "canvas") return `/canvases/${res.id}/acl`;
+}
+
+async function fetchGrants(args) {
+    const {client: client, resourcePath: resourcePath, signal: signal} = args;
+    return client.request({
+        url: resourcePath,
+        tag: REQUEST_TAG.accessGrants,
+        ...signal ? {
+            signal: signal
         } : {}
-    }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
-    await deployOrRollback({
-        client: client,
-        instanceId: instance._id,
-        committedRev: committed._rev,
-        restore: {
-            stages: instance.stages,
-            history: instance.history
-        },
-        reversible: !0,
-        deploy: () => deployStageGuards({
-            client: client,
-            clientForGdr: clientForGdr,
-            instance: instance,
-            definition: definition,
-            stageName: stage.name,
-            now: now,
-            snapshot: ctx.snapshot
-        })
-    }), await autoActivatePrimedActivities({
-        client: client,
-        instanceId: instanceId,
-        definition: definition,
-        stage: stage,
-        actor: actor,
-        clientForGdr: clientForGdr,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
     });
 }
 
-async function autoActivatePrimedActivities({client: client, instanceId: instanceId, definition: definition, stage: stage, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    for (const activity of stage.activities ?? []) activity.activation === "auto" && await activatePrimedActivity({
+const actorCache = /* @__PURE__ */ new WeakMap, grantsCache = /* @__PURE__ */ new WeakMap;
+
+async function resolveAccess(taggedClient, args = {}) {
+    const client = unwrapRequestTag(taggedClient), requestFn = lazyRequest(client);
+    if (requestFn === void 0) throw new invariants.ContractViolationError("workflow: no actor available. The engine resolves the actor from the client's token via `client.request({ uri: '/users/me' })`. Supply a real `@sanity/client` configured with a token (the test bench serves these endpoints per registered token).");
+    const grantsPromise = args.grantsFromPath !== void 0 ? cachedGrants({
         client: client,
-        instanceId: instanceId,
-        definition: definition,
-        activity: activity,
+        requestFn: requestFn,
+        resourcePath: args.grantsFromPath
+    }) : Promise.resolve(void 0), [actor, grants] = await Promise.all([ cachedActor(client, requestFn), grantsPromise ]);
+    if (actor === void 0) throw new invariants.ContractViolationError("workflow: failed to resolve actor from `/users/me`. The client is configured but the endpoint returned no usable identity — check the token.");
+    return {
         actor: actor,
-        clientForGdr: clientForGdr,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
+        ...grants !== void 0 ? {
+            grants: grants
+        } : {}
+    };
+}
+
+function cachedActor(client, requestFn) {
+    const cached = actorCache.get(client);
+    if (cached !== void 0) return cached;
+    const pending = fetchActor(requestFn).catch(err => {
+        throw actorCache.get(client) === pending && actorCache.delete(client), err;
     });
+    return actorCache.set(client, pending), pending;
 }
 
-async function activatePrimedActivity({client: client, instanceId: instanceId, definition: definition, activity: activity, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    const updated = await getInstanceDocument(client, instanceId);
-    if (!updated) return;
-    const ctx = await buildEngineContext({
+function grantsForClientPath(taggedClient, resourcePath) {
+    const client = unwrapRequestTag(taggedClient), requestFn = lazyRequest(client);
+    return requestFn === void 0 ? Promise.resolve(void 0) : cachedGrants({
         client: client,
-        clientForGdr: clientForGdr,
-        instance: updated,
-        definition: definition,
-        ...clock ? {
-            clock: clock
-        } : {},
-        ...actor ? {
-            actor: actor
-        } : {},
-        ...executionContext ? {
-            executionContext: executionContext
-        } : {},
-        ...telemetry ? {
-            telemetry: telemetry
-        } : {}
-    }), mutation = startMutation(updated), mutEntry = currentActivities(mutation).find(t => t.name === activity.name);
-    mutEntry && mutEntry.status === "pending" && (await activateActivity({
-        ctx: ctx,
-        mutation: mutation,
-        activity: activity,
-        entry: mutEntry,
-        actor: actor
-    }), await persist(ctx, mutation));
+        requestFn: requestFn,
+        resourcePath: resourcePath
+    });
 }
 
-const CASCADE_LIMIT = 100;
+function lazyRequest(client) {
+    return client.request === void 0 ? void 0 : opts => client.request(opts);
+}
 
-async function gatherAutoResolveCandidates(ctx, activities) {
-    const currentActivitiesList = findCurrentActivities(ctx.instance), candidates = [];
-    for (const activity of activities) {
-        if (currentActivitiesList.find(e => e.name === activity.name)?.status !== "active") continue;
-        const outcome = await evaluateResolutionGate({
-            ctx: ctx,
-            activity: activity
+function cachedGrants({client: client, requestFn: requestFn, resourcePath: resourcePath}) {
+    let byPath = grantsCache.get(client);
+    byPath === void 0 && (byPath = /* @__PURE__ */ new Map, grantsCache.set(client, byPath));
+    let cached = byPath.get(resourcePath);
+    return cached === void 0 && (cached = fetchGrantsCached(requestFn, resourcePath), 
+    byPath.set(resourcePath, cached)), cached;
+}
+
+async function fetchActor(requestFn) {
+    let user;
+    try {
+        user = await requestFn({
+            uri: "/users/me",
+            tag: REQUEST_TAG.accessResolveActor
         });
-        outcome !== void 0 && candidates.push({
-            activity: activity,
-            outcome: outcome
+    } catch (err) {
+        throw new Error('workflow: /users/me request failed. The engine resolves the actor from the client\'s token via `client.request({ uri: "/users/me" })`. Check the token/connectivity.', {
+            cause: err
         });
     }
-    return candidates;
+    if (!user || typeof user.id != "string" || user.id.length === 0) return;
+    const roleNames = user.roles?.map(r => r.name).filter(n => !!n) ?? [];
+    return {
+        kind: "person",
+        id: user.id,
+        ...roleNames.length > 0 ? {
+            roles: roleNames
+        } : {}
+    };
 }
 
-async function resolveCompleteWhen({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
-    const ctx = await loadContext({
-        client: client,
-        instanceId: instanceId,
-        options: {
-            clientForGdr: clientForGdr,
-            ...actor ? {
-                actor: actor
-            } : {},
-            ...clock ? {
-                clock: clock
-            } : {},
-            ...executionContext ? {
-                executionContext: executionContext
-            } : {},
-            ...telemetry ? {
-                telemetry: telemetry
-            } : {},
-            ...overlay ? {
-                overlay: overlay
-            } : {}
-        }
-    }), stage = findStage(ctx.definition, ctx.instance.currentStage), gatedActivities = (stage.activities ?? []).filter(t => effectiveCompleteWhen(t) !== void 0 || t.failWhen !== void 0);
-    if (gatedActivities.length === 0) return 0;
-    const candidates = await gatherAutoResolveCandidates(ctx, gatedActivities);
-    if (candidates.length === 0) return 0;
-    const mutation = startMutation(ctx.instance);
-    let count = 0;
-    for (const {activity: activity, outcome: outcome} of candidates) {
-        const mutEntry = currentActivities(mutation).find(t => t.name === activity.name);
-        mutEntry === void 0 || mutEntry.status !== "active" || (applyGateOutcome({
-            entry: mutEntry,
-            history: mutation.history,
-            stage: stage.name,
-            at: ctx.now,
-            outcome: outcome,
-            actor: actor
-        }), count++);
+async function fetchGrantsCached(requestFn, resourcePath) {
+    try {
+        return await fetchGrants({
+            client: {
+                request: requestFn
+            },
+            resourcePath: resourcePath
+        });
+    } catch (err) {
+        console.warn(`workflow: failed to fetch grants from "${resourcePath}"; advisory permission reads that depend on them are skipped — a rendered $can stays undefined (conditions referencing it fail closed) and the subject-write forecast omits this resource. The lake still enforces writes. Original error: ${invariants.errorMessage(err)}`);
+        return;
     }
-    return count > 0 && await persist(ctx, mutation), count;
 }
 
-async function cascadeAutoTransitions({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
-    let count = 0;
-    for (;;) {
-        if (await drainCondemnedChildren({
-            client: client,
-            instanceId: instanceId,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            clock: clock,
-            executionContext: executionContext,
-            telemetry: telemetry
-        }), await resolveCompleteWhen({
-            client: client,
-            instanceId: instanceId,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            clock: clock,
-            executionContext: executionContext,
-            telemetry: telemetry,
-            overlay: overlay
-        }), !(await evaluateAutoTransitions({
-            client: client,
-            instanceId: instanceId,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            ...clock ? {
-                clock: clock
-            } : {},
-            ...executionContext ? {
-                executionContext: executionContext
-            } : {},
-            ...telemetry ? {
-                telemetry: telemetry
-            } : {},
-            ...overlay ? {
-                overlay: overlay
-            } : {}
-        })).fired) return count;
-        if (count++, count >= CASCADE_LIMIT) throw new CascadeLimitError({
-            instanceId: instanceId,
-            limit: CASCADE_LIMIT
+async function buildFieldInsights({sites: sites, snapshot: snapshot}) {
+    const insights = [];
+    for (const field of fieldsReadAcross(sites)) {
+        const involved = sites.filter(entry => readsField(entry.insight, field));
+        insights.push({
+            field: field,
+            reads: groqConditionDescribe.dedupeReads(involved.flatMap(entry => fieldReads(entry.insight, field))),
+            involvedIn: involved.map(entry => entry.site),
+            proposals: await verifyProposals({
+                field: field,
+                involved: involved,
+                snapshot: snapshot
+            })
         });
     }
+    return insights;
 }
 
-async function drainCondemnedChildren({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining = /* @__PURE__ */ new Set}) {
-    if (draining.has(instanceId)) return;
-    draining.add(instanceId);
-    const instance = await getInstanceDocument(client, instanceId);
-    if (!instance) return;
-    const condemned = condemnedSubworkflows(instance);
-    if (condemned.length !== 0) {
-        for (const row of condemned) await settleCondemnedRow({
-            client: client,
-            ownerId: instanceId,
-            row: row,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            clock: clock,
-            executionContext: executionContext,
-            telemetry: telemetry,
-            draining: draining
-        });
-        await stampDrainedRows({
-            client: client,
-            instance: instance,
-            condemned: condemned,
-            clock: clock,
-            executionContext: executionContext
-        });
-    }
+function fieldsReadAcross(sites) {
+    const names = sites.flatMap(entry => entry.insight.analysis.reads).filter(read => read.variable === "fields").map(read => read.path[0]).filter(head => typeof head == "string");
+    return [ ...new Set(names) ];
 }
 
-async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining}) {
-    const childId = invariants.toBareId(row.ref.id);
-    try {
-        await abortInstance({
-            client: client,
-            instanceId: childId,
-            reason: row.abortPending?.reason ?? "condemned by parent",
-            options: {
-                ...actor ? {
-                    actor: actor
-                } : {},
-                clientForGdr: clientForGdr,
-                ...clock ? {
-                    clock: clock
-                } : {},
-                ...executionContext ? {
-                    executionContext: executionContext
-                } : {},
-                ...telemetry ? {
-                    telemetry: telemetry
-                } : {}
-            }
-        }), await drainCondemnedChildren({
-            client: client,
-            instanceId: childId,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            clock: clock,
-            executionContext: executionContext,
-            telemetry: telemetry,
-            draining: draining
-        });
-    } catch (cause) {
-        if (cause instanceof invariants.InstanceNotFoundError) return;
-        throw cause instanceof WorkflowStateDivergedError ? cause : new WorkflowStateDivergedError({
-            instanceId: ownerId,
-            guardError: cause,
-            reason: `owed child abort of "${childId}" failed while draining condemned rows`
+function fieldReads(insight, field) {
+    return insight.analysis.reads.filter(read => read.variable === "fields" && read.path[0] === field);
+}
+
+function readsField(insight, field) {
+    return fieldReads(insight, field).length > 0;
+}
+
+async function verifyProposals({field: field, involved: involved, snapshot: snapshot}) {
+    const proposals = [];
+    for (const assign of candidateAssignments(involved, field)) {
+        const consequences = [];
+        for (const entry of involved) {
+            const result = await groqConditionDescribe.whatIfCondition({
+                condition: entry.condition,
+                dataset: snapshot.docs,
+                params: entry.params,
+                assign: assign
+            });
+            result.changed && consequences.push({
+                site: entry.site,
+                before: result.before,
+                after: result.after
+            });
+        }
+        consequences.length > 0 && proposals.push({
+            assign: assign,
+            consequences: consequences
         });
     }
+    return proposals;
 }
 
-async function stampDrainedRows({client: client, instance: instance, condemned: condemned, clock: clock, executionContext: executionContext}) {
-    const now = (clock ?? wallClock)(), stamp = resolveExecutionContext(executionContext), ids = condemned.map(row => invariants.toBareId(row.ref.id)), children = await client.fetch("*[_id in $ids]{_id, currentStage, completedAt, abortedAt, modelVersion, minReaderModel}", {
-        ids: ids
-    }), byId = new Map(children.map(c => [ assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
-        if (row.resolved !== void 0 || !condemnedKeys.has(row._key)) return row;
-        const child = byId.get(invariants.toBareId(row.ref.id)), resolved = child !== void 0 ? terminalResolution(child) : {
-            at: now,
-            aborted: !0
-        };
-        return resolved === void 0 ? row : (history.push(...stampHistoryEntries([ subworkflowResolvedEntry({
-            row: row,
-            at: now,
-            status: resolved.aborted === !0 ? "aborted" : "done"
-        }) ], stamp)), {
-            ...row,
-            resolved: resolved
-        });
-    });
-    await client.patch(instance._id).set({
-        subworkflows: subworkflows,
-        history: history,
-        lastChangedAt: now
-    }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
+function candidateAssignments(involved, field) {
+    const candidates = involved.flatMap(entry => entry.insight.blockedBy).flatMap(atom => atom.requirement !== void 0 ? [ atom.requirement ] : []).filter(requirement => requirement.target.variable === "fields").filter(requirement => requirement.target.path[0] === field).flatMap(assignmentFor).filter(fabricatable);
+    return groqConditionDescribe.dedupeBy(candidates, assignment => JSON.stringify([ assignment.target.path, assignment.value ]));
 }
 
-function terminalResolution(child) {
-    const status = resolvedChildStatus(child);
-    if (!(status === void 0 || child.completedAt === void 0 || child.completedAt === null)) return {
-        at: child.completedAt,
-        stage: child.currentStage,
-        ...status === "aborted" ? {
-            aborted: !0
-        } : {}
-    };
+function assignmentFor(requirement) {
+    switch (requirement.kind) {
+      case "equals":
+        return [ {
+            target: requirement.target,
+            value: requirement.value
+        } ];
+
+      case "truthy":
+        return [ {
+            target: requirement.target,
+            value: !0
+        } ];
+
+      case "falsy":
+        return [ {
+            target: requirement.target,
+            value: !1
+        } ];
+
+      case "differs":
+      case "defined":
+      case "undefined":
+      case "compares":
+        return [];
+    }
 }
 
-function subworkflowResolvedEntry({row: row, at: at, status: status}) {
-    return {
-        _key: randomKey(),
-        _type: "subworkflowResolved",
-        at: at,
-        activity: row.activity,
-        instanceRef: row.ref,
-        status: status
-    };
+function fabricatable(assignment) {
+    return assignment.target.path.every(segment => typeof segment != "number" || segment <= groqConditionDescribe.MAX_COUNTERFACTUAL_INDEX);
 }
 
-async function propagateToAncestors({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    const loaded = await loadPropagationPair(client, instanceId);
-    if (loaded === void 0) return;
-    const {child: child, parent: parent} = loaded, definition = parseDefinitionSnapshot(parent), ctx = await buildEngineContext({
+async function subjectResourceGrants(args) {
+    const {clientForGdr: clientForGdr, instance: instance} = args, clients = /* @__PURE__ */ new Map;
+    for (const {parsed: parsed, resource: resource} of foreignSubjectRefs(instance)) {
+        const key = invariants.resourceGdr(resource);
+        clients.has(key) || clients.set(key, {
+            resource: resource,
+            client: clientForGdr(parsed)
+        });
+    }
+    const resolved = await Promise.all([ ...clients.entries() ].map(async ([key, entry]) => {
+        const path = aclPathForResource(entry.resource);
+        if (path === void 0) return;
+        const grants = await grantsForClientPath(entry.client, path);
+        return grants === void 0 ? void 0 : [ key, grants ];
+    }));
+    return new Map(resolved.filter(entry => entry !== void 0));
+}
+
+const UNBOUND_CALLER_VARS = Object.fromEntries(invariants.CALLER_BOUND_VARS.map(name => [ name, void 0 ]));
+
+async function evaluateInstance(args) {
+    const {client: client, tag: tag, workflowResource: workflowResource, instanceId: instanceId, resourceClients: resourceClients} = args, now = (args.clock ?? wallClock)();
+    invariants.validateTag(tag);
+    const {actor: actor, grants: grants} = await resolveAccess(client, {
+        ...args.grantsFromPath !== void 0 ? {
+            grantsFromPath: args.grantsFromPath
+        } : {}
+    }), instance = await reload({
+        client: client,
+        instanceId: instanceId,
+        tag: tag
+    }), definition = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+        client: client,
+        workflowResource: workflowResource,
+        resourceClients: resourceClients
+    }), snapshot = await hydrateSnapshot({
         client: client,
         clientForGdr: clientForGdr,
-        instance: parent,
+        instance: instance
+    }), guards = await verdictGuardsForInstance(client, instance._id), resourceGrants = await subjectResourceGrants({
+        clientForGdr: clientForGdr,
+        instance: instance
+    });
+    return evaluateFromSnapshot({
+        instance: instance,
         definition: definition,
-        ...clock ? {
-            clock: clock
-        } : {},
-        ...actor ? {
-            actor: actor
-        } : {},
-        ...executionContext ? {
-            executionContext: executionContext
-        } : {},
-        ...telemetry ? {
-            telemetry: telemetry
-        } : {}
-    }), mutation = startMutation(parent), row = mutation.subworkflows.find(r => invariants.toBareId(r.ref.id) === child._id);
-    if (row === void 0) {
-        await recordOrphanedPropagation({
-            ctx: ctx,
-            mutation: mutation,
-            child: child
-        });
-        return;
-    }
-    let changed = stampResolvedChild({
-        mutation: mutation,
-        row: row,
-        child: child,
-        now: ctx.now
-    });
-    const parentTerminal = parent.completedAt !== void 0;
-    !parentTerminal && await flipOpenCohortGate({
-        ctx: ctx,
-        mutation: mutation,
-        definition: definition,
-        row: row
-    }) && (changed = !0), changed && await persist(ctx, mutation), !parentTerminal && (await cascadeAutoTransitions({
-        client: client,
-        instanceId: parent._id,
-        actor: actor,
-        clientForGdr: clientForGdr,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
-    }), await propagateToAncestors({
-        client: client,
-        instanceId: parent._id,
-        actor: actor,
-        clientForGdr: clientForGdr,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
-    }));
-}
-
-async function loadPropagationPair(client, instanceId) {
-    const child = await getInstanceDocument(client, instanceId);
-    if (!child) return;
-    const parentGdr = parentRef(child);
-    if (parentGdr === void 0) return;
-    const parent = await getInstanceDocument(client, invariants.toBareId(parentGdr.id));
-    if (!(!parent || parent._type !== WORKFLOW_INSTANCE_TYPE) && typeof parent.definitionSnapshot == "string") return {
-        child: child,
-        parent: parent
-    };
-}
-
-function stampResolvedChild({mutation: mutation, row: row, child: child, now: now}) {
-    if (row.resolved !== void 0) return !1;
-    const resolved = terminalResolution(child);
-    return resolved === void 0 ? !1 : (row.resolved = resolved, mutation.history.push(subworkflowResolvedEntry({
-        row: row,
-        at: now,
-        status: resolved.aborted === !0 ? "aborted" : "done"
-    })), !0);
-}
-
-async function flipOpenCohortGate({ctx: ctx, mutation: mutation, definition: definition, row: row}) {
-    const openEntry = findOpenStageEntry(mutation);
-    if (openEntry === void 0 || row.stageEntry !== openEntry._key) return !1;
-    const entry = openEntry.activities.find(e => e.name === row.activity);
-    if (entry === void 0 || entry.status !== "active") return !1;
-    const activityDef = (definition.stages.find(s => s.name === openEntry.name)?.activities ?? []).find(a => a.name === row.activity);
-    if (activityDef?.subworkflows === void 0) return !1;
-    const gateCtx = {
-        ...ctx,
-        instance: materializeInstance(ctx.instance, mutation)
-    }, outcome = await evaluateResolutionGate({
-        ctx: gateCtx,
-        activity: activityDef
-    });
-    return outcome === void 0 ? !1 : (applyGateOutcome({
-        entry: entry,
-        history: mutation.history,
-        stage: openEntry.name,
-        at: ctx.now,
-        outcome: outcome,
-        ...ctx.actor !== void 0 ? {
-            actor: ctx.actor
-        } : {}
-    }), !0);
-}
-
-async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: child}) {
-    const childUri = invariants.selfGdr(child);
-    mutation.history.some(h => h._type === "subworkflowOrphaned" && h.instanceRef.id === childUri) || (mutation.history.push({
-        _key: randomKey(),
-        _type: "subworkflowOrphaned",
-        at: ctx.now,
-        instanceRef: {
-            id: childUri,
-            type: WORKFLOW_INSTANCE_TYPE
-        },
-        detail: `Instance "${child._id}" names this instance as its parent but no subworkflow-registry row matches it, so its state cannot drive any gate here.`
-    }), await persist(ctx, mutation));
-}
-
-const parsedFilters = /* @__PURE__ */ new Map;
-
-async function matchesFilter(args) {
-    const {document: document, filter: filter, userId: userId} = args;
-    parsedFilters.has(filter) || parsedFilters.set(filter, groqJs.parse(`*[${filter}]`));
-    const ast = parsedFilters.get(filter), data = await (await groqJs.evaluate(ast, {
-        dataset: [ document ],
-        ...userId !== void 0 ? {
-            identity: userId
-        } : {}
-    })).get();
-    return Array.isArray(data) && data.length === 1;
-}
-
-async function grantsPermissionOn(args) {
-    const {document: document, grants: grants, permission: permission, userId: userId} = args;
-    if (!document || grants.length === 0) return !1;
-    for (const grant of grants) if (grant.permissions.includes(permission) && await matchesFilter({
-        document: document,
-        filter: grant.filter,
-        ...userId !== void 0 ? {
-            userId: userId
-        } : {}
-    })) return !0;
-    return !1;
-}
-
-function aclPathForResource(res) {
-    if (res.type === "dataset") {
-        const {projectId: projectId, dataset: dataset} = invariants.datasetResourceParts(res.id);
-        return `/projects/${projectId}/datasets/${dataset}/acl`;
-    }
-    if (res.type === "canvas") return `/canvases/${res.id}/acl`;
-}
-
-async function fetchGrants(args) {
-    const {client: client, resourcePath: resourcePath, signal: signal} = args;
-    return client.request({
-        url: resourcePath,
-        tag: REQUEST_TAG.accessGrants,
-        ...signal ? {
-            signal: signal
-        } : {}
-    });
-}
-
-const actorCache = /* @__PURE__ */ new WeakMap, grantsCache = /* @__PURE__ */ new WeakMap;
-
-async function resolveAccess(taggedClient, args = {}) {
-    const client = unwrapRequestTag(taggedClient), requestFn = lazyRequest(client);
-    if (requestFn === void 0) throw new invariants.ContractViolationError("workflow: no actor available. The engine resolves the actor from the client's token via `client.request({ uri: '/users/me' })`. Supply a real `@sanity/client` configured with a token (the test bench serves these endpoints per registered token).");
-    const grantsPromise = args.grantsFromPath !== void 0 ? cachedGrants({
-        client: client,
-        requestFn: requestFn,
-        resourcePath: args.grantsFromPath
-    }) : Promise.resolve(void 0), [actor, grants] = await Promise.all([ cachedActor(client, requestFn), grantsPromise ]);
-    if (actor === void 0) throw new invariants.ContractViolationError("workflow: failed to resolve actor from `/users/me`. The client is configured but the endpoint returned no usable identity — check the token.");
-    return {
         actor: actor,
+        snapshot: snapshot,
+        guards: guards,
+        now: now,
+        resourceGrants: resourceGrants,
         ...grants !== void 0 ? {
             grants: grants
         } : {}
-    };
-}
-
-function cachedActor(client, requestFn) {
-    const cached = actorCache.get(client);
-    if (cached !== void 0) return cached;
-    const pending = fetchActor(requestFn).catch(err => {
-        throw actorCache.get(client) === pending && actorCache.delete(client), err;
-    });
-    return actorCache.set(client, pending), pending;
-}
-
-function grantsForClientPath(taggedClient, resourcePath) {
-    const client = unwrapRequestTag(taggedClient), requestFn = lazyRequest(client);
-    return requestFn === void 0 ? Promise.resolve(void 0) : cachedGrants({
-        client: client,
-        requestFn: requestFn,
-        resourcePath: resourcePath
     });
 }
 
-function lazyRequest(client) {
-    return client.request === void 0 ? void 0 : opts => client.request(opts);
-}
-
-function cachedGrants({client: client, requestFn: requestFn, resourcePath: resourcePath}) {
-    let byPath = grantsCache.get(client);
-    byPath === void 0 && (byPath = /* @__PURE__ */ new Map, grantsCache.set(client, byPath));
-    let cached = byPath.get(resourcePath);
-    return cached === void 0 && (cached = fetchGrantsCached(requestFn, resourcePath), 
-    byPath.set(resourcePath, cached)), cached;
-}
-
-async function fetchActor(requestFn) {
-    let user;
+function currentStageOf(instance, definition) {
     try {
-        user = await requestFn({
-            uri: "/users/me",
-            tag: REQUEST_TAG.accessResolveActor
-        });
+        return findStage(definition, instance.currentStage);
     } catch (err) {
-        throw new Error('workflow: /users/me request failed. The engine resolves the actor from the client\'s token via `client.request({ uri: "/users/me" })`. Check the token/connectivity.', {
+        throw new Error(`Instance "${instance._id}" currentStage "${instance.currentStage}" not in definition`, {
             cause: err
         });
     }
-    if (!user || typeof user.id != "string" || user.id.length === 0) return;
-    const roleNames = user.roles?.map(r => r.name).filter(n => !!n) ?? [];
-    return {
-        kind: "person",
-        id: user.id,
-        ...roleNames.length > 0 ? {
-            roles: roleNames
-        } : {}
-    };
-}
-
-async function fetchGrantsCached(requestFn, resourcePath) {
-    try {
-        return await fetchGrants({
-            client: {
-                request: requestFn
-            },
-            resourcePath: resourcePath
-        });
-    } catch (err) {
-        console.warn(`workflow: failed to fetch grants from "${resourcePath}"; advisory permission reads that depend on them are skipped — a rendered $can stays undefined (conditions referencing it fail closed) and the subject-write forecast omits this resource. The lake still enforces writes. Original error: ${invariants.errorMessage(err)}`);
-        return;
-    }
-}
-
-async function buildFieldInsights({sites: sites, snapshot: snapshot}) {
-    const insights = [];
-    for (const field of fieldsReadAcross(sites)) {
-        const involved = sites.filter(entry => readsField(entry.insight, field));
-        insights.push({
-            field: field,
-            reads: groqConditionDescribe.dedupeReads(involved.flatMap(entry => fieldReads(entry.insight, field))),
-            involvedIn: involved.map(entry => entry.site),
-            proposals: await verifyProposals({
-                field: field,
-                involved: involved,
-                snapshot: snapshot
-            })
-        });
-    }
-    return insights;
-}
-
-function fieldsReadAcross(sites) {
-    const names = sites.flatMap(entry => entry.insight.analysis.reads).filter(read => read.variable === "fields").map(read => read.path[0]).filter(head => typeof head == "string");
-    return [ ...new Set(names) ];
-}
-
-function fieldReads(insight, field) {
-    return insight.analysis.reads.filter(read => read.variable === "fields" && read.path[0] === field);
 }
 
-function readsField(insight, field) {
-    return fieldReads(insight, field).length > 0;
-}
-
-async function verifyProposals({field: field, involved: involved, snapshot: snapshot}) {
-    const proposals = [];
-    for (const assign of candidateAssignments(involved, field)) {
-        const consequences = [];
-        for (const entry of involved) {
-            const result = await groqConditionDescribe.whatIfCondition({
-                condition: entry.condition,
-                dataset: snapshot.docs,
-                params: entry.params,
-                assign: assign
-            });
-            result.changed && consequences.push({
-                site: entry.site,
-                before: result.before,
-                after: result.after
-            });
-        }
-        consequences.length > 0 && proposals.push({
-            assign: assign,
-            consequences: consequences
-        });
-    }
-    return proposals;
-}
-
-function candidateAssignments(involved, field) {
-    const candidates = involved.flatMap(entry => entry.insight.blockedBy).flatMap(atom => atom.requirement !== void 0 ? [ atom.requirement ] : []).filter(requirement => requirement.target.variable === "fields").filter(requirement => requirement.target.path[0] === field).flatMap(assignmentFor).filter(fabricatable);
-    return groqConditionDescribe.dedupeBy(candidates, assignment => JSON.stringify([ assignment.target.path, assignment.value ]));
-}
-
-function assignmentFor(requirement) {
-    switch (requirement.kind) {
-      case "equals":
-        return [ {
-            target: requirement.target,
-            value: requirement.value
-        } ];
-
-      case "truthy":
-        return [ {
-            target: requirement.target,
-            value: !0
-        } ];
-
-      case "falsy":
-        return [ {
-            target: requirement.target,
-            value: !1
-        } ];
-
-      case "differs":
-      case "defined":
-      case "undefined":
-      case "compares":
-        return [];
-    }
-}
-
-function fabricatable(assignment) {
-    return assignment.target.path.every(segment => typeof segment != "number" || segment <= groqConditionDescribe.MAX_COUNTERFACTUAL_INDEX);
-}
-
-async function subjectResourceGrants(args) {
-    const {clientForGdr: clientForGdr, instance: instance} = args, clients = /* @__PURE__ */ new Map;
-    for (const {parsed: parsed, resource: resource} of foreignSubjectRefs(instance)) {
-        const key = invariants.resourceGdr(resource);
-        clients.has(key) || clients.set(key, {
-            resource: resource,
-            client: clientForGdr(parsed)
-        });
-    }
-    const resolved = await Promise.all([ ...clients.entries() ].map(async ([key, entry]) => {
-        const path = aclPathForResource(entry.resource);
-        if (path === void 0) return;
-        const grants = await grantsForClientPath(entry.client, path);
-        return grants === void 0 ? void 0 : [ key, grants ];
-    }));
-    return new Map(resolved.filter(entry => entry !== void 0));
-}
-
-const UNBOUND_CALLER_VARS = Object.fromEntries(invariants.CALLER_BOUND_VARS.map(name => [ name, void 0 ]));
-
-async function evaluateInstance(args) {
-    const {client: client, tag: tag, workflowResource: workflowResource, instanceId: instanceId, resourceClients: resourceClients} = args, now = (args.clock ?? wallClock)();
-    invariants.validateTag(tag);
-    const {actor: actor, grants: grants} = await resolveAccess(client, {
-        ...args.grantsFromPath !== void 0 ? {
-            grantsFromPath: args.grantsFromPath
-        } : {}
-    }), instance = await reload({
-        client: client,
-        instanceId: instanceId,
-        tag: tag
-    }), definition = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
-        client: client,
-        workflowResource: workflowResource,
-        resourceClients: resourceClients
-    }), snapshot = await hydrateSnapshot({
-        client: client,
-        clientForGdr: clientForGdr,
-        instance: instance
-    }), guards = await verdictGuardsForInstance(client, instance._id), resourceGrants = await subjectResourceGrants({
-        clientForGdr: clientForGdr,
-        instance: instance
-    });
-    return evaluateFromSnapshot({
-        instance: instance,
-        definition: definition,
-        actor: actor,
-        snapshot: snapshot,
-        guards: guards,
-        now: now,
-        resourceGrants: resourceGrants,
-        ...grants !== void 0 ? {
-            grants: grants
-        } : {}
-    });
-}
-
-function currentStageOf(instance, definition) {
-    try {
-        return findStage(definition, instance.currentStage);
-    } catch (err) {
-        throw new Error(`Instance "${instance._id}" currentStage "${instance.currentStage}" not in definition`, {
-            cause: err
-        });
-    }
-}
-
-async function explainSite(args) {
-    const {site: site, condition: condition, params: params, snapshot: snapshot, sites: sites} = args, insight = await groqConditionDescribe.explainCondition({
-        condition: condition,
-        dataset: snapshot.docs,
-        params: params
-    });
-    return sites.push({
-        site: site,
-        condition: condition,
-        params: params,
-        insight: insight
-    }), insight;
+async function explainSite(args) {
+    const {site: site, condition: condition, params: params, snapshot: snapshot, sites: sites} = args, insight = await groqConditionDescribe.explainCondition({
+        condition: condition,
+        dataset: snapshot.docs,
+        params: params
+    });
+    return sites.push({
+        site: site,
+        condition: condition,
+        params: params,
+        insight: insight
+    }), insight;
 }
 
 async function evaluateFromSnapshot(args) {
@@ -6111,14 +5595,14 @@ async function evaluateFromSnapshot(args) {
                 kind: "transition",
                 transition: transition.name
             },
-            condition: transition.filter,
+            condition: transition.when,
             params: cascadeParams,
             snapshot: snapshot,
             sites: sites
         });
         transitionEvaluations.push({
             transition: transition,
-            filterSatisfied: insight.outcome === "satisfied",
+            whenSatisfied: insight.outcome === "satisfied",
             unevaluable: insight.outcome === "unevaluable",
             insight: insight
         });
@@ -6322,7 +5806,7 @@ function activityScopeFor(args) {
 }
 
 async function evaluateActivity(args) {
-    const {activity: activity, statusEntry: statusEntry, instance: instance, actor: actor, snapshot: snapshot, scope: scope, roleAliases: roleAliases, stageHasExits: stageHasExits, guardDenial: guardDenial, subjectPermissionReason: subjectPermissionReason, sites: sites} = args, status = statusEntry?.status ?? "pending", activityScope = activityScopeFor({
+    const {activity: activity, statusEntry: statusEntry, instance: instance, actor: actor, snapshot: snapshot, scope: scope, roleAliases: roleAliases, stageHasExits: stageHasExits, guardDenial: guardDenial, subjectPermissionReason: subjectPermissionReason, sites: sites} = args, status = statusEntry?.status ?? "skipped", activityScope = activityScopeFor({
         scope: scope,
         instance: instance,
         snapshot: snapshot,
@@ -6354,8 +5838,13 @@ async function evaluateActivity(args) {
     return {
         activity: activity,
         status: status,
-        kind: activityKind(activity),
-        pendingOnActor: (status === "active" || status === "pending") && assigned,
+        kind: invariants.deriveActivityKind(activity),
+        classification: invariants.deriveExecutorClassification(activity),
+        pendingOnActor: status === "active" && assigned,
+        scopedOut: isFilterScopedOut({
+            status: status,
+            startedAt: statusEntry?.startedAt
+        }),
         ...unmetRequirements.length > 0 ? {
             unmetRequirements: unmetRequirements
         } : {},
@@ -6380,13 +5869,7 @@ async function explainActivityConditions({activity: activity, activityScope: act
     const requirementInsights = Object.fromEntries(requirementEntries), unmetRequirements = requirementEntries.filter(([, insight]) => insight.outcome !== "satisfied").map(([name]) => name), filterInsight = activity.filter !== void 0 ? await explainAt({
         kind: "activity-filter",
         activity: activity.name
-    }, activity.filter) : void 0, completeWhenInsight = activity.completeWhen !== void 0 ? await explainAt({
-        kind: "complete-when",
-        activity: activity.name
-    }, activity.completeWhen) : void 0, failWhenInsight = activity.failWhen !== void 0 ? await explainAt({
-        kind: "fail-when",
-        activity: activity.name
-    }, activity.failWhen) : void 0;
+    }, activity.filter) : void 0;
     return {
         unmetRequirements: unmetRequirements,
         ...activity.requirements !== void 0 ? {
@@ -6394,116 +5877,915 @@ async function explainActivityConditions({activity: activity, activityScope: act
         } : {},
         ...filterInsight !== void 0 ? {
             filterInsight: filterInsight
-        } : {},
-        ...completeWhenInsight !== void 0 ? {
-            completeWhenInsight: completeWhenInsight
-        } : {},
-        ...failWhenInsight !== void 0 ? {
-            failWhenInsight: failWhenInsight
         } : {}
     };
 }
 
 async function evaluateAction(args) {
-    const {action: action, activityName: activityName, status: status, instance: instance, snapshot: snapshot, activityScope: activityScope, stageHasExits: stageHasExits, guardDenial: guardDenial, subjectPermissionReason: subjectPermissionReason, requirementsReason: requirementsReason, sites: sites} = args, insight = action.filter !== void 0 ? await explainSite({
+    const {action: action, activityName: activityName, snapshot: snapshot, activityScope: activityScope, sites: sites} = args, conditionScope = invariants.isCascadeFired(action) ? {
+        ...activityScope,
+        ...UNBOUND_CALLER_VARS,
+        assigned: !1
+    } : activityScope, insights = await explainActionGates({
+        action: action,
+        activityName: activityName,
+        conditionScope: conditionScope,
+        snapshot: snapshot,
+        sites: sites
+    });
+    return action.when !== void 0 ? triggeredActionVerdict({
+        action: action,
+        when: action.when,
+        insights: insights
+    }) : fireableActionVerdict({
+        args: args,
+        insights: insights
+    });
+}
+
+async function explainActionGates({action: action, activityName: activityName, conditionScope: conditionScope, snapshot: snapshot, sites: sites}) {
+    const insight = action.filter !== void 0 ? await explainSite({
         site: {
             kind: "action",
             activity: activityName,
             action: action.name
         },
         condition: action.filter,
-        params: activityScope,
+        params: conditionScope,
+        snapshot: snapshot,
+        sites: sites
+    }) : void 0, whenInsight = action.when !== void 0 ? await explainSite({
+        site: {
+            kind: "action-when",
+            activity: activityName,
+            action: action.name
+        },
+        condition: action.when,
+        params: conditionScope,
         snapshot: snapshot,
         sites: sites
-    }) : void 0, lifecycle = lifecycleReason({
+    }) : void 0;
+    return {
+        ...insight !== void 0 ? {
+            insight: insight
+        } : {},
+        ...whenInsight !== void 0 ? {
+            whenInsight: whenInsight
+        } : {}
+    };
+}
+
+function triggeredActionVerdict({action: action, when: when, insights: insights}) {
+    return insights.insight !== void 0 && insights.insight.outcome === "unsatisfied" ? disabled({
+        action: action,
+        reason: {
+            kind: "filter-failed",
+            filter: action.filter ?? ""
+        },
+        ...insights
+    }) : {
+        action: action,
+        allowed: !1,
+        triggered: !0,
+        disabledReason: {
+            kind: "cascade-fired",
+            when: when
+        },
+        ...insights
+    };
+}
+
+function fireableActionVerdict({args: args, insights: insights}) {
+    const {action: action, status: status, instance: instance, stageHasExits: stageHasExits, guardDenial: guardDenial} = args, lifecycle = lifecycleReason({
         instance: instance,
         status: status,
         stageHasExits: stageHasExits
     });
-    return lifecycle !== void 0 ? disabled({
+    if (lifecycle !== void 0) return disabled({
         action: action,
         reason: lifecycle,
-        insight: insight
-    }) : guardDenial !== void 0 ? disabled({
+        ...insights
+    });
+    if (guardDenial !== void 0) return disabled({
         action: action,
         reason: guardDenial,
-        insight: insight
-    }) : subjectPermissionReason !== void 0 && (action.effects?.length ?? 0) > 0 ? disabled({
+        ...insights
+    });
+    if (args.subjectPermissionReason !== void 0 && (action.effects?.length ?? 0) > 0) return disabled({
         action: action,
-        reason: subjectPermissionReason,
-        insight: insight
-    }) : requirementsReason !== void 0 ? disabled({
+        reason: args.subjectPermissionReason,
+        ...insights
+    });
+    if (args.requirementsReason !== void 0) return disabled({
         action: action,
-        reason: requirementsReason,
-        insight: insight
-    }) : action.filter !== void 0 && insight !== void 0 && insight.outcome !== "satisfied" ? disabled({
+        reason: args.requirementsReason,
+        ...insights
+    });
+    const {insight: insight} = insights;
+    return action.filter !== void 0 && insight !== void 0 && insight.outcome !== "satisfied" ? disabled({
         action: action,
         reason: {
             kind: "filter-failed",
             filter: action.filter
         },
-        insight: insight
+        ...insights
     }) : {
         action: action,
         allowed: !0,
-        ...insight !== void 0 ? {
-            insight: insight
+        ...insights
+    };
+}
+
+async function instanceGuardReason({instance: instance, actor: actor, guards: guards}) {
+    if (guards === void 0 || guards.length === 0) return;
+    const denied = await instanceWriteDenials({
+        instance: instance,
+        guards: guards,
+        identity: actor.id
+    });
+    if (denied.length !== 0) return {
+        kind: "mutation-guard-denied",
+        denied: deniedGuardRefs(denied)
+    };
+}
+
+function lifecycleReason({instance: instance, status: status, stageHasExits: stageHasExits}) {
+    const terminal = terminalState(instance);
+    if (terminal === "aborted" && instance.abortedAt !== void 0) return {
+        kind: "instance-aborted",
+        abortedAt: instance.abortedAt
+    };
+    if (terminal === "completed" && instance.completedAt !== void 0) return {
+        kind: "instance-completed",
+        completedAt: instance.completedAt
+    };
+    if (!stageHasExits) return {
+        kind: "stage-terminal",
+        stage: instance.currentStage
+    };
+    if (invariants.isTerminalActivityStatus(status)) return {
+        kind: "activity-not-active",
+        status: status
+    };
+}
+
+function disabled(args) {
+    return {
+        action: args.action,
+        allowed: !1,
+        disabledReason: args.reason,
+        ...args.insight !== void 0 ? {
+            insight: args.insight
+        } : {},
+        ...args.whenInsight !== void 0 ? {
+            whenInsight: args.whenInsight
+        } : {}
+    };
+}
+
+function subjectDenialLabels(denied) {
+    return denied.map(d => `${d.permission} on ${d.subject} (${d.resource})`);
+}
+
+class ActionDisabledError extends invariants.WorkflowError {
+    reason;
+    activity;
+    action;
+    constructor(args) {
+        super("action-disabled", formatDisabledReason({
+            activity: args.activity,
+            action: args.action,
+            reason: args.reason
+        })), this.name = "ActionDisabledError", this.reason = args.reason, this.activity = args.activity, 
+        this.action = args.action;
+    }
+}
+
+function actionRendering(action) {
+    const kind = action.disabledReason?.kind;
+    return kind === "filter-failed" ? "absent" : action.triggered === !0 || kind === "cascade-fired" ? "automation" : "button";
+}
+
+const disabledReasonDetail = {
+    "filter-failed": r => `action filter returned false${r.detail ? ` (${r.detail})` : ""}`,
+    "cascade-fired": r => `the action is cascade-fired (when: ${JSON.stringify(r.when)}) — the engine fires it on truth; it cannot be invoked via fireAction`,
+    "activity-not-active": r => `activity status is "${r.status}"`,
+    "stage-terminal": r => `stage "${r.stage}" is terminal`,
+    "instance-completed": r => `instance completed at ${r.completedAt}`,
+    "instance-aborted": r => `instance aborted at ${r.abortedAt}`,
+    "requirements-unmet": r => `unmet requirement(s): ${r.unmetRequirements.join(", ")}`,
+    "subject-permission-denied": r => `missing subject permission(s): ${subjectDenialLabels(r.denied).join(", ")}`
+};
+
+function actionDisabledDetail(reason) {
+    return disabledReasonDetail[reason.kind](reason);
+}
+
+function formatDisabledReason({activity: activity, action: action, reason: reason}) {
+    return `Action "${activity}:${action}" is not allowed: ${actionDisabledDetail(reason)}`;
+}
+
+class EditFieldDeniedError extends invariants.WorkflowError {
+    reason;
+    target;
+    constructor(args) {
+        super("edit-field-denied", formatEditDisabledReason(args.target, args.reason)), 
+        this.name = "EditFieldDeniedError", this.reason = args.reason, this.target = args.target;
+    }
+}
+
+const editDisabledReasonDetail = {
+    "not-editable": () => "field is not declared editable",
+    "instance-completed": r => `instance completed at ${r.completedAt}`,
+    "instance-aborted": r => `instance aborted at ${r.abortedAt}`,
+    "edit-window-closed": r => `edit window closed (${r.detail})`,
+    "editor-not-permitted": r => `editor not permitted (${r.predicate})`
+};
+
+function formatEditDisabledReason(target, reason) {
+    const detail = editDisabledReasonDetail[reason.kind](reason), where = target.activity !== void 0 ? `${target.activity}.${target.field}` : target.field;
+    return `Field "${target.scope}:${where}" is not editable: ${detail}`;
+}
+
+async function fireAction(args) {
+    const {client: client, instanceId: instanceId, activity: activity, action: action, params: params, requestRecord: requestRecord, options: options} = args;
+    return retryOnRevisionConflict({
+        client: client,
+        instanceId: instanceId,
+        options: options,
+        commit: ctx => commitAction({
+            ctx: ctx,
+            activityName: activity,
+            actionName: action,
+            callerParams: params,
+            requestRecord: requestRecord,
+            options: options
+        }),
+        onExhausted: () => new ConcurrentFireActionError({
+            instanceId: instanceId,
+            activity: activity,
+            action: action,
+            attempts: CONCURRENT_COMMIT_MAX_ATTEMPTS
+        })
+    });
+}
+
+async function resolveActionCommit({ctx: ctx, activityName: activityName, actionName: actionName, callerParams: callerParams, options: options}) {
+    const actor = options?.actor, {stage: stage, activity: activity} = findActivityInCurrentStage(ctx, activityName), action = (activity.actions ?? []).find(a => a.name === actionName);
+    if (action === void 0) throw new invariants.ContractViolationError(`Action "${actionName}" not declared on activity "${activityName}"`);
+    if (action.when !== void 0) throw new ActionDisabledError({
+        activity: activityName,
+        action: actionName,
+        reason: {
+            kind: "cascade-fired",
+            when: action.when
+        }
+    });
+    if (action.filter !== void 0) {
+        const can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan({
+            instance: ctx.instance,
+            actor: actor,
+            grants: options.grants
+        }) : void 0;
+        if (!await ctxEvaluateCondition({
+            ctx: ctx,
+            condition: action.filter,
+            opts: {
+                activityName: activityName,
+                ...actor !== void 0 ? {
+                    actor: actor
+                } : {},
+                ...can !== void 0 ? {
+                    vars: {
+                        can: can
+                    }
+                } : {}
+            }
+        })) throw new ActionDisabledError({
+            activity: activityName,
+            action: actionName,
+            reason: {
+                kind: "filter-failed",
+                filter: action.filter,
+                detail: "commit re-check"
+            }
+        });
+    }
+    const entry = findCurrentActivities(ctx.instance).find(t => t.name === activityName);
+    if (entry === void 0 || entry.status !== "active") throw notActiveAtCommit({
+        activityName: activityName,
+        actionName: actionName,
+        status: entry?.status
+    });
+    const params = validateActionParams({
+        action: action,
+        activityName: activityName,
+        callerParams: callerParams
+    });
+    return {
+        stage: stage,
+        activity: activity,
+        action: action,
+        params: params
+    };
+}
+
+function notActiveAtCommit(args) {
+    const {activityName: activityName, actionName: actionName, status: status} = args;
+    return status !== void 0 && invariants.isTerminalActivityStatus(status) ? new ActionDisabledError({
+        activity: activityName,
+        action: actionName,
+        reason: {
+            kind: "activity-not-active",
+            status: status
+        }
+    }) : new Error(`Activity "${activityName}" must be active to fire action "${actionName}"; status is ${status ?? "missing"}`);
+}
+
+async function applyActionFire({ctx: ctx, mutation: mutation, activity: activity, action: action, params: params, actor: actor, triggered: triggered}) {
+    mutation.history.push({
+        _key: randomKey(),
+        _type: "actionFired",
+        at: ctx.now,
+        stage: mutation.currentStage,
+        activity: activity.name,
+        action: action.name,
+        ...actor !== void 0 ? {
+            actor: actor,
+            driverKind: invariants.driverKind(actor)
+        } : {},
+        ...triggered ? {
+            triggered: !0
+        } : {}
+    });
+    const ranOps = await runOps({
+        ops: action.ops,
+        mutation: mutation,
+        stage: mutation.currentStage,
+        origin: {
+            activity: activity.name,
+            action: action.name
+        },
+        params: params,
+        actor: actor,
+        self: invariants.selfGdr(ctx.instance),
+        now: ctx.now,
+        snapshot: ctx.snapshot
+    });
+    return await queueEffects({
+        ctx: ctx,
+        mutation: mutation,
+        effects: action.effects,
+        origin: {
+            kind: "action",
+            name: action.name
+        },
+        actor: actor,
+        opts: {
+            callerParams: params,
+            activityName: activity.name
+        }
+    }), action.spawn !== void 0 && await spawnSubworkflows({
+        ctx: ctx,
+        mutation: mutation,
+        activity: activity,
+        action: action,
+        sub: action.spawn,
+        actor: actor
+    }), {
+        ranOps: ranOps
+    };
+}
+
+async function commitAction({ctx: ctx, activityName: activityName, actionName: actionName, callerParams: callerParams, requestRecord: requestRecord, options: options}) {
+    assertRequestUnprocessed({
+        instance: ctx.instance,
+        record: requestRecord,
+        now: ctx.now
+    });
+    const actor = options?.actor, {stage: stage, activity: activity, action: action, params: params} = await resolveActionCommit({
+        ctx: ctx,
+        activityName: activityName,
+        actionName: actionName,
+        callerParams: callerParams,
+        options: options
+    }), mutation = startMutation(ctx.instance);
+    recordProcessedRequest({
+        mutation: mutation,
+        record: requestRecord,
+        now: ctx.now
+    });
+    const mutEntry = requireMutationActivityEntry(mutation, activityName), statusBefore = mutEntry.status, {ranOps: ranOps} = await applyActionFire({
+        ctx: ctx,
+        mutation: mutation,
+        activity: activity,
+        action: action,
+        params: params,
+        actor: actor,
+        triggered: !1
+    }), newStatus = mutEntry.status !== statusBefore ? mutEntry.status : void 0;
+    return await persistThenMaybeRefresh({
+        ctx: ctx,
+        mutation: mutation,
+        stageName: stage.name,
+        didChangeState: ranOps.some(isFieldOp)
+    }), {
+        fired: !0,
+        activity: activityName,
+        action: actionName,
+        ...newStatus !== void 0 ? {
+            newStatus: newStatus
+        } : {},
+        ...ranOps.length > 0 ? {
+            ranOps: ranOps
+        } : {}
+    };
+}
+
+async function runTriggeredActions({ctx: ctx, mutation: mutation, stage: stage}) {
+    let fires = 0, ranFieldOps = !1;
+    const liveCtx = liveViewContext(ctx, mutation);
+    let firedThisPass = !0;
+    for (;firedThisPass; ) {
+        firedThisPass = !1;
+        for (const activity of stage.activities ?? []) {
+            const fired = await runActivityTriggers({
+                ctx: liveCtx,
+                mutation: mutation,
+                activity: activity
+            });
+            fires += fired.fires, ranFieldOps = ranFieldOps || fired.ranFieldOps, fired.fires > 0 && (firedThisPass = !0);
+        }
+    }
+    return {
+        fires: fires,
+        ranFieldOps: ranFieldOps
+    };
+}
+
+async function runActivityTriggers({ctx: ctx, mutation: mutation, activity: activity}) {
+    let fires = 0, ranFieldOps = !1;
+    for (const action of activity.actions ?? []) {
+        if (!invariants.isCascadeFired(action)) continue;
+        const entry = currentActivities(mutation).find(e => e.name === activity.name);
+        if (entry === void 0 || entry.status !== "active") break;
+        if ((entry.firedActions ?? []).includes(action.name) || !await triggerIsLive({
+            ctx: ctx,
+            activity: activity,
+            action: action
+        })) continue;
+        const result = await fireTriggeredAction({
+            ctx: ctx,
+            mutation: mutation,
+            activity: activity,
+            action: action,
+            entry: entry
+        });
+        if (fires++, ranFieldOps = ranFieldOps || result.ranFieldOps, invariants.isTerminalActivityStatus(entry.status)) break;
+    }
+    return {
+        fires: fires,
+        ranFieldOps: ranFieldOps
+    };
+}
+
+async function triggerIsLive({ctx: ctx, activity: activity, action: action}) {
+    if (!tokenMayExecute({
+        actor: ctx.actor,
+        action: action,
+        ctx: ctx
+    })) return !1;
+    const scope = {
+        activityName: activity.name
+    };
+    return action.filter !== void 0 && await ctxEvaluateConditionOutcome({
+        ctx: ctx,
+        condition: action.filter,
+        opts: scope
+    }) !== "satisfied" ? !1 : await ctxEvaluateConditionOutcome({
+        ctx: ctx,
+        condition: action.when,
+        opts: scope
+    }) === "satisfied";
+}
+
+function tokenMayExecute({actor: actor, action: action, ctx: ctx}) {
+    const roles = action.roles;
+    return roles === void 0 || roles.length === 0 ? !0 : actor === void 0 ? !1 : roles.some(required => invariants.actorFulfillsRole({
+        actorRoles: actor.roles,
+        required: required,
+        aliases: ctx.definition.roleAliases
+    }));
+}
+
+async function fireTriggeredAction({ctx: ctx, mutation: mutation, activity: activity, action: action, entry: entry}) {
+    entry.firedActions = [ ...entry.firedActions ?? [], action.name ];
+    const {ranOps: ranOps} = await applyActionFire({
+        ctx: ctx,
+        mutation: mutation,
+        activity: activity,
+        action: action,
+        params: {},
+        actor: ctx.actor,
+        triggered: !0
+    });
+    return {
+        ranFieldOps: ranOps.some(isFieldOp)
+    };
+}
+
+async function primeInitialStage({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
+    const instance = await getInstanceDocument(client, instanceId);
+    if (!instance || instance.stages.length > 0) return;
+    const definition = parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
+    if (stage === void 0) return;
+    const ctx = await buildEngineContext({
+        client: client,
+        clientForGdr: clientForGdr,
+        instance: instance,
+        definition: definition,
+        ...clock ? {
+            clock: clock
+        } : {},
+        ...actor ? {
+            actor: actor
+        } : {},
+        ...executionContext ? {
+            executionContext: executionContext
+        } : {},
+        ...telemetry ? {
+            telemetry: telemetry
+        } : {}
+    }), now = ctx.now, discards = [], initialStageEntry = {
+        _key: randomKey(),
+        name: stage.name,
+        enteredAt: now,
+        fields: await resolveStageFieldEntries({
+            client: client,
+            instance: instance,
+            stage: stage,
+            now: now,
+            recordDiscard: recordFieldDiscards({
+                target: discards,
+                scope: "stage",
+                at: now
+            })
+        }),
+        activities: []
+    }, primedCtx = {
+        ...ctx,
+        instance: {
+            ...instance,
+            stages: [ initialStageEntry ]
+        }
+    };
+    initialStageEntry.activities = await buildStageActivities({
+        ctx: primedCtx,
+        stage: stage,
+        recordDiscard: recordFieldDiscards({
+            target: discards,
+            scope: "activity",
+            at: now
+        })
+    });
+    const terminal = isTerminalStage(stage), committed = await client.patch(instance._id).set({
+        stages: [ initialStageEntry ],
+        lastChangedAt: now,
+        ...terminal ? {
+            completedAt: now
+        } : {},
+        ...discards.length > 0 ? {
+            history: [ ...instance.history, ...stampHistoryEntries(discards, ctx.executionContext) ]
+        } : {}
+    }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
+    await deployOrRollback({
+        client: client,
+        instanceId: instance._id,
+        committedRev: committed._rev,
+        restore: {
+            stages: instance.stages,
+            history: instance.history
+        },
+        ...terminal ? {
+            unset: [ "completedAt" ]
+        } : {},
+        reversible: !0,
+        deploy: () => deployStageGuards({
+            client: client,
+            clientForGdr: clientForGdr,
+            instance: instance,
+            definition: definition,
+            stageName: stage.name,
+            now: now,
+            snapshot: ctx.snapshot
+        })
+    });
+}
+
+const CASCADE_LIMIT = 100;
+
+async function runCascadeHop({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
+    const ctx = await loadContext({
+        client: client,
+        instanceId: instanceId,
+        options: {
+            clientForGdr: clientForGdr,
+            ...actor ? {
+                actor: actor
+            } : {},
+            ...clock ? {
+                clock: clock
+            } : {},
+            ...executionContext ? {
+                executionContext: executionContext
+            } : {},
+            ...telemetry ? {
+                telemetry: telemetry
+            } : {},
+            ...overlay ? {
+                overlay: overlay
+            } : {}
+        }
+    });
+    if (isTerminal(ctx)) return {
+        moved: !1
+    };
+    const stage = findStage(ctx.definition, ctx.instance.currentStage), mutation = startMutation(ctx.instance), fired = await runTriggeredActions({
+        ctx: ctx,
+        mutation: mutation,
+        stage: stage
+    }), hopCtx = liveViewContext(ctx, mutation), transition = await pickTransition(hopCtx, stage);
+    return transition === void 0 ? (fired.fires > 0 && await persistThenMaybeRefresh({
+        ctx: ctx,
+        mutation: mutation,
+        stageName: stage.name,
+        didChangeState: fired.ranFieldOps
+    }), {
+        moved: !1
+    }) : (await commitStageMove({
+        ctx: ctx,
+        mutation: mutation,
+        fromStage: stage,
+        toStage: findStage(ctx.definition, transition.to),
+        transition: transition.name,
+        via: "transition",
+        actor: actor
+    }), {
+        moved: !0
+    });
+}
+
+async function cascadeAutoTransitions({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
+    let count = 0;
+    for (;;) {
+        if (await drainCondemnedChildren({
+            client: client,
+            instanceId: instanceId,
+            actor: actor,
+            clientForGdr: clientForGdr,
+            clock: clock,
+            executionContext: executionContext,
+            telemetry: telemetry
+        }), !(await runCascadeHop({
+            client: client,
+            instanceId: instanceId,
+            actor: actor,
+            clientForGdr: clientForGdr,
+            clock: clock,
+            executionContext: executionContext,
+            telemetry: telemetry,
+            overlay: overlay
+        })).moved) return count;
+        if (count++, count >= CASCADE_LIMIT) throw new CascadeLimitError({
+            instanceId: instanceId,
+            limit: CASCADE_LIMIT
+        });
+    }
+}
+
+async function drainCondemnedChildren({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining = /* @__PURE__ */ new Set}) {
+    if (draining.has(instanceId)) return;
+    draining.add(instanceId);
+    const instance = await getInstanceDocument(client, instanceId);
+    if (!instance) return;
+    const condemned = condemnedSubworkflows(instance);
+    if (condemned.length !== 0) {
+        for (const row of condemned) await settleCondemnedRow({
+            client: client,
+            ownerId: instanceId,
+            row: row,
+            actor: actor,
+            clientForGdr: clientForGdr,
+            clock: clock,
+            executionContext: executionContext,
+            telemetry: telemetry,
+            draining: draining
+        });
+        await stampDrainedRows({
+            client: client,
+            instance: instance,
+            condemned: condemned,
+            clock: clock,
+            executionContext: executionContext
+        });
+    }
+}
+
+async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining}) {
+    const childId = invariants.toBareId(row.ref.id);
+    try {
+        await abortInstance({
+            client: client,
+            instanceId: childId,
+            reason: row.abortPending?.reason ?? "condemned by parent",
+            options: {
+                ...actor ? {
+                    actor: actor
+                } : {},
+                clientForGdr: clientForGdr,
+                ...clock ? {
+                    clock: clock
+                } : {},
+                ...executionContext ? {
+                    executionContext: executionContext
+                } : {},
+                ...telemetry ? {
+                    telemetry: telemetry
+                } : {}
+            }
+        }), await drainCondemnedChildren({
+            client: client,
+            instanceId: childId,
+            actor: actor,
+            clientForGdr: clientForGdr,
+            clock: clock,
+            executionContext: executionContext,
+            telemetry: telemetry,
+            draining: draining
+        });
+    } catch (cause) {
+        if (cause instanceof invariants.InstanceNotFoundError) return;
+        throw cause instanceof WorkflowStateDivergedError ? cause : new WorkflowStateDivergedError({
+            instanceId: ownerId,
+            guardError: cause,
+            reason: `owed child abort of "${childId}" failed while draining condemned rows`
+        });
+    }
+}
+
+async function stampDrainedRows({client: client, instance: instance, condemned: condemned, clock: clock, executionContext: executionContext}) {
+    const now = (clock ?? wallClock)(), stamp = resolveExecutionContext(executionContext), ids = condemned.map(row => invariants.toBareId(row.ref.id)), children = await client.fetch("*[_id in $ids]{_id, currentStage, completedAt, abortedAt, modelVersion, minReaderModel}", {
+        ids: ids
+    }), byId = new Map(children.map(c => [ assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
+        if (row.resolved !== void 0 || !condemnedKeys.has(row._key)) return row;
+        const child = byId.get(invariants.toBareId(row.ref.id)), resolved = child !== void 0 ? terminalResolution(child) : {
+            at: now,
+            aborted: !0
+        };
+        return resolved === void 0 ? row : (history.push(...stampHistoryEntries([ subworkflowResolvedEntry({
+            row: row,
+            at: now,
+            status: resolved.aborted === !0 ? "aborted" : "done"
+        }) ], stamp)), {
+            ...row,
+            resolved: resolved
+        });
+    });
+    await client.patch(instance._id).set({
+        subworkflows: subworkflows,
+        history: history,
+        lastChangedAt: now
+    }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
+}
+
+function terminalResolution(child) {
+    const status = resolvedChildStatus(child);
+    if (!(status === void 0 || child.completedAt === void 0 || child.completedAt === null)) return {
+        at: child.completedAt,
+        stage: child.currentStage,
+        ...status === "aborted" ? {
+            aborted: !0
         } : {}
     };
 }
 
-async function instanceGuardReason({instance: instance, actor: actor, guards: guards}) {
-    if (guards === void 0 || guards.length === 0) return;
-    const denied = await instanceWriteDenials({
-        instance: instance,
-        guards: guards,
-        identity: actor.id
-    });
-    if (denied.length !== 0) return {
-        kind: "mutation-guard-denied",
-        denied: deniedGuardRefs(denied)
-    };
-}
-
-function lifecycleReason({instance: instance, status: status, stageHasExits: stageHasExits}) {
-    const terminal = terminalState(instance);
-    if (terminal === "aborted" && instance.abortedAt !== void 0) return {
-        kind: "instance-aborted",
-        abortedAt: instance.abortedAt
-    };
-    if (terminal === "completed" && instance.completedAt !== void 0) return {
-        kind: "instance-completed",
-        completedAt: instance.completedAt
-    };
-    if (!stageHasExits) return {
-        kind: "stage-terminal",
-        stage: instance.currentStage
-    };
-    if (invariants.isTerminalActivityStatus(status)) return {
-        kind: "activity-not-active",
+function subworkflowResolvedEntry({row: row, at: at, status: status}) {
+    return {
+        _key: randomKey(),
+        _type: "subworkflowResolved",
+        at: at,
+        activity: row.activity,
+        instanceRef: row.ref,
         status: status
     };
 }
 
-function disabled(args) {
-    return {
-        action: args.action,
-        allowed: !1,
-        disabledReason: args.reason,
-        ...args.insight !== void 0 ? {
-            insight: args.insight
+async function propagateToAncestors({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
+    const loaded = await loadPropagationPair(client, instanceId);
+    if (loaded === void 0) return;
+    const {child: child, parent: parent} = loaded, definition = parseDefinitionSnapshot(parent), ctx = await buildEngineContext({
+        client: client,
+        clientForGdr: clientForGdr,
+        instance: parent,
+        definition: definition,
+        ...clock ? {
+            clock: clock
+        } : {},
+        ...actor ? {
+            actor: actor
+        } : {},
+        ...executionContext ? {
+            executionContext: executionContext
+        } : {},
+        ...telemetry ? {
+            telemetry: telemetry
         } : {}
+    }), mutation = startMutation(parent), row = mutation.subworkflows.find(r => invariants.toBareId(r.ref.id) === child._id);
+    if (row === void 0) {
+        await recordOrphanedPropagation({
+            ctx: ctx,
+            mutation: mutation,
+            child: child
+        });
+        return;
+    }
+    const changed = stampResolvedChild({
+        mutation: mutation,
+        row: row,
+        child: child,
+        now: ctx.now
+    }), parentTerminal = parent.completedAt !== void 0;
+    changed && await persist(ctx, mutation), !parentTerminal && (await cascadeAutoTransitions({
+        client: client,
+        instanceId: parent._id,
+        actor: actor,
+        clientForGdr: clientForGdr,
+        clock: clock,
+        executionContext: executionContext,
+        telemetry: telemetry
+    }), await propagateToAncestors({
+        client: client,
+        instanceId: parent._id,
+        actor: actor,
+        clientForGdr: clientForGdr,
+        clock: clock,
+        executionContext: executionContext,
+        telemetry: telemetry
+    }));
+}
+
+async function loadPropagationPair(client, instanceId) {
+    const child = await getInstanceDocument(client, instanceId);
+    if (!child) return;
+    const parentGdr = parentRef(child);
+    if (parentGdr === void 0) return;
+    const parent = await getInstanceDocument(client, invariants.toBareId(parentGdr.id));
+    if (!(!parent || parent._type !== WORKFLOW_INSTANCE_TYPE) && typeof parent.definitionSnapshot == "string") return {
+        child: child,
+        parent: parent
     };
 }
 
+function stampResolvedChild({mutation: mutation, row: row, child: child, now: now}) {
+    if (row.resolved !== void 0) return !1;
+    const resolved = terminalResolution(child);
+    return resolved === void 0 ? !1 : (row.resolved = resolved, mutation.history.push(subworkflowResolvedEntry({
+        row: row,
+        at: now,
+        status: resolved.aborted === !0 ? "aborted" : "done"
+    })), !0);
+}
+
+async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: child}) {
+    const childUri = invariants.selfGdr(child);
+    mutation.history.some(h => h._type === "subworkflowOrphaned" && h.instanceRef.id === childUri) || (mutation.history.push({
+        _key: randomKey(),
+        _type: "subworkflowOrphaned",
+        at: ctx.now,
+        instanceRef: {
+            id: childUri,
+            type: WORKFLOW_INSTANCE_TYPE
+        },
+        detail: `Instance "${child._id}" names this instance as its parent but no subworkflow-registry row matches it, so its state cannot drive any gate here.`
+    }), await persist(ctx, mutation));
+}
+
+function inFlightFilter() {
+    return "!defined(completedAt)";
+}
+
 const FIELD_REFS_DOC = "count(fields[value.id in $documents]) > 0 || count(fields[count(value[id in $documents]) > 0]) > 0", ACTIVITY_REFS_DOC = `count(stages[count(activities[${FIELD_REFS_DOC}]) > 0]) > 0`;
 
+function documentPrefilter(documents, params) {
+    for (const document of documents) if (!invariants.isGdrUri(document)) throw new invariants.ContractViolationError(`every document must be a resource-qualified GDR URI (e.g. "dataset:project:dataset:doc-id"); got: ${JSON.stringify(document)}`);
+    return params.documents = [ ...documents ], params.bareIds = documents.map(invariants.extractDocumentId), 
+    `_id in $bareIds || count(ancestors[id in $documents]) > 0 || ${FIELD_REFS_DOC} || count(stages[${FIELD_REFS_DOC}]) > 0 || ${ACTIVITY_REFS_DOC}`;
+}
+
 function documentArm(filter, params) {
     if (filter.documents === void 0 && filter.document === void 0) return;
     const documents = [ ...filter.documents ?? [], ...filter.document !== void 0 ? [ filter.document ] : [] ];
-    for (const document of documents) if (!invariants.isGdrUri(document)) throw new invariants.ContractViolationError(`instancesQuery: every document must be a resource-qualified GDR URI (e.g. "dataset:project:dataset:doc-id"); got: ${JSON.stringify(document)}`);
-    return params.documents = documents, params.bareIds = documents.map(invariants.extractDocumentId), 
-    `_id in $bareIds || count(ancestors[id in $documents]) > 0 || ${FIELD_REFS_DOC} || count(stages[${FIELD_REFS_DOC}]) > 0 || ${ACTIVITY_REFS_DOC}`;
+    return documentPrefilter(documents, params);
 }
 
 function idsArm(filter, params) {
@@ -6519,7 +6801,7 @@ function instancesQuery(args) {
     const conditions = [ `_type == "${WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ], params = {
         tag: tag
     };
-    filter.includeCompleted !== !0 && conditions.push("!defined(completedAt)"), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
+    filter.includeCompleted !== !0 && conditions.push(inFlightFilter()), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
     params.definition = filter.definition), filter.stage !== void 0 && (conditions.push("currentStage == $stage"), 
     params.stage = filter.stage);
     const arms = [ documentArm(filter, params), idsArm(filter, params) ].filter(arm => arm !== void 0);
@@ -6596,17 +6878,12 @@ function topoSortDefinitions(definitions, ctx) {
 }
 
 function refsOf(def) {
-    const out = [];
-    for (const stage of def.stages) for (const activity of stage.activities ?? []) {
-        const ref = activity.subworkflows?.definition;
-        ref !== void 0 && out.push({
-            name: ref.name,
-            ...ref.version !== void 0 ? {
-                version: ref.version
-            } : {}
-        });
-    }
-    return out;
+    return def.stages.flatMap(stage => stage.activities ?? []).flatMap(activity => activity.actions ?? []).flatMap(action => action.spawn === void 0 ? [] : [ action.spawn.definition ]).map(ref => ({
+        name: ref.name,
+        ...ref.version !== void 0 ? {
+            version: ref.version
+        } : {}
+    }));
 }
 
 function hashDefinitionContent(def) {
@@ -6681,284 +6958,66 @@ function parseDefinitionInput(def, caller) {
 
 function stripSystemFields(doc) {
     const out = {};
-    for (const [k, v2] of Object.entries(doc)) k === "_rev" || k === "_createdAt" || k === "_updatedAt" || (out[k] = v2);
-    return out;
-}
-
-function stableStringify(value) {
-    return value === null || typeof value != "object" ? JSON.stringify(value) : Array.isArray(value) ? `[${value.map(stableStringify).join(",")}]` : `{${Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([k, v2]) => `${JSON.stringify(k)}:${stableStringify(v2)}`).join(",")}}`;
-}
-
-async function loadDefinition({client: client, definition: definition, version: version, tag: tag}) {
-    if (version !== void 0) {
-        const doc = await client.fetch(definitionLookupGroq(!0), {
-            definition: definition,
-            version: version,
-            tag: tag
-        });
-        if (!doc) throw new invariants.DefinitionNotFoundError({
-            definition: definition,
-            version: version
-        });
-        return assertReadableModel(doc);
-    }
-    const latest = await loadLatestDeployed({
-        client: client,
-        definition: definition,
-        tag: tag
-    });
-    if (!latest) throw new invariants.DefinitionNotFoundError({
-        definition: definition
-    });
-    return latest;
-}
-
-async function loadLatestDeployed({client: client, definition: definition, tag: tag}) {
-    const doc = await client.fetch(definitionLookupGroq(!1), {
-        definition: definition,
-        tag: tag
-    });
-    return doc ? assertReadableModel(doc) : void 0;
-}
-
-async function loadDefinitionVersions({client: client, definition: definition, tag: tag}) {
-    return (await client.fetch(`*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${invariants.tagScopeFilter()}] | order(version desc)`, {
-        definition: definition,
-        tag: tag
-    })).map(assertReadableModel);
-}
-
-async function loadDefinitionVersionsOrThrow({client: client, definition: definition, tag: tag}) {
-    const versions = await loadDefinitionVersions({
-        client: client,
-        definition: definition,
-        tag: tag
-    });
-    if (versions.length === 0) throw new invariants.DefinitionNotFoundError({
-        definition: definition
-    });
-    return versions;
-}
-
-function subjectDenialLabels(denied) {
-    return denied.map(d => `${d.permission} on ${d.subject} (${d.resource})`);
-}
-
-class ActionDisabledError extends invariants.WorkflowError {
-    reason;
-    activity;
-    action;
-    constructor(args) {
-        super("action-disabled", formatDisabledReason({
-            activity: args.activity,
-            action: args.action,
-            reason: args.reason
-        })), this.name = "ActionDisabledError", this.reason = args.reason, this.activity = args.activity, 
-        this.action = args.action;
-    }
-}
-
-const disabledReasonDetail = {
-    "filter-failed": r => `action filter returned false${r.detail ? ` (${r.detail})` : ""}`,
-    "activity-not-active": r => `activity status is "${r.status}"`,
-    "stage-terminal": r => `stage "${r.stage}" is terminal`,
-    "instance-completed": r => `instance completed at ${r.completedAt}`,
-    "instance-aborted": r => `instance aborted at ${r.abortedAt}`,
-    "requirements-unmet": r => `unmet requirement(s): ${r.unmetRequirements.join(", ")}`,
-    "subject-permission-denied": r => `missing subject permission(s): ${subjectDenialLabels(r.denied).join(", ")}`
-};
-
-function actionDisabledDetail(reason) {
-    return disabledReasonDetail[reason.kind](reason);
-}
-
-function formatDisabledReason({activity: activity, action: action, reason: reason}) {
-    return `Action "${activity}:${action}" is not allowed: ${actionDisabledDetail(reason)}`;
-}
-
-class EditFieldDeniedError extends invariants.WorkflowError {
-    reason;
-    target;
-    constructor(args) {
-        super("edit-field-denied", formatEditDisabledReason(args.target, args.reason)), 
-        this.name = "EditFieldDeniedError", this.reason = args.reason, this.target = args.target;
-    }
-}
-
-const editDisabledReasonDetail = {
-    "not-editable": () => "field is not declared editable",
-    "instance-completed": r => `instance completed at ${r.completedAt}`,
-    "instance-aborted": r => `instance aborted at ${r.abortedAt}`,
-    "edit-window-closed": r => `edit window closed (${r.detail})`,
-    "editor-not-permitted": r => `editor not permitted (${r.predicate})`
-};
-
-function formatEditDisabledReason(target, reason) {
-    const detail = editDisabledReasonDetail[reason.kind](reason), where = target.activity !== void 0 ? `${target.activity}.${target.field}` : target.field;
-    return `Field "${target.scope}:${where}" is not editable: ${detail}`;
+    for (const [k, v2] of Object.entries(doc)) k === "_rev" || k === "_createdAt" || k === "_updatedAt" || (out[k] = v2);
+    return out;
 }
 
-async function fireAction(args) {
-    const {client: client, instanceId: instanceId, activity: activity, action: action, params: params, requestRecord: requestRecord, options: options} = args;
-    return retryOnRevisionConflict({
-        client: client,
-        instanceId: instanceId,
-        options: options,
-        commit: ctx => commitAction({
-            ctx: ctx,
-            activityName: activity,
-            actionName: action,
-            callerParams: params,
-            requestRecord: requestRecord,
-            options: options
-        }),
-        onExhausted: () => new ConcurrentFireActionError({
-            instanceId: instanceId,
-            activity: activity,
-            action: action,
-            attempts: CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS
-        })
-    });
+function stableStringify(value) {
+    if (value === null || typeof value != "object") return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record).toSorted().map(k => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
 }
 
-async function resolveActionCommit({ctx: ctx, activityName: activityName, actionName: actionName, callerParams: callerParams, options: options}) {
-    const actor = options?.actor, {stage: stage, activity: activity} = findActivityInCurrentStage(ctx, activityName), action = (activity.actions ?? []).find(a => a.name === actionName);
-    if (action === void 0) throw new invariants.ContractViolationError(`Action "${actionName}" not declared on activity "${activityName}"`);
-    if (action.filter !== void 0) {
-        const can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan({
-            instance: ctx.instance,
-            actor: actor,
-            grants: options.grants
-        }) : void 0;
-        if (!await ctxEvaluateCondition({
-            ctx: ctx,
-            condition: action.filter,
-            opts: {
-                activityName: activityName,
-                ...actor !== void 0 ? {
-                    actor: actor
-                } : {},
-                ...can !== void 0 ? {
-                    vars: {
-                        can: can
-                    }
-                } : {}
-            }
-        })) throw new ActionDisabledError({
-            activity: activityName,
-            action: actionName,
-            reason: {
-                kind: "filter-failed",
-                filter: action.filter,
-                detail: "commit re-check"
-            }
+async function loadDefinition({client: client, definition: definition, version: version, tag: tag}) {
+    if (version !== void 0) {
+        const doc = await client.fetch(definitionLookupGroq(!0), {
+            definition: definition,
+            version: version,
+            tag: tag
+        });
+        if (!doc) throw new invariants.DefinitionNotFoundError({
+            definition: definition,
+            version: version
         });
+        return assertReadableModel(doc);
     }
-    const entry = findCurrentActivities(ctx.instance).find(t => t.name === activityName);
-    if (entry === void 0 || entry.status !== "active") throw notActiveAtCommit({
-        activityName: activityName,
-        actionName: actionName,
-        status: entry?.status
+    const latest = await loadLatestDeployed({
+        client: client,
+        definition: definition,
+        tag: tag
     });
-    const params = validateActionParams({
-        action: action,
-        activityName: activityName,
-        callerParams: callerParams
+    if (!latest) throw new invariants.DefinitionNotFoundError({
+        definition: definition
     });
-    return {
-        stage: stage,
-        activity: activity,
-        action: action,
-        params: params
-    };
+    return latest;
 }
 
-function notActiveAtCommit(args) {
-    const {activityName: activityName, actionName: actionName, status: status} = args;
-    return status !== void 0 && invariants.isTerminalActivityStatus(status) ? new ActionDisabledError({
-        activity: activityName,
-        action: actionName,
-        reason: {
-            kind: "activity-not-active",
-            status: status
-        }
-    }) : new Error(`Activity "${activityName}" must be active to fire action "${actionName}"; status is ${status ?? "missing"}`);
+async function loadLatestDeployed({client: client, definition: definition, tag: tag}) {
+    const doc = await client.fetch(definitionLookupGroq(!1), {
+        definition: definition,
+        tag: tag
+    });
+    return doc ? assertReadableModel(doc) : void 0;
 }
 
-async function commitAction({ctx: ctx, activityName: activityName, actionName: actionName, callerParams: callerParams, requestRecord: requestRecord, options: options}) {
-    assertRequestUnprocessed({
-        instance: ctx.instance,
-        record: requestRecord,
-        now: ctx.now
-    });
-    const actor = options?.actor, {stage: stage, action: action, params: params} = await resolveActionCommit({
-        ctx: ctx,
-        activityName: activityName,
-        actionName: actionName,
-        callerParams: callerParams,
-        options: options
-    }), mutation = startMutation(ctx.instance);
-    recordProcessedRequest({
-        mutation: mutation,
-        record: requestRecord,
-        now: ctx.now
+async function loadDefinitionVersions({client: client, definition: definition, tag: tag}) {
+    return (await client.fetch(`*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${invariants.tagScopeFilter()}] | order(version desc)`, {
+        definition: definition,
+        tag: tag
+    })).map(assertReadableModel);
+}
+
+async function loadDefinitionVersionsOrThrow({client: client, definition: definition, tag: tag}) {
+    const versions = await loadDefinitionVersions({
+        client: client,
+        definition: definition,
+        tag: tag
     });
-    const mutEntry = requireMutationActivityEntry(mutation, activityName), now = ctx.now;
-    mutation.history.push({
-        _key: randomKey(),
-        _type: "actionFired",
-        at: now,
-        stage: stage.name,
-        activity: activityName,
-        action: actionName,
-        ...actor !== void 0 ? {
-            actor: actor,
-            driverKind: driverKind(actor)
-        } : {}
+    if (versions.length === 0) throw new invariants.DefinitionNotFoundError({
+        definition: definition
     });
-    const statusBefore = mutEntry.status, ranOps = await runOps({
-        ops: action.ops,
-        mutation: mutation,
-        stage: stage.name,
-        origin: {
-            activity: activityName,
-            action: actionName
-        },
-        params: params,
-        actor: actor,
-        self: invariants.selfGdr(ctx.instance),
-        now: now,
-        snapshot: ctx.snapshot
-    }), newStatus = mutEntry.status !== statusBefore ? mutEntry.status : void 0;
-    return await queueEffects({
-        ctx: ctx,
-        mutation: mutation,
-        effects: action.effects,
-        origin: {
-            kind: "action",
-            name: actionName
-        },
-        actor: actor,
-        opts: {
-            callerParams: params,
-            activityName: activityName
-        }
-    }), await persistThenMaybeRefresh({
-        ctx: ctx,
-        mutation: mutation,
-        stageName: stage.name,
-        didChangeState: ranOps.some(isFieldOp)
-    }), {
-        fired: !0,
-        activity: activityName,
-        action: actionName,
-        ...newStatus !== void 0 ? {
-            newStatus: newStatus
-        } : {},
-        ...ranOps.length > 0 ? {
-            ranOps: ranOps
-        } : {}
-    };
+    return versions;
 }
 
 async function editField(args) {
@@ -6978,7 +7037,7 @@ async function editField(args) {
         onExhausted: () => new ConcurrentEditFieldError({
             instanceId: instanceId,
             target: labelTarget(target),
-            attempts: CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS
+            attempts: CONCURRENT_COMMIT_MAX_ATTEMPTS
         })
     });
 }
@@ -7274,7 +7333,7 @@ async function abortAndPropagate(args) {
         ...telemetry !== void 0 ? {
             telemetry: telemetry
         } : {}
-    }), result.fired && await propagateToAncestors({
+    }), await propagateToAncestors({
         client: client,
         instanceId: instanceId,
         actor: actor,
@@ -7289,12 +7348,12 @@ async function abortAndPropagate(args) {
     }), result.fired;
 }
 
-function toEffectsContextEntries(ctx) {
-    return Object.entries(ctx).map(([id, value]) => toEffectsContextSeedEntry(id, value));
+function toContextEntries(ctx) {
+    return Object.entries(ctx).map(([id, value]) => toContextSeedEntry(id, value));
 }
 
-function toEffectsContextSeedEntry(name, value) {
-    return typeof value == "string" || typeof value == "number" || typeof value == "boolean" || invariants.isGdr(value) ? effectsContextEntry(name, value) : effectsContextJsonEntry(name, value);
+function toContextSeedEntry(name, value) {
+    return typeof value == "string" || typeof value == "number" || typeof value == "boolean" || invariants.isGdr(value) ? contextEntry(name, value) : contextJsonEntry(name, value);
 }
 
 async function dispatchGatedWrite(args) {
@@ -7414,12 +7473,7 @@ function buildEngineCallOptions(args) {
 
 async function applyAction(args) {
     const {client: client, instance: instance, activity: activity, action: action, params: params, requestRecord: requestRecord, ...rest} = args, options = buildEngineCallOptions(rest);
-    return findCurrentActivityEntry(instance, activity)?.status === "pending" && await invokeActivity({
-        client: client,
-        instanceId: instance._id,
-        activity: activity,
-        options: options
-    }), (await fireAction({
+    return (await fireAction({
         client: client,
         instanceId: instance._id,
         activity: activity,
@@ -7513,7 +7567,7 @@ async function assertNoSpawnReferrers({client: client, tag: tag, definition: def
 
 async function nonTerminalInstanceIds({client: client, tag: tag, definition: definition, version: version}) {
     const versionFilter = version === void 0 ? "" : " && pinnedVersion == $version";
-    return (await client.fetch(`*[_type == "${WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && !defined(completedAt)${versionFilter}] | order(_id asc){_id}`, {
+    return (await client.fetch(`*[_type == "${WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && ${inFlightFilter()}${versionFilter}] | order(_id asc){_id}`, {
         definition: definition,
         tag: tag,
         ...version !== void 0 ? {
@@ -7541,6 +7595,16 @@ async function abortInstances(args) {
     return aborted;
 }
 
+async function fetchStartFilterSlice(args) {
+    const {client: client, tag: tag} = args, {query: query, params: params} = instancesQuery({
+        tag: tag,
+        filter: {
+            includeCompleted: !0
+        }
+    });
+    return (await client.fetch(query, params)).map(assertReadableModel);
+}
+
 const workflow = {
     deployDefinitions: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.deploy), {client: client, tag: tag, resourceAliases: resourceAliases} = args;
@@ -7615,16 +7679,22 @@ const workflow = {
         }), result;
     },
     startInstance: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.start), {client: client, tag: tag, workflowResource: workflowResource, definition: definitionName, version: version, initialFields: initialFields, ancestors: ancestors, effectsContext: effectsContext, instanceId: instanceId, perspective: perspective, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr} = await resolveOperationContext(args), clock = args.clock ?? wallClock, definition = await loadDefinition({
+        const args = taggedScope(rawArgs, REQUEST_TAG.start), {client: client, tag: tag, workflowResource: workflowResource, definition: definitionName, version: version, initialFields: initialFields, ancestors: ancestors, context: context, instanceId: instanceId, perspective: perspective, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr} = await resolveOperationContext(args), clock = args.clock ?? wallClock, seedFields = initialFields ?? [], definition = await loadDefinition({
             client: client,
             definition: definitionName,
             version: version,
             tag: tag
         }), id = instanceId ?? instanceDocId(tag);
         if (definition.stages.find(s => s.name === definition.initialStage) === void 0) throw new Error(`Initial stage "${definition.initialStage}" missing in ${definitionName} v${definition.version}`);
-        const now = clock(), effectsContextEntries = effectsContext ? toEffectsContextEntries(effectsContext) : [], fieldDiscards = [], resolvedFields = await resolveDeclaredFields({
+        const now = clock();
+        assertRequiredInputProvided({
             entryDefs: definition.fields ?? [],
-            initialFields: initialFields ?? [],
+            initialFields: seedFields,
+            definitionName: definition.name
+        });
+        const contextEntries = context ? toContextEntries(context) : [], fieldDiscards = [], resolvedFields = await resolveDeclaredFields({
+            entryDefs: definition.fields ?? [],
+            initialFields: seedFields,
             ctx: {
                 client: client,
                 now: now,
@@ -7652,7 +7722,7 @@ const workflow = {
             pinnedContentHash: definition.contentHash,
             definition: definition,
             fields: resolvedFields,
-            effectsContext: effectsContextEntries,
+            context: contextEntries,
             ancestors: ancestors ?? [],
             perspective: effectivePerspective,
             initialStage: definition.initialStage,
@@ -7662,20 +7732,8 @@ const workflow = {
                 extraHistory: fieldDiscards
             } : {}
         });
-        await client.create(base, SYNC_COMMIT), await primeInitialStage({
-            client: client,
-            instanceId: id,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            clock: clock,
-            ...executionContext !== void 0 ? {
-                executionContext: executionContext
-            } : {},
-            ...args.telemetry !== void 0 ? {
-                telemetry: args.telemetry
-            } : {}
-        });
-        const cascaded = await cascade({
+        await client.create(base, SYNC_COMMIT);
+        const runArgs = {
             client: client,
             instanceId: id,
             actor: actor,
@@ -7687,11 +7745,13 @@ const workflow = {
             ...args.telemetry !== void 0 ? {
                 telemetry: args.telemetry
             } : {}
-        });
+        };
+        await primeInitialStage(runArgs);
+        const cascaded = await cascade(runArgs);
         return resolveTelemetry(args.telemetry).log(WorkflowInstanceStarted, instanceStartedData({
             definition: definition,
             instanceId: id,
-            initialFieldCount: initialFields?.length ?? 0,
+            initialFieldCount: seedFields.length,
             viaSpawn: !1
         })), {
             instance: await reload({
@@ -8264,12 +8324,21 @@ const workflow = {
     definitionsForDocument: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.definitionsForDocument), {client: client, tag: tag, document: document} = args;
         invariants.validateTag(tag);
-        const deployed = (await client.fetch(definitionsListGroq("desc"), {
+        const clock = args.clock ?? wallClock, deployed = (await client.fetch(definitionsListGroq("desc"), {
             tag: tag
         })).map(assertReadableModel), latest = latestDeployedDefinitions(deployed);
+        let slice;
         return applicableDefinitions({
             definitions: latest,
-            document: document
+            document: document,
+            scope: {
+                tag: tag,
+                now: clock(),
+                fetchDataset: () => slice ??= fetchStartFilterSlice({
+                    client: client,
+                    tag: tag
+                })
+            }
         });
     },
     permissions: {
@@ -9381,6 +9450,24 @@ async function computeDiffEntries({client: client, defs: defs, target: target})
     return entries;
 }
 
+function buildInitialFields({declared: declared, values: values}) {
+    const settable = declared.filter(f => f.initialValue?.type === "input"), settableNames = settable.map(f => f.name).join(", ");
+    return Object.entries(values).map(([name, value]) => {
+        const entry = declared.find(f => f.name === name);
+        if (entry === void 0) throw new Error(settable.length > 0 ? `workflow declares no field "${name}" — input fields: ${settableNames}` : `workflow declares no field "${name}" — it declares no input fields at all`);
+        if (entry.initialValue?.type !== "input") throw new Error(`field "${name}" is not input-sourced — the engine would silently ignore the value. ` + (settable.length > 0 ? `Input fields: ${settableNames}` : "This workflow has no input fields."));
+        return {
+            type: entry.type,
+            name: name,
+            value: value
+        };
+    });
+}
+
+function startRefusal(definition) {
+    if (!invariants.isStartableDefinition(definition)) return "definition is spawn-only (lifecycle: 'child') — instances of it are spawned by a parent workflow's activity, not started standalone";
+}
+
 const HISTORY_DISPLAY = {
     stageEntered: {
         title: "Stage entered",
@@ -9390,17 +9477,13 @@ const HISTORY_DISPLAY = {
         title: "Stage exited",
         description: "The instance left a stage on the way to the next one."
     },
-    activityActivated: {
-        title: "Activity activated",
-        description: "An activity flipped from `pending` to `active` and its onEnter effects queued."
-    },
     activityStatusChanged: {
         title: "Activity status changed",
         description: "An action or op flipped an activity's status (active → done / skipped / failed)."
     },
     actionFired: {
         title: "Action fired",
-        description: "An action was invoked against an activity — ops ran, status may have flipped, effects queued."
+        description: "An action fired against an activity — via fireAction, or cascade-fired when its `when` turned true (`triggered`) — ops ran, status may have flipped, effects queued, spawn reconciled."
     },
     transitionFired: {
         title: "Transition fired",
@@ -9412,7 +9495,7 @@ const HISTORY_DISPLAY = {
     },
     effectCompleted: {
         title: "Effect settled",
-        description: "A queued effect settled: a drainer ran its handler to completion (done or failed, outputs merged into effectsContext), or an abort cancelled it before dispatch."
+        description: "A queued effect settled: a drainer ran its handler to completion (done or failed, outputs recorded on the run row and readable as $effects), or an abort cancelled it before dispatch."
     },
     effectClaimReleased: {
         title: "Stale claim released",
@@ -9420,7 +9503,7 @@ const HISTORY_DISPLAY = {
     },
     spawned: {
         title: "Spawned child",
-        description: "An activity's `subworkflows` declaration spawned a child workflow instance."
+        description: "An action's `spawn` declaration spawned a child workflow instance."
     },
     subworkflowAdopted: {
         title: "Child adopted",
@@ -9446,6 +9529,23 @@ const HISTORY_DISPLAY = {
         title: "Query result discarded",
         description: "A query-sourced field's GROQ result didn't fit the field's declared kind, so it was discarded and the field fell back to its default."
     }
+}, EXECUTOR_CLASSIFICATION_DISPLAY = {
+    autonomous: {
+        title: "Autonomous",
+        description: "Every action is cascade-fired — the engine advances it; no caller is ever needed."
+    },
+    interactive: {
+        title: "Interactive",
+        description: "Only fireAction-fired actions — a caller (editor, robot, agent) must act."
+    },
+    "off-system": {
+        title: "Off-system",
+        description: "The work happens outside the system (the `target` deep-link); someone records it here."
+    },
+    hybrid: {
+        title: "Hybrid",
+        description: "A mix of caller-fired actions and cascade-fired triggers."
+    }
 }, FIELD_KIND_DISPLAY = {
     "doc.ref": {
         title: "Document reference",
@@ -9522,7 +9622,7 @@ const HISTORY_DISPLAY = {
     },
     "field.updateWhere": {
         title: "Update matching rows",
-        description: "Merge fields into rows of an array-kind entry that match the `where` condition."
+        description: "Merge declared sub-fields into rows of an `array` entry that match the `where` condition (`array` only — `doc.refs`/`assignees` rows are engine-shaped)."
     },
     "field.removeWhere": {
         title: "Remove matching rows",
@@ -9532,26 +9632,26 @@ const HISTORY_DISPLAY = {
         title: "Set activity status",
         description: "Flip an activity's status explicitly (the action-level `status:` sugar desugars to this)."
     }
-}, EFFECTS_CONTEXT_DISPLAY = {
-    "effectsContext.string": {
+}, CONTEXT_ENTRY_DISPLAY = {
+    "context.string": {
         title: "String",
-        description: "Stable string parameter for effect handlers."
+        description: "Start-seeded string value, read as `$context.<name>`."
     },
-    "effectsContext.number": {
+    "context.number": {
         title: "Number",
-        description: "Stable numeric parameter for effect handlers."
+        description: "Start-seeded numeric value, read as `$context.<name>`."
     },
-    "effectsContext.boolean": {
+    "context.boolean": {
         title: "Boolean",
-        description: "Stable boolean parameter for effect handlers."
+        description: "Start-seeded boolean value, read as `$context.<name>`."
     },
-    "effectsContext.ref": {
+    "context.ref": {
         title: "GDR reference",
-        description: "Stable GDR pointer parameter for effect handlers."
+        description: "Start-seeded GDR pointer, read as `$context.<name>`."
     },
-    "effectsContext.json": {
+    "context.json": {
         title: "JSON",
-        description: "Stable JSON payload for effect handlers."
+        description: "Start-seeded JSON payload, read as `$context.<name>`."
     }
 }, AUTHORING_DISPLAY = {
     pendingEffect: {
@@ -9581,7 +9681,7 @@ const HISTORY_DISPLAY = {
     },
     script: {
         title: "Script activity",
-        description: "The engine runs a step inline and resolves on activation — an audit row."
+        description: "The engine runs a step inline and resolves it in the same cascade hop — an audit row."
     },
     manual: {
         title: "Manual activity",
@@ -9621,7 +9721,7 @@ const HISTORY_DISPLAY = {
     ...HISTORY_DISPLAY,
     ...FIELD_KIND_DISPLAY,
     ...OP_DISPLAY,
-    ...EFFECTS_CONTEXT_DISPLAY,
+    ...CONTEXT_ENTRY_DISPLAY,
     ...AUTHORING_DISPLAY
 };
 
@@ -9641,12 +9741,16 @@ exports.CONDITION_VARS = invariants.CONDITION_VARS;
 
 exports.ContractViolationError = invariants.ContractViolationError;
 
+exports.DEFAULT_TRANSITION_WHEN = invariants.DEFAULT_TRANSITION_WHEN;
+
 exports.DRIVER_KINDS = invariants.DRIVER_KINDS;
 
 exports.DefinitionInUseError = invariants.DefinitionInUseError;
 
 exports.DefinitionNotFoundError = invariants.DefinitionNotFoundError;
 
+exports.EXECUTOR_CLASSIFICATIONS = invariants.EXECUTOR_CLASSIFICATIONS;
+
 exports.EffectNotFoundError = invariants.EffectNotFoundError;
 
 exports.FILTER_SCOPE_VARS = invariants.FILTER_SCOPE_VARS;
@@ -9661,14 +9765,24 @@ exports.InstanceNotFoundError = invariants.InstanceNotFoundError;
 
 exports.RESERVED_CONDITION_VARS = invariants.RESERVED_CONDITION_VARS;
 
+exports.START_FILTER_VARS = invariants.START_FILTER_VARS;
+
 exports.WORKFLOW_DEFINITION_TYPE = invariants.WORKFLOW_DEFINITION_TYPE;
 
 exports.WorkflowError = invariants.WorkflowError;
 
 exports.clientConfigFromResource = invariants.clientConfigFromResource;
 
+exports.conditionFieldReadNames = invariants.conditionFieldReadNames;
+
 exports.datasetResourceParts = invariants.datasetResourceParts;
 
+exports.deriveActivityKind = invariants.deriveActivityKind;
+
+exports.deriveExecutorClassification = invariants.deriveExecutorClassification;
+
+exports.driverKind = invariants.driverKind;
+
 exports.errorMessage = invariants.errorMessage;
 
 exports.extractDocumentId = invariants.extractDocumentId;
@@ -9681,12 +9795,16 @@ exports.gdrUri = invariants.gdrUri;
 
 exports.groupMembershipNames = invariants.groupMembershipNames;
 
+exports.isCascadeFired = invariants.isCascadeFired;
+
 exports.isGdr = invariants.isGdr;
 
 exports.isNotesEntry = invariants.isNotesEntry;
 
 exports.isStartableDefinition = invariants.isStartableDefinition;
 
+exports.isSubjectEntry = invariants.isSubjectEntry;
+
 exports.isTerminalActivityStatus = invariants.isTerminalActivityStatus;
 
 exports.isTodoListEntry = invariants.isTodoListEntry;
@@ -9697,6 +9815,8 @@ exports.parseGdr = invariants.parseGdr;
 
 exports.parseResourceGdr = invariants.parseResourceGdr;
 
+exports.readsRootDocument = invariants.readsRootDocument;
+
 exports.refCanvas = invariants.refCanvas;
 
 exports.refDashboard = invariants.refDashboard;
@@ -9717,6 +9837,8 @@ exports.resourceFromParsed = invariants.resourceFromParsed;
 
 exports.resourceGdr = invariants.resourceGdr;
 
+exports.startKindOf = invariants.startKindOf;
+
 exports.tagScopeFilter = invariants.tagScopeFilter;
 
 exports.toBareId = invariants.toBareId;
@@ -9810,8 +9932,12 @@ exports.ActionDisabledError = ActionDisabledError;
 
 exports.ActionParamsInvalidError = ActionParamsInvalidError;
 
+exports.CONTEXT_ENTRY_DISPLAY = CONTEXT_ENTRY_DISPLAY;
+
 exports.CascadeLimitError = CascadeLimitError;
 
+exports.ConcurrentCompleteEffectError = ConcurrentCompleteEffectError;
+
 exports.ConcurrentEditFieldError = ConcurrentEditFieldError;
 
 exports.ConcurrentFireActionError = ConcurrentFireActionError;
@@ -9830,12 +9956,12 @@ exports.DISPLAY = DISPLAY;
 
 exports.DRIVER_KIND_DISPLAY = DRIVER_KIND_DISPLAY;
 
-exports.EFFECTS_CONTEXT_DISPLAY = EFFECTS_CONTEXT_DISPLAY;
-
 exports.ENGINE_API_VERSION = ENGINE_API_VERSION;
 
 exports.EXECUTION_KINDS = EXECUTION_KINDS;
 
+exports.EXECUTOR_CLASSIFICATION_DISPLAY = EXECUTOR_CLASSIFICATION_DISPLAY;
+
 exports.EditFieldDeniedError = EditFieldDeniedError;
 
 exports.EffectOpsInvalidError = EffectOpsInvalidError;
@@ -9900,9 +10026,9 @@ exports.aclPathForResource = aclPathForResource;
 
 exports.actionDisabledDetail = actionDisabledDetail;
 
-exports.actionVerdict = actionVerdict;
+exports.actionRendering = actionRendering;
 
-exports.activityKind = activityKind;
+exports.actionVerdict = actionVerdict;
 
 exports.applicableDefinitions = applicableDefinitions;
 
@@ -9910,6 +10036,8 @@ exports.assertReadableModel = assertReadableModel;
 
 exports.availableActions = availableActions;
 
+exports.buildInitialFields = buildInitialFields;
+
 exports.buildSnapshot = buildSnapshot;
 
 exports.checklistLines = checklistLines;
@@ -9920,8 +10048,14 @@ exports.computeDiffEntries = computeDiffEntries;
 
 exports.conditionSitesOf = conditionSitesOf;
 
+exports.contentDocQuery = contentDocQuery;
+
+exports.contentDraftFallback = contentDraftFallback;
+
 exports.contentReleaseName = contentReleaseName;
 
+exports.contextMap = contextMap;
+
 exports.createEngine = createEngine;
 
 exports.createTelemetryIntake = createTelemetryIntake;
@@ -9942,8 +10076,6 @@ exports.denyingGuards = denyingGuards;
 
 exports.deployStageGuards = deployStageGuards;
 
-exports.deriveActivityKind = deriveActivityKind;
-
 exports.describeAtom = describeAtom;
 
 exports.describeCondition = describeCondition;
@@ -9970,14 +10102,16 @@ exports.displayTitle = displayTitle;
 
 exports.documentActionDenials = documentActionDenials;
 
-exports.driverKind = driverKind;
+exports.documentPrefilter = documentPrefilter;
 
-exports.effectsContextMap = effectsContextMap;
+exports.effectOutputsMap = effectOutputsMap;
 
 exports.evaluateFromSnapshot = evaluateFromSnapshot;
 
 exports.evaluateMutationGuard = evaluateMutationGuard;
 
+exports.evaluateStartFilter = evaluateStartFilter;
+
 exports.fieldTreeShape = fieldTreeShape;
 
 exports.findCurrentActivityEntry = findCurrentActivityEntry;
@@ -9996,6 +10130,8 @@ exports.guardsForResource = guardsForResource;
 
 exports.hashDefinitionContent = hashDefinitionContent;
 
+exports.inFlightFilter = inFlightFilter;
+
 exports.instanceGuardQuery = instanceGuardQuery;
 
 exports.instanceWatchesDocument = instanceWatchesDocument;
@@ -10006,6 +10142,8 @@ exports.isClaimExpired = isClaimExpired;
 
 exports.isDefinitionApplicable = isDefinitionApplicable;
 
+exports.isFilterScopedOut = isFilterScopedOut;
+
 exports.isGuardLifted = isGuardLifted;
 
 exports.isTelemetryEnvDenied = isTelemetryEnvDenied;
@@ -10028,10 +10166,14 @@ exports.noopTelemetry = noopTelemetry;
 
 exports.parentRef = parentRef;
 
+exports.parseDefinitionInput = parseDefinitionInput;
+
 exports.parseDefinitionSnapshot = parseDefinitionSnapshot;
 
 exports.processShellUserProperties = processShellUserProperties;
 
+exports.projectToWatchRef = projectToWatchRef;
+
 exports.readsRaw = readsRaw;
 
 exports.remediationsFor = remediationsFor;
@@ -10044,6 +10186,8 @@ exports.retractStageGuards = retractStageGuards;
 
 exports.silentLogger = silentLogger;
 
+exports.startRefusal = startRefusal;
+
 exports.stripSystemFields = stripSystemFields;
 
 exports.subjectDenialLabels = subjectDenialLabels;