@sanity/workflow-engine 0.19.0 → 0.21.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import { terminalState, andConditions, deriveActivityKind, parseDefinitionSnapshot, CALLER_BOUND_VARS, START_ALLOWED_VARS, CONDITION_VARS, SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, rethrowWithContext, conditionParameterNames, isGdr, WORKFLOW_INSTANCE_TYPE, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, parentRef, actorFulfillsRole, toBareId, WorkflowError, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, errorMessage, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, evaluateCondition, isSingleDocRefEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, parseGdr, isGdrUri, gdrRef, isInputSourced, checkFieldValue, toPhysicalGdr, isBareSeedId, tolerantEntries, NonEmptyString, FIELD_VALUE_KINDS, tolerantObject, ActorShape, IsoTimestamp, ACTIVITY_STATUSES, GdrShape, DRIVER_KINDS, FIELD_SCOPES, fieldValueSchemas, parsePersistedDoc, assertReadableModel, InstanceNotFoundError, modelStampFor, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, minReaderModelOf, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, isUnprimed, DefinitionInUseError, assertReaderModelAcknowledgement, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
+import { terminalState, andConditions, deriveActivityKind, parseDefinitionSnapshot, CALLER_BOUND_VARS, START_REQUIREMENT_VARS, CONDITION_VARS, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, rethrowWithContext, isGdr, errorMessage, conditionParameterNames, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, parentRef, actorFulfillsRole, toBareId, WorkflowError, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, evaluateCondition, isSingleDocRefEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, WORKFLOW_INSTANCE_TYPE, parseGdr, isGdrUri, gdrRef, isInputSourced, parseFieldValue, VersionSpecificDatasetGdrError, toPhysicalGdr, isBareSeedId, tolerantEntries, NonEmptyString, FIELD_VALUE_KINDS, tolerantObject, ActorShape, IsoTimestamp, ACTIVITY_STATUSES, GdrShape, DRIVER_KINDS, FIELD_SCOPES, fieldValueSchemas, parsePersistedDoc, ACTOR_KINDS, classifyPrincipalId, assertReadableModel, InstanceNotFoundError, modelStampFor, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, minReaderModelOf, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, lakePrincipalId, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, isUnprimed, DefinitionInUseError, assertReaderModelAcknowledgement, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
 
-import { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTOR_KINDS, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_TRANSITION_WHEN, EXECUTOR_CLASSIFICATIONS, FILTER_SCOPE_VARS, GROUP_KINDS, GUARD_PREDICATE_VARS, ModelVersionAheadError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, clientConfigFromResource, fieldTreeShape, gdrUri, isNotesEntry, isTodoListEntry, isTodoListItem, modelVersionOf, parseResourceGdr, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, releaseDocId, releaseRef, requiredModelFeatures, requiredReaderModel, resourceAliasesToMap, schemaTreeShape, startKindOf } from "./_chunks-es/invariants.js";
+import { ACTION_SEMANTICS, ACTIVITY_KINDS, ANONYMOUS_IDENTITY, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_TRANSITION_WHEN, EXECUTOR_CLASSIFICATIONS, FILTER_SCOPE_VARS, GROUP_KINDS, GUARD_PREDICATE_VARS, ModelVersionAheadError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, SYSTEM_IDENTITY, clientConfigFromResource, fieldTreeShape, gdrUri, isNotesEntry, isTodoListEntry, isTodoListItem, modelVersionOf, parseResourceGdr, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, releaseDocId, releaseRef, requiredModelFeatures, requiredReaderModel, resourceAliasesToMap, schemaTreeShape, startKindOf } from "./_chunks-es/invariants.js";
 
 import { atomNode, dedupeBy, analyzeCondition, atomReadsDataset, checklistLines as checklistLines$1, phrase, quoted, listAnd, describeAtom as describeAtom$1, describeCondition as describeCondition$1, guillemets, formatValue, humanize, listOr, scopeReadOf, describeRead, explainCondition, dedupeReads, whatIfCondition, MAX_COUNTERFACTUAL_INDEX } from "@sanity/groq-condition-describe";
 
@@ -265,6 +265,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,
@@ -845,7 +849,7 @@ function toGroqDescribeContext(ctx) {
     };
 }
 
-const VAR_LABELS = new Map([ ...START_ALLOWED_VARS, ...CONDITION_VARS ].map(entry => [ entry.name, entry.label ]));
+const VAR_LABELS = new Map([ ...START_REQUIREMENT_VARS, ...CONDITION_VARS ].map(entry => [ entry.name, entry.label ]));
 
 function renderWorkflowRead(read, ctx) {
     if (read.variable === "fields" && typeof read.path[0] == "string") {
@@ -918,13 +922,6 @@ function clauseVarRequirement(requirement) {
             params: {},
             text: "no activity in this stage may have failed"
         });
-        if (target.variable === SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR) return kind === "truthy" ? phrase("requirement.subject-has-in-flight-instance", {
-            params: {},
-            text: "the subject must already have an in-flight workflow"
-        }) : phrase("requirement.subject-has-no-in-flight-instance", {
-            params: {},
-            text: "the subject must not already have an in-flight workflow"
-        });
     }
 }
 
