@sanity/workflow-engine 0.19.0 → 0.21.0

package/dist/index.cjs

@@ -279,6 +279,10 @@ const HIGH_FREQUENCY_SAMPLE_MS = 6e4, WorkflowDefinitionDeployed = defineWorkflo
     name: "Editorial Workflows Stage Set",
     version: 1,
     description: "The set-stage admin override was invoked (changed: false = already at the target stage)"
+}), WorkflowActivityReset = defineWorkflowEvent({
+    name: "Editorial Workflows Activity Reset",
+    version: 1,
+    description: "The reset-activity admin override was invoked (changed: false = already at the target status, or the instance was terminal)"
 }), WorkflowDefinitionDeleted = defineWorkflowEvent({
     name: "Editorial Workflows Definition Deleted",
     version: 1,
@@ -859,7 +863,7 @@ function toGroqDescribeContext(ctx) {
     };
 }
 
-const VAR_LABELS = new Map([ ...invariants.START_ALLOWED_VARS, ...invariants.CONDITION_VARS ].map(entry => [ entry.name, entry.label ]));
+const VAR_LABELS = new Map([ ...invariants.START_REQUIREMENT_VARS, ...invariants.CONDITION_VARS ].map(entry => [ entry.name, entry.label ]));
 
 function renderWorkflowRead(read, ctx) {
     if (read.variable === "fields" && typeof read.path[0] == "string") {
@@ -932,13 +936,6 @@ function clauseVarRequirement(requirement) {
             params: {},
             text: "no activity in this stage may have failed"
         });
-        if (target.variable === invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR) return kind === "truthy" ? groqConditionDescribe.phrase("requirement.subject-has-in-flight-instance", {
-            params: {},
-            text: "the subject must already have an in-flight workflow"
-        }) : groqConditionDescribe.phrase("requirement.subject-has-no-in-flight-instance", {
-            params: {},
-            text: "the subject must not already have an in-flight workflow"
-        });
     }
 }
 
@@ -1434,14 +1431,14 @@ function activitySites(activity, stage) {
             activity: activity.name
         },
         condition: activity.filter
-    } ] : [], ...Object.entries(activity.requirements ?? {}).map(([requirement, condition]) => ({
+    } ] : [], ...(activity.requirements ?? []).map(requirement => ({
         stage: stage,
         address: {
             kind: "requirement",
             activity: activity.name,
-            requirement: requirement
+            requirement: requirement.name
         },
-        condition: condition
+        condition: requirement.query
     })), ...(activity.actions ?? []).flatMap(action => [ ...action.filter !== void 0 ? [ {
         stage: stage,
         address: {
@@ -1509,13 +1506,7 @@ async function evaluateStartFilter(args) {
     const {filter: filter, definition: definition, document: document, scope: scope} = args, parsed = parseStartFilter({
         filter: filter,
         definition: definition
-    });
-    assertFilterSubject({
-        readsSubject: parsed.readsSubject,
-        definition: definition,
-        scope: scope
-    });
-    const dataset = await filterDataset(parsed.needsDataset, scope);
+    }), dataset = await filterDataset(parsed.needsDataset, scope);
     if (dataset === void 0) return !1;
     try {
         const result = await (await groqJs.evaluate(parsed.tree, {
@@ -1525,8 +1516,7 @@ async function evaluateStartFilter(args) {
             dataset: dataset,
             params: startContextParams({
                 definition: definition,
-                scope: scope,
-                dataset: dataset
+                scope: scope
             })
         })).get();
         return invariants.isUnevaluable(result) ? !1 : !!result;
@@ -1542,11 +1532,9 @@ async function evaluateStartFilter(args) {
 function parseStartFilter(args) {
     const {filter: filter, definition: definition} = args;
     try {
-        const readsSubject = readsSubjectHasInFlightInstance(filter);
         return {
             tree: groqJs.parse(filter),
-            needsDataset: groqConditionDescribe.analyzeCondition(filter).readsDataset || readsSubject,
-            readsSubject: readsSubject
+            needsDataset: groqConditionDescribe.analyzeCondition(filter).readsDataset
         };
     } catch (err) {
         rethrowNamingDefinition({
@@ -1557,70 +1545,81 @@ function parseStartFilter(args) {
     }
 }
 
-function assertFilterSubject(args) {
-    if (!(!args.readsSubject || args.scope?.subject !== void 0)) throw new invariants.ContractViolationError(`start.filter on definition "${args.definition.name ?? "<unnamed>"}" reads $${invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR}, but the caller supplied no resource-qualified \`scope.subject\` — a loaded document alone cannot identify its project and dataset.`);
-}
-
 async function filterDataset(needsDataset, scope) {
     if (!needsDataset) return [];
     if (scope?.fetchDataset !== void 0) return scope.fetchDataset();
 }
 
-async function explainStartAllowed(args) {
-    const {allowed: allowed, definition: definition, fields: fields, scope: scope} = args;
+async function explainStartRequirement(args) {
+    const {query: query, definition: definition, fields: fields, scope: scope} = args;
     let needsDataset;
     try {
-        needsDataset = groqConditionDescribe.analyzeCondition(allowed).readsDataset || readsSubjectHasInFlightInstance(allowed);
+        needsDataset = groqConditionDescribe.analyzeCondition(query).readsDataset;
     } catch (err) {
         rethrowNamingDefinition({
             err: err,
             definition: definition,
-            key: "allowed"
+            key: "requirement"
         });
     }
     let dataset = [];
     if (needsDataset) {
-        if (scope?.fetchDataset === void 0) throw new invariants.ContractViolationError(`start.allowed on definition "${definition.name ?? "<unnamed>"}" reads the dataset (\`*[...]\`), but the caller supplied no \`scope.fetchDataset\` — evaluating over an empty slice would let a count()-style rule pass vacuously. Supply the instance slice.`);
+        if (scope?.fetchDataset === void 0) throw new invariants.ContractViolationError(`start requirement on definition "${definition.name ?? "<unnamed>"}" reads the dataset (\`*[...]\`), but the caller supplied no \`scope.fetchDataset\` — evaluating over an empty slice would let a count()-style rule pass vacuously. Supply the instance slice.`);
         dataset = await scope.fetchDataset();
     }
     try {
         return await groqConditionDescribe.explainCondition({
-            condition: allowed,
+            condition: query,
             dataset: dataset,
             params: startContextParams({
                 definition: definition,
                 scope: scope,
-                fields: fields,
-                dataset: dataset
+                fields: fields
             })
         });
     } catch (err) {
         rethrowNamingDefinition({
             err: err,
             definition: definition,
-            key: "allowed"
+            key: "requirement"
         });
     }
 }
 
-function unboundAllowedReads(allowed, fields) {
-    return [ ...invariants.conditionFieldReadNames(allowed) ].filter(name => !Object.hasOwn(fields, name));
+function unboundRequirementReads(query, fields) {
+    return [ ...invariants.conditionFieldReadNames(query) ].filter(name => !Object.hasOwn(fields, name));
+}
+
+function hasSingleSubjectRequirement(definition) {
+    return definition.start?.requirements?.some(requirement => requirement.type === "singleSubject") ?? !1;
+}
+
+async function singleSubjectRequirementRefused(args) {
+    const {definition: definition, fields: fields, scope: scope} = args, name = singleSubjectDefinitionName(definition), subject = (fields !== void 0 ? startSubject(definition, fields) : void 0) ?? scope?.subject;
+    if (subject === void 0) return !1;
+    if (scope?.fetchDataset === void 0) throw new invariants.ContractViolationError(`singleSubject requirement on definition "${name}" scans the tag's instance slice, but the caller supplied no \`scope.fetchDataset\` — evaluating over an empty slice would let the rule pass vacuously. Supply the projected start slice.`);
+    const dataset = await scope.fetchDataset();
+    return sliceHasInFlightSubject({
+        dataset: dataset,
+        subject: subject,
+        definition: name
+    });
 }
 
-function unboundAllowedReadsWithSubject(args) {
-    const {allowed: allowed, fields: fields, definition: definition} = args, subjectField = (definition.fields ?? []).find(invariants.isSubjectEntry)?.name, reads = unboundAllowedReads(allowed, fields);
-    return subjectField !== void 0 && readsSubjectHasInFlightInstance(allowed) && !Object.hasOwn(fields, subjectField) && !reads.includes(subjectField) && reads.push(subjectField), 
-    reads;
+function singleSubjectDefinitionName(definition) {
+    const label = definition.name ?? "<unnamed>";
+    if (definition.start?.requirements?.find(requirement => requirement.type === "singleSubject") === void 0) throw new invariants.ContractViolationError(`singleSubjectRequirementRefused called for definition "${label}", which declares no \`singleSubject\` requirement — evaluate only what the definition declares.`);
+    if (definition.name === void 0) throw new invariants.ContractViolationError("singleSubjectRequirementRefused needs the definition `name` — the rule scopes its in-flight scan to instances of the definition, which a nameless source cannot identify.");
+    return definition.name;
 }
 
 function rethrowNamingDefinition({err: err, definition: definition, key: key}) {
-    invariants.rethrowWithContext(err, `start.${key} on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (check the predicate and its evaluation inputs)`);
+    invariants.rethrowWithContext(err, `${key === "filter" ? "start.filter" : "start requirement"} on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (check the predicate and its evaluation inputs)`);
 }
 
-function startContextParams({definition: definition, scope: scope, fields: fields, dataset: dataset}) {
-    const subject = fields === void 0 ? scope?.subject : startSubject(definition, fields) ?? scope?.subject, params = baseStartParams(definition, scope);
-    return fields !== void 0 && (params.fields = fields), subject !== void 0 && (params[invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR] = subjectHasInFlightInstance(dataset, subject)), 
-    params;
+function startContextParams({definition: definition, scope: scope, fields: fields}) {
+    const params = baseStartParams(definition, scope);
+    return fields !== void 0 && (params.fields = fields), params;
 }
 
 function baseStartParams(definition, scope) {
@@ -1637,10 +1636,6 @@ function baseStartParams(definition, scope) {
     };
 }
 
-function readsSubjectHasInFlightInstance(groq) {
-    return invariants.conditionParameterNames(groq).has(invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR);
-}
-
 function startSubject(definition, fields) {
     const subjectEntry = (definition.fields ?? []).find(invariants.isSubjectEntry);
     if (subjectEntry === void 0) return;
@@ -1648,15 +1643,12 @@ function startSubject(definition, fields) {
     return invariants.isGdr(value) ? value.id : void 0;
 }
 
-function subjectHasInFlightInstance(dataset, subject) {
+function sliceHasInFlightSubject(args) {
+    const {dataset: dataset, subject: subject, definition: definition} = args;
     return dataset.some(row => {
         if (typeof row != "object" || row === null) return !1;
         const instance = row;
-        return instance._type !== invariants.WORKFLOW_INSTANCE_TYPE || instance.completedAt !== void 0 || !Array.isArray(instance.fields) ? !1 : instance.fields.some(entry => {
-            if (typeof entry != "object" || entry === null) return !1;
-            const field = entry;
-            return field._type === "subject" && invariants.isGdr(field.value) && field.value.id === subject;
-        });
+        return instance.completedAt != null || instance.definition !== definition ? !1 : instance.subject === subject;
     });
 }
 
@@ -1686,11 +1678,11 @@ function startFilterSyntaxIssues(groq) {
     });
 }
 
-function startAllowedSyntaxIssues(groq) {
+function startRequirementSyntaxIssues(groq) {
     return startContextSyntaxIssues({
         groq: groq,
-        vars: invariants.START_ALLOWED_VARS,
-        context: "start-allowed"
+        vars: invariants.START_REQUIREMENT_VARS,
+        context: "start-requirement"
     });
 }
 
@@ -1698,7 +1690,7 @@ function startContextSyntaxIssues({groq: groq, vars: vars, context: context, ski
     try {
         groqJs.parse(groq);
     } catch (err) {
-        return [ err instanceof Error ? err.message : String(err) ];
+        return [ invariants.errorMessage(err) ];
     }
     const bound = new Set(vars.map(v2 => v2.name));
     return [ ...invariants.conditionParameterNames(groq) ].filter(name => !bound.has(name) && name !== skip).map(name => `reads $${name}, which the ${context} context does not bind (an unbound variable is GROQ null, so the predicate silently misevaluates — failing closed or passing vacuously by shape). Bound here: ` + vars.map(v2 => `$${v2.name}`).join(", "));
@@ -2538,24 +2530,24 @@ function applyFieldSet(op, ctx) {
         src: op.value,
         ctx: ctx,
         target: entrySlot(entry)
-    });
-    return invariants.validateFieldValue({
+    }), validated = invariants.validateFieldValue({
         entryType: entry._type,
         entryName: entry.name,
         value: value,
         ...entryShape(entry)
-    }), assertRuntimeRefsWithinSurface({
+    });
+    return assertRuntimeRefsWithinSurface({
         entryType: entry._type,
         entryName: entry.name,
-        value: value,
+        value: validated,
         ...entryShape(entry),
         ctx: ctx,
         src: op.value
-    }), setEntryValue(entry, value), {
+    }), setEntryValue(entry, validated), {
         opType: op.type,
         target: op.target,
         resolved: {
-            value: value
+            value: validated
         }
     };
 }
@@ -2616,27 +2608,27 @@ function applyFieldAppend(op, ctx) {
         ...slot !== void 0 ? {
             target: slot
         } : {}
-    });
-    invariants.validateFieldAppendItem({
+    }), validated = invariants.validateFieldAppendItem({
         entryType: entry._type,
         entryName: entry.name,
         item: item,
         types: entry._type === "doc.refs" ? entry.types : void 0,
         of: entry._type === "array" ? entry.of : void 0
-    }), assertRuntimeRefsWithinSurface({
+    });
+    assertRuntimeRefsWithinSurface({
         entryType: entry._type === "doc.refs" ? "doc.ref" : "object",
         entryName: entry.name,
-        value: item,
+        value: validated,
         fields: entry._type === "array" ? entry.of : void 0,
         ctx: ctx,
         src: op.value
     });
     const current = Array.isArray(entry.value) ? entry.value : [];
-    return setEntryValue(entry, [ ...current, withRowKey(item) ]), {
+    return setEntryValue(entry, [ ...current, withRowKey(validated) ]), {
         opType: op.type,
         target: op.target,
         resolved: {
-            item: item
+            item: validated
         }
     };
 }
@@ -2664,8 +2656,9 @@ async function applyFieldUpdateWhere(op, ctx) {
         mode: "value",
         issues: [ `field.updateWhere value must resolve to an object of fields to merge (target "${op.target.field}")` ]
     });
+    const mergeRecord = merge;
     requireNoReservedMergeKeys({
-        merge: merge,
+        merge: mergeRecord,
         entry: entry,
         op: op
     });
@@ -2675,25 +2668,27 @@ async function applyFieldUpdateWhere(op, ctx) {
         ctx: ctx
     }), next = rows.map((row, index) => matches[index] ? {
         ...row,
-        ...merge
-    } : row);
-    return invariants.validateFieldValue({
+        ...mergeRecord
+    } : row), validated = invariants.validateFieldValue({
         entryType: entry._type,
         entryName: entry.name,
         value: next,
         of: entry.of
-    }), assertRuntimeRefsWithinSurface({
+    });
+    assertRuntimeRefsWithinSurface({
         entryType: "object",
         entryName: entry.name,
         value: merge,
         fields: entry.of,
         ctx: ctx,
         src: op.value
-    }), setEntryValue(entry, next), {
+    }), setEntryValue(entry, validated);
+    const firstMatch = matches.indexOf(!0), persistedRows = validated, persistedMerge = firstMatch === -1 ? merge : Object.fromEntries(Object.keys(mergeRecord).map(key => [ key, persistedRows[firstMatch]?.[key] ]));
+    return {
         opType: op.type,
         target: op.target,
         resolved: {
-            merge: merge
+            merge: persistedMerge
         }
     };
 }
@@ -2885,8 +2880,8 @@ function validateDefinition(definition) {
             address: address
         }));
     }
-    definition.start?.filter !== void 0 && v2.report("start.filter", startFilterSyntaxIssues(definition.start.filter)), 
-    definition.start?.allowed !== void 0 && v2.report("start.allowed", startAllowedSyntaxIssues(definition.start.allowed));
+    definition.start?.filter !== void 0 && v2.report("start.filter", startFilterSyntaxIssues(definition.start.filter));
+    for (const [index, requirement] of (definition.start?.requirements ?? []).entries()) requirement.type === "groq" && v2.report(`start.requirements[${index}].query`, startRequirementSyntaxIssues(requirement.query));
     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}`);
@@ -3316,6 +3311,11 @@ function definitionsListGroq(versionOrder) {
     return `*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && ${invariants.tagScopeFilter()}] | order(name asc, version ${versionOrder})`;
 }
 
+function latestDefinitionsGroq() {
+    const scoped = `_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && ${invariants.tagScopeFilter()}`;
+    return `*[${scoped} && version == math::max(*[${scoped} && name == ^.name].version)] | order(name asc)`;
+}
+
 function latestDeployedDefinitions(rows) {
     const byName = /* @__PURE__ */ new Map;
     for (const row of rows) {
@@ -3397,7 +3397,7 @@ function blockedState(input) {
     if (blocked !== void 0) return {
         state: "blocked",
         activity: blocked.activity.name,
-        requirements: blocked.unmetRequirements ?? [],
+        requirements: (blocked.unmetRequirements ?? []).map(requirement => requirement.name),
         assignees: input.assignees[blocked.activity.name] ?? []
     };
 }
@@ -3440,7 +3440,7 @@ function diagnoseInstance(input) {
     };
 }
 
-const RUNNABLE_VERBS = /* @__PURE__ */ new Set([ "set-stage", "abort", "drain-effects" ]);
+const RUNNABLE_VERBS = /* @__PURE__ */ new Set([ "set-stage", "abort", "drain-effects", "reset-activity" ]);
 
 function remediationsForCause(cause) {
     switch (cause.kind) {
@@ -3942,7 +3942,7 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
         defaultValue: defaultValue
     });
     if (entry.initialValue?.type === "query") {
-        const issues = invariants.checkFieldValue({
+        const check = invariants.parseFieldValue({
             entryType: entry.type,
             value: value,
             types: entry.types,
@@ -3951,9 +3951,9 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
             options: entry.options,
             validation: entry.validation
         });
-        return issues !== void 0 ? (ctx.recordDiscard?.({
+        return "issues" in check ? (ctx.recordDiscard?.({
             field: entry.name,
-            detail: issues.join("; ")
+            detail: check.issues.join("; ")
         }), buildResolvedEntry({
             entry: entry,
             value: defaultValue,
@@ -3961,12 +3961,12 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
             now: ctx.now
         })) : buildResolvedEntry({
             entry: entry,
-            value: value,
+            value: check.output,
             _key: randomKey2(),
             now: ctx.now
         });
     }
-    return invariants.validateFieldValue({
+    const validated = invariants.validateFieldValue({
         entryType: entry.type,
         entryName: entry.name,
         value: value,
@@ -3975,16 +3975,17 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
         of: entry.of,
         options: entry.options,
         validation: entry.validation
-    }), entry.initialValue?.type === "input" && ctx.inputProvenance !== "definition" && assertRefsWithinSurface({
+    });
+    return entry.initialValue?.type === "input" && ctx.inputProvenance !== "definition" && assertRefsWithinSurface({
         entryType: entry.type,
         entryName: entry.name,
-        value: value,
+        value: validated,
         fields: entry.fields,
         of: entry.of,
         surface: ctx.refSurface
     }), buildResolvedEntry({
         entry: entry,
-        value: value,
+        value: validated,
         _key: randomKey2(),
         now: ctx.now
     });
@@ -4016,12 +4017,27 @@ function assertInputValueShape(entry, value) {
 function assertGdrShape(value, context) {
     if (typeof value != "object" || value === null) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: expected { id: "<scheme>:...", type: "<schema>" }, got ${typeof value}.`);
     const v2 = value;
-    if (typeof v2.id != "string" || !invariants.isGdrUri(v2.id)) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: \`id\` must be a GDR URI ("<scheme>:<...id-parts>" with scheme dataset|canvas|media-library|dashboard). Got ${JSON.stringify(v2.id)}. Construct via \`gdrFromResource\` / \`refDataset\` / \`refCanvas\` etc. — bare document ids are not accepted.`);
+    if (typeof v2.id != "string") throw invalidGdrUriError(context, v2.id);
+    try {
+        invariants.parseGdr(v2.id);
+    } catch (error) {
+        throw error instanceof invariants.VersionSpecificDatasetGdrError ? new invariants.ContractViolationError(`Invalid GDR for ${context}: ${error.message}`) : invalidGdrUriError(context, v2.id);
+    }
     if (typeof v2.type != "string" || v2.type.length === 0) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: \`type\` (schema name) must be a non-empty string. Got ${JSON.stringify(v2.type)}.`);
 }
 
+function invalidGdrUriError(context, id) {
+    return new invariants.ContractViolationError(`Invalid GDR for ${context}: \`id\` must be a GDR URI ("<scheme>:<...id-parts>" with scheme dataset|canvas|media-library|dashboard). Got ${JSON.stringify(id)}. Construct via \`gdrFromResource\` / \`refDataset\` / \`refCanvas\` etc. — bare document ids are not accepted.`);
+}
+
 function normalizeQueryResult({entryType: entryType, raw: raw, workflowResource: workflowResource}) {
-    return raw == null ? raw : invariants.isSingleDocRefKind(entryType) ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
+    if (raw == null) return raw;
+    try {
+        return invariants.isSingleDocRefKind(entryType) ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
+    } catch (error) {
+        if (error instanceof invariants.VersionSpecificDatasetGdrError) return raw;
+        throw error;
+    }
 }
 
 function coerceGdrShape(raw, workflowResource) {
@@ -4363,219 +4379,706 @@ function parseInstanceDocument(doc) {
     });
 }
 