@@ -1420,14 +1417,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: {
@@ -1495,13 +1492,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 evaluate(parsed.tree, {
@@ -1511,8 +1502,7 @@ async function evaluateStartFilter(args) {
             dataset: dataset,
             params: startContextParams({
                 definition: definition,
-                scope: scope,
-                dataset: dataset
+                scope: scope
             })
         })).get();
         return isUnevaluable(result) ? !1 : !!result;
@@ -1528,11 +1518,9 @@ async function evaluateStartFilter(args) {
 function parseStartFilter(args) {
     const {filter: filter, definition: definition} = args;
     try {
-        const readsSubject = readsSubjectHasInFlightInstance(filter);
         return {
             tree: parse(filter),
-            needsDataset: analyzeCondition(filter).readsDataset || readsSubject,
-            readsSubject: readsSubject
+            needsDataset: analyzeCondition(filter).readsDataset
         };
     } catch (err) {
         rethrowNamingDefinition({
@@ -1543,70 +1531,81 @@ function parseStartFilter(args) {
     }
 }
 
-function assertFilterSubject(args) {
-    if (!(!args.readsSubject || args.scope?.subject !== void 0)) throw new ContractViolationError(`start.filter on definition "${args.definition.name ?? "<unnamed>"}" reads $${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 = analyzeCondition(allowed).readsDataset || readsSubjectHasInFlightInstance(allowed);
+        needsDataset = 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 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 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 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 [ ...conditionFieldReadNames(allowed) ].filter(name => !Object.hasOwn(fields, name));
+function unboundRequirementReads(query, fields) {
+    return [ ...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 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(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 ContractViolationError(`singleSubjectRequirementRefused called for definition "${label}", which declares no \`singleSubject\` requirement — evaluate only what the definition declares.`);
+    if (definition.name === void 0) throw new 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}) {
-    rethrowWithContext(err, `start.${key} on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (check the predicate and its evaluation inputs)`);
+    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[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) {
@@ -1623,10 +1622,6 @@ function baseStartParams(definition, scope) {
     };
 }
 
-function readsSubjectHasInFlightInstance(groq) {
-    return conditionParameterNames(groq).has(SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR);
-}
-
 function startSubject(definition, fields) {
     const subjectEntry = (definition.fields ?? []).find(isSubjectEntry);
     if (subjectEntry === void 0) return;
@@ -1634,15 +1629,12 @@ function startSubject(definition, fields) {
     return 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 !== 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" && isGdr(field.value) && field.value.id === subject;
-        });
+        return instance.completedAt != null || instance.definition !== definition ? !1 : instance.subject === subject;
     });
 }
 
@@ -1672,11 +1664,11 @@ function startFilterSyntaxIssues(groq) {
     });
 }
 
-function startAllowedSyntaxIssues(groq) {
+function startRequirementSyntaxIssues(groq) {
     return startContextSyntaxIssues({
         groq: groq,
-        vars: START_ALLOWED_VARS,
-        context: "start-allowed"
+        vars: START_REQUIREMENT_VARS,
+        context: "start-requirement"
     });
 }
 
@@ -1684,7 +1676,7 @@ function startContextSyntaxIssues({groq: groq, vars: vars, context: context, ski
     try {
         parse(groq);
     } catch (err) {
-        return [ err instanceof Error ? err.message : String(err) ];
+        return [ errorMessage(err) ];
     }
     const bound = new Set(vars.map(v2 => v2.name));
     return [ ...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(", "));
@@ -2523,24 +2515,24 @@ function applyFieldSet(op, ctx) {
         src: op.value,
         ctx: ctx,
         target: entrySlot(entry)
-    });
-    return validateFieldValue({
+    }), validated = 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
         }
     };
 }
@@ -2601,27 +2593,27 @@ function applyFieldAppend(op, ctx) {
         ...slot !== void 0 ? {
             target: slot
         } : {}
-    });
-    validateFieldAppendItem({
+    }), validated = 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
         }
     };
 }
@@ -2649,8 +2641,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
     });
@@ -2660,25 +2653,27 @@ async function applyFieldUpdateWhere(op, ctx) {
         ctx: ctx
     }), next = rows.map((row, index) => matches[index] ? {
         ...row,
-        ...merge
-    } : row);
-    return validateFieldValue({
+        ...mergeRecord
+    } : row), validated = 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
         }
     };
 }