-async function getInstanceDocument(client, instanceId) {
-    const doc = await client.getDocument(instanceId);
-    return doc ? readInstanceDoc(doc) : void 0;
-}
+const SYNC_COMMIT = {
+    visibility: "sync"
+}, ENGINE_API_VERSION = "2026-04-29", REQUEST_TAG = {
+    engine: "workflow",
+    deploy: "workflow.deploy",
+    deleteDefinition: "workflow.delete-definition",
+    start: "workflow.start",
+    fireAction: "workflow.fire-action",
+    editField: "workflow.edit-field",
+    completeEffect: "workflow.complete-effect",
+    commitEffectOps: "workflow.commit-effect-ops",
+    tick: "workflow.tick",
+    evaluate: "workflow.evaluate",
+    evaluateStart: "workflow.evaluate-start",
+    diagnose: "workflow.diagnose",
+    availableActions: "workflow.available-actions",
+    setStage: "workflow.set-stage",
+    abort: "workflow.abort",
+    resetActivity: "workflow.reset-activity",
+    getInstance: "workflow.get-instance",
+    children: "workflow.children",
+    instancesForDocument: "workflow.instances-for-document",
+    definitionsForDocument: "workflow.definitions-for-document",
+    query: "workflow.query",
+    discover: "workflow.discover",
+    guardQuery: "workflow.guard.query",
+    guardDeploy: "workflow.guard.deploy",
+    guardRefresh: "workflow.guard.refresh",
+    guardRetract: "workflow.guard.retract",
+    effectList: "workflow.effect.list",
+    effectFind: "workflow.effect.find",
+    drain: "workflow.drain",
+    effect: "workflow.effect",
+    verifyDefinitions: "workflow.verify-definitions",
+    accessResolveActor: "workflow.access.resolve-actor",
+    accessGrants: "workflow.access.grants"
+}, RAW_PATCH = /* @__PURE__ */ Symbol("workflow-engine.raw-patch");
 