@@ -2870,8 +2865,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 checkWorkflowInvariants(definition)) v2.errors.push(`  · ${formatIssuePath(issue.path)}: ${issue.message}`);
@@ -3301,6 +3296,11 @@ function definitionsListGroq(versionOrder) {
     return `*[_type == "${WORKFLOW_DEFINITION_TYPE}" && ${tagScopeFilter()}] | order(name asc, version ${versionOrder})`;
 }
 
+function latestDefinitionsGroq() {
+    const scoped = `_type == "${WORKFLOW_DEFINITION_TYPE}" && ${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) {
@@ -3382,7 +3382,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] ?? []
     };
 }
@@ -3425,7 +3425,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) {
@@ -3927,7 +3927,7 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
         defaultValue: defaultValue
     });
     if (entry.initialValue?.type === "query") {
-        const issues = checkFieldValue({
+        const check = parseFieldValue({
             entryType: entry.type,
             value: value,
             types: entry.types,
@@ -3936,9 +3936,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,
@@ -3946,12 +3946,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 validateFieldValue({
+    const validated = validateFieldValue({
         entryType: entry.type,
         entryName: entry.name,
         value: value,
@@ -3960,16 +3960,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
     });
@@ -4001,12 +4002,27 @@ function assertInputValueShape(entry, value) {
 function assertGdrShape(value, context) {
     if (typeof value != "object" || value === null) throw new ContractViolationError(`Invalid GDR for ${context}: expected { id: "<scheme>:...", type: "<schema>" }, got ${typeof value}.`);
     const v2 = value;
-    if (typeof v2.id != "string" || !isGdrUri(v2.id)) throw new 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 {
+        parseGdr(v2.id);
+    } catch (error) {
+        throw error instanceof VersionSpecificDatasetGdrError ? new ContractViolationError(`Invalid GDR for ${context}: ${error.message}`) : invalidGdrUriError(context, v2.id);
+    }
     if (typeof v2.type != "string" || v2.type.length === 0) throw new 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 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 : 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 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 VersionSpecificDatasetGdrError) return raw;
+        throw error;
+    }
 }
 
 function coerceGdrShape(raw, workflowResource) {
@@ -4348,219 +4364,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(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 InstanceNotFoundError({
-        instanceId: instanceId
-    });
-    if (doc.tag !== tag) throw new 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) {
-        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: 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,
-        ...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(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 = 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: 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 === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : 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(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} = 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 datasetResourceParts(resource.id).projectId;
+}
+
+function collectLegacyIds(instance) {
+    const found = /* @__PURE__ */ new Set;
+    return rewriteIdentitySlots(instance, id => {
+        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 => {
+            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: ${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) && 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(assertReadableModel(doc));
+}
+
+async function reload({client: client, instanceId: instanceId, tag: tag}) {
+    const doc = await getInstanceDocument(client, instanceId);
+    if (!doc) throw new InstanceNotFoundError({
+        instanceId: instanceId
+    });
+    if (doc.tag !== tag) throw new 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) {
+        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: 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,
+        ...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(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 = tryParseGdr(uri);
+    return parsed === void 0 ? {
+        client: defaultClient,
+        id: uri,
+        perspective: perspective,
+        resource: defaultResource
+    } : {
+        client: clientForGdr(parsed),
+        id: parsed.documentId,
+        perspective: perspective,
+        resource: 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 === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : 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);
@@ -4576,29 +5079,31 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
     if (!instance) throw new InstanceNotFoundError({
         instanceId: instanceId
     });
-    const definition = 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: 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) {
@@ -4636,6 +5141,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
         } : {},
@@ -4644,7 +5152,10 @@ async function buildEngineContext(args) {
         snapshot: await hydrateSnapshot({
             client: client,
             clientForGdr: clientForGdr,
-            instance: instance
+            instance: instance,
+            ...args.overlay !== void 0 ? {
+                overlay: args.overlay
+            } : {}
         })
     };
 }
@@ -4767,10 +5278,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 selfGdr(ctx.instance);
@@ -4793,63 +5300,342 @@ function resolveGuardRead(args) {
     throw new Error(`Guard read "${expr}" is not a supported deploy-time value — use "$self", "$now", "$fields.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $fields or $effects)`);
 }
 