-function readInstanceDoc(doc) {
-    return parseInstanceDocument(invariants.assertReadableModel(doc));
+function unwrapPatch(patch) {
+    return typeof patch == "object" && patch !== null && RAW_PATCH in patch ? patch[RAW_PATCH] : patch;
 }
 
-async function reload({client: client, instanceId: instanceId, tag: tag}) {
-    const doc = await getInstanceDocument(client, instanceId);
-    if (!doc) throw new invariants.InstanceNotFoundError({
-        instanceId: instanceId
-    });
-    if (doc.tag !== tag) throw new invariants.InstanceNotFoundError({
-        instanceId: instanceId,
-        detail: "not visible to this engine: tag mismatch"
-    });
-    return doc;
-}
+const wrapperCache = /* @__PURE__ */ new WeakMap, effectHandlerClientCache = /* @__PURE__ */ new WeakMap, RAW_CLIENT = /* @__PURE__ */ Symbol("workflow-engine.raw-client");
 
-function contextEntry(name, value) {
-    const _key = randomKey();
-    return typeof value == "string" ? {
-        _key: _key,
-        _type: "context.string",
-        name: name,
-        value: value
-    } : typeof value == "number" ? {
-        _key: _key,
-        _type: "context.number",
-        name: name,
-        value: value
-    } : typeof value == "boolean" ? {
-        _key: _key,
-        _type: "context.boolean",
-        name: name,
-        value: value
-    } : {
-        _key: _key,
-        _type: "context.ref",
-        name: name,
-        value: value
-    };
+function unwrapRequestTag(client) {
+    let current = client;
+    for (;RAW_CLIENT in current; ) current = current[RAW_CLIENT];
+    return current;
 }
 
-function contextJsonEntry(name, value) {
-    return {
-        _key: randomKey(),
-        _type: "context.json",
-        name: name,
-        value: serializeContextValue(name, value)
-    };
+function withRequestTag(client, fallback) {
+    let byTag = wrapperCache.get(client);
+    byTag === void 0 && (byTag = /* @__PURE__ */ new Map, wrapperCache.set(client, byTag));
+    const cached = byTag.get(fallback);
+    if (cached !== void 0) return cached;
+    const wrapped = buildTaggedClient(client, fallback);
+    return byTag.set(fallback, wrapped), wrapped;
 }
 
-function serializeContextValue(name, value) {
-    let json;
-    try {
-        json = JSON.stringify(value);
-    } catch (err) {
-        invariants.rethrowWithContext(err, `context entry "${name}" holds unserializable JSON`);
+function effectHandlerClient(client) {
+    const cached = effectHandlerClientCache.get(client);
+    if (cached !== void 0) return cached;
+    let tagged;
+    if (client.withConfig === void 0) tagged = withRequestTag(client, REQUEST_TAG.effect); else {
+        const prefix = clientRequestTagPrefix(client), effectTag = composeRequestTag(prefix, REQUEST_TAG.effect);
+        tagged = client.withConfig({
+            requestTagPrefix: effectTag
+        });
     }
-    if (json === void 0) throw new Error(`context entry "${name}" holds a non-JSON value (undefined, a function, or a symbol)`);
-    return json;
+    return effectHandlerClientCache.set(client, tagged), tagged;
 }
 
-function buildInstanceBase(args) {
-    const {id: id, now: now, actor: actor, perspective: perspective, executionContext: executionContext} = args, entries = [ {
-        _key: randomKey(),
-        _type: "stageEntered",
-        at: now,
-        stage: args.initialStage,
-        ...actor !== void 0 ? {
-            actor: actor
-        } : {}
-    }, ...args.extraHistory ?? [] ], history = executionContext !== void 0 ? stampHistoryEntries(entries, executionContext) : entries, body = {
-        _id: id,
-        _type: invariants.WORKFLOW_INSTANCE_TYPE,
-        _rev: "",
-        _createdAt: now,
-        _updatedAt: now,
-        tag: args.tag,
-        workflowResource: args.workflowResource,
-        definition: args.definitionName,
-        pinnedVersion: args.pinnedVersion,
-        ...args.pinnedContentHash !== void 0 ? {
-            pinnedContentHash: args.pinnedContentHash
-        } : {},
-        definitionSnapshot: JSON.stringify(args.definition),
-        fields: args.fields,
-        context: args.context,
-        ancestors: args.ancestors,
-        ...perspective !== void 0 ? {
-            perspective: perspective
-        } : {},
-        currentStage: args.initialStage,
-        stages: [],
-        subworkflows: [],
-        pendingEffects: [],
-        effectHistory: [],
-        history: history,
-        startedAt: now,
-        lastChangedAt: now
-    };
-    return {
-        ...body,
-        ...invariants.modelStampFor({
-            documentType: "instance",
-            document: body
-        })
-    };
+function effectHandlerResolver(resolver) {
+    return mapResourceClientResolver(resolver, effectHandlerClient);
 }
 
-async function hydrateSnapshot(args) {
-    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay} = args, loaded = [], visited = /* @__PURE__ */ new Set, loadInto = async (uri, perspective) => {
-        if (visited.has(uri)) return;
-        const held = overlay?.get(uri);
-        if (held !== void 0) {
-            loaded.push(held), visited.add(uri);
-            return;
-        }
-        const fetched = await loadByGdr({
-            defaultClient: client,
-            clientForGdr: clientForGdr,
-            defaultResource: instance.workflowResource,
-            uri: uri,
-            perspective: perspective
-        });
-        fetched && (loaded.push(fetched), visited.add(uri));
+function mapResourceClientResolver(resolver, mapClient) {
+    if (resolver !== void 0) return parsed => {
+        const client = resolver(parsed);
+        return client === void 0 ? void 0 : mapClient(client);
     };
-    loaded.push({
-        doc: instance,
-        resource: instance.workflowResource
-    }), visited.add(invariants.selfGdr(instance));
-    for (const ref of collectWatchRefs(instance)) await loadInto(ref.id, readsRaw(ref) ? "raw" : instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE);
-    return buildSnapshot({
-        docs: loaded
-    });
-}
-
-async function loadByGdr({defaultClient: defaultClient, clientForGdr: clientForGdr, defaultResource: defaultResource, uri: uri, perspective: perspective}) {
-    const parsed = invariants.tryParseGdr(uri);
-    if (parsed === void 0) {
-        const doc2 = await readDoc({
-            client: defaultClient,
-            id: uri,
-            perspective: perspective
-        });
-        return doc2 ? {
-            doc: doc2,
-            resource: defaultResource
-        } : null;
-    }
-    const routed = clientForGdr(parsed), doc = await readDoc({
-        client: routed,
-        id: parsed.documentId,
-        perspective: perspective
-    });
-    return doc ? {
-        doc: doc,
-        resource: invariants.resourceFromParsed(parsed)
-    } : null;
 }
 
-async function readDoc({client: client, id: id, perspective: perspective}) {
-    if (perspective === "raw") {
-        const doc2 = await client.getDocument(id) ?? null;
-        return doc2 ? doc2._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : invariants.assertReadableModel(doc2) : null;
-    }
-    const {query: query, params: params} = contentDocQuery(id);
-    return await client.fetch(query, params, {
-        perspective: perspective
-    }) ?? null;
+function isWorkflowsFamilyPrefix(prefix) {
+    return prefix === void 0 ? !1 : prefix === "sanity.workflows" || prefix.startsWith("sanity.workflows.") || prefix === "sanity.workflows-mcp";
 }
 
-function collectEntryDocUris(resolvedFieldEntries) {
-    return entryDocRefs(resolvedFieldEntries).map(ref => ref.id);
+function clientRequestTagPrefix(client) {
+    const probe = client;
+    return typeof probe.config == "function" ? probe.config().requestTagPrefix : void 0;
 }
 
-function isEngineContext(ctx) {
-    return "client" in ctx;
+function composeRequestTag(prefix, tag) {
+    if (prefix === void 0) return tag;
+    const relative = isWorkflowsFamilyPrefix(prefix) ? stripWorkflowRoot(tag) : tag;
+    return `${prefix}.${relative}`;
 }
 
-function loadCallContext({client: client, instanceId: instanceId, options: options}) {
-    return loadContext({
-        client: client,
-        instanceId: instanceId,
-        options: {
-            clientForGdr: options.clientForGdr,
-            refSurface: options.refSurface,
-            ...options.actor ? {
-                actor: options.actor
-            } : {},
-            ...options.clock ? {
-                clock: options.clock
-            } : {},
-            ...options.executionContext ? {
-                executionContext: options.executionContext
-            } : {},
-            ...options.telemetry ? {
-                telemetry: options.telemetry
-            } : {}
-        }
-    });
+function stripWorkflowRoot(tag) {
+    return tag.startsWith("workflow.") ? tag.slice(9) : tag;
 }
 
-async function retryOnRevisionConflict(args) {
-    const {client: client, instanceId: instanceId, options: options, commit: commit, onExhausted: onExhausted} = args;
-    for (let attempt = 1; attempt <= CONCURRENT_COMMIT_MAX_ATTEMPTS; attempt++) {
-        const ctx = await loadCallContext({
-            client: client,
-            instanceId: instanceId,
-            options: options
+function buildTaggedClient(client, fallback) {
+    const strip = isWorkflowsFamilyPrefix(clientRequestTagPrefix(unwrapRequestTag(client))), normalize = tag => strip ? stripWorkflowRoot(tag) : tag, stamp = options => options === void 0 ? {
+        tag: normalize(fallback)
+    } : options.tag === void 0 ? {
+        ...options,
+        tag: normalize(fallback)
+    } : typeof options.tag == "string" && options.tag !== normalize(options.tag) ? {
+        ...options,
+        tag: normalize(options.tag)
+    } : options, wrapPatch = patch => {
+        let target = patch;
+        const wrapped = {
+            get [RAW_PATCH]() {
+                return target;
+            },
+            set: props => (target = target.set(props), wrapped),
+            setIfMissing: props => (target = target.setIfMissing(props), wrapped),
+            unset: paths => (target = target.unset(paths), wrapped),
+            ifRevisionId: rev => (target = target.ifRevisionId(rev), wrapped),
+            commit: options => target.commit(stamp(options))
+        };
+        return wrapped;
+    }, wrapTransaction = tx => {
+        let target = tx;
+        const wrapped = {
+            create: doc => (target = target.create(doc), wrapped),
+            patch: patch => (target = target.patch(unwrapPatch(patch)), wrapped),
+            delete: id => (target = target.delete(id), wrapped),
+            commit: options => target.commit(stamp(options))
+        };
+        return wrapped;
+    }, overrides = {
+        [RAW_CLIENT]: unwrapRequestTag(client),
+        fetch: (query, params, options) => client.fetch(query, params, stamp(options)),
+        getDocument: (id, options) => client.getDocument(id, stamp(options)),
+        patch: documentId => wrapPatch(client.patch(documentId)),
+        create: (doc, options) => client.create(doc, stamp(options)),
+        transaction: () => wrapTransaction(client.transaction()),
+        ...client.withConfig !== void 0 ? {
+            withConfig: config => withRequestTag(client.withConfig(config), fallback)
+        } : {},
+        ...client.action !== void 0 ? {
+            action: (action, options) => client.action(action, stamp(options))
+        } : {},
+        ...client.request !== void 0 ? {
+            request: opts => client.request(stamp(opts))
+        } : {}
+    };
+    return new Proxy(client, {
+        has: (target, property) => Object.hasOwn(overrides, property) || property in target,
+        get: (target, property) => {
+            if (Object.hasOwn(overrides, property)) return Reflect.get(overrides, property, overrides);
+            const value = Reflect.get(target, property, target);
+            return typeof value == "function" ? value.bind(target) : value;
+        }
+    });
+}
+
+const pinCache = /* @__PURE__ */ new WeakMap, enginePinned = /* @__PURE__ */ new WeakSet;
+
+function pinApiVersion(client) {
+    const raw = unwrapRequestTag(client);
+    if (enginePinned.has(raw) || raw.withConfig === void 0) return client;
+    let sibling = pinCache.get(raw);
+    return sibling === void 0 && (sibling = raw.withConfig({
+        apiVersion: ENGINE_API_VERSION
+    }), pinCache.set(raw, sibling), enginePinned.add(unwrapRequestTag(sibling))), sibling;
+}
+
+function taggedResolver(resolver, fallback) {
+    return mapResourceClientResolver(resolver, client => withRequestTag(pinApiVersion(client), fallback));
+}
+
+function taggedScope(args, tag) {
+    const resourceClients = taggedResolver(args.resourceClients, tag);
+    return {
+        ...args,
+        client: withRequestTag(pinApiVersion(args.client), tag),
+        ...resourceClients !== void 0 ? {
+            resourceClients: resourceClients
+        } : {}
+    };
+}
+
+const ACTOR_KIND_SET = new Set(invariants.ACTOR_KINDS), resolutionCache = /* @__PURE__ */ new WeakMap, warnedInstances = /* @__PURE__ */ new WeakMap;
+
+async function normalizeInstanceIdentities(args) {
+    const {client: client, instance: instance} = args, pending = collectLegacyIds(instance);
+    if (pending.size === 0) return instance;
+    const resolved = await resolveLegacyIds({
+        client: client,
+        instance: instance,
+        pending: pending
+    }), unresolved = [ ...pending ].filter(id => !resolved.has(id));
+    return unresolved.length > 0 ? (warnUnresolvedOnce({
+        client: client,
+        instance: instance,
+        unresolved: unresolved
+    }), instance) : rewriteIdentitySlots(instance, id => resolved.get(id));
+}
+
+async function resolveLegacyIds(args) {
+    const resolved = /* @__PURE__ */ new Map, directoryIds = [];
+    for (const id of args.pending) {
+        const {globalId: globalId} = invariants.classifyPrincipalId(id);
+        globalId !== void 0 ? resolved.set(id, globalId) : directoryIds.push(id);
+    }
+    const projectId = anchorProjectId(args.instance.workflowResource);
+    if (directoryIds.length === 0 || projectId === void 0) return resolved;
+    const fromDirectory = await resolveThroughDirectory({
+        client: args.client,
+        projectId: projectId,
+        ids: directoryIds
+    });
+    for (const [id, globalId] of fromDirectory) resolved.set(id, globalId);
+    return resolved;
+}
+
+function warnUnresolvedOnce(args) {
+    const key = unwrapRequestTag(args.client);
+    let warned = warnedInstances.get(key);
+    warned === void 0 && (warned = /* @__PURE__ */ new Set, warnedInstances.set(key, warned)), 
+    !warned.has(args.instance._id) && (warned.add(args.instance._id), console.warn(`workflow: instance "${args.instance._id}" carries ${args.unresolved.length} legacy project-scoped principal id(s) the project-users directory could not resolve (${args.unresolved.join(", ")}). Its identity values are left as stored — comparisons against them fail closed — and the document does not self-heal until they resolve.`));
+}
+
+function anchorProjectId(resource) {
+    if (resource.type === "dataset") return invariants.datasetResourceParts(resource.id).projectId;
+}
+
+function collectLegacyIds(instance) {
+    const found = /* @__PURE__ */ new Set;
+    return rewriteIdentitySlots(instance, id => {
+        invariants.classifyPrincipalId(id).namespace === "project" && found.add(id);
+    }), found;
+}
+
+function rewriteIdentitySlots(instance, visit) {
+    const record = instance, fields = walkEntries(record.fields, visit), stages = walkStages(record.stages, visit);
+    return fields === record.fields && stages === record.stages ? instance : {
+        ...record,
+        fields: fields,
+        stages: stages
+    };
+}
+
+function walkStages(stages, visit) {
+    return Array.isArray(stages) ? shareMap(stages, stage => {
+        const walked = walkEntryRow({
+            row: stage,
+            visit: visit
+        });
+        if (walked === null || typeof walked != "object") return walked;
+        const record = walked, activities = walkActivities(record.activities, visit);
+        return activities === record.activities ? walked === stage ? stage : walked : {
+            ...record,
+            activities: activities
+        };
+    }) : stages;
+}
+
+function walkActivities(activities, visit) {
+    return Array.isArray(activities) ? shareMap(activities, activity => walkEntryRow({
+        row: activity,
+        visit: visit
+    })) : activities;
+}
+
+function walkEntryRow(args) {
+    const {row: row, visit: visit} = args;
+    if (row === null || typeof row != "object") return row;
+    const record = row, patch = {}, fields = walkEntries(record.fields, visit);
+    if (fields !== record.fields && (patch.fields = fields), typeof record.completedBy == "string") {
+        const stamped = visit(record.completedBy) ?? record.completedBy;
+        stamped !== record.completedBy && (patch.completedBy = stamped);
+    }
+    return Object.keys(patch).length === 0 ? row : {
+        ...record,
+        ...patch
+    };
+}
+
+function walkEntries(entries, visit) {
+    return Array.isArray(entries) ? shareMap(entries, entry => {
+        if (entry === null || typeof entry != "object") return entry;
+        const record = entry, value = walkDeclaredValue({
+            type: record._type,
+            fields: record.fields,
+            of: record.of,
+            value: record.value,
+            visit: visit
+        });
+        return value === record.value ? entry : {
+            ...record,
+            value: value
+        };
+    }) : entries;
+}
+
+function collectDeclaredGlobalIds(args) {
+    const found = /* @__PURE__ */ new Set;
+    return walkDeclaredValue({
+        type: args.type,
+        fields: args.fields,
+        of: args.of,
+        value: args.value,
+        visit: id => {
+            invariants.classifyPrincipalId(id).namespace === "global" && found.add(id);
+        }
+    }), found;
+}
+
+function rewriteDeclaredPrincipalIds(args) {
+    return walkDeclaredValue({
+        type: args.type,
+        fields: args.fields,
+        of: args.of,
+        value: args.value,
+        visit: id => args.map.get(id)
+    });
+}
+
+function walkDeclaredValue(args) {
+    const {type: type, value: value, visit: visit} = args;
+    return type === "actor" || type === "assignee" ? visitPrincipalObject(value, visit) : type === "assignees" ? Array.isArray(value) ? shareMap(value, item => visitPrincipalObject(item, visit)) : value : type === "object" ? walkDeclaredObject({
+        value: value,
+        shapes: args.fields,
+        visit: visit
+    }) : type === "array" && Array.isArray(value) ? shareMap(value, row => walkDeclaredObject({
+        value: row,
+        shapes: args.of,
+        visit: visit
+    })) : value;
+}
+
+function walkDeclaredObject(args) {
+    const {value: value, shapes: shapes, visit: visit} = args;
+    if (value === null || typeof value != "object" || Array.isArray(value) || !Array.isArray(shapes)) return value;
+    const record = value, patch = {};
+    for (const shape of shapes) {
+        const step = walkDeclaredProperty({
+            record: record,
+            shape: shape,
+            visit: visit
+        });
+        step !== void 0 && (patch[step.name] = step.value);
+    }
+    return Object.keys(patch).length === 0 ? value : {
+        ...record,
+        ...patch
+    };
+}
+
+function walkDeclaredProperty(args) {
+    const {record: record, shape: shape, visit: visit} = args;
+    if (shape === null || typeof shape != "object") return;
+    const name = shape.name;
+    if (typeof name != "string" || !Object.hasOwn(record, name)) return;
+    const walked = walkDeclaredValue({
+        type: shape.type,
+        fields: shape.fields,
+        of: shape.of,
+        value: record[name],
+        visit: visit
+    });
+    return walked === record[name] ? void 0 : {
+        name: name,
+        value: walked
+    };
+}
+
+function visitPrincipalObject(value, visit) {
+    if (value === null || typeof value != "object" || Array.isArray(value)) return value;
+    const record = value;
+    if (typeof record.id != "string" || record.type !== "user" && !(typeof record.kind == "string" && ACTOR_KIND_SET.has(record.kind))) return value;
+    const stamped = visit(record.id) ?? record.id;
+    return stamped === record.id ? value : {
+        ...record,
+        id: stamped
+    };
+}
+
+function shareMap(items, fn) {
+    let changed = !1;
+    const next = items.map(item => {
+        const out = fn(item);
+        return out !== item && (changed = !0), out;
+    });
+    return changed ? next : items;
+}
+
+const SAFE_ID = /^[A-Za-z0-9_-]+$/;
+
+async function resolveThroughDirectory(args) {
+    const {client: client, projectId: projectId, ids: ids} = args, cache = cacheFor(unwrapRequestTag(client)), out = /* @__PURE__ */ new Map, safeMisses = ids.filter(id => {
+        const hit = cache.get(id);
+        return typeof hit == "string" && out.set(id, hit), hit === void 0;
+    }).filter(id => SAFE_ID.test(id) && SAFE_ID.test(projectId));
+    if (safeMisses.length === 0 || client.request === void 0) return out;
+    try {
+        const response = await client.request({
+            uri: `/projects/${encodeURIComponent(projectId)}/users/${safeMisses.map(encodeURIComponent).join(",")}`,
+            tag: REQUEST_TAG.accessResolveActor
+        });
+        ingestDirectoryRows({
+            response: response,
+            requested: new Set(safeMisses),
+            cache: cache,
+            out: out
+        });
+        for (const id of safeMisses) out.has(id) || cache.set(id, null);
+    } catch (err) {
+        console.warn(`workflow: project-users directory lookup failed for project "${projectId}" — legacy principal ids stay unresolved this pass. Original error: ${invariants.errorMessage(err)}`);
+    }
+    return out;
+}
+
+function cacheFor(client) {
+    let cache = resolutionCache.get(client);
+    return cache === void 0 && (cache = /* @__PURE__ */ new Map, resolutionCache.set(client, cache)), 
+    cache;
+}
+
+function ingestDirectoryRows(args) {
+    const records = Array.isArray(args.response) ? args.response : [ args.response ];
+    for (const row of records) typeof row?.id != "string" || typeof row.sanityUserId != "string" || args.requested.has(row.id) && invariants.classifyPrincipalId(row.sanityUserId).namespace === "global" && (args.cache.set(row.id, row.sanityUserId), 
+    args.out.set(row.id, row.sanityUserId));
+}
+
+async function getInstanceDocument(client, instanceId) {
+    const doc = await client.getDocument(instanceId);
+    if (doc) return normalizeInstanceIdentities({
+        client: client,
+        instance: readInstanceDoc(doc)
+    });
+}
+
+function readInstanceDoc(doc) {
+    return parseInstanceDocument(invariants.assertReadableModel(doc));
+}
+
+async function reload({client: client, instanceId: instanceId, tag: tag}) {
+    const doc = await getInstanceDocument(client, instanceId);
+    if (!doc) throw new invariants.InstanceNotFoundError({
+        instanceId: instanceId
+    });
+    if (doc.tag !== tag) throw new invariants.InstanceNotFoundError({
+        instanceId: instanceId,
+        detail: "not visible to this engine: tag mismatch"
+    });
+    return doc;
+}
+
+function contextEntry(name, value) {
+    const _key = randomKey();
+    return typeof value == "string" ? {
+        _key: _key,
+        _type: "context.string",
+        name: name,
+        value: value
+    } : typeof value == "number" ? {
+        _key: _key,
+        _type: "context.number",
+        name: name,
+        value: value
+    } : typeof value == "boolean" ? {
+        _key: _key,
+        _type: "context.boolean",
+        name: name,
+        value: value
+    } : {
+        _key: _key,
+        _type: "context.ref",
+        name: name,
+        value: value
+    };
+}
+
+function contextJsonEntry(name, value) {
+    return {
+        _key: randomKey(),
+        _type: "context.json",
+        name: name,
+        value: serializeContextValue(name, value)
+    };
+}
+
+function serializeContextValue(name, value) {
+    let json;
+    try {
+        json = JSON.stringify(value);
+    } catch (err) {
+        invariants.rethrowWithContext(err, `context entry "${name}" holds unserializable JSON`);
+    }
+    if (json === void 0) throw new Error(`context entry "${name}" holds a non-JSON value (undefined, a function, or a symbol)`);
+    return json;
+}
+
+function buildInstanceBase(args) {
+    const {id: id, now: now, actor: actor, perspective: perspective, executionContext: executionContext} = args, entries = [ {
+        _key: randomKey(),
+        _type: "stageEntered",
+        at: now,
+        stage: args.initialStage,
+        ...actor !== void 0 ? {
+            actor: actor
+        } : {}
+    }, ...args.extraHistory ?? [] ], history = executionContext !== void 0 ? stampHistoryEntries(entries, executionContext) : entries, body = {
+        _id: id,
+        _type: invariants.WORKFLOW_INSTANCE_TYPE,
+        _rev: "",
+        _createdAt: now,
+        _updatedAt: now,
+        tag: args.tag,
+        workflowResource: args.workflowResource,
+        definition: args.definitionName,
+        pinnedVersion: args.pinnedVersion,
+        ...args.pinnedContentHash !== void 0 ? {
+            pinnedContentHash: args.pinnedContentHash
+        } : {},
+        definitionSnapshot: JSON.stringify(args.definition),
+        fields: args.fields,
+        context: args.context,
+        ancestors: args.ancestors,
+        ...perspective !== void 0 ? {
+            perspective: perspective
+        } : {},
+        currentStage: args.initialStage,
+        stages: [],
+        subworkflows: [],
+        pendingEffects: [],
+        effectHistory: [],
+        history: history,
+        startedAt: now,
+        lastChangedAt: now
+    };
+    return {
+        ...body,
+        ...invariants.modelStampFor({
+            documentType: "instance",
+            document: body
+        })
+    };
+}
+
+async function hydrateSnapshot(args) {
+    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay} = args, loaded = [], visited = /* @__PURE__ */ new Set;
+    loaded.push({
+        doc: instance,
+        resource: instance.workflowResource
+    }), visited.add(invariants.selfGdr(instance));
+    const {pending: pending, ordered: ordered} = planReads({
+        client: client,
+        clientForGdr: clientForGdr,
+        instance: instance,
+        overlay: overlay,
+        visited: visited
+    }), fetched = await readPending(pending);
+    for (const entry of ordered) if (!isPendingRead(entry)) loaded.push(entry); else {
+        const doc = fetched.get(entry);
+        doc !== void 0 && loaded.push({
+            doc: doc,
+            resource: entry.resource
+        });
+    }
+    return buildSnapshot({
+        docs: loaded
+    });
+}
+
+function planReads(args) {
+    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay, visited: visited} = args, pending = [], ordered = [];
+    for (const ref of collectWatchRefs(instance)) {
+        if (visited.has(ref.id)) continue;
+        visited.add(ref.id);
+        const held = overlay?.get(ref.id);
+        if (held !== void 0) ordered.push(held); else {
+            const read = routeRead({
+                defaultClient: client,
+                clientForGdr: clientForGdr,
+                defaultResource: instance.workflowResource,
+                uri: ref.id,
+                perspective: readsRaw(ref) ? "raw" : instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE
+            });
+            pending.push(read), ordered.push(read);
+        }
+    }
+    return {
+        pending: pending,
+        ordered: ordered
+    };
+}
+
+function isPendingRead(entry) {
+    return "client" in entry;
+}
+
+const SNAPSHOT_READ_BATCH_SIZE = 100, SNAPSHOT_READ_CONCURRENCY = 4, snapshotDocsQuery = "*[_id in $ids]";
+
+function routeRead({defaultClient: defaultClient, clientForGdr: clientForGdr, defaultResource: defaultResource, uri: uri, perspective: perspective}) {
+    const parsed = invariants.tryParseGdr(uri);
+    return parsed === void 0 ? {
+        client: defaultClient,
+        id: uri,
+        perspective: perspective,
+        resource: defaultResource
+    } : {
+        client: clientForGdr(parsed),
+        id: parsed.documentId,
+        perspective: perspective,
+        resource: invariants.resourceFromParsed(parsed)
+    };
+}
+
+async function readPending(reads) {
+    const batches = groupReads(reads).flatMap(group => chunks(group.reads, SNAPSHOT_READ_BATCH_SIZE).map(batch => ({
+        group: group,
+        batch: batch
+    }))), results = [];
+    for (const wave of chunks(batches, SNAPSHOT_READ_CONCURRENCY)) results.push(...await Promise.all(wave.map(readBatch)));
+    return new Map(results.flat());
+}
+
+async function readBatch(args) {
+    const {group: group, batch: batch} = args, ids = batch.map(read => read.id), docs = await group.client.fetch(snapshotDocsQuery, {
+        ids: ids
+    }, {
+        perspective: group.perspective
+    }), byId = new Map(docs.map(doc => [ doc._id, validateRawDoc(doc, group.perspective) ]));
+    return batch.flatMap(read => {
+        const doc = byId.get(read.id);
+        return doc === void 0 ? [] : [ [ read, doc ] ];
+    });
+}
+
+function validateRawDoc(doc, perspective) {
+    return perspective !== "raw" ? doc : doc._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : invariants.assertReadableModel(doc);
+}
+
+function groupReads(reads) {
+    const byClient = /* @__PURE__ */ new Map;
+    for (const read of reads) {
+        let clientGroups = byClient.get(read.client);
+        clientGroups === void 0 && (clientGroups = /* @__PURE__ */ new Map, byClient.set(read.client, clientGroups));
+        const key = JSON.stringify(read.perspective);
+        let group = clientGroups.get(key);
+        group === void 0 && (group = {
+            client: read.client,
+            perspective: read.perspective,
+            reads: []
+        }, clientGroups.set(key, group)), group.reads.push(read);
+    }
+    return [ ...byClient.values() ].flatMap(groups => [ ...groups.values() ]);
+}
+
+function chunks(values, size) {
+    return Array.from({
+        length: Math.ceil(values.length / size)
+    }, (_, index) => values.slice(index * size, (index + 1) * size));
+}
+
+function collectEntryDocUris(resolvedFieldEntries) {
+    return entryDocRefs(resolvedFieldEntries).map(ref => ref.id);
+}
+
+function isEngineContext(ctx) {
+    return "client" in ctx;
+}
+
+function loadCallContext({client: client, instanceId: instanceId, options: options}) {
+    return loadContext({
+        client: client,
+        instanceId: instanceId,
+        options: {
+            clientForGdr: options.clientForGdr,
+            refSurface: options.refSurface,
+            ...options.actor ? {
+                actor: options.actor
+            } : {},
+            ...options.clock ? {
+                clock: options.clock
+            } : {},
+            ...options.executionContext ? {
+                executionContext: options.executionContext
+            } : {},
+            ...options.telemetry ? {
+                telemetry: options.telemetry
+            } : {}
+        }
+    });
+}
+
+async function retryOnRevisionConflict(args) {
+    const {client: client, instanceId: instanceId, options: options, commit: commit, onExhausted: onExhausted} = args;
+    for (let attempt = 1; attempt <= CONCURRENT_COMMIT_MAX_ATTEMPTS; attempt++) {
+        const ctx = await loadCallContext({
+            client: client,
+            instanceId: instanceId,
+            options: options
         });
         try {
             return await commit(ctx);
@@ -4591,29 +5094,31 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
     if (!instance) throw new invariants.InstanceNotFoundError({
         instanceId: instanceId
     });
-    const definition = invariants.parseDefinitionSnapshot(instance), {clientForGdr: clientForGdr, refSurface: refSurface} = options, clock = options.clock ?? wallClock, snapshot = await hydrateSnapshot({
+    return buildEngineContext({
         client: client,
-        clientForGdr: clientForGdr,
+        clientForGdr: options.clientForGdr,
+        refSurface: options.refSurface,
         instance: instance,
+        definition: invariants.parseDefinitionSnapshot(instance),
+        ...options.actor !== void 0 ? {
+            actor: options.actor
+        } : {},
+        ...options.clock !== void 0 ? {
+            clock: options.clock
+        } : {},
+        ...options.executionContext !== void 0 ? {
+            executionContext: options.executionContext
+        } : {},
+        ...options.telemetry !== void 0 ? {
+            telemetry: options.telemetry
+        } : {},
         ...options.overlay !== void 0 ? {
             overlay: options.overlay
+        } : {},
+        ...options.settlingCohorts !== void 0 ? {
+            settlingCohorts: options.settlingCohorts
         } : {}
     });
-    return {
-        client: client,
-        clientForGdr: clientForGdr,
-        refSurface: refSurface,
-        clock: clock,
-        now: clock(),
-        executionContext: resolveExecutionContext(options?.executionContext),
-        telemetry: resolveTelemetry(options.telemetry),
-        ...options?.actor !== void 0 ? {
-            actor: options.actor
-        } : {},
-        instance: instance,
-        definition: definition,
-        snapshot: snapshot
-    };
 }
 
 async function ctxConditionParams(ctx, opts) {
@@ -4651,6 +5156,9 @@ async function buildEngineContext(args) {
         now: clock(),
         executionContext: resolveExecutionContext(args.executionContext),
         telemetry: resolveTelemetry(args.telemetry),
+        ...args.settlingCohorts !== void 0 ? {
+            settlingCohorts: args.settlingCohorts
+        } : {},
         ...args.actor !== void 0 ? {
             actor: args.actor
         } : {},
@@ -4659,7 +5167,10 @@ async function buildEngineContext(args) {
         snapshot: await hydrateSnapshot({
             client: client,
             clientForGdr: clientForGdr,
-            instance: instance
+            instance: instance,
+            ...args.overlay !== void 0 ? {
+                overlay: args.overlay
+            } : {}
         })
     };
 }
@@ -4782,10 +5293,6 @@ function recordProcessedRequest({mutation: mutation, record: record, now: now})
     } ];
 }
 
-const SYNC_COMMIT = {
-    visibility: "sync"
-}, ENGINE_API_VERSION = "2026-04-29";
-
 function resolveGuardRead(args) {
     const {expr: expr, ctx: ctx, deref: deref} = args;
     if (expr === "$self") return invariants.selfGdr(ctx.instance);
@@ -4839,32 +5346,311 @@ function resolveIdRefTargets(idRefs, ctx) {
     return targets.length === 0 ? null : targets;
 }
 
-function assertSingleResource(targets) {
-    const resource = invariants.resourceFromParsed(targets[0].parsed);
-    for (const g of targets) {
-        const r = invariants.resourceFromParsed(g.parsed);
-        if (r.type !== resource.type || r.id !== resource.id) throw new Error(`Guard targets span multiple resources (${resource.type}:${resource.id} vs ${r.type}:${r.id}); a guard is single-resource.`);
-    }
-    return resource;
+function assertSingleResource(targets) {
+    const resource = invariants.resourceFromParsed(targets[0].parsed);
+    for (const g of targets) {
+        const r = invariants.resourceFromParsed(g.parsed);
+        if (r.type !== resource.type || r.id !== resource.id) throw new Error(`Guard targets span multiple resources (${resource.type}:${resource.id} vs ${r.type}:${r.id}); a guard is single-resource.`);
+    }
+    return resource;
+}
+
+function bareIdRefs(targets) {
+    return targets.flatMap(g => [ g.parsed.documentId, `drafts.${g.parsed.documentId}` ]);
+}
+
+function resolveMatchTypes(targets, authorTypes) {
+    if (authorTypes !== void 0) return authorTypes;
+    const inferred = [ ...new Set(targets.map(g => g.type).filter(t => !!t)) ];
+    return inferred.length > 0 ? inferred : void 0;
+}
+
+function resolveMetadata(metadata, ctx) {
+    const out = {};
+    for (const [k, expr] of Object.entries(metadata ?? {})) out[k] = resolveGuardRead({
+        expr: expr,
+        ctx: ctx,
+        deref: !0
+    });
+    return out;
+}
+
+function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+
+function isClientProjectUser(value) {
+    return isRecord(value) && typeof value.id == "string" && (value.sanityUserId === void 0 || typeof value.sanityUserId == "string") && (value.displayName === void 0 || typeof value.displayName == "string") && (value.email === void 0 || typeof value.email == "string") && (value.imageUrl === void 0 || value.imageUrl === null || typeof value.imageUrl == "string");
+}
+
+function objectProperty(value, property) {
+    if (!isRecord(value)) return;
+    const propertyValue = value[property];
+    return typeof propertyValue == "object" && propertyValue !== null ? propertyValue : void 0;
+}
+
+function stringProperty(value, property) {
+    const propertyValue = Reflect.get(value, property);
+    return typeof propertyValue == "string" ? propertyValue : void 0;
+}
+
+function apiErrorType(error) {
+    const response = objectProperty(error, "response"), body = objectProperty(response, "body");
+    if (!body) return;
+    const nestedError = objectProperty(body, "error");
+    return (nestedError ? stringProperty(nestedError, "type") : void 0) ?? stringProperty(body, "type");
+}
+
+function isProjectUserNotFoundError(error) {
+    return apiErrorType(error) === "projectUserNotFoundError";
+}
+
+const memberJoinCache = /* @__PURE__ */ new WeakMap;
+
+function joinCacheFor(client) {
+    let cache = memberJoinCache.get(client);
+    return cache === void 0 && (cache = /* @__PURE__ */ new Map, memberJoinCache.set(client, cache)), 
+    cache;
+}
+
+async function projectMemberIds(request, projectId) {
+    const project = await request({
+        uri: `/projects/${encodeURIComponent(projectId)}`
+    }), members = isRecord(project) ? project.members : void 0;
+    return Array.isArray(members) ? members.map(member => isRecord(member) ? member.id : void 0).filter(id => typeof id == "string") : [];
+}
+
+async function resolveGlobalProjectUser(args) {
+    const {client: client, request: request, projectId: projectId, id: id} = args, cache = joinCacheFor(client), key = `${projectId}:${id}`, hit = cache.get(key);
+    if (hit !== void 0) return hit === null ? {
+        status: "missing"
+    } : {
+        status: "resolved",
+        user: hit
+    };
+    try {
+        await ingestMemberJoin({
+            request: request,
+            projectId: projectId,
+            cache: cache
+        });
+        const found = cache.get(key);
+        return found != null ? {
+            status: "resolved",
+            user: found
+        } : (cache.set(key, null), {
+            status: "missing"
+        });
+    } catch (cause) {
+        return {
+            status: "inaccessible",
+            cause: cause
+        };
+    }
+}
+
+async function ingestMemberJoin(args) {
+    const {request: request, projectId: projectId, cache: cache} = args, memberIds = await projectMemberIds(request, projectId);
+    if (memberIds.length === 0) return;
+    const response = await request({
+        uri: `/projects/${encodeURIComponent(projectId)}/users/${memberIds.map(encodeURIComponent).join(",")}`
+    });
+    for (const row of Array.isArray(response) ? response : [ response ]) isClientProjectUser(row) && typeof row.sanityUserId == "string" && cache.set(`${projectId}:${row.sanityUserId}`, row);
+}
+
+function clientProjectUserDirectory(client, projectId) {
+    return {
+        findById: async id => {
+            if (!client.request) return {
+                status: "inaccessible",
+                cause: new Error("Project-user resolution requires WorkflowClient.request")
+            };
+            if (invariants.classifyPrincipalId(id).namespace === "global") return resolveGlobalProjectUser({
+                client: client,
+                request: client.request,
+                projectId: projectId,
+                id: id
+            });
+            try {
+                const response = await client.request({
+                    uri: `/projects/${encodeURIComponent(projectId)}/users/${encodeURIComponent(id)}`
+                }), candidate = Array.isArray(response) ? response[0] : response;
+                return candidate == null ? {
+                    status: "missing"
+                } : isClientProjectUser(candidate) ? {
+                    status: "resolved",
+                    user: candidate
+                } : {
+                    status: "inaccessible",
+                    cause: new Error("Project-user response had an invalid shape")
+                };
+            } catch (cause) {
+                return isProjectUserNotFoundError(cause) ? {
+                    status: "missing"
+                } : {
+                    status: "inaccessible",
+                    cause: cause
+                };
+            }
+        }
+    };
+}
+
+function resolveClientActor(client, args) {
+    return resolveActor(clientProjectUserDirectory(client, args.projectId), args.actor);
+}
+
+async function resolveActor(directory, actor) {
+    if (actor.kind !== "person") return {
+        status: "not-person",
+        actor: actor
+    };
+    const personActor = {
+        ...actor,
+        kind: "person"
+    }, lookup = await directory.findById(personActor.id);
+    return lookup.status === "resolved" ? {
+        status: "resolved",
+        actor: personActor,
+        user: lookup.user
+    } : lookup.status === "inaccessible" ? {
+        status: "inaccessible",
+        actor: personActor,
+        ...lookup.cause === void 0 ? {} : {
+            cause: lookup.cause
+        }
+    } : {
+        status: "missing",
+        actor: personActor
+    };
+}
+
+const IDENTITY_KINDS = /* @__PURE__ */ new Set([ "actor", "assignee", "assignees" ]);
+
+async function localizeGuardMetadata(args) {
+    const {doc: doc, guard: guard, client: client, instance: instance, definition: definition} = args;
+    if (doc.resourceType !== "dataset" || client.request === void 0) return doc;
+    const request = client.request, {projectId: projectId} = invariants.datasetResourceParts(doc.resourceId), shapes = metadataShapes({
+        guard: guard,
+        instance: instance,
+        definition: definition
+    }), globals = collectMetadataGlobals({
+        metadata: doc.metadata,
+        shapes: shapes
+    });
+    if (globals.size === 0) return doc;
+    const map = /* @__PURE__ */ new Map;
+    for (const id of globals) {
+        const lookup = await resolveGlobalProjectUser({
+            client: client,
+            request: request,
+            projectId: projectId,
+            id: id
+        });
+        lookup.status === "resolved" && map.set(id, lookup.user.id);
+    }
+    return map.size === 0 ? doc : {
+        ...doc,
+        metadata: rewriteMetadata({
+            metadata: doc.metadata,
+            shapes: shapes,
+            map: map
+        })
+    };
+}
+
+function metadataShapes(args) {
+    const out = /* @__PURE__ */ new Map;
+    for (const [key, expr] of Object.entries(args.guard.metadata ?? {})) {
+        const shape = shapeOfRead({
+            expr: expr,
+            instance: args.instance,
+            definition: args.definition
+        });
+        shape !== void 0 && out.set(key, shape);
+    }
+    return out;
+}
+
+function shapeOfRead(args) {
+    const fieldRead = invariants.FIELD_READ.exec(args.expr);
+    if (fieldRead !== null) return shapeOfFieldRead(args.instance, fieldRead);
+    const effectsRead = invariants.EFFECTS_READ.exec(args.expr);
+    if (effectsRead !== null) return shapeOfEffectsRead(args.definition, effectsRead);
+}
+
+function shapeOfFieldRead(instance, fieldRead) {
+    const entry = (instance.fields ?? []).find(s => s.name === fieldRead[1]);
+    if (entry !== void 0) return narrowByPath({
+        type: entry._type,
+        fields: Reflect.get(entry, "fields"),
+        of: Reflect.get(entry, "of")
+    }, fieldRead[2]);
 }
 
-function bareIdRefs(targets) {
-    return targets.flatMap(g => [ g.parsed.documentId, `drafts.${g.parsed.documentId}` ]);
+function shapeOfEffectsRead(definition, effectsRead) {
+    const outputs = findEffect(definition, effectsRead[1])?.outputs ?? [], path = effectsRead[2];
+    if (path === void 0) return;
+    const [head, ...rest] = path.split("."), output = outputs.find(shape => shape.name === head);
+    if (output !== void 0) return narrowByPath({
+        type: output.type,
+        fields: output.fields,
+        of: output.of
+    }, rest.length > 0 ? rest.join(".") : void 0);
 }
 
-function resolveMatchTypes(targets, authorTypes) {
-    if (authorTypes !== void 0) return authorTypes;
-    const inferred = [ ...new Set(targets.map(g => g.type).filter(t => !!t)) ];
-    return inferred.length > 0 ? inferred : void 0;
+function narrowByPath(shape, path) {
+    if (path === void 0) return shape;
+    if (typeof shape.type != "string" || !IDENTITY_KINDS.has(shape.type)) return;
+    const steps = identityPathSteps(shape.type, path);
+    if (steps === void 0) return;
+    const itemType = shape.type === "assignees" ? "assignee" : shape.type;
+    if (steps.length === 0) return {
+        type: itemType
+    };
+    if (steps.length === 1 && steps[0] === "id") return {
+        type: itemType,
+        idLeaf: !0
+    };
 }
 
-function resolveMetadata(metadata, ctx) {
-    const out = {};
-    for (const [k, expr] of Object.entries(metadata ?? {})) out[k] = resolveGuardRead({
-        expr: expr,
-        ctx: ctx,
-        deref: !0
-    });
+function identityPathSteps(kind, path) {
+    const segments = path.split(".");
+    return kind !== "assignees" ? segments : /^\d+$/.test(segments[0] ?? "") ? segments.slice(1) : void 0;
+}
+
+function collectMetadataGlobals(args) {
+    const found = /* @__PURE__ */ new Set;
+    for (const [key, shape] of args.shapes) {
+        const value = args.metadata[key];
+        if (shape.idLeaf === !0) {
+            typeof value == "string" && invariants.classifyPrincipalId(value).namespace === "global" && found.add(value);
+            continue;
+        }
+        for (const id of collectDeclaredGlobalIds({
+            ...shape,
+            value: value
+        })) found.add(id);
+    }
+    return found;
+}
+
+function rewriteMetadata(args) {
+    const out = {
+        ...args.metadata
+    };
+    for (const [key, shape] of args.shapes) {
+        const value = out[key];
+        if (shape.idLeaf === !0) {
+            typeof value == "string" && (out[key] = args.map.get(value) ?? value);
+            continue;
+        }
+        out[key] = rewriteDeclaredPrincipalIds({
+            ...shape,
+            value: value,
+            map: args.map
+        });
+    }
     return out;
 }
 
@@ -4900,151 +5686,6 @@ function parseGuardDocument(doc) {
     });
 }
 
-const REQUEST_TAG = {
-    engine: "workflow",
-    deploy: "workflow.deploy",
-    deleteDefinition: "workflow.delete-definition",
-    start: "workflow.start",
-    fireAction: "workflow.fire-action",
-    editField: "workflow.edit-field",
-    completeEffect: "workflow.complete-effect",
-    commitEffectOps: "workflow.commit-effect-ops",
-    tick: "workflow.tick",
-    evaluate: "workflow.evaluate",
-    evaluateStart: "workflow.evaluate-start",
-    diagnose: "workflow.diagnose",
-    availableActions: "workflow.available-actions",
-    setStage: "workflow.set-stage",
-    abort: "workflow.abort",
-    getInstance: "workflow.get-instance",
-    children: "workflow.children",
-    instancesForDocument: "workflow.instances-for-document",
-    definitionsForDocument: "workflow.definitions-for-document",
-    query: "workflow.query",
-    discover: "workflow.discover",
-    guardQuery: "workflow.guard.query",
-    guardDeploy: "workflow.guard.deploy",
-    guardRefresh: "workflow.guard.refresh",
-    guardRetract: "workflow.guard.retract",
-    effectList: "workflow.effect.list",
-    effectFind: "workflow.effect.find",
-    drain: "workflow.drain",
-    effect: "workflow.effect",
-    verifyDefinitions: "workflow.verify-definitions",
-    accessResolveActor: "workflow.access.resolve-actor",
-    accessGrants: "workflow.access.grants"
-}, RAW_PATCH = /* @__PURE__ */ Symbol("workflow-engine.raw-patch");
-
-function unwrapPatch(patch) {
-    return typeof patch == "object" && patch !== null && RAW_PATCH in patch ? patch[RAW_PATCH] : patch;
-}
-
-const wrapperCache = /* @__PURE__ */ new WeakMap, RAW_CLIENT = /* @__PURE__ */ Symbol("workflow-engine.raw-client");
-
-function unwrapRequestTag(client) {
-    let current = client;
-    for (;RAW_CLIENT in current; ) current = current[RAW_CLIENT];
-    return current;
-}
-
-function withRequestTag(client, fallback) {
-    let byTag = wrapperCache.get(client);
-    byTag === void 0 && (byTag = /* @__PURE__ */ new Map, wrapperCache.set(client, byTag));
-    const cached = byTag.get(fallback);
-    if (cached !== void 0) return cached;
-    const wrapped = buildTaggedClient(client, fallback);
-    return byTag.set(fallback, wrapped), wrapped;
-}
-
-function isWorkflowsFamilyPrefix(prefix) {
-    return prefix === void 0 ? !1 : prefix === "sanity.workflows" || prefix.startsWith("sanity.workflows.") || prefix === "sanity.workflows-mcp";
-}
-
-function clientRequestTagPrefix(client) {
-    const probe = client;
-    return typeof probe.config == "function" ? probe.config().requestTagPrefix : void 0;
-}
-
-function buildTaggedClient(client, fallback) {
-    const strip = isWorkflowsFamilyPrefix(clientRequestTagPrefix(unwrapRequestTag(client))), normalize = tag => strip && tag.startsWith("workflow.") ? tag.slice(9) : tag, stamp = options => options === void 0 ? {
-        tag: normalize(fallback)
-    } : options.tag === void 0 ? {
-        ...options,
-        tag: normalize(fallback)
-    } : typeof options.tag == "string" && options.tag !== normalize(options.tag) ? {
-        ...options,
-        tag: normalize(options.tag)
-    } : options, wrapPatch = patch => {
-        let target = patch;
-        const wrapped = {
-            get [RAW_PATCH]() {
-                return target;
-            },
-            set: props => (target = target.set(props), wrapped),
-            setIfMissing: props => (target = target.setIfMissing(props), wrapped),
-            unset: paths => (target = target.unset(paths), wrapped),
-            ifRevisionId: rev => (target = target.ifRevisionId(rev), wrapped),
-            commit: options => target.commit(stamp(options))
-        };
-        return wrapped;
-    }, wrapTransaction = tx => {
-        let target = tx;
-        const wrapped = {
-            create: doc => (target = target.create(doc), wrapped),
-            patch: patch => (target = target.patch(unwrapPatch(patch)), wrapped),
-            delete: id => (target = target.delete(id), wrapped),
-            commit: options => target.commit(stamp(options))
-        };
-        return wrapped;
-    };
-    return {
-        [RAW_CLIENT]: unwrapRequestTag(client),
-        fetch: (query, params, options) => client.fetch(query, params, stamp(options)),
-        getDocument: (id, options) => client.getDocument(id, stamp(options)),
-        patch: documentId => wrapPatch(client.patch(documentId)),
-        create: (doc, options) => client.create(doc, stamp(options)),
-        transaction: () => wrapTransaction(client.transaction()),
-        ...client.withConfig !== void 0 ? {
-            withConfig: config => withRequestTag(client.withConfig(config), fallback)
-        } : {},
-        ...client.action !== void 0 ? {
-            action: (action, options) => client.action(action, stamp(options))
-        } : {},
-        ...client.request !== void 0 ? {
-            request: opts => client.request(stamp(opts))
-        } : {}
-    };
-}
-
-const pinCache = /* @__PURE__ */ new WeakMap, enginePinned = /* @__PURE__ */ new WeakSet;
-
-function pinApiVersion(client) {
-    const raw = unwrapRequestTag(client);
-    if (enginePinned.has(raw) || raw.withConfig === void 0) return client;
-    let sibling = pinCache.get(raw);
-    return sibling === void 0 && (sibling = raw.withConfig({
-        apiVersion: ENGINE_API_VERSION
-    }), pinCache.set(raw, sibling), enginePinned.add(unwrapRequestTag(sibling))), sibling;
-}
-
-function taggedResolver(resolver, fallback) {
-    if (resolver !== void 0) return parsed => {
-        const client = resolver(parsed);
-        return client === void 0 ? void 0 : withRequestTag(pinApiVersion(client), fallback);
-    };
-}
-
-function taggedScope(args, tag) {
-    const resourceClients = taggedResolver(args.resourceClients, tag);
-    return {
-        ...args,
-        client: withRequestTag(pinApiVersion(args.client), tag),
-        ...resourceClients !== void 0 ? {
-            resourceClients: resourceClients
-        } : {}
-    };
-}
-
 async function fetchGuards(args) {
     return (await args.client.fetch(args.query, args.params, {
         tag: REQUEST_TAG.guardQuery
@@ -5061,16 +5702,20 @@ function guardsForResource(client) {
     });
 }
 
-function instanceGuardQuery(instanceId) {
+function instancesGuardQuery(instanceIds) {
     return {
-        query: "*[_type == $guardType && sourceInstanceId == $instanceId]",
+        query: "*[_type == $guardType && sourceInstanceId in $instanceIds] | order(_id asc)",
         params: {
             guardType: GUARD_DOC_TYPE,
-            instanceId: instanceId
+            instanceIds: [ ...instanceIds ]
         }
     };
 }
 
+function instanceGuardQuery(instanceId) {
+    return instancesGuardQuery([ instanceId ]);
+}
+
 function verdictGuardsForInstance(client, instanceId) {
     const {query: query, params: params} = instanceGuardQuery(instanceId);
     return fetchGuards({
@@ -5172,7 +5817,7 @@ function dedupById(guards) {
     return [ ...new Map(guards.map(g => [ g._id, g ])).values() ].sort((a, b) => a._id.localeCompare(b._id));
 }
 
-const GUARD_OWNER = "robot:workflow-engine";
+const GUARD_OWNER = "robot:workflow-engine", DELETE_CHUNK_SIZE = 200;
 
 function resolveGuardRoute(guard, ctx) {
     const targets = resolveIdRefTargets(guard.match.idRefs, ctx);
@@ -5225,10 +5870,9 @@ function resolveGuard({guard: guard, instance: instance, stageName: stageName, n
     };
 }
 
-async function upsertGuard(client, doc) {
-    if (!await client.getDocument(doc._id, {
-        tag: REQUEST_TAG.guardDeploy
-    })) {
+async function upsertGuard(args) {
+    const {client: client, doc: doc, exists: exists} = args;
+    if (!exists) {
         await client.create(doc, {
             ...SYNC_COMMIT,
             tag: REQUEST_TAG.guardDeploy
@@ -5254,7 +5898,9 @@ function resolvedStageGuards(args) {
         });
         resolved !== null && out.push({
             client: args.clientForGdr(resolved.routeGdr),
-            doc: resolved.doc
+            resourceKey: invariants.resourceGdr(invariants.resourceFromParsed(resolved.routeGdr)),
+            value: resolved.doc,
+            guard: guard
         });
     }
     return out;
@@ -5271,12 +5917,54 @@ function resolvedStageGuardRoutes(args) {
         const route = resolveGuardRoute(guard, ctx);
         route !== null && out.push({
             client: args.clientForGdr(route.routeGdr),
-            guardId: route.guardId
+            resourceKey: invariants.resourceGdr(invariants.resourceFromParsed(route.routeGdr)),
+            value: route.guardId
         });
     }
     return out;
 }
 
+function groupByResource(routed) {
+    const groups = /* @__PURE__ */ new Map;
+    for (const item of routed) {
+        const existing = groups.get(item.resourceKey);
+        if (existing !== void 0) {
+            existing.values.push(item.value);
+            continue;
+        }
+        groups.set(item.resourceKey, {
+            client: item.client,
+            resourceKey: item.resourceKey,
+            values: [ item.value ]
+        });
+    }
+    return [ ...groups.values() ];
+}
+
+async function existingGuardIds(groups) {
+    const entries = await Promise.all(groups.map(async ({client: client, resourceKey: resourceKey, values: values}) => {
+        const ids = values.map(doc => doc._id), existing = await client.fetch("*[_id in $ids]._id", {
+            ids: ids
+        }, {
+            tag: REQUEST_TAG.guardDeploy
+        });
+        return [ resourceKey, new Set(existing) ];
+    }));
+    return new Map(entries);
+}
+
+async function observedGuards(groups) {
+    const entries = await Promise.all(groups.map(async ({client: client, resourceKey: resourceKey, values: ids}) => {
+        const guards = await client.fetch("*[_id in $ids]{_id, predicate, _rev}", {
+            ids: ids
+        }, {
+            tag: REQUEST_TAG.guardRetract
+        });
+        return [ resourceKey, new Map(guards.map(guard => [ guard._id, guard ])) ];
+    }));
+    return new Map(entries);
+}
+
 async function committedInstance(args) {
     return getInstanceDocument(args.client, args.instance._id);
 }
@@ -5284,10 +5972,22 @@ async function committedInstance(args) {
 async function deployStageGuards(args) {
     const live = await committedInstance(args);
     if (live === void 0 || live.currentStage !== args.stageName || live.abortedAt !== void 0) return;
+    const routed = resolvedStageGuards(args), existingByResource = await existingGuardIds(groupByResource(routed));
     let deployed = 0;
-    for (const {client: client, doc: doc} of resolvedStageGuards(args)) {
+    for (const {client: client, resourceKey: resourceKey, value: doc, guard: guard} of routed) {
         try {
-            await upsertGuard(client, doc);
+            const localized = await localizeGuardMetadata({
+                doc: doc,
+                guard: guard,
+                client: client,
+                instance: args.instance,
+                definition: args.definition
+            });
+            await upsertGuard({
+                client: client,
+                doc: localized,
+                exists: existingByResource.get(resourceKey)?.has(doc._id) ?? !1
+            });
         } catch (cause) {
             throw deployed > 0 ? new PartialGuardDeployError({
                 stageName: args.stageName,
@@ -5300,13 +6000,11 @@ async function deployStageGuards(args) {
 }
 
 async function retractStageGuards(args) {
-    const observed = [];
-    for (const {client: client, guardId: guardId} of resolvedStageGuardRoutes(args)) {
-        const guard = await client.getDocument(guardId, {
-            tag: REQUEST_TAG.guardRetract
-        });
+    const observed = [], routed = resolvedStageGuardRoutes(args), guardsByResource = await observedGuards(groupByResource(routed));
+    for (const {client: client, resourceKey: resourceKey, value: guardId} of routed) {
+        const guard = guardsByResource.get(resourceKey)?.get(guardId);
         if (guard) {
-            if (guard._rev === void 0) throw new Error(`Cannot retract guard ${guardId}: persisted document has no revision`);
+            if (guard._rev === void 0 || guard._rev === null) throw new Error(`Cannot retract guard ${guardId}: persisted document has no revision`);
             observed.push({
                 client: client,
                 guardId: guardId,
@@ -5337,10 +6035,11 @@ async function deleteOrphanedDefinitionGuards(args) {
     let count = 0;
     for (const {client: resourceClient, guards: guards} of perClient) {
         const own = guards.filter(guard => guard.sourceInstanceId.startsWith(ownPartitionPrefix));
-        if (own.length === 0) continue;
-        const tx = resourceClient.transaction();
-        for (const guard of own) tx.delete(guard._id);
-        await tx.commit(), count += own.length;
+        if (own.length !== 0) for (let start = 0; start < own.length; start += DELETE_CHUNK_SIZE) {
+            const chunk = own.slice(start, start + DELETE_CHUNK_SIZE), tx = resourceClient.transaction();
+            for (const guard of chunk) tx.delete(guard._id);
+            await tx.commit(), count += chunk.length;
+        }
     }
     return count;
 }
@@ -5406,7 +6105,8 @@ async function commitAbort({ctx: ctx, reason: reason, requestRecord: requestReco
         ...actor !== void 0 ? {
             actor: actor
         } : {}
-    }), mutation.completedAt = at, mutation.abortedAt = at, await persist(ctx, mutation), 
+    }), mutation.completedAt = at, mutation.abortedAt = at;
+    const instance = readInstanceDoc(await persist(ctx, mutation));
     await retractStageGuards({
         client: ctx.client,
         clientForGdr: ctx.clientForGdr,
@@ -5426,7 +6126,8 @@ async function commitAbort({ctx: ctx, reason: reason, requestRecord: requestReco
     });
     return {
         fired: !0,
-        stage: stage.name
+        stage: stage.name,
+        instance: instance
     };
 }
 
@@ -6178,18 +6879,42 @@ async function fetchGrants(args) {
     });
 }
 
-async function advisoryCan({instance: instance, actor: actor, grants: grants}) {
+async function advisoryCanForCall(args) {
+    const actor = args.options?.actor;
+    if (!(args.options?.grants === void 0 || actor === void 0)) return advisoryCan({
+        instance: args.instance,
+        identity: invariants.lakePrincipalId({
+            actor: actor,
+            localPrincipalId: args.options.localPrincipalId
+        }),
+        grants: args.options.grants
+    });
+}
+
+async function advisoryCan({instance: instance, identity: identity, grants: grants}) {
     if (grants === void 0) return;
     const can = {};
     for (const permission of invariants.DOCUMENT_VALUE_PERMISSIONS) can[permission] = await grantsPermissionOn({
         document: instance,
         grants: grants,
         permission: permission,
-        userId: actor.id
+        userId: identity
     });
     return can;
 }
 
+function requirementDescriptor(requirement) {
+    return {
+        name: requirement.name,
+        ...requirement.title !== void 0 ? {
+            title: requirement.title
+        } : {},
+        ...requirement.description !== void 0 ? {
+            description: requirement.description
+        } : {}
+    };
+}
+
 function subjectDenialLabels(denied) {
     return denied.map(d => `${d.permission} on ${d.subject} (${d.resource})`);
 }
@@ -6210,10 +6935,10 @@ class ActionDisabledError extends invariants.WorkflowError {
 
 class StartNotAllowedError extends invariants.WorkflowError {
     definition;
-    insight;
+    unmetRequirements;
     constructor(args) {
-        super("start-not-allowed", `startInstance refused: start.allowed on definition "${args.definition}" evaluated ` + (args.insight.outcome === "unevaluable" ? `GROQ null ("can't decide" — fail-closed)` : "false") + " for the supplied initialFields. Pre-flight the verdict with evaluateStart."), 
-        this.name = "StartNotAllowedError", this.definition = args.definition, this.insight = args.insight;
+        super("start-not-allowed", `startInstance refused definition "${args.definition}": ${args.unmetRequirements.map(requirement => requirement.title ?? requirement.name).join(", ")}. Pre-flight the verdict with evaluateStart.`), 
+        this.name = "StartNotAllowedError", this.definition = args.definition, this.unmetRequirements = args.unmetRequirements;
     }
 }
 
@@ -6229,7 +6954,7 @@ const disabledReasonDetail = {
     "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(", ")}`,
+    "requirements-unmet": r => `unmet requirement(s): ${r.unmetRequirements.map(requirement => requirement.name).join(", ")}`,
     "subject-permission-denied": r => `missing subject permission(s): ${subjectDenialLabels(r.denied).join(", ")}`
 };
 
@@ -6298,11 +7023,10 @@ async function resolveActionCommit({ctx: ctx, activityName: activityName, action
         }
     });
     if (action.filter !== void 0) {
-        const can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan({
+        const can = await advisoryCanForCall({
             instance: ctx.instance,
-            actor: actor,
-            grants: options.grants
-        }) : void 0;
+            options: options
+        });
         if (!await ctxEvaluateCondition({
             ctx: ctx,
             condition: action.filter,
@@ -6543,42 +7267,24 @@ async function fireTriggeredAction({ctx: ctx, mutation: mutation, activity: acti
     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, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    const instance = await getInstanceDocument(client, instanceId);
-    if (!instance || instance.stages.length > 0) return;
-    const definition = invariants.parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
-    if (stage === void 0) return;
-    const ctx = await buildEngineContext({
-        client: client,
-        clientForGdr: clientForGdr,
-        refSurface: refSurface,
-        instance: instance,
-        definition: definition,
-        ...clock ? {
-            clock: clock
-        } : {},
-        ...actor ? {
-            actor: actor
-        } : {},
-        ...executionContext ? {
-            executionContext: executionContext
-        } : {},
-        ...telemetry ? {
-            telemetry: telemetry
-        } : {}
-    }), now = ctx.now, discards = [], initialStageEntry = {
+        mutation: mutation,
+        activity: activity,
+        action: action,
+        params: {},
+        actor: ctx.actor,
+        triggered: !0
+    });
+    return {
+        ranFieldOps: ranOps.some(isFieldOp)
+    };
+}
+
+async function primeInitialStage(args) {
+    const {client: client, instanceId: instanceId, refSurface: refSurface, clientForGdr: clientForGdr} = args, instance = await getInstanceDocument(client, instanceId);
+    if (!instance || instance.stages.length > 0) return;
+    const ctx = await buildCascadeStepContext(args, instance), {definition: definition} = ctx, stage = definition.stages.find(s => s.name === instance.currentStage);
+    if (stage === void 0) return;
+    const now = ctx.now, discards = [], initialStageEntry = {
         _key: randomKey(),
         name: stage.name,
         enteredAt: now,
@@ -6647,29 +7353,37 @@ async function primeInitialStage({client: client, instanceId: instanceId, actor:
 
 const CASCADE_LIMIT = 100;
 
-async function runCascadeHop({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
-    const ctx = await loadContext({
+async function runCascadeHop({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay, settlingCohorts: settlingCohorts, instance: instance}) {
+    const contextOptions = {
+        clientForGdr: clientForGdr,
+        refSurface: refSurface,
+        ...actor ? {
+            actor: actor
+        } : {},
+        ...clock ? {
+            clock: clock
+        } : {},
+        ...executionContext ? {
+            executionContext: executionContext
+        } : {},
+        ...telemetry ? {
+            telemetry: telemetry
+        } : {},
+        ...overlay ? {
+            overlay: overlay
+        } : {},
+        ...settlingCohorts ? {
+            settlingCohorts: settlingCohorts
+        } : {}
+    }, ctx = instance === void 0 ? await loadContext({
         client: client,
         instanceId: instanceId,
-        options: {
-            clientForGdr: clientForGdr,
-            refSurface: refSurface,
-            ...actor ? {
-                actor: actor
-            } : {},
-            ...clock ? {
-                clock: clock
-            } : {},
-            ...executionContext ? {
-                executionContext: executionContext
-            } : {},
-            ...telemetry ? {
-                telemetry: telemetry
-            } : {},
-            ...overlay ? {
-                overlay: overlay
-            } : {}
-        }
+        options: contextOptions
+    }) : await buildEngineContext({
+        client: client,
+        instance: instance,
+        definition: invariants.parseDefinitionSnapshot(instance),
+        ...contextOptions
     });
     if (isTerminal(ctx)) return {
         moved: !1
@@ -6699,10 +7413,10 @@ async function runCascadeHop({client: client, instanceId: instanceId, actor: act
     });
 }
 
-async function cascadeAutoTransitions({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
+async function cascadeAutoTransitions({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay, settlingCohorts: settlingCohorts}) {
     let count = 0;
     for (;;) {
-        if (await drainCondemnedChildren({
+        const drained = await drainCondemnedChildren({
             client: client,
             instanceId: instanceId,
             actor: actor,
@@ -6711,7 +7425,8 @@ async function cascadeAutoTransitions({client: client, instanceId: instanceId, a
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry
-        }), !(await runCascadeHop({
+        });
+        if (!(await runCascadeHop({
             client: client,
             instanceId: instanceId,
             actor: actor,
@@ -6720,7 +7435,11 @@ async function cascadeAutoTransitions({client: client, instanceId: instanceId, a
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry,
-            overlay: overlay
+            overlay: overlay,
+            settlingCohorts: settlingCohorts,
+            ...drained.drained ? {} : {
+                instance: drained.instance
+            }
         })).moved) return count;
         if (count++, count >= CASCADE_LIMIT) throw new CascadeLimitError({
             instanceId: instanceId,
@@ -6729,39 +7448,50 @@ async function cascadeAutoTransitions({client: client, instanceId: instanceId, a
     }
 }
 
-async function drainCondemnedChildren({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining = /* @__PURE__ */ new Set}) {
-    if (draining.has(instanceId)) return;
+async function drainCondemnedChildren({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining = /* @__PURE__ */ new Set, instance: preloadedInstance}) {
+    if (draining.has(instanceId)) return {
+        instance: preloadedInstance,
+        drained: !1
+    };
     draining.add(instanceId);
-    const instance = await getInstanceDocument(client, instanceId);
-    if (!instance) return;
+    const instance = preloadedInstance ?? await getInstanceDocument(client, instanceId);
+    if (!instance) return {
+        instance: void 0,
+        drained: !1
+    };
     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,
-            refSurface: refSurface,
-            clock: clock,
-            executionContext: executionContext,
-            telemetry: telemetry,
-            draining: draining
-        });
-        await stampDrainedRows({
-            client: client,
-            instance: instance,
-            condemned: condemned,
-            clock: clock,
-            executionContext: executionContext
-        });
-    }
+    if (condemned.length === 0) return {
+        instance: instance,
+        drained: !1
+    };
+    for (const row of condemned) await settleCondemnedRow({
+        client: client,
+        ownerId: instanceId,
+        row: row,
+        actor: actor,
+        clientForGdr: clientForGdr,
+        refSurface: refSurface,
+        clock: clock,
+        executionContext: executionContext,
+        telemetry: telemetry,
+        draining: draining
+    });
+    return await stampDrainedRows({
+        client: client,
+        instance: instance,
+        condemned: condemned,
+        clock: clock,
+        executionContext: executionContext
+    }), {
+        instance: instance,
+        drained: !0
+    };
 }
 
 async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining}) {
     const childId = invariants.toBareId(row.ref.id);
     try {
-        await abortInstance({
+        const result = await abortInstance({
             client: client,
             instanceId: childId,
             reason: row.abortPending?.reason ?? "condemned by parent",
@@ -6781,7 +7511,8 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
                     telemetry: telemetry
                 } : {}
             }
-        }), await drainCondemnedChildren({
+        });
+        await drainCondemnedChildren({
             client: client,
             instanceId: childId,
             actor: actor,
@@ -6790,7 +7521,10 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry,
-            draining: draining
+            draining: draining,
+            ...result.fired ? {
+                instance: result.instance
+            } : {}
         });
     } catch (cause) {
         if (cause instanceof invariants.InstanceNotFoundError) return;
@@ -6803,9 +7537,7 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
 }
 
 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 => [ invariants.assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
+    const now = (clock ?? wallClock)(), stamp = resolveExecutionContext(executionContext), ids = condemned.map(row => invariants.toBareId(row.ref.id)), byId = await loadInstancesById(client, ids), 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,
@@ -6827,6 +7559,16 @@ async function stampDrainedRows({client: client, instance: instance, condemned:
     }).ifRevisionId(instance._rev).commit(SYNC_COMMIT);
 }
 
+async function loadInstancesById(client, ids) {
+    const children = await client.fetch("*[_id in $ids]", {
+        ids: ids
+    });
+    return new Map(children.filter(child => child._type === invariants.WORKFLOW_INSTANCE_TYPE).map(child => {
+        const instance = readInstanceDoc(child);
+        return [ instance._id, instance ];
+    }));
+}
+
 function terminalResolution(child) {
     const status = resolvedChildStatus(child);
     if (!(status === void 0 || child.completedAt === void 0 || child.completedAt === null)) return {
@@ -6849,28 +7591,18 @@ function subworkflowResolvedEntry({row: row, at: at, status: status}) {
     };
 }
 
-async function propagateToAncestors({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
-    const loaded = await loadPropagationPair(client, instanceId);
-    if (loaded === void 0) return;
-    const {child: child, parent: parent} = loaded, definition = invariants.parseDefinitionSnapshot(parent), ctx = await buildEngineContext({
+async function propagateToAncestors(args) {
+    const {instance: instance, ...stepArgs} = args, {client: client, instanceId: instanceId} = stepArgs, loaded = await loadPropagationPair({
         client: client,
-        clientForGdr: clientForGdr,
-        refSurface: refSurface,
-        instance: parent,
-        definition: definition,
-        ...clock ? {
-            clock: clock
-        } : {},
-        ...actor ? {
-            actor: actor
-        } : {},
-        ...executionContext ? {
-            executionContext: executionContext
-        } : {},
-        ...telemetry ? {
-            telemetry: telemetry
+        instanceId: instanceId,
+        ...instance !== void 0 ? {
+            instance: instance
         } : {}
-    }), mutation = startMutation(parent), row = mutation.subworkflows.find(r => invariants.toBareId(r.ref.id) === child._id);
+    });
+    if (loaded === void 0) return;
+    const {child: child, parent: parent} = loaded;
+    if (stepArgs.settlingCohorts?.has(parent._id)) return;
+    const ctx = await buildCascadeStepContext(stepArgs, parent), mutation = startMutation(parent), row = mutation.subworkflows.find(r => invariants.toBareId(r.ref.id) === child._id);
     if (row === void 0) {
         await recordOrphanedPropagation({
             ctx: ctx,
@@ -6885,29 +7617,11 @@ async function propagateToAncestors({client: client, instanceId: instanceId, act
         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,
-        refSurface: refSurface,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
-    }), await propagateToAncestors({
-        client: client,
-        instanceId: parent._id,
-        actor: actor,
-        clientForGdr: clientForGdr,
-        refSurface: refSurface,
-        clock: clock,
-        executionContext: executionContext,
-        telemetry: telemetry
-    }));
+    changed && await persist(ctx, mutation), !parentTerminal && await cascadeAndPropagateParent(stepArgs, parent);
 }
 
-async function loadPropagationPair(client, instanceId) {
-    const child = await getInstanceDocument(client, instanceId);
+async function loadPropagationPair({client: client, instanceId: instanceId, instance: instance}) {
+    const child = instance ?? await getInstanceDocument(client, instanceId);
     if (!child) return;
     const parentGdr = invariants.parentRef(child);
     if (parentGdr === void 0) return;
@@ -6918,6 +7632,83 @@ async function loadPropagationPair(client, instanceId) {
     };
 }
 
+async function propagateSpawnBatch(args) {
+    const {childIds: childIds, ...stepArgs} = args, {client: client, instanceId: instanceId} = stepArgs, parent = await getInstanceDocument(client, instanceId);
+    if (parent === void 0) return;
+    const children = await loadInstancesById(client, childIds);
+    if (children.size !== childIds.length) throw new Error(`Spawn batch for ${instanceId} could not reload every child`);
+    const ctx = await buildCascadeStepContext(stepArgs, parent), mutation = startMutation(parent);
+    stampSpawnBatch({
+        mutation: mutation,
+        parent: parent,
+        children: children,
+        childIds: childIds,
+        now: ctx.now
+    }) && await persist(ctx, mutation), parent.completedAt === void 0 && await cascadeAndPropagateParent(stepArgs, parent);
+}
+
+async function buildCascadeStepContext(args, instance) {
+    return buildEngineContext({
+        client: args.client,
+        clientForGdr: args.clientForGdr,
+        refSurface: args.refSurface,
+        instance: instance,
+        definition: invariants.parseDefinitionSnapshot(instance),
+        ...args.clock ? {
+            clock: args.clock
+        } : {},
+        ...args.actor ? {
+            actor: args.actor
+        } : {},
+        ...args.executionContext ? {
+            executionContext: args.executionContext
+        } : {},
+        ...args.telemetry ? {
+            telemetry: args.telemetry
+        } : {},
+        ...args.settlingCohorts ? {
+            settlingCohorts: args.settlingCohorts
+        } : {}
+    });
+}
+
+async function cascadeAndPropagateParent(args, parent) {
+    await cascadeAutoTransitions({
+        ...args,
+        instanceId: parent._id
+    }), await propagateToAncestors({
+        ...args,
+        instanceId: parent._id
+    });
+}
+
+function stampSpawnBatch({mutation: mutation, parent: parent, children: children, childIds: childIds, now: now}) {
+    let changed = !1;
+    for (const childId of childIds) {
+        const child = requireSpawnBatchChild({
+            parent: parent,
+            children: children,
+            childId: childId
+        }), row = mutation.subworkflows.find(entry => invariants.toBareId(entry.ref.id) === childId);
+        if (row === void 0) throw new Error(`Spawn batch child ${childId} has no registry row on parent ${parent._id}`);
+        changed = stampResolvedChild({
+            mutation: mutation,
+            row: row,
+            child: child,
+            now: now
+        }) || changed;
+    }
+    return changed;
+}
+
+function requireSpawnBatchChild({parent: parent, children: children, childId: childId}) {
+    const child = children.get(childId);
+    if (child === void 0) throw new Error(`Spawn batch child ${childId} disappeared`);
+    const expectedParent = invariants.parentRef(child);
+    if (expectedParent === void 0 || invariants.toBareId(expectedParent.id) !== parent._id) throw new Error(`Spawn batch child ${childId} does not belong to parent ${parent._id}`);
+    return child;
+}
+
 function stampResolvedChild({mutation: mutation, row: row, child: child, now: now}) {
     if (row.resolved !== void 0) return !1;
     const resolved = terminalResolution(child);
@@ -7053,36 +7844,14 @@ async function persist(ctx, mutation) {
     for (const {body: body} of pendingCreates) tx.create(body);
     tx.patch(ctx.client.patch(ctx.instance._id).set(set).ifRevisionId(ctx.instance._rev)), 
     await tx.commit(), mutation.pendingCreates = [];
-    const actorForPriming = ctx.actor;
-    for (const {body: body, started: started} of pendingCreates) try {
-        await primeInitialStage({
-            client: ctx.client,
-            instanceId: body._id,
-            actor: actorForPriming,
-            clientForGdr: ctx.clientForGdr,
-            refSurface: ctx.refSurface,
-            clock: ctx.clock,
-            executionContext: ctx.executionContext,
-            telemetry: ctx.telemetry
-        }), await cascadeAutoTransitions({
-            client: ctx.client,
-            instanceId: body._id,
-            actor: actorForPriming,
-            clientForGdr: ctx.clientForGdr,
-            refSurface: ctx.refSurface,
-            clock: ctx.clock,
-            executionContext: ctx.executionContext,
-            telemetry: ctx.telemetry
-        }), await propagateToAncestors({
-            client: ctx.client,
+    const actorForPriming = ctx.actor, settlingCohorts = new Set(ctx.settlingCohorts).add(ctx.instance._id);
+    for (const {body: body} of pendingCreates) try {
+        const stepArgs = spawnStepArgs(ctx, {
             instanceId: body._id,
             actor: actorForPriming,
-            clientForGdr: ctx.clientForGdr,
-            refSurface: ctx.refSurface,
-            clock: ctx.clock,
-            executionContext: ctx.executionContext,
-            telemetry: ctx.telemetry
-        }), ctx.telemetry.log(WorkflowInstanceStarted, started);
+            settlingCohorts: settlingCohorts
+        });
+        await primeInitialStage(stepArgs), await cascadeAutoTransitions(stepArgs);
     } catch (cause) {
         throw cause instanceof WorkflowStateDivergedError ? cause : new WorkflowStateDivergedError({
             instanceId: ctx.instance._id,
@@ -7090,11 +7859,50 @@ async function persist(ctx, mutation) {
             reason: `spawned child "${body._id}" failed to settle after the spawn transaction committed`
         });
     }
+    await settleSpawnBatch(ctx, {
+        pendingCreates: pendingCreates,
+        actor: actorForPriming,
+        settlingCohorts: settlingCohorts
+    });
+    for (const {started: started} of pendingCreates) ctx.telemetry.log(WorkflowInstanceStarted, started);
     const reloaded = await getInstanceDocument(ctx.client, ctx.instance._id);
     if (!reloaded) throw new Error(`Instance ${ctx.instance._id} disappeared after transaction commit`);
     return reloaded;
 }
 
+async function settleSpawnBatch(ctx, args) {
+    try {
+        await propagateSpawnBatch({
+            ...spawnStepArgs(ctx, {
+                instanceId: ctx.instance._id,
+                actor: args.actor,
+                settlingCohorts: args.settlingCohorts
+            }),
+            childIds: args.pendingCreates.map(({body: body}) => body._id)
+        });
+    } catch (cause) {
+        throw cause instanceof WorkflowStateDivergedError ? cause : new WorkflowStateDivergedError({
+            instanceId: ctx.instance._id,
+            guardError: cause,
+            reason: "spawned children failed to propagate after the spawn transaction committed"
+        });
+    }
+}
+
+function spawnStepArgs(ctx, args) {
+    return {
+        client: ctx.client,
+        instanceId: args.instanceId,
+        actor: args.actor,
+        clientForGdr: ctx.clientForGdr,
+        refSurface: ctx.refSurface,
+        clock: ctx.clock,
+        executionContext: ctx.executionContext,
+        telemetry: ctx.telemetry,
+        settlingCohorts: args.settlingCohorts ?? ctx.settlingCohorts
+    };
+}
+
 function stampExecutionContext(ctx, mutation) {
     const stamp = ctx.executionContext, appended = mutation.history.slice(ctx.instance.history.length);
     mutation.history = [ ...mutation.history.slice(0, ctx.instance.history.length), ...stampHistoryEntries(appended, stamp) ];
@@ -7222,24 +8030,25 @@ function buildEffectSettlement(pending, outcome) {
 }
 
 function validateEffectOutputs(args) {
-    const {outputs: outputs, declared: declared, effectName: effectName} = args, byName = new Map(declared.map(shape => [ shape.name, shape ])), issues = [];
+    const {outputs: outputs, declared: declared, effectName: effectName} = args, byName = new Map(declared.map(shape => [ shape.name, shape ])), issues = [], normalized = {};
     for (const [key, value] of Object.entries(outputs)) {
         const shape = byName.get(key);
         if (shape === void 0) {
             issues.push(`"${key}" is not a declared output`);
             continue;
         }
-        const shapeIssues = effectOutputIssues(shape, value);
-        shapeIssues !== void 0 && issues.push(...shapeIssues.map(i => `"${key}": ${i}`));
+        const check = effectOutputCheck(shape, value);
+        "issues" in check ? issues.push(...check.issues.map(i => `"${key}": ${i}`)) : normalized[key] = check.output;
     }
     if (issues.length > 0) throw new EffectOutputsInvalidError({
         effect: effectName,
         issues: issues
     });
+    return normalized;
 }
 
-function effectOutputIssues(shape, value) {
-    return invariants.checkFieldValue({
+function effectOutputCheck(shape, value) {
+    return invariants.parseFieldValue({
         entryType: shape.type,
         value: value,
         ...shape.fields !== void 0 ? {
@@ -7285,15 +8094,15 @@ function validateCompletionInput({pending: pending, definition: definition, stat
         effect: pending.name,
         issues: [ "outputs cannot accompany a failed completion — report outputs on a done completion instead" ]
     });
-    if (outputs !== void 0) {
-        const declared = findEffect(definition, pending.name)?.outputs ?? [];
-        validateEffectOutputs({
-            outputs: outputs,
-            declared: declared,
-            effectName: pending.name
-        });
-    }
-    return ops !== void 0 ? validateEffectOps(ops, pending.name) : [];
+    const normalizedOutputs = outputs !== void 0 ? validateEffectOutputs({
+        outputs: outputs,
+        declared: findEffect(definition, pending.name)?.outputs ?? [],
+        effectName: pending.name
+    }) : void 0;
+    return {
+        ops: ops !== void 0 ? validateEffectOps(ops, pending.name) : [],
+        outputs: normalizedOutputs
+    };
 }
 
 async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: status, outputs: outputs, ops: ops, detail: detail, error: error, durationMs: durationMs, requestRecord: requestRecord, actor: actor}) {
@@ -7302,7 +8111,7 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         record: requestRecord,
         now: ctx.now
     });
-    const pending = requirePendingEffect(ctx.instance, effectKey), validatedOps = validateCompletionInput({
+    const pending = requirePendingEffect(ctx.instance, effectKey), {ops: validatedOps, outputs: validatedOutputs} = validateCompletionInput({
         pending: pending,
         definition: ctx.definition,
         status: status,
@@ -7321,7 +8130,7 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         detail: detail,
         error: error,
         durationMs: durationMs,
-        outputs: outputs
+        outputs: validatedOutputs
     });
     mutation.effectHistory.push(settlement.run);
     const wroteEffectOutputs = status === "done" && outputs !== void 0;
@@ -7519,6 +8328,64 @@ async function commitReport({ctx: ctx, effectKey: effectKey, claimToken: claimTo
     };
 }
 
+const RESET_ACTIVITY_TARGETS = [ "active", "skipped" ];
+
+function isResetActivityTarget(value) {
+    return RESET_ACTIVITY_TARGETS.includes(value);
+}
+
+async function resetActivity(args) {
+    const {client: client, instanceId: instanceId, activity: activity, to: to, requestRecord: requestRecord, options: options} = args, ctx = await loadCallContext({
+        client: client,
+        instanceId: instanceId,
+        options: options
+    });
+    return commitResetActivity({
+        ctx: ctx,
+        activity: activity,
+        to: to,
+        requestRecord: requestRecord,
+        actor: options?.actor
+    });
+}
+
+async function commitResetActivity({ctx: ctx, activity: activity, to: to, requestRecord: requestRecord, actor: actor}) {
+    if (assertRequestUnprocessed({
+        instance: ctx.instance,
+        record: requestRecord,
+        now: ctx.now
+    }), isTerminal(ctx)) return {
+        fired: !1
+    };
+    const mutation = startMutation(ctx.instance), openStage2 = findOpenStageEntry(mutation), entry = findCurrentActivityEntry(mutation, activity);
+    if (openStage2 === void 0 || entry === void 0) throw new invariants.ContractViolationError(`resetActivity: activity "${activity}" is not in the current stage of instance "${ctx.instance._id}"`);
+    const from = entry.status;
+    if (from === to) return {
+        fired: !1
+    };
+    if (!invariants.isTerminalActivityStatus(from)) throw new invariants.ContractViolationError(`resetActivity: activity "${activity}" is "${from}", not a terminal status — a reset only recovers a resolved (typically failed) activity. Use setStage to force past a live stage.`);
+    return recordProcessedRequest({
+        mutation: mutation,
+        record: requestRecord,
+        now: ctx.now
+    }), applyActivityStatusChange({
+        entry: entry,
+        history: mutation.history,
+        stage: openStage2.name,
+        to: to,
+        at: ctx.now,
+        ...actor !== void 0 ? {
+            actor: actor
+        } : {}
+    }), await persist(ctx, mutation), {
+        fired: !0,
+        stage: openStage2.name,
+        activity: activity,
+        from: from,
+        to: to
+    };
+}
+
 const actorCache = /* @__PURE__ */ new WeakMap, grantsCache = /* @__PURE__ */ new WeakMap;
 
 async function resolveAccess(taggedClient, args = {}) {
@@ -7528,10 +8395,13 @@ async function resolveAccess(taggedClient, args = {}) {
         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.");
+    }) : Promise.resolve(void 0), [identity, grants] = await Promise.all([ cachedActor(client, requestFn), grantsPromise ]);
+    if (identity === 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,
+        actor: identity.actor,
+        ...identity.localPrincipalId !== void 0 ? {
+            localPrincipalId: identity.localPrincipalId
+        } : {},
         ...grants !== void 0 ? {
             grants: grants
         } : {}
@@ -7541,7 +8411,7 @@ async function resolveAccess(taggedClient, args = {}) {
 function cachedActor(client, requestFn) {
     const cached = actorCache.get(client);
     if (cached !== void 0) return cached;
-    const pending = fetchActor(requestFn).catch(err => {
+    const pending = fetchActor(client, requestFn).catch(err => {
         throw actorCache.get(client) === pending && actorCache.delete(client), err;
     });
     return actorCache.set(client, pending), pending;
@@ -7568,27 +8438,90 @@ function cachedGrants({client: client, requestFn: requestFn, resourcePath: resou
     byPath.set(resourcePath, cached)), cached;
 }
 
-async function fetchActor(requestFn) {
-    let user;
+async function fetchActor(client, requestFn) {
+    const [resourceUser, globalUser] = await Promise.all([ fetchCurrentUser(requestFn, "the workflow resource host"), fetchGlobalUser(client) ]), resourceId = usableId(resourceUser), globalId = usableId(globalUser.user), id = globalId ?? resourceId;
+    if (id === void 0) return;
+    refuseProjectPrincipalWithoutGlobal({
+        resourceId: resourceId,
+        globalId: globalId,
+        globalUser: globalUser
+    });
+    const roleNames = (resourceUser?.roles?.length ? resourceUser : globalUser.user)?.roles?.map(r => r.name).filter(n => !!n) ?? [];
+    return {
+        actor: {
+            kind: "person",
+            id: id,
+            ...roleNames.length > 0 ? {
+                roles: roleNames
+            } : {}
+        },
+        ...resourceId !== void 0 && resourceId !== id ? {
+            localPrincipalId: resourceId
+        } : {}
+    };
+}
+
+function refuseProjectPrincipalWithoutGlobal(args) {
+    const {resourceId: resourceId, globalId: globalId, globalUser: globalUser} = args;
+    if (globalId !== void 0 || resourceId === void 0 || invariants.classifyPrincipalId(resourceId).namespace !== "project") return;
+    const reason = "reason" in globalUser ? globalUser.reason : "no record";
+    throw new Error(`workflow: the caller's identity on the workflow resource host is project-scoped ("${resourceId}") and the account-global record could not be resolved (${reason}). The engine speaks account-global user ids only and never acts as a project-scoped principal.`, "cause" in globalUser ? {
+        cause: globalUser.cause
+    } : void 0);
+}
+
+function usableId(user) {
+    if (!(!user || typeof user.id != "string" || user.id.length === 0)) return user.id;
+}
+
+async function fetchCurrentUser(requestFn, hostDescription) {
     try {
-        user = await requestFn({
+        return await requestFn({
             uri: "/users/me",
             tag: REQUEST_TAG.accessResolveActor
         });
     } 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(`workflow: /users/me request against ${hostDescription} failed. The engine resolves the actor from the client's token via \`client.request({ uri: '/users/me' })\`. Check the token/connectivity.`, {
             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 fetchGlobalUser(client) {
+    if (typeof client.withConfig != "function") return {
+        user: void 0,
+        reason: "the client cannot reach the global API host (no withConfig)"
+    };
+    let globalRequest, globalClient;
+    try {
+        globalClient = client.withConfig({
+            useProjectHostname: !1
+        }), globalRequest = lazyRequest(globalClient);
+    } catch (err) {
+        return {
+            user: void 0,
+            reason: `building the global-host sibling client failed: ${invariants.errorMessage(err)}`,
+            cause: err
+        };
+    }
+    if (globalRequest === void 0) return {
+        user: void 0,
+        reason: "the global-host sibling client cannot issue requests"
     };
+    try {
+        return {
+            user: await globalRequest({
+                uri: "/users/me",
+                tag: REQUEST_TAG.accessResolveActor
+            })
+        };
+    } catch (err) {
+        return {
+            user: void 0,
+            reason: `global-host /users/me failed: ${invariants.errorMessage(err)}`,
+            cause: err
+        };
+    }
 }
 
 async function fetchGrantsCached(requestFn, resourcePath) {
@@ -7764,35 +8697,48 @@ async function subjectResourceGrants(args) {
     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 ];
+        const [grants, actorId] = await Promise.all([ grantsForClientPath(entry.client, path), resourceActorId(entry.client) ]);
+        if (!(grants === void 0 || actorId === void 0)) return [ key, {
+            grants: grants,
+            actorId: actorId
+        } ];
     }));
     return new Map(resolved.filter(entry => entry !== void 0));
 }
 
+async function resourceActorId(client) {
+    try {
+        const access = await resolveAccess(client);
+        return invariants.lakePrincipalId(access);
+    } catch (err) {
+        console.warn(`workflow: failed to resolve the actor identity on a subject resource; the subject-write forecast omits this resource (degrade open — the lake still enforces writes). Original error: ${invariants.errorMessage(err)}`);
+        return;
+    }
+}
+
 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, {
+    const [access, instance] = await Promise.all([ resolveAccess(client, {
         ...args.grantsFromPath !== void 0 ? {
             grantsFromPath: args.grantsFromPath
         } : {}
-    }), instance = await reload({
+    }), reload({
         client: client,
         instanceId: instanceId,
         tag: tag
-    }), definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
         client: client,
         workflowResource: workflowResource,
         resourceClients: resourceClients
-    }), snapshot = await hydrateSnapshot({
+    }), [snapshot, guards, resourceGrants] = await Promise.all([ hydrateSnapshot({
         client: client,
         clientForGdr: clientForGdr,
         instance: instance
-    }), guards = await verdictGuardsForInstance(client, instance._id), resourceGrants = await subjectResourceGrants({
+    }), verdictGuardsForInstance(client, instance._id), subjectResourceGrants({
         clientForGdr: clientForGdr,
         instance: instance
-    });
+    }) ]);
     return evaluateFromSnapshot({
         instance: instance,
         definition: definition,
@@ -7801,6 +8747,9 @@ async function evaluateInstance(args) {
         guards: guards,
         now: now,
         resourceGrants: resourceGrants,
+        ...localPrincipalId !== void 0 ? {
+            localPrincipalId: localPrincipalId
+        } : {},
         ...grants !== void 0 ? {
             grants: grants
         } : {}
@@ -7856,9 +8805,12 @@ async function evaluateFromSnapshot(args) {
         definition: definition,
         snapshot: snapshot,
         now: now
-    }, can = await advisoryCan({
-        instance: instance,
+    }, anchorIdentity = invariants.lakePrincipalId({
         actor: actor,
+        localPrincipalId: args.localPrincipalId
+    }), can = await advisoryCan({
+        instance: instance,
+        identity: anchorIdentity,
         grants: grants
     }), scope = await renderConditionScope(scopeSource, {
         actor: actor,
@@ -7875,11 +8827,10 @@ async function evaluateFromSnapshot(args) {
         activityName: activityName
     })), currentActivityEntries = findOpenStageEntry(instance)?.activities ?? [], guardDenial = await instanceGuardReason({
         instance: instance,
-        actor: actor,
+        identity: anchorIdentity,
         guards: args.guards
     }), subjectDenials = await forecastSubjectDenials({
         instance: instance,
-        actor: actor,
         snapshot: snapshot,
         resourceGrants: args.resourceGrants
     }), subjectPermissionReason = subjectDenials.length > 0 ? {
@@ -8023,20 +8974,20 @@ async function editPredicateInsight(args) {
 }
 
 async function forecastSubjectDenials(args) {
-    const {instance: instance, actor: actor, snapshot: snapshot, resourceGrants: resourceGrants} = args;
+    const {instance: instance, snapshot: snapshot, resourceGrants: resourceGrants} = args;
     if (resourceGrants === void 0 || resourceGrants.size === 0) return [];
     const denials = [], seen = /* @__PURE__ */ new Set;
     for (const {ref: ref, parsed: parsed, resource: resource} of foreignSubjectRefs(instance)) {
         if (seen.has(ref.id)) continue;
         seen.add(ref.id);
-        const grants = resourceGrants.get(invariants.resourceGdr(resource));
-        if (grants === void 0) continue;
+        const access = resourceGrants.get(invariants.resourceGdr(resource));
+        if (access === void 0) continue;
         const doc = snapshot.docs.find(d => d._id === ref.id);
         doc !== void 0 && await subjectUpdateAllowed({
             doc: doc,
             parsed: parsed,
-            grants: grants,
-            actorId: actor.id
+            grants: access.grants,
+            actorId: access.actorId
         }) === !1 && denials.push({
             subject: ref.id,
             resource: invariants.resourceGdr(resource),
@@ -8117,12 +9068,12 @@ async function explainActivityConditions({activity: activity, activityScope: act
         snapshot: snapshot,
         sites: sites
     }), requirementEntries = [];
-    for (const [name, condition] of Object.entries(activity.requirements ?? {})) requirementEntries.push([ name, await explainAt({
+    for (const requirement of activity.requirements ?? []) requirementEntries.push([ requirement, await explainAt({
         kind: "requirement",
         activity: activity.name,
-        requirement: name
-    }, condition) ]);
-    const requirementInsights = Object.fromEntries(requirementEntries), unmetRequirements = requirementEntries.filter(([, insight]) => insight.outcome !== "satisfied").map(([name]) => name), filterInsight = activity.filter !== void 0 ? await explainSite({
+        requirement: requirement.name
+    }, requirement.query) ]);
+    const requirementInsights = Object.fromEntries(requirementEntries.map(([requirement, insight]) => [ requirement.name, insight ])), unmetRequirements = requirementEntries.filter(([, insight]) => insight.outcome !== "satisfied").map(([requirement]) => requirementDescriptor(requirement)), filterInsight = activity.filter !== void 0 ? await explainSite({
         site: {
             kind: "activity-filter",
             activity: activity.name
@@ -8268,12 +9219,12 @@ function actionEvaluationIdentity(action) {
     };
 }
 
-async function instanceGuardReason({instance: instance, actor: actor, guards: guards}) {
+async function instanceGuardReason({instance: instance, identity: identity, guards: guards}) {
     if (guards === void 0 || guards.length === 0) return;
     const denied = await instanceWriteDenials({
         instance: instance,
         guards: guards,
-        identity: actor.id
+        identity: identity
     });
     if (denied.length !== 0) return {
         kind: "mutation-guard-denied",
@@ -8312,24 +9263,24 @@ 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`;
+const FIELD_REFS_DOC = "count(fields[value.id in $documents]) > 0 || count(fields[count(value[id in $documents]) > 0]) > 0", OPEN_STAGE_REFS_DOC = `count(stages[!defined(exitedAt) && (${FIELD_REFS_DOC} || count(activities[${FIELD_REFS_DOC}]) > 0)]) > 0`, LIVE_SUBWORKFLOW_REFS_DOC = "count(subworkflows[!defined(resolved) && ref.id in $documents]) > 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}`;
+    `_id in $bareIds || count(ancestors[id in $documents]) > 0 || ${LIVE_SUBWORKFLOW_REFS_DOC} || ${FIELD_REFS_DOC} || ${OPEN_STAGE_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 ] : [] ];
+    const documents = [ .../* @__PURE__ */ new Set([ ...filter.documents ?? [], ...filter.document !== void 0 ? [ filter.document ] : [] ]) ].sort();
     return documentPrefilter(documents, params);
 }
 
 function idsArm(filter, params) {
     if (filter.ids !== void 0) {
         for (const id of filter.ids) if (invariants.isGdrUri(id)) throw new invariants.ContractViolationError(`instancesQuery: every id must be a bare instance document id (an instance's _id is never resource-qualified); got a GDR URI: ${JSON.stringify(id)}`);
-        return params.ids = [ ...filter.ids ], "_id in $ids";
+        return params.ids = [ ...new Set(filter.ids) ].sort(), "_id in $ids";
     }
 }
 
@@ -8743,11 +9694,10 @@ async function commitEdit({ctx: ctx, target: target, mode: mode, value: value, r
 }
 
 async function assertFieldEditable({ctx: ctx, site: site, options: options}) {
-    const actor = options?.actor, window = fieldWindowOpen(ctx.instance, site), can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan({
+    const actor = options?.actor, window = fieldWindowOpen(ctx.instance, site), can = await advisoryCanForCall({
         instance: ctx.instance,
-        actor: actor,
-        grants: options.grants
-    }) : void 0, predicateSatisfied = window.open && site.effective !== !0 && site.effective !== void 0 ? await ctxEvaluateCondition({
+        options: options
+    }), predicateSatisfied = window.open && site.effective !== !0 && site.effective !== void 0 ? await ctxEvaluateCondition({
         ctx: ctx,
         condition: site.effective,
         opts: {
@@ -9105,8 +10055,7 @@ async function abortAndPropagate(args) {
             executionContext: executionContext,
             telemetry: telemetry
         })
-    });
-    return await drainCondemnedChildren({
+    }), drained = await drainCondemnedChildren({
         client: client,
         instanceId: instanceId,
         actor: actor,
@@ -9118,8 +10067,12 @@ async function abortAndPropagate(args) {
         } : {},
         ...telemetry !== void 0 ? {
             telemetry: telemetry
+        } : {},
+        ...result.fired ? {
+            instance: result.instance
         } : {}
-    }), await propagateToAncestors({
+    });
+    return await propagateToAncestors({
         client: client,
         instanceId: instanceId,
         actor: actor,
@@ -9131,6 +10084,9 @@ async function abortAndPropagate(args) {
         } : {},
         ...telemetry !== void 0 ? {
             telemetry: telemetry
+        } : {},
+        ...result.fired && !drained.drained ? {
+            instance: drained.instance
         } : {}
     }), result.fired;
 }
@@ -9238,6 +10194,9 @@ function buildEngineCallOptions(args) {
         actor: args.actor,
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
+        ...args.localPrincipalId !== void 0 ? {
+            localPrincipalId: args.localPrincipalId
+        } : {},
         ...args.grants !== void 0 ? {
             grants: args.grants
         } : {},
@@ -9379,6 +10338,15 @@ async function abortInstances(args) {
     return aborted;
 }
 
+function projectStartSliceRow(instance) {
+    const subject = (instance.fields ?? []).find(field => field._type === "subject")?.value;
+    return {
+        definition: instance.definition,
+        subject: typeof subject == "object" && subject !== null && "id" in subject && invariants.isGdrUri(subject.id) ? subject.id : null,
+        completedAt: instance.completedAt ?? null
+    };
+}
+
 async function fetchStartSlice(args) {
     const {client: client, tag: tag} = args, {query: query, params: params} = instancesQuery({
         tag: tag,
@@ -9386,7 +10354,7 @@ async function fetchStartSlice(args) {
             includeCompleted: !0
         }
     });
-    return (await client.fetch(query, params)).map(invariants.assertReadableModel);
+    return (await client.fetch(query, params)).map(invariants.assertReadableModel).map(projectStartSliceRow);
 }
 
 const workflow = {
@@ -9535,6 +10503,9 @@ const workflow = {
                         ...access.grants !== void 0 ? {
                             grants: access.grants
                         } : {},
+                        ...access.localPrincipalId !== void 0 ? {
+                            localPrincipalId: access.localPrincipalId
+                        } : {},
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
@@ -9603,6 +10574,9 @@ const workflow = {
                         ...access.grants !== void 0 ? {
                             grants: access.grants
                         } : {},
+                        ...access.localPrincipalId !== void 0 ? {
+                            localPrincipalId: access.localPrincipalId
+                        } : {},
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
@@ -9762,7 +10736,7 @@ const workflow = {
         });
     },
     tick: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.tick), {client: client, tag: tag, instanceId: instanceId, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, current = await reload({
+        const args = taggedScope(rawArgs, REQUEST_TAG.tick), {client: client, tag: tag, instanceId: instanceId, executionContext: executionContext} = args, {access: access, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, current = await reload({
             client: client,
             instanceId: instanceId,
             tag: tag
@@ -9770,7 +10744,7 @@ const workflow = {
         await assertInstanceWriteAllowed({
             instance: current,
             guards: guards,
-            identity: actor.id
+            identity: invariants.lakePrincipalId(access)
         });
         const {cascaded: cascaded, instance: instance} = await cascadeAndReload({
             client: client,
@@ -9887,6 +10861,59 @@ const workflow = {
             }
         });
     },
+    resetActivity: async rawArgs => {
+        const args = taggedScope(rawArgs, REQUEST_TAG.resetActivity), {client: client, tag: tag, instanceId: instanceId, activity: activity, executionContext: executionContext} = args, to = args.to ?? "active";
+        if (!isResetActivityTarget(to)) throw new invariants.ContractViolationError(`resetActivity: "to" must be "active" or "skipped"; got ${JSON.stringify(args.to)}`);
+        return runCommitVerb({
+            args: args,
+            op: "resetActivity",
+            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+                const result = await resetActivity({
+                    client: client,
+                    instanceId: instanceId,
+                    activity: activity,
+                    to: to,
+                    ...record !== void 0 ? {
+                        requestRecord: record
+                    } : {},
+                    options: engineOptionsForActor({
+                        actor: actor,
+                        clock: clock,
+                        clientForGdr: clientForGdr,
+                        refSurface: refSurface,
+                        executionContext: executionContext,
+                        telemetry: args.telemetry
+                    })
+                }), cascaded = result.fired ? await cascade({
+                    client: client,
+                    instanceId: instanceId,
+                    actor: actor,
+                    clientForGdr: clientForGdr,
+                    refSurface: refSurface,
+                    clock: clock,
+                    ...executionContext !== void 0 ? {
+                        executionContext: executionContext
+                    } : {},
+                    ...args.telemetry !== void 0 ? {
+                        telemetry: args.telemetry
+                    } : {}
+                }) : 0;
+                return resolveTelemetry(args.telemetry).log(WorkflowActivityReset, {
+                    ...definitionHashFragment(before.pinnedContentHash),
+                    instanceId: instanceId,
+                    changed: result.fired
+                }), {
+                    instance: await reload({
+                        client: client,
+                        instanceId: instanceId,
+                        tag: tag
+                    }),
+                    cascaded: cascaded,
+                    changed: result.fired
+                };
+            }
+        });
+    },
     getInstance: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.getInstance), {client: client, tag: tag, instanceId: instanceId} = args;
         return invariants.validateTag(tag), reload({
@@ -10033,21 +11060,18 @@ const workflow = {
         return (await client.fetch(query, params)).map(readInstanceDoc).filter(instance => instanceWatchesDocument(instance, document));
     },
     definitionsForDocument: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.definitionsForDocument), {client: client, tag: tag, document: document, subject: subject} = args;
+        const args = taggedScope(rawArgs, REQUEST_TAG.definitionsForDocument), {client: client, tag: tag, document: document} = args;
         invariants.validateTag(tag);
-        const clock = args.clock ?? wallClock, deployed = (await client.fetch(definitionsListGroq("desc"), {
+        const clock = args.clock ?? wallClock, deployed = (await client.fetch(latestDefinitionsGroq(), {
             tag: tag
-        })).map(invariants.assertReadableModel), latest = latestDeployedDefinitions(deployed);
+        })).map(invariants.assertReadableModel);
         let slice;
         return applicableDefinitions({
-            definitions: latest,
+            definitions: deployed,
             document: document,
             scope: {
                 tag: tag,
                 now: clock(),
-                ...subject !== void 0 ? {
-                    subject: subject
-                } : {},
                 fetchDataset: () => slice ??= fetchStartSlice({
                     client: client,
                     tag: tag
@@ -10070,34 +11094,17 @@ const workflow = {
         }), missingRequired = missingRequiredInputs({
             entryDefs: definition.fields ?? [],
             initialFields: initialFields ?? []
-        }), allowed = definition.start?.allowed;
-        if (allowed === void 0) return {
-            allowed: invalidInitialFields.length === 0,
-            outcome: "satisfied",
-            unboundReads: [],
-            missingRequired: missingRequired,
-            invalidInitialFields: invalidInitialFields
-        };
-        const unboundReads = unboundAllowedReadsWithSubject({
-            allowed: allowed,
-            fields: startFieldsParam({
-                entryDefs: definition.fields ?? [],
-                initialFields: initialFields ?? []
-            }),
-            definition: definition
-        }), insight = await startAllowedInsight({
+        }), verdict = await startRequirementVerdict({
             client: client,
             tag: tag,
             definition: definition,
-            allowed: allowed,
             initialFields: initialFields ?? [],
-            now: clock()
-        }), provisional = unboundReads.length > 0;
+            now: clock(),
+            preflight: !0
+        });
         return {
-            allowed: invalidInitialFields.length === 0 && !provisional && insight.outcome === "satisfied",
-            outcome: provisional ? "unevaluable" : insight.outcome,
-            insight: insight,
-            unboundReads: unboundReads,
+            ...verdict,
+            allowed: invalidInitialFields.length === 0 && verdict.allowed,
             missingRequired: missingRequired,
             invalidInitialFields: invalidInitialFields
         };
@@ -10109,11 +11116,10 @@ const workflow = {
     }
 };
 
-async function startAllowedInsight(args) {
-    const {client: client, tag: tag, definition: definition, allowed: allowed, initialFields: initialFields, now: now} = args;
-    return explainStartAllowed({
-        allowed: allowed,
-        definition: definition,
+function startPredicateContext(args) {
+    const {client: client, tag: tag, definition: definition, initialFields: initialFields, now: now} = args;
+    let slice;
+    return {
         fields: startFieldsParam({
             entryDefs: definition.fields ?? [],
             initialFields: initialFields
@@ -10121,12 +11127,71 @@ async function startAllowedInsight(args) {
         scope: {
             tag: tag,
             now: now,
-            fetchDataset: () => fetchStartSlice({
+            fetchDataset: () => slice ??= fetchStartSlice({
                 client: client,
                 tag: tag
             })
         }
-    });
+    };
+}
+
+async function startRequirementVerdict(args) {
+    const {client: client, tag: tag, definition: definition, initialFields: initialFields, now: now, preflight: preflight = !1} = args, declared = definition.start?.requirements ?? [];
+    if (declared.length === 0) return {
+        allowed: !0,
+        outcome: "satisfied",
+        requirements: [],
+        unboundReads: []
+    };
+    const {fields: fields, scope: scope} = startPredicateContext({
+        client: client,
+        tag: tag,
+        definition: definition,
+        initialFields: initialFields,
+        now: now
+    }), subjectEntry = (definition.fields ?? []).find(invariants.isSubjectEntry)?.name, requirements = [], unbound = /* @__PURE__ */ new Set;
+    for (const requirement of declared) {
+        const descriptor = requirementDescriptor(requirement);
+        if (requirement.type === "singleSubject") {
+            if (preflight && subjectEntry !== void 0 && !Object.hasOwn(fields, subjectEntry)) unbound.add(subjectEntry), 
+            requirements.push({
+                ...descriptor,
+                outcome: "unevaluable"
+            }); else {
+                const refused = await singleSubjectRequirementRefused({
+                    definition: definition,
+                    fields: fields,
+                    scope: scope
+                });
+                requirements.push({
+                    ...descriptor,
+                    outcome: refused ? "unsatisfied" : "satisfied"
+                });
+            }
+            continue;
+        }
+        const missing = unboundRequirementReads(requirement.query, fields);
+        missing.forEach(name => unbound.add(name));
+        const insight = await explainStartRequirement({
+            query: requirement.query,
+            definition: definition,
+            fields: fields,
+            scope: scope
+        });
+        requirements.push({
+            ...descriptor,
+            outcome: preflight && missing.length > 0 ? "unevaluable" : insight.outcome,
+            insight: insight
+        });
+    }
+    let outcome = "satisfied";
+    return requirements.some(requirement => requirement.outcome === "unsatisfied") ? outcome = "unsatisfied" : requirements.some(requirement => requirement.outcome === "unevaluable") && (outcome = "unevaluable"), 
+    {
+        allowed: outcome === "satisfied",
+        outcome: outcome,
+        requirements: requirements,
+        unboundReads: [ ...unbound ]
+    };
 }
 
 async function startFreshInstance(args) {
@@ -10226,19 +11291,16 @@ async function assertStartInputs(args) {
         initialFields: initialFields,
         definitionName: definition.name
     });
-    const allowed = definition.start?.allowed;
-    if (allowed === void 0) return;
-    const insight = await startAllowedInsight({
+    const unmetRequirements = (await startRequirementVerdict({
         client: client,
         tag: tag,
         definition: definition,
-        allowed: allowed,
         initialFields: initialFields,
         now: now
-    });
-    if (insight.outcome !== "satisfied") throw new StartNotAllowedError({
+    })).requirements.filter(requirement => requirement.outcome !== "satisfied").map(requirementDescriptor);
+    if (unmetRequirements.length > 0) throw new StartNotAllowedError({
         definition: definition.name,
-        insight: insight
+        unmetRequirements: unmetRequirements
     });
 }
 
@@ -10271,97 +11333,6 @@ async function resolveStartFields(args) {
     };
 }
 
-function isRecord(value) {
-    return typeof value == "object" && value !== null && !Array.isArray(value);
-}
-
-function isClientProjectUser(value) {
-    return isRecord(value) && typeof value.id == "string" && (value.displayName === void 0 || typeof value.displayName == "string") && (value.email === void 0 || typeof value.email == "string") && (value.imageUrl === void 0 || value.imageUrl === null || typeof value.imageUrl == "string");
-}
-
-function objectProperty(value, property) {
-    if (!isRecord(value)) return;
-    const propertyValue = value[property];
-    return typeof propertyValue == "object" && propertyValue !== null ? propertyValue : void 0;
-}
-
-function stringProperty(value, property) {
-    const propertyValue = Reflect.get(value, property);
-    return typeof propertyValue == "string" ? propertyValue : void 0;
-}
-
-function apiErrorType(error) {
-    const response = objectProperty(error, "response"), body = objectProperty(response, "body");
-    if (!body) return;
-    const nestedError = objectProperty(body, "error");
-    return (nestedError ? stringProperty(nestedError, "type") : void 0) ?? stringProperty(body, "type");
-}
-
-function isProjectUserNotFoundError(error) {
-    return apiErrorType(error) === "projectUserNotFoundError";
-}
-
-function clientProjectUserDirectory(client, projectId) {
-    return {
-        findById: async id => {
-            if (!client.request) return {
-                status: "inaccessible",
-                cause: new Error("Project-user resolution requires WorkflowClient.request")
-            };
-            try {
-                const response = await client.request({
-                    uri: `/projects/${encodeURIComponent(projectId)}/users/${encodeURIComponent(id)}`
-                }), candidate = Array.isArray(response) ? response[0] : response;
-                return candidate == null ? {
-                    status: "missing"
-                } : isClientProjectUser(candidate) ? {
-                    status: "resolved",
-                    user: candidate
-                } : {
-                    status: "inaccessible",
-                    cause: new Error("Project-user response had an invalid shape")
-                };
-            } catch (cause) {
-                return isProjectUserNotFoundError(cause) ? {
-                    status: "missing"
-                } : {
-                    status: "inaccessible",
-                    cause: cause
-                };
-            }
-        }
-    };
-}
-
-function resolveClientActor(client, args) {
-    return resolveActor(clientProjectUserDirectory(client, args.projectId), args.actor);
-}
-
-async function resolveActor(directory, actor) {
-    if (actor.kind !== "person") return {
-        status: "not-person",
-        actor: actor
-    };
-    const personActor = {
-        ...actor,
-        kind: "person"
-    }, lookup = await directory.findById(personActor.id);
-    return lookup.status === "resolved" ? {
-        status: "resolved",
-        actor: personActor,
-        user: lookup.user
-    } : lookup.status === "inaccessible" ? {
-        status: "inaccessible",
-        actor: personActor,
-        ...lookup.cause === void 0 ? {} : {
-            cause: lookup.cause
-        }
-    } : {
-        status: "missing",
-        actor: personActor
-    };
-}
-
 const EFFECT_COMMIT_QUEUE_DEPTH = 32, EFFECT_COMMIT_DISPATCH_CAP = 200;
 
 class EffectCommitQueueOverflowError extends invariants.WorkflowError {
@@ -10540,7 +11511,7 @@ function isCancelledCompletion(data) {
 }
 
 async function drainEffectsInternal(args) {
-    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger, handlerClient: handlerClient, handlerResourceClients: handlerResourceClients} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, routeGdr = buildClientForGdr({
+    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger, handlerClient: rawHandlerClient, handlerResourceClients: rawHandlerResourceClients} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, handlerClient = effectHandlerClient(rawHandlerClient), handlerResourceClients = effectHandlerResolver(rawHandlerResourceClients), routeGdr = buildClientForGdr({
         client: handlerClient,
         workflowResource: workflowResource,
         resourceClients: handlerResourceClients
@@ -10906,22 +11877,30 @@ function createInstanceSession(args) {
     }, tickScope = opScope(REQUEST_TAG.tick), fireScope = opScope(REQUEST_TAG.fireAction), editScope = opScope(REQUEST_TAG.editField), evalScope = opScope(REQUEST_TAG.evaluate);
     let overlay = /* @__PURE__ */ new Map;
     const previews = /* @__PURE__ */ new Map;
-    let heldGuards = [], committing = !1, buffered, deferredUpdateError;
-    const selfUri = () => invariants.gdrFromResource(instance.workflowResource, instance._id), applyUpdate = docs => {
-        const next = /* @__PURE__ */ new Map;
-        for (const ld of docs) {
-            const owned = {
-                doc: structuredClone(ld.doc),
-                resource: ld.resource
-            }, uri = invariants.gdrFromResource(owned.resource, owned.doc._id);
-            if (uri === selfUri()) {
-                const rawStamp = owned.doc._updatedAt;
-                !invariants.isParseableInstant(rawStamp) || owned.doc._type !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
-                continue;
-            }
-            next.set(uri, owned);
+    let heldGuards = [], committing = !1, buffered;
+    const bufferedDocuments = /* @__PURE__ */ new Map;
+    let deferredUpdateError;
+    const flushDeferredError = () => {
+        if (deferredUpdateError === void 0) return;
+        const failure = deferredUpdateError;
+        throw deferredUpdateError = void 0, failure;
+    }, selfUri = () => invariants.gdrFromResource(instance.workflowResource, instance._id), applyDocument = (ld, target) => {
+        const owned = {
+            doc: structuredClone(ld.doc),
+            resource: ld.resource
+        }, uri = invariants.gdrFromResource(owned.resource, owned.doc._id);
+        if (uri === selfUri()) {
+            const rawStamp = owned.doc._updatedAt;
+            !invariants.isParseableInstant(rawStamp) || owned.doc._type !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
+            return;
         }
+        target.set(uri, owned);
+    }, applyUpdate = docs => {
+        const next = /* @__PURE__ */ new Map;
+        for (const ld of docs) applyDocument(ld, next);
         overlay = next;
+    }, applyDocumentUpdate = doc => {
+        applyDocument(doc, overlay);
     }, access = () => resolveAccess(client, {
         ...args.grantsFromPath !== void 0 ? {
             grantsFromPath: args.grantsFromPath
@@ -10979,17 +11958,23 @@ function createInstanceSession(args) {
             refSurface: evalScope.refSurface
         });
     }, evaluateWith = async ({held: held, guards: guards, self: self}) => {
-        const {actor: actor, grants: grants} = await access(), resourceGrants = await subjectResourceGrants({
+        const {actor: actor, localPrincipalId: localPrincipalId, grants: grants} = await access(), resourceGrants = await subjectResourceGrants({
             clientForGdr: evalScope.clientForGdr,
             instance: instance
+        }), normalizedSelf = await normalizeInstanceIdentities({
+            client: evalScope.client,
+            instance: self
         });
         return evaluateFromSnapshot({
-            instance: self,
+            instance: normalizedSelf,
             definition: definitionOf(),
             actor: actor,
-            snapshot: snapshotFrom(held, self),
+            snapshot: snapshotFrom(held, normalizedSelf),
             guards: guards,
             resourceGrants: resourceGrants,
+            ...localPrincipalId !== void 0 ? {
+                localPrincipalId: localPrincipalId
+            } : {},
             ...clock !== void 0 ? {
                 now: clock()
             } : {},
@@ -11035,8 +12020,13 @@ function createInstanceSession(args) {
         committing = !0;
         const held = new Map(overlay);
         try {
-            const {actor: actor} = await access();
-            return await run(actor, held);
+            const {actor: actor, localPrincipalId: localPrincipalId} = await access();
+            return await run({
+                actor: actor,
+                ...localPrincipalId !== void 0 ? {
+                    localPrincipalId: localPrincipalId
+                } : {}
+            }, held);
         } finally {
             if (committing = !1, buffered !== void 0) {
                 const next = buffered;
@@ -11047,6 +12037,12 @@ function createInstanceSession(args) {
                     deferredUpdateError = err;
                 }
             }
+            for (const next of bufferedDocuments.values()) try {
+                applyDocumentUpdate(next);
+            } catch (err) {
+                deferredUpdateError = err;
+            }
+            bufferedDocuments.clear();
         }
     };
     return {
@@ -11054,15 +12050,26 @@ function createInstanceSession(args) {
             return subscriptionDocumentsForInstance(instance);
         },
         update(docs) {
-            if (committing) buffered = docs; else try {
+            if (committing) buffered = docs, bufferedDocuments.clear(); else try {
                 applyUpdate(docs);
             } catch (err) {
                 throw deferredUpdateError = void 0, err;
             }
-            if (deferredUpdateError !== void 0) {
-                const failure = deferredUpdateError;
-                throw deferredUpdateError = void 0, failure;
+            flushDeferredError();
+        },
+        updateDocument(doc) {
+            if (committing) {
+                const uri = invariants.gdrFromResource(doc.resource, doc.doc._id);
+                bufferedDocuments.set(uri, {
+                    doc: structuredClone(doc.doc),
+                    resource: doc.resource
+                });
+            } else try {
+                applyDocumentUpdate(doc);
+            } catch (err) {
+                throw deferredUpdateError = void 0, err;
             }
+            flushDeferredError();
         },
         updateGuards(guards) {
             heldGuards = guards.map(guard => parseGuardDocument(structuredClone(guard)));
@@ -11094,11 +12101,14 @@ function createInstanceSession(args) {
             site !== void 0 && previews.delete(siteKey(site));
         },
         tick() {
-            return commit(async (actor, held) => {
+            return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
                 await assertInstanceWriteAllowed({
                     instance: instance,
                     guards: heldGuards,
-                    identity: actor.id
+                    identity: invariants.lakePrincipalId({
+                        actor: actor,
+                        localPrincipalId: localPrincipalId
+                    })
                 });
                 const before = await reload({
                     client: tickScope.client,
@@ -11125,7 +12135,7 @@ function createInstanceSession(args) {
             });
         },
         fireAction({activity: activity, action: action, params: params}) {
-            return commit(async (actor, held) => {
+            return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
                 assertActionAllowed({
                     evaluation: await evaluateWith({
                         held: held,
@@ -11141,6 +12151,9 @@ function createInstanceSession(args) {
                     activity: activity,
                     action: action,
                     actor: actor,
+                    ...localPrincipalId !== void 0 ? {
+                        localPrincipalId: localPrincipalId
+                    } : {},
                     clientForGdr: fireScope.clientForGdr,
                     refSurface: fireScope.refSurface,
                     ...grants !== void 0 ? {
@@ -11183,7 +12196,7 @@ function createInstanceSession(args) {
             } catch (err) {
                 return Promise.reject(err);
             }
-            return commit(async (actor, held) => {
+            return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
                 assertEditAllowed(await evaluateWith({
                     held: held,
                     guards: heldGuards,
@@ -11200,6 +12213,9 @@ function createInstanceSession(args) {
                         value: value
                     } : {},
                     actor: actor,
+                    ...localPrincipalId !== void 0 ? {
+                        localPrincipalId: localPrincipalId
+                    } : {},
                     clientForGdr: editScope.clientForGdr,
                     refSurface: editScope.refSurface,
                     ...grants !== void 0 ? {
@@ -11310,6 +12326,7 @@ function createEngine(args) {
         availableActions: rest => workflow.availableActions(withScope(rest)),
         setStage: rest => workflow.setStage(withScope(rest)),
         abortInstance: rest => workflow.abortInstance(withScope(rest)),
+        resetActivity: rest => workflow.resetActivity(withScope(rest)),
         deleteDefinition: rest => workflow.deleteDefinition(withScope(rest)),
         getInstance: rest => workflow.getInstance(withScope(rest)),
         subscriptionDocumentsForInstance: rest => workflow.getInstance(withScope(rest)).then(subscriptionDocumentsForInstance),
@@ -11882,6 +12899,8 @@ exports.ACTIVITY_KINDS = invariants.ACTIVITY_KINDS;
 
 exports.ACTOR_KINDS = invariants.ACTOR_KINDS;
 
+exports.ANONYMOUS_IDENTITY = invariants.ANONYMOUS_IDENTITY;
+
 exports.CONDITION_VARS = invariants.CONDITION_VARS;
 
 exports.ContractViolationError = invariants.ContractViolationError;
@@ -11924,10 +12943,12 @@ exports.RESERVED_CONDITION_VARS = invariants.RESERVED_CONDITION_VARS;
 
 exports.ReaderModelAcknowledgementError = invariants.ReaderModelAcknowledgementError;
 
-exports.START_ALLOWED_VARS = invariants.START_ALLOWED_VARS;
-
 exports.START_FILTER_VARS = invariants.START_FILTER_VARS;
 
+exports.START_REQUIREMENT_VARS = invariants.START_REQUIREMENT_VARS;
+
+exports.SYSTEM_IDENTITY = invariants.SYSTEM_IDENTITY;
+
 exports.SpawnContractsInvalidError = invariants.SpawnContractsInvalidError;
 
 exports.WORKFLOW_DEFINITION_TYPE = invariants.WORKFLOW_DEFINITION_TYPE;
@@ -11940,6 +12961,8 @@ exports.assertReadableModel = invariants.assertReadableModel;
 
 exports.assertReaderModelAcknowledgement = invariants.assertReaderModelAcknowledgement;
 
+exports.classifyPrincipalId = invariants.classifyPrincipalId;
+
 exports.clientConfigFromResource = invariants.clientConfigFromResource;
 
 exports.conditionFieldReadNames = invariants.conditionFieldReadNames;
@@ -11990,6 +13013,8 @@ exports.isTodoListItem = invariants.isTodoListItem;
 
 exports.isUnprimed = invariants.isUnprimed;
 
+exports.lakePrincipalId = invariants.lakePrincipalId;
+
 exports.minReaderModelOf = invariants.minReaderModelOf;
 
 exports.modelVersionOf = invariants.modelVersionOf;
@@ -12216,6 +13241,8 @@ exports.StartNotSettledError = StartNotSettledError;
 
 exports.WorkflowActionFired = WorkflowActionFired;
 
+exports.WorkflowActivityReset = WorkflowActivityReset;
+
 exports.WorkflowDefinitionDeleted = WorkflowDefinitionDeleted;
 
 exports.WorkflowDefinitionDeployed = WorkflowDefinitionDeployed;
@@ -12348,7 +13375,7 @@ exports.evaluateStartFilter = evaluateStartFilter;
 
 exports.expandResourceAliases = expandResourceAliases;
 
-exports.explainStartAllowed = explainStartAllowed;
+exports.explainStartRequirement = explainStartRequirement;
 
 exports.findCurrentActivityEntry = findCurrentActivityEntry;
 
@@ -12364,6 +13391,8 @@ exports.guardsForInstance = guardsForInstance;
 
 exports.guardsForResource = guardsForResource;
 
+exports.hasSingleSubjectRequirement = hasSingleSubjectRequirement;
+
 exports.hashDefinitionContent = hashDefinitionContent;
 
 exports.inFlightFilter = inFlightFilter;
@@ -12376,10 +13405,14 @@ exports.instanceGuardQuery = instanceGuardQuery;
 
 exports.instanceWatchesDocument = instanceWatchesDocument;
 
+exports.instancesGuardQuery = instancesGuardQuery;
+
 exports.instancesQuery = instancesQuery;
 
 exports.isClaimExpired = isClaimExpired;
 
+exports.isClientProjectUser = isClientProjectUser;
+
 exports.isDefinitionApplicable = isDefinitionApplicable;
 
 exports.isFilterScopedOut = isFilterScopedOut;
@@ -12392,6 +13425,8 @@ exports.isTerminalStage = isTerminalStage;
 
 exports.lakeGuardId = lakeGuardId;
 
+exports.latestDefinitionsGroq = latestDefinitionsGroq;
+
 exports.latestDeployedDefinitions = latestDeployedDefinitions;
 
 exports.lintEffectOutputs = lintEffectOutputs;
@@ -12410,6 +13445,8 @@ exports.parseInstanceDocument = parseInstanceDocument;
 
 exports.processShellUserProperties = processShellUserProperties;
 
+exports.projectStartSliceRow = projectStartSliceRow;
+
 exports.projectToWatchRef = projectToWatchRef;
 
 exports.readInstanceDoc = readInstanceDoc;
@@ -12432,6 +13469,8 @@ exports.retractStageGuards = retractStageGuards;
 
 exports.silentLogger = silentLogger;
 
+exports.singleSubjectRequirementRefused = singleSubjectRequirementRefused;
+
 exports.stageAutonomyOf = stageAutonomyOf;
 
 exports.startFieldsParam = startFieldsParam;
@@ -12448,7 +13487,7 @@ exports.subscriptionDocumentsForInstance = subscriptionDocumentsForInstance;
 
 exports.sweepStaleClaims = sweepStaleClaims;
 
-exports.unboundAllowedReads = unboundAllowedReads;
+exports.unboundRequirementReads = unboundRequirementReads;
 
 exports.unsatisfiedTransitionSummaries = unsatisfiedTransitionSummaries;