-function resolveIdRefTarget(expr, ctx) {
-    const value = resolveGuardRead({
-        expr: expr,
-        ctx: ctx,
-        deref: !1
-    });
-    if (typeof value == "string" && isGdrUri(value)) return {
-        parsed: parseGdr(value)
-    };
-    if (value && typeof value == "object") {
-        const v2 = value;
-        if (typeof v2.id == "string" && isGdrUri(v2.id)) return typeof v2.type == "string" ? {
-            parsed: parseGdr(v2.id),
-            type: v2.type
-        } : {
-            parsed: parseGdr(v2.id)
-        };
+function resolveIdRefTarget(expr, ctx) {
+    const value = resolveGuardRead({
+        expr: expr,
+        ctx: ctx,
+        deref: !1
+    });
+    if (typeof value == "string" && isGdrUri(value)) return {
+        parsed: parseGdr(value)
+    };
+    if (value && typeof value == "object") {
+        const v2 = value;
+        if (typeof v2.id == "string" && isGdrUri(v2.id)) return typeof v2.type == "string" ? {
+            parsed: parseGdr(v2.id),
+            type: v2.type
+        } : {
+            parsed: parseGdr(v2.id)
+        };
+    }
+    return null;
+}
+
+function resolveIdRefTargets(idRefs, ctx) {
+    const targets = [];
+    for (const expr of idRefs ?? []) {
+        const target = resolveIdRefTarget(expr, ctx);
+        if (target === null) return null;
+        targets.push(target);
+    }
+    return targets.length === 0 ? null : targets;
+}
+
+function assertSingleResource(targets) {
+    const resource = resourceFromParsed(targets[0].parsed);
+    for (const g of targets) {
+        const r = 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 (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} = 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 null;
+    return map.size === 0 ? doc : {
+        ...doc,
+        metadata: rewriteMetadata({
+            metadata: doc.metadata,
+            shapes: shapes,
+            map: map
+        })
+    };
 }
 
-function resolveIdRefTargets(idRefs, ctx) {
-    const targets = [];
-    for (const expr of idRefs ?? []) {
-        const target = resolveIdRefTarget(expr, ctx);
-        if (target === null) return null;
-        targets.push(target);
+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 targets.length === 0 ? null : targets;
+    return out;
 }
 
-function assertSingleResource(targets) {
-    const resource = resourceFromParsed(targets[0].parsed);
-    for (const g of targets) {
-        const r = 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 shapeOfRead(args) {
+    const fieldRead = FIELD_READ.exec(args.expr);
+    if (fieldRead !== null) return shapeOfFieldRead(args.instance, fieldRead);
+    const effectsRead = EFFECTS_READ.exec(args.expr);
+    if (effectsRead !== null) return shapeOfEffectsRead(args.definition, effectsRead);
 }
 
-function bareIdRefs(targets) {
-    return targets.flatMap(g => [ g.parsed.documentId, `drafts.${g.parsed.documentId}` ]);
+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 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 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 resolveMetadata(metadata, ctx) {
-    const out = {};
-    for (const [k, expr] of Object.entries(metadata ?? {})) out[k] = resolveGuardRead({
-        expr: expr,
-        ctx: ctx,
-        deref: !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 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" && 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;
 }
 
@@ -4885,151 +5671,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
@@ -5046,16 +5687,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({
@@ -5157,7 +5802,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);
@@ -5210,10 +5855,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
@@ -5239,7 +5883,9 @@ function resolvedStageGuards(args) {
         });
         resolved !== null && out.push({
             client: args.clientForGdr(resolved.routeGdr),
-            doc: resolved.doc
+            resourceKey: resourceGdr(resourceFromParsed(resolved.routeGdr)),
+            value: resolved.doc,
+            guard: guard
         });
     }
     return out;
@@ -5256,12 +5902,54 @@ function resolvedStageGuardRoutes(args) {
         const route = resolveGuardRoute(guard, ctx);
         route !== null && out.push({
             client: args.clientForGdr(route.routeGdr),
-            guardId: route.guardId
+            resourceKey: resourceGdr(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);
 }
@@ -5269,10 +5957,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,
@@ -5285,13 +5985,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,
@@ -5322,10 +6020,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;
 }
@@ -5391,7 +6090,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,
@@ -5411,7 +6111,8 @@ async function commitAbort({ctx: ctx, reason: reason, requestRecord: requestReco
     });
     return {
         fired: !0,
-        stage: stage.name
+        stage: stage.name,
+        instance: instance
     };
 }
 
@@ -6162,18 +6863,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: 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 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})`);
 }
@@ -6194,10 +6919,10 @@ class ActionDisabledError extends WorkflowError {
 
 class StartNotAllowedError extends 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;
     }
 }
 
@@ -6213,7 +6938,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(", ")}`
 };
 
@@ -6282,11 +7007,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,
@@ -6539,30 +7263,12 @@ async function fireTriggeredAction({ctx: ctx, mutation: mutation, activity: acti
     };
 }
 
-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);
+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 definition = parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
+    const ctx = await buildCascadeStepContext(args, instance), {definition: definition} = ctx, 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 = {
+    const now = ctx.now, discards = [], initialStageEntry = {
         _key: randomKey(),
         name: stage.name,
         enteredAt: now,
@@ -6631,29 +7337,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: parseDefinitionSnapshot(instance),
+        ...contextOptions
     });
     if (isTerminal(ctx)) return {
         moved: !1
@@ -6683,10 +7397,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,
@@ -6695,7 +7409,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,
@@ -6704,7 +7419,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,
@@ -6713,39 +7432,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 = toBareId(row.ref.id);
     try {
-        await abortInstance({
+        const result = await abortInstance({
             client: client,
             instanceId: childId,
             reason: row.abortPending?.reason ?? "condemned by parent",
@@ -6765,7 +7495,8 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
                     telemetry: telemetry
                 } : {}
             }
-        }), await drainCondemnedChildren({
+        });
+        await drainCondemnedChildren({
             client: client,
             instanceId: childId,
             actor: actor,
@@ -6774,7 +7505,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 InstanceNotFoundError) return;
@@ -6787,9 +7521,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 => toBareId(row.ref.id)), children = await client.fetch("*[_id in $ids]{_id, currentStage, completedAt, abortedAt, modelVersion, minReaderModel}", {
-        ids: ids
-    }), byId = new Map(children.map(c => [ assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
+    const now = (clock ?? wallClock)(), stamp = resolveExecutionContext(executionContext), ids = condemned.map(row => 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(toBareId(row.ref.id)), resolved = child !== void 0 ? terminalResolution(child) : {
             at: now,
@@ -6811,6 +7543,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 === 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 {
@@ -6833,28 +7575,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 = 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 => 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 => toBareId(r.ref.id) === child._id);
     if (row === void 0) {
         await recordOrphanedPropagation({
             ctx: ctx,
@@ -6869,29 +7601,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 = parentRef(child);
     if (parentGdr === void 0) return;
@@ -6902,6 +7616,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: 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 => 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 = parentRef(child);
+    if (expectedParent === void 0 || 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);
@@ -7037,36 +7828,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,
@@ -7074,11 +7843,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) ];
@@ -7206,24 +8014,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 checkFieldValue({
+function effectOutputCheck(shape, value) {
+    return parseFieldValue({
         entryType: shape.type,
         value: value,
         ...shape.fields !== void 0 ? {
@@ -7269,15 +8078,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}) {
@@ -7286,7 +8095,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,
@@ -7305,7 +8114,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;
@@ -7503,6 +8312,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 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 (!isTerminalActivityStatus(from)) throw new 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 = {}) {
@@ -7512,10 +8379,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 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 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
         } : {}
@@ -7525,7 +8395,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;
@@ -7552,27 +8422,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 || 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: ${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: ${errorMessage(err)}`,
+            cause: err
+        };
+    }
 }
 
 async function fetchGrantsCached(requestFn, resourcePath) {
@@ -7748,35 +8681,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 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: ${errorMessage(err)}`);
+        return;
+    }
+}
+
 async function evaluateInstance(args) {
     const {client: client, tag: tag, workflowResource: workflowResource, instanceId: instanceId, resourceClients: resourceClients} = args, now = (args.clock ?? wallClock)();
     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 = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = 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,
@@ -7785,6 +8731,9 @@ async function evaluateInstance(args) {
         guards: guards,
         now: now,
         resourceGrants: resourceGrants,
+        ...localPrincipalId !== void 0 ? {
+            localPrincipalId: localPrincipalId
+        } : {},
         ...grants !== void 0 ? {
             grants: grants
         } : {}
@@ -7840,9 +8789,12 @@ async function evaluateFromSnapshot(args) {
         definition: definition,
         snapshot: snapshot,
         now: now
-    }, can = await advisoryCan({
-        instance: instance,
+    }, anchorIdentity = lakePrincipalId({
         actor: actor,
+        localPrincipalId: args.localPrincipalId
+    }), can = await advisoryCan({
+        instance: instance,
+        identity: anchorIdentity,
         grants: grants
     }), scope = await renderConditionScope(scopeSource, {
         actor: actor,
@@ -7859,11 +8811,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 ? {
@@ -8007,20 +8958,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(resourceGdr(resource));
-        if (grants === void 0) continue;
+        const access = resourceGrants.get(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: resourceGdr(resource),
@@ -8101,12 +9052,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
@@ -8252,12 +9203,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",
@@ -8296,24 +9247,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 (!isGdrUri(document)) throw new 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(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 (isGdrUri(id)) throw new 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";
     }
 }
 
@@ -8727,11 +9678,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: {
@@ -9089,8 +10039,7 @@ async function abortAndPropagate(args) {
             executionContext: executionContext,
             telemetry: telemetry
         })
-    });
-    return await drainCondemnedChildren({
+    }), drained = await drainCondemnedChildren({
         client: client,
         instanceId: instanceId,
         actor: actor,
@@ -9102,8 +10051,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,
@@ -9115,6 +10068,9 @@ async function abortAndPropagate(args) {
         } : {},
         ...telemetry !== void 0 ? {
             telemetry: telemetry
+        } : {},
+        ...result.fired && !drained.drained ? {
+            instance: drained.instance
         } : {}
     }), result.fired;
 }
@@ -9222,6 +10178,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
         } : {},
@@ -9363,6 +10322,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 && 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,
@@ -9370,7 +10338,7 @@ async function fetchStartSlice(args) {
             includeCompleted: !0
         }
     });
-    return (await client.fetch(query, params)).map(assertReadableModel);
+    return (await client.fetch(query, params)).map(assertReadableModel).map(projectStartSliceRow);
 }
 
 const workflow = {
@@ -9519,6 +10487,9 @@ const workflow = {
                         ...access.grants !== void 0 ? {
                             grants: access.grants
                         } : {},
+                        ...access.localPrincipalId !== void 0 ? {
+                            localPrincipalId: access.localPrincipalId
+                        } : {},
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
@@ -9587,6 +10558,9 @@ const workflow = {
                         ...access.grants !== void 0 ? {
                             grants: access.grants
                         } : {},
+                        ...access.localPrincipalId !== void 0 ? {
+                            localPrincipalId: access.localPrincipalId
+                        } : {},
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
@@ -9746,7 +10720,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
@@ -9754,7 +10728,7 @@ const workflow = {
         await assertInstanceWriteAllowed({
             instance: current,
             guards: guards,
-            identity: actor.id
+            identity: lakePrincipalId(access)
         });
         const {cascaded: cascaded, instance: instance} = await cascadeAndReload({
             client: client,
@@ -9871,6 +10845,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 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 validateTag(tag), reload({
@@ -10017,21 +11044,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;
         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(assertReadableModel), latest = latestDeployedDefinitions(deployed);
+        })).map(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
@@ -10054,34 +11078,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
         };
@@ -10093,11 +11100,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
@@ -10105,12 +11111,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(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) {
@@ -10210,19 +11275,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
     });
 }
 
@@ -10255,97 +11317,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 WorkflowError {
@@ -10524,7 +11495,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
@@ -10890,22 +11861,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 = () => 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 = gdrFromResource(owned.resource, owned.doc._id);
-            if (uri === selfUri()) {
-                const rawStamp = owned.doc._updatedAt;
-                !isParseableInstant(rawStamp) || owned.doc._type !== 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 = () => gdrFromResource(instance.workflowResource, instance._id), applyDocument = (ld, target) => {
+        const owned = {
+            doc: structuredClone(ld.doc),
+            resource: ld.resource
+        }, uri = gdrFromResource(owned.resource, owned.doc._id);
+        if (uri === selfUri()) {
+            const rawStamp = owned.doc._updatedAt;
+            !isParseableInstant(rawStamp) || owned.doc._type !== 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
@@ -10963,17 +11942,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()
             } : {},
@@ -11019,8 +12004,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;
@@ -11031,6 +12021,12 @@ function createInstanceSession(args) {
                     deferredUpdateError = err;
                 }
             }
+            for (const next of bufferedDocuments.values()) try {
+                applyDocumentUpdate(next);
+            } catch (err) {
+                deferredUpdateError = err;
+            }
+            bufferedDocuments.clear();
         }
     };
     return {
@@ -11038,15 +12034,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 = 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)));
@@ -11078,11 +12085,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: lakePrincipalId({
+                        actor: actor,
+                        localPrincipalId: localPrincipalId
+                    })
                 });
                 const before = await reload({
                     client: tickScope.client,
@@ -11109,7 +12119,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,
@@ -11125,6 +12135,9 @@ function createInstanceSession(args) {
                     activity: activity,
                     action: action,
                     actor: actor,
+                    ...localPrincipalId !== void 0 ? {
+                        localPrincipalId: localPrincipalId
+                    } : {},
                     clientForGdr: fireScope.clientForGdr,
                     refSurface: fireScope.refSurface,
                     ...grants !== void 0 ? {
@@ -11167,7 +12180,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,
@@ -11184,6 +12197,9 @@ function createInstanceSession(args) {
                         value: value
                     } : {},
                     actor: actor,
+                    ...localPrincipalId !== void 0 ? {
+                        localPrincipalId: localPrincipalId
+                    } : {},
                     clientForGdr: editScope.clientForGdr,
                     refSurface: editScope.refSurface,
                     ...grants !== void 0 ? {
@@ -11294,6 +12310,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),
@@ -11860,4 +12877,4 @@ function displayDescription(typeKey) {
     if (typeKey) return DISPLAY[typeKey]?.description;
 }
 
-export { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTIVITY_KIND_DISPLAY, ACTOR_KINDS, AUTHORING_DISPLAY, ActionDisabledError, ActionParamsInvalidError, CONDITION_VARS, CONTEXT_ENTRY_DISPLAY, CascadeLimitError, ConcurrentCommitEffectOpsError, ConcurrentCompleteEffectError, ConcurrentEditFieldError, ConcurrentFireActionError, ContractViolationError, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_CONTENT_PERSPECTIVE, DEFAULT_EFFECT_LEASE_MS, DEFAULT_IDEMPOTENCY_TTL_MS, DEFAULT_TRANSITION_WHEN, DISPLAY, DRIVER_KINDS, DRIVER_KIND_DISPLAY, DefinitionInUseError, DefinitionNotFoundError, EFFECT_COMMIT_DISPATCH_CAP, EFFECT_COMMIT_QUEUE_DEPTH, ENGINE_API_VERSION, EXECUTION_KINDS, EXECUTOR_CLASSIFICATIONS, EXECUTOR_CLASSIFICATION_DISPLAY, EditFieldDeniedError, EffectCommitQueueOverflowError, EffectNotFoundError, EffectOpsInvalidError, EffectOutputsInvalidError, FIELD_KIND_DISPLAY, FILTER_SCOPE_VARS, FieldValueShapeError, GROUP_KINDS, GROUP_KIND_DISPLAY, GUARD_DOC_TYPE, GUARD_OWNER, GUARD_PREDICATE_VARS, HISTORY_DISPLAY, InitialFieldsInvalidError, InstanceNotFoundError, MAX_COUNTERFACTUAL_INDEX2 as MAX_COUNTERFACTUAL_INDEX, MissingHandlerError, ModelVersionAheadError, MutationGuardDeniedError, MutationGuardDocSchema, OP_DISPLAY, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, START_ALLOWED_VARS, START_FILTER_VARS, SpawnContractsInvalidError, StaleEffectClaimError, StartNotAllowedError, StartNotPrimedError, StartNotSettledError, WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, WorkflowActionFired, WorkflowDefinitionDeleted, WorkflowDefinitionDeployed, WorkflowEffectCompleted, WorkflowEffectStateReported, WorkflowEffectsDrained, WorkflowError, WorkflowFieldEdited, WorkflowInstanceAborted, WorkflowInstanceSchema, WorkflowInstanceStarted, WorkflowInstanceTicked, WorkflowStageSet, WorkflowStageTransitioned, WorkflowStateDivergedError, abortReason, acceptsDocumentType, aclPathForResource, actionDisabledDetail, actionRendering, actionVerdict, activityAutonomyOf, analyzeCondition2 as analyzeCondition, applicableDefinitions, assertReadableModel, assertReaderModelAcknowledgement, atomReadsDataset2 as atomReadsDataset, autonomySummary, availableActions, buildInitialFields, buildSnapshot, checklistLines, clientConfigFromResource, clientProjectUserDirectory, compileGuard, computeDiffEntries, conditionFieldReadNames, conditionSitesOf, contentDocQuery, contentDraftFallback, contentReleaseName, contextMap, createEngine, createTelemetryIntake, datasetResourceParts, defaultLoggerFactory, definitionDeployedData, definitionLookupGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartAllowed, extractDocumentId, fieldTreeShape, findCurrentActivityEntry, findOpenStageEntry, formatRead, gdrFromResource, gdrRef, gdrUri, groupMembershipNames, groupSitesOf, guardMatches, guardsForDefinition, guardsForInstance, guardsForResource, guillemets2 as guillemets, hashDefinitionContent, humanize2 as humanize, inFlightFilter, initialFieldIssues, instanceDocId, instanceGuardQuery, instanceWatchesDocument, instancesQuery, isCascadeFired, isClaimExpired, isComparisonOp, isDefinitionApplicable, isFilterScopedOut, isGdr, isInputSourced, isNotesEntry, isProjectUserNotFoundError, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseGdr, parseGuardDocument, parseInstanceDocument, parseResourceGdr, processShellUserProperties, projectToWatchRef, quoted2 as quoted, readInstanceDoc, readsRaw, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, refsOf, rejectedRefTypes, releaseDocId, releaseRef, remediationsFor, requiredModelFeatures, requiredReaderModel, resolveAccess, resolveActor, resolveClientActor, resolveFieldEntry$1 as resolveFieldEntry, resourceAliasesToMap, resourceFromParsed, resourceGdr, retractStageGuards, sameResource, scalarValidationIssues, schemaTreeShape, sentenceCase, silentLogger, stageAutonomyOf, startFieldsParam, startKindOf, startRefusal, stripSystemFields, subjectDenialLabels, subscriptionDocument, subscriptionDocumentsForInstance, sweepStaleClaims, tagScopeFilter, terminalState, toBareId, tryParseGdr, unboundAllowedReads, unsatisfiedTransitionSummaries, validateDefinition, validateTag, verdictGuardsForInstance, wallClock, whatIfCondition2 as whatIfCondition, withAssignment, workflow };
+export { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTIVITY_KIND_DISPLAY, ACTOR_KINDS, ANONYMOUS_IDENTITY, AUTHORING_DISPLAY, ActionDisabledError, ActionParamsInvalidError, CONDITION_VARS, CONTEXT_ENTRY_DISPLAY, CascadeLimitError, ConcurrentCommitEffectOpsError, ConcurrentCompleteEffectError, ConcurrentEditFieldError, ConcurrentFireActionError, ContractViolationError, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_CONTENT_PERSPECTIVE, DEFAULT_EFFECT_LEASE_MS, DEFAULT_IDEMPOTENCY_TTL_MS, DEFAULT_TRANSITION_WHEN, DISPLAY, DRIVER_KINDS, DRIVER_KIND_DISPLAY, DefinitionInUseError, DefinitionNotFoundError, EFFECT_COMMIT_DISPATCH_CAP, EFFECT_COMMIT_QUEUE_DEPTH, ENGINE_API_VERSION, EXECUTION_KINDS, EXECUTOR_CLASSIFICATIONS, EXECUTOR_CLASSIFICATION_DISPLAY, EditFieldDeniedError, EffectCommitQueueOverflowError, EffectNotFoundError, EffectOpsInvalidError, EffectOutputsInvalidError, FIELD_KIND_DISPLAY, FILTER_SCOPE_VARS, FieldValueShapeError, GROUP_KINDS, GROUP_KIND_DISPLAY, GUARD_DOC_TYPE, GUARD_OWNER, GUARD_PREDICATE_VARS, HISTORY_DISPLAY, InitialFieldsInvalidError, InstanceNotFoundError, MAX_COUNTERFACTUAL_INDEX2 as MAX_COUNTERFACTUAL_INDEX, MissingHandlerError, ModelVersionAheadError, MutationGuardDeniedError, MutationGuardDocSchema, OP_DISPLAY, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, START_FILTER_VARS, START_REQUIREMENT_VARS, SYSTEM_IDENTITY, SpawnContractsInvalidError, StaleEffectClaimError, StartNotAllowedError, StartNotPrimedError, StartNotSettledError, WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, WorkflowActionFired, WorkflowActivityReset, WorkflowDefinitionDeleted, WorkflowDefinitionDeployed, WorkflowEffectCompleted, WorkflowEffectStateReported, WorkflowEffectsDrained, WorkflowError, WorkflowFieldEdited, WorkflowInstanceAborted, WorkflowInstanceSchema, WorkflowInstanceStarted, WorkflowInstanceTicked, WorkflowStageSet, WorkflowStageTransitioned, WorkflowStateDivergedError, abortReason, acceptsDocumentType, aclPathForResource, actionDisabledDetail, actionRendering, actionVerdict, activityAutonomyOf, analyzeCondition2 as analyzeCondition, applicableDefinitions, assertReadableModel, assertReaderModelAcknowledgement, atomReadsDataset2 as atomReadsDataset, autonomySummary, availableActions, buildInitialFields, buildSnapshot, checklistLines, classifyPrincipalId, clientConfigFromResource, clientProjectUserDirectory, compileGuard, computeDiffEntries, conditionFieldReadNames, conditionSitesOf, contentDocQuery, contentDraftFallback, contentReleaseName, contextMap, createEngine, createTelemetryIntake, datasetResourceParts, defaultLoggerFactory, definitionDeployedData, definitionLookupGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartRequirement, extractDocumentId, fieldTreeShape, findCurrentActivityEntry, findOpenStageEntry, formatRead, gdrFromResource, gdrRef, gdrUri, groupMembershipNames, groupSitesOf, guardMatches, guardsForDefinition, guardsForInstance, guardsForResource, guillemets2 as guillemets, hasSingleSubjectRequirement, hashDefinitionContent, humanize2 as humanize, inFlightFilter, initialFieldIssues, instanceDocId, instanceGuardQuery, instanceWatchesDocument, instancesGuardQuery, instancesQuery, isCascadeFired, isClaimExpired, isClientProjectUser, isComparisonOp, isDefinitionApplicable, isFilterScopedOut, isGdr, isInputSourced, isNotesEntry, isProjectUserNotFoundError, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, lakePrincipalId, latestDefinitionsGroq, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseGdr, parseGuardDocument, parseInstanceDocument, parseResourceGdr, processShellUserProperties, projectStartSliceRow, projectToWatchRef, quoted2 as quoted, readInstanceDoc, readsRaw, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, refsOf, rejectedRefTypes, releaseDocId, releaseRef, remediationsFor, requiredModelFeatures, requiredReaderModel, resolveAccess, resolveActor, resolveClientActor, resolveFieldEntry$1 as resolveFieldEntry, resourceAliasesToMap, resourceFromParsed, resourceGdr, retractStageGuards, sameResource, scalarValidationIssues, schemaTreeShape, sentenceCase, silentLogger, singleSubjectRequirementRefused, stageAutonomyOf, startFieldsParam, startKindOf, startRefusal, stripSystemFields, subjectDenialLabels, subscriptionDocument, subscriptionDocumentsForInstance, sweepStaleClaims, tagScopeFilter, terminalState, toBareId, tryParseGdr, unboundRequirementReads, unsatisfiedTransitionSummaries, validateDefinition, validateTag, verdictGuardsForInstance, wallClock, whatIfCondition2 as whatIfCondition, withAssignment, workflow };