@sanity/workflow-engine 0.29.0 → 0.31.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { rethrowWithContext, andConditions, deriveActivityKind, WorkflowError, CALLER_BOUND_VARS, START_REQUIREMENT_VARS, CONDITION_VARS, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, isGdr, errorMessage, conditionParameterNames, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, actorFulfillsRole, toBareId, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, isAlwaysArrayFieldKind, evaluateCondition, isSingleDocRefEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, 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, directoryBridgeId, InstanceNotFoundError, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, lakePrincipalId, firstCarriedGlobalId, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, DefinitionInUseError, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
+import { rethrowWithContext, andConditions, deriveActivityKind, CALLER_BOUND_VARS, START_REQUIREMENT_VARS, CONDITION_VARS, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, isGdr, errorMessage, conditionParameterNames, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, actorFulfillsRole, toBareId, WorkflowError, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, isAlwaysArrayFieldKind, evaluateCondition, isRecord, isSingleDocRefEntry, isAssignmentFieldEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, assignmentKindAcceptsRoles, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, classifyPrincipalId, directoryBridgeId, parseGdr, isGdrUri, gdrRef, isInputSourced, parseFieldValue, VersionSpecificDatasetGdrError, toPhysicalGdr, isBareSeedId, NonEmptyString, tolerantEntries, FIELD_VALUE_KINDS, tolerantObject, ActorShape, IsoTimestamp, ACTIVITY_STATUSES, GdrShape, DRIVER_KINDS, FIELD_SCOPES, fieldValueSchemas, parsePersistedDoc, ACTOR_KINDS, InstanceNotFoundError, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, lakePrincipalId, firstCarriedGlobalId, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, DefinitionInUseError, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
 
 import { ACTION_SEMANTICS, ACTIVITY_KINDS, ANONYMOUS_IDENTITY, DECISION_SEMANTICS, DEFAULT_TRANSITION_WHEN, EXECUTOR_CLASSIFICATIONS, FILTER_SCOPE_VARS, GROUP_KINDS, GUARD_PREDICATE_VARS, PersistedDocShapeError, RESERVED_CONDITION_VARS, SIGNAL_SEMANTICS, SYSTEM_IDENTITY, clientConfigFromResource, gdrUri, isNotesEntry, isTodoListEntry, isTodoListItem, parseResourceGdr, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, releaseDocId, releaseRef, resourceAliasesToMap, schemaTreeShape, startKindOf } from "./_chunks-es/invariants.js";
 
@@ -130,6 +130,9 @@ function resolveFieldSite(site, stage) {
         ...site.entry.validation !== void 0 ? {
             validation: site.entry.validation
         } : {},
+        ...site.entry.roles !== void 0 ? {
+            roles: site.entry.roles
+        } : {},
         ref: {
             scope: site.scope,
             field: site.entry.name
@@ -266,58 +269,58 @@ function resolveTelemetry(telemetry) {
 }
 
 const HIGH_FREQUENCY_SAMPLE_MS = 6e4, WorkflowDefinitionDeployed = defineWorkflowEvent({
-    name: "Editorial Workflows Definition Deployed",
+    name: "Workflows Definition Deployed",
     version: 1,
     description: "A definition went through a deploy — status distinguishes a newly minted version from an unchanged redeploy"
 }), WorkflowInstanceStarted = defineWorkflowEvent({
-    name: "Editorial Workflows Instance Started",
+    name: "Workflows Instance Started",
     version: 1,
     description: "A workflow instance was started from a deployed definition"
 }), WorkflowStageTransitioned = defineWorkflowEvent({
-    name: "Editorial Workflows Stage Transitioned",
+    name: "Workflows Stage Transitioned",
     version: 1,
     description: "A committed stage move — one event per hop, cascades included, whichever verb drove it. Unsampled: funnel and dwell reads need complete counts, and volume is bounded by actual movement"
 }), WorkflowActionFired = defineWorkflowEvent({
-    name: "Editorial Workflows Action Fired",
+    name: "Workflows Action Fired",
     version: 1,
     description: "An action was fired against an activity"
 }), WorkflowFieldEdited = defineWorkflowEvent({
-    name: "Editorial Workflows Field Edited",
+    name: "Workflows Field Edited",
     version: 1,
     description: "A declared-editable field was edited through the generic edit seam",
     maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
 }), WorkflowInstanceTicked = defineWorkflowEvent({
-    name: "Editorial Workflows Instance Ticked",
+    name: "Workflows Instance Ticked",
     version: 1,
     description: "An instance was re-evaluated for auto-transitions and due waits",
     maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
 }), WorkflowEffectsDrained = defineWorkflowEvent({
-    name: "Editorial Workflows Effects Drained",
+    name: "Workflows Effects Drained",
     version: 1,
     description: "A drain pass ran — drainedCount/drainedEffects report the successful dispatches. Unsampled when non-empty (outcome counts must be complete; volume is bounded by real effect work); empty polls are machine-cadence noise, throttled engine-side to at most one per minute"
 }), WorkflowEffectStateReported = defineWorkflowEvent({
-    name: "Editorial Workflows Effect State Reported",
+    name: "Workflows Effect State Reported",
     version: 1,
     description: "A running effect handler committed mid-dispatch field state through commitEffectOps. Sampled (high-frequency by design — a dispatch may report many times): an adoption and usage signal, not an exact per-run report count",
     maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
 }), WorkflowEffectCompleted = defineWorkflowEvent({
-    name: "Editorial Workflows Effect Completed",
+    name: "Workflows Effect Completed",
     version: 1,
-    description: "An effect outcome was recorded — reported directly through completeEffect, or cancelled by the abort verb (external runtimes; engine-drained effects surface via Editorial Workflows Effects Drained instead — each outcome counts once)"
+    description: "An effect outcome was recorded — reported directly through completeEffect, or cancelled by the abort verb (external runtimes; engine-drained effects surface via Workflows Effects Drained instead — each outcome counts once)"
 }), WorkflowInstanceAborted = defineWorkflowEvent({
-    name: "Editorial Workflows Instance Aborted",
+    name: "Workflows Instance Aborted",
     version: 1,
     description: "The abort admin override was invoked (changed: false = instance already terminal)"
 }), WorkflowStageSet = defineWorkflowEvent({
-    name: "Editorial Workflows Stage Set",
+    name: "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",
+    name: "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",
+    name: "Workflows Definition Deleted",
     version: 1,
     description: "A deployed definition (or one version of it) was removed via the admin verb"
 });
@@ -435,438 +438,131 @@ function fieldEditedData(args) {
     };
 }
 
-const DATA_MODEL_VERSION = 7, DATA_MODEL_MIN_READER = 4, READER_MODEL_ROLLOUT_URL = "https://www.sanity.io/docs/editorial-workflows/prerelease";
+function effectSites(def) {
+    const sites = [];
+    for (const stage of def.stages ?? []) for (const activity of stage.activities ?? []) for (const action of activity.actions ?? []) for (const effect of action.effects ?? []) sites.push({
+        effect: effect,
+        location: `stage[${stage.name}].activity[${activity.name}].action[${action.name}].effects`
+    });
+    return sites;
+}
 
-class ReaderModelAcknowledgementError extends WorkflowError {
-    code="WORKFLOW_READER_MODEL_ACKNOWLEDGEMENT_MISMATCH";
-    expectedMinReaderModel;
-    engineMinReaderModel=DATA_MODEL_MIN_READER;
-    engineModelVersion=DATA_MODEL_VERSION;
-    documentationUrl=READER_MODEL_ROLLOUT_URL;
-    constructor(expectedMinReaderModel, context = "Deployment") {
-        const expected = expectedMinReaderModel === void 0 ? "missing" : String(expectedMinReaderModel);
-        super("reader-model-acknowledgement", `${context} expected reader floor ${expected}; the installed engine requires acknowledgement ${DATA_MODEL_MIN_READER}.\nDo not change the acknowledgement yet: accepting ${DATA_MODEL_MIN_READER} authorizes this engine to write documents that older readers will refuse.\nUpgrade every Studio, CLI, MCP server, Function, and other runtime that reads engine-owned documents; verify that rollout in every environment sharing the workflow resource; then change the literal in deployment configuration and deploy the writer.\nRollout guide: ${READER_MODEL_ROLLOUT_URL}`), 
-        this.name = "ReaderModelAcknowledgementError", this.expectedMinReaderModel = expectedMinReaderModel;
-    }
+function findEffect(def, name) {
+    return effectSites(def).find(site => site.effect.name === name)?.effect;
 }
 
-function assertReaderModelAcknowledgement(expectedMinReaderModel, context) {
-    if (typeof expectedMinReaderModel != "number" || !Number.isFinite(expectedMinReaderModel) || !Number.isInteger(expectedMinReaderModel) || expectedMinReaderModel < 0 || expectedMinReaderModel !== DATA_MODEL_MIN_READER) throw new ReaderModelAcknowledgementError(expectedMinReaderModel, context);
+function rolesGateOf(atom) {
+    const node = atomNode(atom);
+    if (atom.negated || node.type !== "OpCall" || node.op !== ">" || node.right.type !== "Value" || node.right.value !== 0) return;
+    const count = node.left;
+    if (!(count.type !== "FuncCall" || count.name !== "count" || count.args.length !== 1)) return rolesFilterList(count.args[0]);
 }
 
-const DATA_MODEL_CHANGES = Object.freeze([ Object.freeze({
-    id: "governed-model-stamps",
-    introducedInModel: 1,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "additive",
-    applicability: "unconditional",
-    summary: "Definition and instance documents carry model provenance and reader-floor stamps."
-}), Object.freeze({
-    id: "subject-field-kind",
-    introducedInModel: 2,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "A workflow-level subject field identifies the document a workflow is about."
-}), Object.freeze({
-    id: "typed-scalar-choice-lists",
-    introducedInModel: 2,
-    minReaderModel: 2,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "reader-floor",
-    applicability: "detectable",
-    summary: "Scalar fields may constrain writes to a persisted typed choice list."
-}), Object.freeze({
-    id: "action-semantics",
-    introducedInModel: 2,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "Ordinary actions may carry advisory workflow semantics."
-}), Object.freeze({
-    id: "inclusive-scalar-bounds",
-    introducedInModel: 2,
-    minReaderModel: 2,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "reader-floor",
-    applicability: "detectable",
-    summary: "String, text, and number values may carry persisted inclusive bounds."
-}), Object.freeze({
-    id: "progress-field-kind",
-    introducedInModel: 3,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "A progress field kind carries application-defined 0–100 completion."
-}), Object.freeze({
-    id: "effect-claim-tokens",
-    introducedInModel: 3,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "instance" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "Pending-effect claims carry an exact-claim token gating mid-dispatch state reports."
-}), Object.freeze({
-    id: "classified-principal-ids",
-    introducedInModel: 4,
-    minReaderModel: 4,
-    documentTypes: Object.freeze([ "instance" ]),
-    compatibility: "reader-floor",
-    applicability: "unconditional",
-    summary: "Principal ids are namespace-classified: actor and assignee writes carry the account-global user id only, and readers resolve legacy project-scoped ids through the prefix classifier at the instance read funnel."
-}), Object.freeze({
-    id: "readiness-requirements",
-    introducedInModel: 4,
-    minReaderModel: 4,
-    documentTypes: Object.freeze([ "definition" ]),
-    compatibility: "reader-floor",
-    applicability: "detectable",
-    summary: "Start and activity readiness use named polymorphic requirement arrays."
-}), Object.freeze({
-    id: "due-date-field-kinds",
-    introducedInModel: 5,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "Due-date field kinds (dueDate, dueDatetime) mark a level deadline, elevated aliases of date/datetime carrying the same stored value."
-}), Object.freeze({
-    id: "node-semantics",
-    introducedInModel: 6,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "Workflow, stage, activity, and action nodes may carry signal or custom advisory semantics."
-}), Object.freeze({
-    id: "field-patch-ops",
-    introducedInModel: 6,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition", "instance" ]),
-    compatibility: "additive",
-    applicability: "detectable",
-    summary: "Field ops may increment, decrement, or initialize a missing field value."
-}), Object.freeze({
-    id: "attributes-condition-var",
-    introducedInModel: 7,
-    minReaderModel: 0,
-    documentTypes: Object.freeze([ "definition" ]),
-    compatibility: "additive",
-    applicability: "unconditional",
-    summary: "Caller-bound $attributes condition variable binds the acting token's org-level User Attributes (advisory; absent when unavailable)."
-}) ]);
+function rolesFilterList(node) {
+    if (node.type !== "Filter") return;
+    const base = node.base;
+    if (!(base.type === "AccessAttribute" && base.name === "roles" && base.base?.type === "Parameter" && base.base.name === "actor")) return;
+    const expr = node.expr;
+    if (expr.type !== "OpCall" || expr.op !== "in" || expr.left.type !== "This" || expr.right.type !== "Array") return;
+    const roles = expr.right.elements.flatMap(element => !element.isSplat && element.value.type === "Value" && typeof element.value.value == "string" ? [ element.value.value ] : []);
+    if (roles.length === expr.right.elements.length) return roles;
+}
 
-function recordOf(value) {
-    return value !== null && typeof value == "object" && !Array.isArray(value) ? value : void 0;
+function deriveWorkflowAutonomy(definition, options = {}) {
+    return workflowAutonomy({
+        definition: definition,
+        children: options.children ?? /* @__PURE__ */ new Map,
+        lineage: /* @__PURE__ */ new Set
+    });
 }
 
-function recordsAt(record, key) {
-    const value = record[key];
-    return Array.isArray(value) ? value.map(recordOf).filter(item => item !== void 0) : [];
+function stageAutonomyOf(autonomy, stageName) {
+    const stage = autonomy.stages.find(candidate => candidate.stage === stageName);
+    if (stage === void 0) throw new Error(`Autonomy rollup is missing stage "${stageName}"`);
+    return stage;
 }
 
-function nestedFieldEntries(entries) {
-    return entries.flatMap(entry => [ entry, ...nestedFieldEntries(recordsAt(entry, "fields")), ...nestedFieldEntries(recordsAt(entry, "of")) ]);
+function activityAutonomyOf(stageAutonomy2, activityName) {
+    const answer = stageAutonomy2.activities[activityName];
+    if (answer === void 0) throw new Error(`Autonomy rollup is missing activity "${activityName}" in stage "${stageAutonomy2.stage}"`);
+    return answer;
 }
 
-function parsedDefinitionSnapshot(root) {
-    if (typeof root.definitionSnapshot == "string") return recordOf(parseDefinitionSnapshotValue({
-        _id: typeof root._id == "string" ? root._id : "<unknown instance>",
-        definitionSnapshot: root.definitionSnapshot
-    }));
+const AUTONOMOUS = {
+    completesWithoutCaller: "yes",
+    waitsOn: []
+}, UNDECIDABLE = {
+    completesWithoutCaller: "conditional",
+    waitsOn: []
+}, CALLER = {
+    completesWithoutCaller: "no",
+    waitsOn: []
+}, VERDICT_RANK = {
+    yes: 0,
+    conditional: 1,
+    no: 2
+};
+
+function allOf(deps) {
+    return {
+        completesWithoutCaller: deps.map(dep => dep.completesWithoutCaller).reduce((worst, verdict) => VERDICT_RANK[verdict] > VERDICT_RANK[worst] ? verdict : worst, "yes"),
+        waitsOn: mergeWaits(deps)
+    };
 }
 
-function persistedDefinitionTree(document) {
-    const root = recordOf(document);
-    if (root === void 0) return;
-    const snapshot = parsedDefinitionSnapshot(root), roots = snapshot === void 0 ? [ root ] : [ root, snapshot ], {stages: stages, activities: activities, actions: actions} = definitionDescendants(roots);
+function anyOf(deps) {
+    const [first, ...rest] = deps;
+    if (first === void 0) throw new Error("anyOf needs at least one route — callers guard empties");
     return {
-        roots: roots,
-        stages: stages,
-        activities: activities,
-        actions: actions
+        completesWithoutCaller: rest.every(dep => dep.completesWithoutCaller === first.completesWithoutCaller) ? first.completesWithoutCaller : "conditional",
+        waitsOn: mergeWaits(deps)
     };
 }
 
-function persistedFieldEntries(document) {
-    const tree = persistedDefinitionTree(document);
-    if (tree === void 0) return [];
-    const {roots: roots, stages: stages, activities: activities, actions: actions} = tree, effects = actions.flatMap(action => recordsAt(action, "effects"));
-    return nestedFieldEntries([ ...roots.flatMap(candidate => recordsAt(candidate, "fields")), ...stages.flatMap(stage => recordsAt(stage, "fields")), ...activities.flatMap(activity => recordsAt(activity, "fields")), ...actions.flatMap(action => recordsAt(action, "params")), ...effects.flatMap(effect => recordsAt(effect, "outputs")) ]);
+function mergeWaits(deps) {
+    return dedupeBy(deps.flatMap(dep => dep.waitsOn), wait => JSON.stringify(wait));
 }
 
-function definitionDescendants(roots) {
-    const stages = roots.flatMap(root => recordsAt(root, "stages")), activities = stages.flatMap(stage => recordsAt(stage, "activities")), actions = activities.flatMap(activity => recordsAt(activity, "actions"));
+function analysisCtx(args) {
+    const memo = /* @__PURE__ */ new Map, visiting = /* @__PURE__ */ new Set;
     return {
-        stages: stages,
-        activities: activities,
-        actions: actions
+        ...args,
+        memoized: (key, compute) => {
+            const hit = memo.get(key);
+            if (hit !== void 0) return hit;
+            if (visiting.has(key)) return UNDECIDABLE;
+            visiting.add(key);
+            try {
+                const answer = compute();
+                return memo.set(key, answer), answer;
+            } finally {
+                visiting.delete(key);
+            }
+        }
     };
 }
 
-function hasChoiceList(document) {
-    return persistedFieldEntries(document).some(entry => {
-        const options = recordOf(entry.options);
-        return options !== void 0 && Array.isArray(options.list);
-    });
-}
-
-function hasFieldKind(document, kind) {
-    return persistedFieldEntries(document).some(entry => entry.type === kind || entry._type === kind);
+function workflowAutonomy(args) {
+    const ctx = analysisCtx({
+        definition: args.definition,
+        children: args.children,
+        lineage: /* @__PURE__ */ new Set([ ...args.lineage, args.definition.name ])
+    }), stages = ctx.definition.stages.map(stage => stageAutonomy(stage, ctx));
+    return {
+        ...allOf(stages),
+        stages: stages
+    };
 }
 
-function definitionNodes(document) {
-    const root = recordOf(document);
-    if (root !== void 0) return {
-        root: root,
-        ...definitionDescendants([ root ])
-    };
-}
-
-function hasActionSemantics(document) {
-    return definitionNodes(document)?.actions.some(hasSemantics) ?? !1;
-}
-
-function hasNodeSemantics(document) {
-    const nodes = definitionNodes(document);
-    return nodes === void 0 ? !1 : [ nodes.root, ...nodes.stages, ...nodes.activities ].some(hasSemantics) ? !0 : nodes.actions.some(action => hasSemantics(action) && action.semantics.some(isNodeSemanticValue));
-}
-
-function isNodeSemanticValue(semantic) {
-    return typeof semantic == "string" && (semantic.startsWith("signal.") || semantic.startsWith("custom."));
-}
-
-function hasSemantics(node) {
-    return Array.isArray(node.semantics);
-}
-
-function hasPersistedOpType(document, types) {
-    const tree = persistedDefinitionTree(document);
-    return tree === void 0 ? !1 : tree.actions.flatMap(action => recordsAt(action, "ops")).some(op => typeof op.type == "string" && types.includes(op.type)) ? !0 : tree.roots.some(root => recordsAt(root, "history").some(entry => entry._type === "opApplied" && typeof entry.opType == "string" && types.includes(entry.opType)));
-}
-
-function hasScalarValidation(document) {
-    return persistedFieldEntries(document).some(entry => {
-        const validation = recordOf(entry.validation);
-        return typeof validation?.min == "number" || typeof validation?.max == "number";
-    });
-}
-
-function hasClaimTokens(document) {
-    const root = recordOf(document);
-    return root === void 0 ? !1 : recordsAt(root, "pendingEffects").some(entry => {
-        const claim = recordOf(entry.claim);
-        return claim !== void 0 && typeof claim.claimToken == "string";
-    });
-}
-
-function hasReadinessRequirements(document) {
-    const root = recordOf(document);
-    return root === void 0 ? !1 : Array.isArray(recordOf(root.start)?.requirements) ? !0 : recordsAt(root, "stages").some(stage => recordsAt(stage, "activities").some(activity => Array.isArray(activity.requirements)));
-}
-
-const featureDetectors = {
-    "governed-model-stamps": () => !0,
-    "subject-field-kind": document => hasFieldKind(document, "subject"),
-    "typed-scalar-choice-lists": hasChoiceList,
-    "action-semantics": hasActionSemantics,
-    "inclusive-scalar-bounds": hasScalarValidation,
-    "progress-field-kind": document => hasFieldKind(document, "progress"),
-    "effect-claim-tokens": hasClaimTokens,
-    "classified-principal-ids": () => !0,
-    "readiness-requirements": hasReadinessRequirements,
-    "due-date-field-kinds": document => hasFieldKind(document, "dueDate") || hasFieldKind(document, "dueDatetime"),
-    "node-semantics": hasNodeSemantics,
-    "field-patch-ops": document => hasPersistedOpType(document, [ "field.inc", "field.dec", "field.setIfMissing" ]),
-    "attributes-condition-var": () => !0
-};
-
-function requiredModelFeatures(documentType, document) {
-    return DATA_MODEL_CHANGES.filter(change => change.documentTypes.some(candidate => candidate === documentType) && featureDetectors[change.id](document));
-}
-
-function requiredReaderModel(documentType, document) {
-    return Math.max(0, ...requiredModelFeatures(documentType, document).map(change => change.minReaderModel));
-}
-
-function modelStampFor(args) {
-    return {
-        modelVersion: DATA_MODEL_VERSION,
-        minReaderModel: Math.max(DATA_MODEL_MIN_READER, args.storedMinReaderModel ?? 0, requiredReaderModel(args.documentType, args.document))
-    };
-}
-
-function fieldTreeShape(value) {
-    if (Array.isArray(value)) return value.map(fieldTreeShape);
-    if (value === null) return "null";
-    if (typeof value == "object") {
-        const record = value;
-        return Object.fromEntries(Object.keys(record).toSorted().map(key => [ key, fieldTreeShape(record[key]) ]));
-    }
-    return typeof value;
-}
-
-function modelVersionOf(doc) {
-    const stamp = doc.modelVersion;
-    return typeof stamp == "number" ? stamp : 0;
-}
-
-function minReaderModelOf(doc) {
-    const floor = doc.minReaderModel;
-    return typeof floor == "number" ? floor : modelVersionOf(doc);
-}
-
-class ModelVersionAheadError extends WorkflowError {
-    documentId;
-    documentModelVersion;
-    requiredReaderModel;
-    engineModelVersion;
-    constructor(args) {
-        super("model-version-ahead", `Document "${args.documentId}" was written by engine data model ${args.documentModelVersion} and requires a reader at model ${args.requiredReaderModel} or newer; this engine reads up to model ${DATA_MODEL_VERSION}. Upgrade @sanity/workflow-engine to a version that understands it.`), 
-        this.name = "ModelVersionAheadError", this.documentId = args.documentId, this.documentModelVersion = args.documentModelVersion, 
-        this.requiredReaderModel = args.requiredReaderModel, this.engineModelVersion = DATA_MODEL_VERSION;
-    }
-}
-
-function assertReadableModel(doc) {
-    const documentReaderModel = minReaderModelOf(doc);
-    if (documentReaderModel > DATA_MODEL_VERSION) throw new ModelVersionAheadError({
-        documentId: doc._id,
-        documentModelVersion: modelVersionOf(doc),
-        requiredReaderModel: documentReaderModel
-    });
-    return doc;
-}
-
-function effectSites(def) {
-    const sites = [];
-    for (const stage of def.stages ?? []) for (const activity of stage.activities ?? []) for (const action of activity.actions ?? []) for (const effect of action.effects ?? []) sites.push({
-        effect: effect,
-        location: `stage[${stage.name}].activity[${activity.name}].action[${action.name}].effects`
-    });
-    return sites;
-}
-
-function findEffect(def, name) {
-    return effectSites(def).find(site => site.effect.name === name)?.effect;
-}
-
-function rolesGateOf(atom) {
-    const node = atomNode(atom);
-    if (atom.negated || node.type !== "OpCall" || node.op !== ">" || node.right.type !== "Value" || node.right.value !== 0) return;
-    const count = node.left;
-    if (!(count.type !== "FuncCall" || count.name !== "count" || count.args.length !== 1)) return rolesFilterList(count.args[0]);
-}
-
-function rolesFilterList(node) {
-    if (node.type !== "Filter") return;
-    const base = node.base;
-    if (!(base.type === "AccessAttribute" && base.name === "roles" && base.base?.type === "Parameter" && base.base.name === "actor")) return;
-    const expr = node.expr;
-    if (expr.type !== "OpCall" || expr.op !== "in" || expr.left.type !== "This" || expr.right.type !== "Array") return;
-    const roles = expr.right.elements.flatMap(element => !element.isSplat && element.value.type === "Value" && typeof element.value.value == "string" ? [ element.value.value ] : []);
-    if (roles.length === expr.right.elements.length) return roles;
-}
-
-function deriveWorkflowAutonomy(definition, options = {}) {
-    return workflowAutonomy({
-        definition: definition,
-        children: options.children ?? /* @__PURE__ */ new Map,
-        lineage: /* @__PURE__ */ new Set
-    });
-}
-
-function stageAutonomyOf(autonomy, stageName) {
-    const stage = autonomy.stages.find(candidate => candidate.stage === stageName);
-    if (stage === void 0) throw new Error(`Autonomy rollup is missing stage "${stageName}"`);
-    return stage;
-}
-
-function activityAutonomyOf(stageAutonomy2, activityName) {
-    const answer = stageAutonomy2.activities[activityName];
-    if (answer === void 0) throw new Error(`Autonomy rollup is missing activity "${activityName}" in stage "${stageAutonomy2.stage}"`);
-    return answer;
-}
-
-const AUTONOMOUS = {
-    completesWithoutCaller: "yes",
-    waitsOn: []
-}, UNDECIDABLE = {
-    completesWithoutCaller: "conditional",
-    waitsOn: []
-}, CALLER = {
-    completesWithoutCaller: "no",
-    waitsOn: []
-}, VERDICT_RANK = {
-    yes: 0,
-    conditional: 1,
-    no: 2
-};
-
-function allOf(deps) {
-    return {
-        completesWithoutCaller: deps.map(dep => dep.completesWithoutCaller).reduce((worst, verdict) => VERDICT_RANK[verdict] > VERDICT_RANK[worst] ? verdict : worst, "yes"),
-        waitsOn: mergeWaits(deps)
-    };
-}
-
-function anyOf(deps) {
-    const [first, ...rest] = deps;
-    if (first === void 0) throw new Error("anyOf needs at least one route — callers guard empties");
-    return {
-        completesWithoutCaller: rest.every(dep => dep.completesWithoutCaller === first.completesWithoutCaller) ? first.completesWithoutCaller : "conditional",
-        waitsOn: mergeWaits(deps)
-    };
-}
-
-function mergeWaits(deps) {
-    return dedupeBy(deps.flatMap(dep => dep.waitsOn), wait => JSON.stringify(wait));
-}
-
-function analysisCtx(args) {
-    const memo = /* @__PURE__ */ new Map, visiting = /* @__PURE__ */ new Set;
-    return {
-        ...args,
-        memoized: (key, compute) => {
-            const hit = memo.get(key);
-            if (hit !== void 0) return hit;
-            if (visiting.has(key)) return UNDECIDABLE;
-            visiting.add(key);
-            try {
-                const answer = compute();
-                return memo.set(key, answer), answer;
-            } finally {
-                visiting.delete(key);
-            }
-        }
-    };
-}
-
-function workflowAutonomy(args) {
-    const ctx = analysisCtx({
-        definition: args.definition,
-        children: args.children,
-        lineage: /* @__PURE__ */ new Set([ ...args.lineage, args.definition.name ])
-    }), stages = ctx.definition.stages.map(stage => stageAutonomy(stage, ctx));
-    return {
-        ...allOf(stages),
-        stages: stages
-    };
-}
-
-function stageAutonomy(stage, ctx) {
-    const activities = Object.fromEntries((stage.activities ?? []).map(activity => [ activity.name, activityCompletion({
-        stage: stage,
-        activity: activity
-    }, ctx) ]));
-    return {
-        ...stageProgress(stage, ctx),
-        stage: stage.name,
-        activities: activities
+function stageAutonomy(stage, ctx) {
+    const activities = Object.fromEntries((stage.activities ?? []).map(activity => [ activity.name, activityCompletion({
+        stage: stage,
+        activity: activity
+    }, ctx) ]));
+    return {
+        ...stageProgress(stage, ctx),
+        stage: stage.name,
+        activities: activities
     };
 }
 
@@ -2157,10 +1853,6 @@ function derefBase(ref, snapshot) {
     };
 }
 
-function isRecord(value) {
-    return typeof value == "object" && value !== null && !Array.isArray(value);
-}
-
 function buildParams(args) {
     const {instance: instance, now: now, snapshot: snapshot, extra: extra} = args, currentActivities2 = findOpenStageEntry(instance)?.activities ?? [];
     return {
@@ -2696,38 +2388,7 @@ function isFieldOp(summary) {
 
 function validateActionParams({action: action, activityName: activityName, callerParams: callerParams}) {
     const declared = action.params ?? [], params = callerParams ?? {}, issues = [];
-    for (const decl of declared) {
-        const value = params[decl.name], present = decl.name in params && value !== void 0 && value !== null;
-        if (decl.required === !0 && !present) {
-            issues.push({
-                param: decl.name,
-                reason: "required but missing"
-            });
-            continue;
-        }
-        if (!present) continue;
-        if (!checkParamType(value, decl)) {
-            issues.push({
-                param: decl.name,
-                reason: `expected type=${decl.type}, got ${typeof value}`
-            });
-            continue;
-        }
-        const choiceIssues = choiceValueIssues(decl.options, value);
-        choiceIssues !== void 0 && issues.push({
-            param: decl.name,
-            reason: choiceIssues.join("; ")
-        });
-        const validationIssues = scalarValidationIssues({
-            entryType: decl.type,
-            validation: decl.validation,
-            value: value
-        });
-        validationIssues !== void 0 && issues.push({
-            param: decl.name,
-            reason: validationIssues.join("; ")
-        });
-    }
+    for (const decl of declared) issues.push(...declaredParamIssues(decl, params));
     if (issues.length > 0) throw new ActionParamsInvalidError({
         action: action.name,
         activity: activityName,
@@ -2736,8 +2397,32 @@ function validateActionParams({action: action, activityName: activityName, calle
     return params;
 }
 
-function hasStringField(value, field) {
-    return typeof value == "object" && value !== null && field in value && typeof value[field] == "string";
+function declaredParamIssues(decl, params) {
+    const value = params[decl.name];
+    if (!(decl.name in params && value !== void 0 && value !== null)) return decl.required === !0 ? [ {
+        param: decl.name,
+        reason: "required but missing"
+    } ] : [];
+    if (!checkParamType(value, decl)) return [ {
+        param: decl.name,
+        reason: `expected type=${decl.type}, got ${typeof value}`
+    } ];
+    const choiceIssues = choiceValueIssues(decl.options, value), validationIssues = scalarValidationIssues({
+        entryType: decl.type,
+        validation: decl.validation,
+        value: value
+    });
+    return [ ...choiceIssues === void 0 ? [] : [ {
+        param: decl.name,
+        reason: choiceIssues.join("; ")
+    } ], ...validationIssues === void 0 ? [] : [ {
+        param: decl.name,
+        reason: validationIssues.join("; ")
+    } ] ];
+}
+
+function hasStringField(value, field) {
+    return typeof value == "object" && value !== null && field in value && typeof value[field] == "string";
 }
 
 function checkParamType(value, decl) {
@@ -2787,7 +2472,9 @@ async function runOps(args) {
             now: now,
             snapshot: snapshot,
             refSurface: refSurface,
-            opsFromDefinition: opsFromDefinition
+            opsFromDefinition: opsFromDefinition,
+            memberRoles: args.memberRoles,
+            roleAliases: args.roleAliases
         });
         summaries.push(summary), shouldRecordOpApplied(summary) && mutation.history.push(opAppliedEntry({
             origin: origin,
@@ -2908,7 +2595,12 @@ function applyFieldSet(op, ctx) {
         entryType: entry._type,
         entryName: entry.name,
         value: value,
-        ...entryShape(entry)
+        ...entryShape(entry),
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.roleAliases,
+        ...entry._type === "assignees" || entry._type === "object" || entry._type === "array" ? {
+            previousValue: entry.value
+        } : {}
     });
     return assertRuntimeRefsWithinSurface({
         entryType: entry._type,
@@ -3005,7 +2697,17 @@ function entryShape(entry) {
         of: entry.of
     } : isSingleDocRefEntry(entry) || entry._type === "doc.refs" ? entry.types !== void 0 ? {
         types: entry.types
-    } : {} : {
+    } : {} : isAssignmentFieldEntry(entry) ? assignmentEntryShape(entry) : scalarEntryShape(entry);
+}
+
+function assignmentEntryShape(entry) {
+    return entry.roles !== void 0 ? {
+        roles: entry.roles
+    } : {};
+}
+
+function scalarEntryShape(entry) {
+    return {
         ...entry.options !== void 0 ? {
             options: entry.options
         } : {},
@@ -3053,7 +2755,10 @@ function applyFieldAppend(op, ctx) {
         entryName: entry.name,
         item: item,
         types: entry._type === "doc.refs" ? entry.types : void 0,
-        of: entry._type === "array" ? entry.of : void 0
+        of: entry._type === "array" ? entry.of : void 0,
+        roles: entry._type === "assignees" ? entry.roles : void 0,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.roleAliases
     });
     assertRuntimeRefsWithinSurface({
         entryType: entry._type === "doc.refs" ? "doc.ref" : "object",
@@ -3101,6 +2806,13 @@ async function applyFieldUpdateWhere(op, ctx) {
         merge: mergeRecord,
         entry: entry,
         op: op
+    }), validateFieldValue({
+        entryType: "array",
+        entryName: entry.name,
+        value: [ mergeRecord ],
+        of: entry.of,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.roleAliases
     });
     const matches = await rowMatches({
         where: op.where,
@@ -3217,18 +2929,6 @@ function subSlot(target, field) {
 function resolveOpValue(args) {
     const {src: src, ctx: ctx, target: target} = args;
     switch (src.type) {
-      case "literal":
-      case "param":
-      case "actor":
-      case "now":
-        return resolveStaticValueExpr(src, ctx);
-
-      case "self":
-        return ctx.self;
-
-      case "stage":
-        return ctx.stage;
-
       case "fieldRead":
         {
             const entry = readEntryFromMutation(ctx, src);
@@ -3258,6 +2958,25 @@ function resolveOpValue(args) {
             }
             return out;
         }
+
+      default:
+        return resolveAtomicOpValue(src, ctx);
+    }
+}
+
+function resolveAtomicOpValue(src, ctx) {
+    switch (src.type) {
+      case "literal":
+      case "param":
+      case "actor":
+      case "now":
+        return resolveStaticValueExpr(src, ctx);
+
+      case "self":
+        return ctx.self;
+
+      case "stage":
+        return ctx.stage;
     }
 }
 
@@ -3699,13 +3418,354 @@ async function instanceWriteDenials(args) {
     });
 }
 
-async function assertInstanceWriteAllowed(args) {
-    const denied = await instanceWriteDenials(args);
-    if (denied.length !== 0) throw MutationGuardDeniedError.fromGuards({
-        documentId: args.instance._id,
-        action: "update",
-        guards: denied
+async function assertInstanceWriteAllowed(args) {
+    const denied = await instanceWriteDenials(args);
+    if (denied.length !== 0) throw MutationGuardDeniedError.fromGuards({
+        documentId: args.instance._id,
+        action: "update",
+        guards: denied
+    });
+}
+
+const DATA_MODEL_VERSION = 8, DATA_MODEL_MIN_READER = 4, DATA_MODEL_MAX_READER = 8, READER_MODEL_ROLLOUT_URL = "https://www.sanity.io/docs/workflows/prerelease";
+
+class ReaderModelAcknowledgementError extends WorkflowError {
+    code="WORKFLOW_READER_MODEL_ACKNOWLEDGEMENT_MISMATCH";
+    expectedMinReaderModel;
+    requiredMinReaderModel;
+    engineMinReaderModel=DATA_MODEL_MIN_READER;
+    engineMaxReaderModel=DATA_MODEL_MAX_READER;
+    engineModelVersion=DATA_MODEL_VERSION;
+    documentationUrl=READER_MODEL_ROLLOUT_URL;
+    constructor(expectedMinReaderModel, options = {}) {
+        const {context: context = "Deployment", requiredMinReaderModel: requiredMinReaderModel = DATA_MODEL_MIN_READER} = options, expected = expectedMinReaderModel === void 0 ? "missing" : String(expectedMinReaderModel);
+        super("reader-model-acknowledgement", `${context} acknowledges reader model ${expected}; the submitted definitions require at least ${requiredMinReaderModel}, and this writer supports acknowledgements through ${DATA_MODEL_MAX_READER}.\nUse a reviewed numeric literal in that range. Before raising it, ensure every runtime sharing the workflow resource can read the required model.\nRollout guide: ${READER_MODEL_ROLLOUT_URL}`), 
+        this.name = "ReaderModelAcknowledgementError", this.expectedMinReaderModel = expectedMinReaderModel, 
+        this.requiredMinReaderModel = requiredMinReaderModel;
+    }
+}
+
+function assertReaderModelAcknowledgement(expectedMinReaderModel, options) {
+    const {context: context, requiredMinReaderModel: requiredMinReaderModel} = options;
+    if (typeof expectedMinReaderModel != "number" || !Number.isFinite(expectedMinReaderModel) || !Number.isInteger(expectedMinReaderModel) || expectedMinReaderModel < 0 || expectedMinReaderModel < requiredMinReaderModel || expectedMinReaderModel > DATA_MODEL_MAX_READER) throw new ReaderModelAcknowledgementError(expectedMinReaderModel, {
+        requiredMinReaderModel: requiredMinReaderModel,
+        ...context !== void 0 ? {
+            context: context
+        } : {}
+    });
+}
+
+const DATA_MODEL_CHANGES = Object.freeze([ Object.freeze({
+    id: "governed-model-stamps",
+    introducedInModel: 1,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "unconditional",
+    summary: "Definition and instance documents carry model provenance and reader-floor stamps."
+}), Object.freeze({
+    id: "subject-field-kind",
+    introducedInModel: 2,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "A workflow-level subject field identifies the document a workflow is about."
+}), Object.freeze({
+    id: "typed-scalar-choice-lists",
+    introducedInModel: 2,
+    minReaderModel: 2,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "Scalar fields may constrain writes to a persisted typed choice list."
+}), Object.freeze({
+    id: "action-semantics",
+    introducedInModel: 2,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Ordinary actions may carry advisory workflow semantics."
+}), Object.freeze({
+    id: "inclusive-scalar-bounds",
+    introducedInModel: 2,
+    minReaderModel: 2,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "String, text, and number values may carry persisted inclusive bounds."
+}), Object.freeze({
+    id: "progress-field-kind",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "A progress field kind carries application-defined 0–100 completion."
+}), Object.freeze({
+    id: "effect-claim-tokens",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Pending-effect claims carry an exact-claim token gating mid-dispatch state reports."
+}), Object.freeze({
+    id: "classified-principal-ids",
+    introducedInModel: 4,
+    minReaderModel: 4,
+    documentTypes: Object.freeze([ "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "unconditional",
+    summary: "Principal ids are namespace-classified: actor and assignee writes carry the account-global user id only, and readers resolve legacy project-scoped ids through the prefix classifier at the instance read funnel."
+}), Object.freeze({
+    id: "readiness-requirements",
+    introducedInModel: 4,
+    minReaderModel: 4,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "Start and activity readiness use named polymorphic requirement arrays."
+}), Object.freeze({
+    id: "due-date-field-kinds",
+    introducedInModel: 5,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Due-date field kinds (dueDate, dueDatetime) mark a level deadline, elevated aliases of date/datetime carrying the same stored value."
+}), Object.freeze({
+    id: "node-semantics",
+    introducedInModel: 6,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Workflow, stage, activity, and action nodes may carry signal or custom advisory semantics."
+}), Object.freeze({
+    id: "field-patch-ops",
+    introducedInModel: 6,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Field ops may increment, decrement, or initialize a missing field value."
+}), Object.freeze({
+    id: "attributes-condition-var",
+    introducedInModel: 7,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "additive",
+    applicability: "unconditional",
+    summary: "Caller-bound $attributes condition variable binds the acting token's org-level User Attributes (advisory; absent when unavailable)."
+}), Object.freeze({
+    id: "role-constrained-assignment-fields",
+    introducedInModel: 8,
+    minReaderModel: 8,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "Assignee fields may restrict newly assigned users and collective roles by role."
+}) ]);
+
+function recordOf(value) {
+    return value !== null && typeof value == "object" && !Array.isArray(value) ? value : void 0;
+}
+
+function recordsAt(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.map(recordOf).filter(item => item !== void 0) : [];
+}
+
+function nestedFieldEntries(entries) {
+    return entries.flatMap(entry => [ entry, ...nestedFieldEntries(recordsAt(entry, "fields")), ...nestedFieldEntries(recordsAt(entry, "of")) ]);
+}
+
+function parsedDefinitionSnapshot(root) {
+    if (typeof root.definitionSnapshot == "string") return recordOf(parseDefinitionSnapshotValue({
+        _id: typeof root._id == "string" ? root._id : "<unknown instance>",
+        definitionSnapshot: root.definitionSnapshot
+    }));
+}
+
+function persistedDefinitionTree(document) {
+    const root = recordOf(document);
+    if (root === void 0) return;
+    const snapshot = parsedDefinitionSnapshot(root), roots = snapshot === void 0 ? [ root ] : [ root, snapshot ], {stages: stages, activities: activities, actions: actions} = definitionDescendants(roots);
+    return {
+        roots: roots,
+        stages: stages,
+        activities: activities,
+        actions: actions
+    };
+}
+
+function persistedFieldEntries(document) {
+    const tree = persistedDefinitionTree(document);
+    if (tree === void 0) return [];
+    const {roots: roots, stages: stages, activities: activities, actions: actions} = tree, effects = actions.flatMap(action => recordsAt(action, "effects"));
+    return nestedFieldEntries([ ...roots.flatMap(candidate => recordsAt(candidate, "fields")), ...stages.flatMap(stage => recordsAt(stage, "fields")), ...activities.flatMap(activity => recordsAt(activity, "fields")), ...actions.flatMap(action => recordsAt(action, "params")), ...effects.flatMap(effect => recordsAt(effect, "outputs")) ]);
+}
+
+function definitionDescendants(roots) {
+    const stages = roots.flatMap(root => recordsAt(root, "stages")), activities = stages.flatMap(stage => recordsAt(stage, "activities")), actions = activities.flatMap(activity => recordsAt(activity, "actions"));
+    return {
+        stages: stages,
+        activities: activities,
+        actions: actions
+    };
+}
+
+function hasChoiceList(document) {
+    return persistedFieldEntries(document).some(entry => {
+        const options = recordOf(entry.options);
+        return options !== void 0 && Array.isArray(options.list);
+    });
+}
+
+function entryHasKind(entry, kind) {
+    return entryKindMatches(entry, candidate => candidate === kind);
+}
+
+function entryKindMatches(entry, accepts) {
+    return [ entry.type, entry._type ].some(kind => typeof kind == "string" && accepts(kind));
+}
+
+function hasFieldKind(document, kind) {
+    return persistedFieldEntries(document).some(entry => entryHasKind(entry, kind));
+}
+
+function definitionNodes(document) {
+    const root = recordOf(document);
+    if (root !== void 0) return {
+        root: root,
+        ...definitionDescendants([ root ])
+    };
+}
+
+function hasActionSemantics(document) {
+    return definitionNodes(document)?.actions.some(hasSemantics) ?? !1;
+}
+
+function hasNodeSemantics(document) {
+    const nodes = definitionNodes(document);
+    return nodes === void 0 ? !1 : [ nodes.root, ...nodes.stages, ...nodes.activities ].some(hasSemantics) ? !0 : nodes.actions.some(action => hasSemantics(action) && action.semantics.some(isNodeSemanticValue));
+}
+
+function isNodeSemanticValue(semantic) {
+    return typeof semantic == "string" && (semantic.startsWith("signal.") || semantic.startsWith("custom."));
+}
+
+function hasSemantics(node) {
+    return Array.isArray(node.semantics);
+}
+
+function hasPersistedOpType(document, types) {
+    const tree = persistedDefinitionTree(document);
+    return tree === void 0 ? !1 : tree.actions.flatMap(action => recordsAt(action, "ops")).some(op => typeof op.type == "string" && types.includes(op.type)) ? !0 : tree.roots.some(root => recordsAt(root, "history").some(entry => entry._type === "opApplied" && typeof entry.opType == "string" && types.includes(entry.opType)));
+}
+
+function hasScalarValidation(document) {
+    return persistedFieldEntries(document).some(entry => {
+        const validation = recordOf(entry.validation);
+        return typeof validation?.min == "number" || typeof validation?.max == "number";
+    });
+}
+
+function hasClaimTokens(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : recordsAt(root, "pendingEffects").some(entry => {
+        const claim = recordOf(entry.claim);
+        return claim !== void 0 && typeof claim.claimToken == "string";
+    });
+}
+
+function hasReadinessRequirements(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : Array.isArray(recordOf(root.start)?.requirements) ? !0 : recordsAt(root, "stages").some(stage => recordsAt(stage, "activities").some(activity => Array.isArray(activity.requirements)));
+}
+
+function hasRoleConstrainedAssignments(document) {
+    return persistedFieldEntries(document).some(entry => entryKindMatches(entry, assignmentKindAcceptsRoles) && Array.isArray(entry.roles) && entry.roles.length > 0);
+}
+
+const featureDetectors = {
+    "governed-model-stamps": () => !0,
+    "subject-field-kind": document => hasFieldKind(document, "subject"),
+    "typed-scalar-choice-lists": hasChoiceList,
+    "action-semantics": hasActionSemantics,
+    "inclusive-scalar-bounds": hasScalarValidation,
+    "progress-field-kind": document => hasFieldKind(document, "progress"),
+    "effect-claim-tokens": hasClaimTokens,
+    "classified-principal-ids": () => !0,
+    "readiness-requirements": hasReadinessRequirements,
+    "due-date-field-kinds": document => hasFieldKind(document, "dueDate") || hasFieldKind(document, "dueDatetime"),
+    "role-constrained-assignment-fields": hasRoleConstrainedAssignments,
+    "node-semantics": hasNodeSemantics,
+    "field-patch-ops": document => hasPersistedOpType(document, [ "field.inc", "field.dec", "field.setIfMissing" ]),
+    "attributes-condition-var": () => !0
+};
+
+function requiredModelFeatures(documentType, document) {
+    return DATA_MODEL_CHANGES.filter(change => change.documentTypes.some(candidate => candidate === documentType) && featureDetectors[change.id](document));
+}
+
+function requiredReaderModel(documentType, document) {
+    return Math.max(0, ...requiredModelFeatures(documentType, document).map(change => change.minReaderModel));
+}
+
+function requiredDefinitionReaderModel(definitions) {
+    return Math.max(DATA_MODEL_MIN_READER, ...definitions.map(definition => requiredReaderModel("definition", definition)));
+}
+
+function modelStampFor(args) {
+    return {
+        modelVersion: DATA_MODEL_VERSION,
+        minReaderModel: Math.max(DATA_MODEL_MIN_READER, args.storedMinReaderModel ?? 0, requiredReaderModel(args.documentType, args.document))
+    };
+}
+
+function fieldTreeShape(value) {
+    if (Array.isArray(value)) return value.map(fieldTreeShape);
+    if (value === null) return "null";
+    if (typeof value == "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).toSorted().map(key => [ key, fieldTreeShape(record[key]) ]));
+    }
+    return typeof value;
+}
+
+function modelVersionOf(doc) {
+    const stamp = doc.modelVersion;
+    return typeof stamp == "number" ? stamp : 0;
+}
+
+function minReaderModelOf(doc) {
+    const floor = doc.minReaderModel;
+    return typeof floor == "number" ? floor : modelVersionOf(doc);
+}
+
+class ModelVersionAheadError extends WorkflowError {
+    documentId;
+    documentModelVersion;
+    requiredReaderModel;
+    engineModelVersion;
+    constructor(args) {
+        super("model-version-ahead", `Document "${args.documentId}" was written by engine data model ${args.documentModelVersion} and requires a reader at model ${args.requiredReaderModel} or newer; this engine reads up to model ${DATA_MODEL_VERSION}. Upgrade @sanity/workflow-engine to a version that understands it.`), 
+        this.name = "ModelVersionAheadError", this.documentId = args.documentId, this.documentModelVersion = args.documentModelVersion, 
+        this.requiredReaderModel = args.requiredReaderModel, this.engineModelVersion = DATA_MODEL_VERSION;
+    }
+}
+
+function assertReadableModel(doc) {
+    const documentReaderModel = minReaderModelOf(doc);
+    if (documentReaderModel > DATA_MODEL_VERSION) throw new ModelVersionAheadError({
+        documentId: doc._id,
+        documentModelVersion: modelVersionOf(doc),
+        requiredReaderModel: documentReaderModel
     });
+    return doc;
 }
 
 async function renderConditionScope(source, opts) {
@@ -3970,7 +4030,207 @@ function isClaimExpired(claim, now) {
     return claim.leaseExpiresAt === void 0 || hasPassed(claim.leaseExpiresAt, now);
 }
 
-const EFFECT_RUN_STATUSES = [ "done", "failed", "cancelled" ], EXECUTION_KINDS = {
+const EFFECT_RUN_STATUSES = [ "done", "failed", "cancelled" ];
+
+function userLoginProvider(user) {
+    return user?.provider ?? user?.loginProvider;
+}
+
+function optionalString(value) {
+    return value === void 0 || typeof value == "string";
+}
+
+function isClientProjectUser(value) {
+    return isRecord(value) && typeof value.id == "string" && optionalString(value.sanityUserId) && optionalString(value.displayName) && optionalString(value.email) && (value.imageUrl === null || optionalString(value.imageUrl)) && optionalString(value.provider) && optionalString(value.loginProvider);
+}
+
+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;
+}
+
+function isClientProjectMember(value) {
+    return isRecord(value) && typeof value.id == "string";
+}
+
+async function requestProjectMembers(request, projectId) {
+    const project = await request({
+        uri: `/projects/${encodeURIComponent(projectId)}`
+    }), members = isRecord(project) ? project.members : void 0;
+    if (!Array.isArray(members) || !members.every(isClientProjectMember)) throw new Error(`Project member directory response is invalid for project "${projectId}"`);
+    return members;
+}
+
+async function requestProjectUsers(args) {
+    const {request: request, projectId: projectId, memberIds: memberIds} = args, response = await request({
+        uri: `/projects/${encodeURIComponent(projectId)}/users/${memberIds.map(encodeURIComponent).join(",")}`
+    }), rows = Array.isArray(response) ? response : [ response ];
+    if (!rows.every(isClientProjectUser)) throw new Error(`Project user directory response is invalid for project "${projectId}"`);
+    const requested = new Set(memberIds);
+    return rows.filter(row => requested.has(row.id));
+}
+
+async function requestProjectMemberDirectory(args) {
+    const {request: request, projectId: projectId} = args, members = await requestProjectMembers(request, projectId), memberIds = members.map(member => member.id).filter(id => classifyPrincipalId(id).namespace === "project");
+    if (memberIds.length === 0) return {
+        members: members,
+        globalUsers: []
+    };
+    const users = await requestProjectUsers({
+        request: request,
+        projectId: projectId,
+        memberIds: memberIds
+    });
+    return {
+        members: members,
+        globalUsers: users.flatMap(user => {
+            const globalId = directoryBridgeId(user.sanityUserId);
+            return globalId === void 0 ? [] : [ {
+                memberId: user.id,
+                globalId: globalId,
+                user: user
+            } ];
+        })
+    };
+}
+
+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, snapshot = await requestProjectMemberDirectory({
+        request: request,
+        projectId: projectId
+    });
+    for (const {globalId: globalId, user: user} of snapshot.globalUsers) cache.set(`${projectId}:${globalId}`, user);
+}
+
+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) ? candidate.id !== id ? {
+                    status: "inaccessible",
+                    cause: new Error(`Project-user response answered id "${candidate.id}", not the requested "${id}"`)
+                } : {
+                    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
+    };
+}
+
+function assertRoleConstrainedAssignmentResource(args) {
+    if (hasRoleConstrainedAssignments(args.definition) && args.workflowResource.type !== "dataset") throw new Error(`${args.context}: definition "${args.definition.name}" uses role-constrained assignment fields, which require a dataset workflow resource; received resource type "${args.workflowResource.type}"`);
+}
+
+const EXECUTION_KINDS = {
     interactive: "interactive",
     server: "server",
     cli: "cli",
@@ -4393,6 +4653,9 @@ function buildResolvedEntry({entry: entry, value: value, _key: _key, now: now})
         ...entry.validation !== void 0 ? {
             validation: entry.validation
         } : {},
+        ...entry.roles !== void 0 ? {
+            roles: entry.roles
+        } : {},
         value: value,
         ...entry.initialValue?.type === "query" ? {
             resolvedAt: now
@@ -4424,7 +4687,10 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
             fields: entry.fields,
             of: entry.of,
             options: entry.options,
-            validation: entry.validation
+            validation: entry.validation,
+            roles: entry.roles,
+            memberRoles: ctx.memberRoles,
+            roleAliases: ctx.roleAliases
         });
         return "issues" in check ? (ctx.recordDiscard?.({
             field: entry.name,
@@ -4449,7 +4715,10 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
         fields: entry.fields,
         of: entry.of,
         options: entry.options,
-        validation: entry.validation
+        validation: entry.validation,
+        roles: entry.roles,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.roleAliases
     });
     return entry.initialValue?.type === "input" && ctx.inputProvenance !== "definition" && assertRefsWithinSurface({
         entryType: entry.type,
@@ -4543,7 +4812,7 @@ function coerceToGdr(raw, workflowResource) {
     } : null;
 }
 
-const NonEmpty = NonEmptyString, UnknownRecord = v.record(v.string(), v.unknown()), PersistedChoiceOptionsSchema = v.looseObject({
+const NonEmpty = NonEmptyString, PersistedAssignmentRolesSchema = v.pipe(v.array(NonEmptyString), v.minLength(1, "assignment roles must not be empty")), UnknownRecord = v.record(v.string(), v.unknown()), PersistedChoiceOptionsSchema = v.looseObject({
     list: v.array(v.looseObject({
         title: v.string(),
         value: v.union([ v.string(), v.number() ])
@@ -4558,6 +4827,7 @@ const NonEmpty = NonEmptyString, UnknownRecord = v.record(v.string(), v.unknown(
     description: v.optional(v.string()),
     options: v.optional(PersistedChoiceOptionsSchema),
     validation: v.optional(PersistedScalarValidationSchema),
+    roles: v.optional(PersistedAssignmentRolesSchema),
     fields: v.optional(v.array(PersistedFieldShapeSchema)),
     of: v.optional(v.array(PersistedFieldShapeSchema))
 }))), ExecutionContextSchema = tolerantObject()({
@@ -4603,7 +4873,13 @@ const OptionalRefTypes = v.exactOptional(v.array(v.string())), ResolvedFieldEntr
 })), v.looseObject(tolerantEntries()({
     ...fieldArm("subject", fieldValueSchemas.subject),
     types: OptionalRefTypes
-})), v.looseObject(tolerantEntries()(fieldArm("release.ref", fieldValueSchemas["release.ref"]))), v.looseObject(tolerantEntries()(fieldArm("string", fieldValueSchemas.string))), v.looseObject(tolerantEntries()(fieldArm("text", fieldValueSchemas.text))), v.looseObject(tolerantEntries()(fieldArm("number", fieldValueSchemas.number))), v.looseObject(tolerantEntries()(fieldArm("progress", fieldValueSchemas.progress))), v.looseObject(tolerantEntries()(fieldArm("boolean", fieldValueSchemas.boolean))), v.looseObject(tolerantEntries()(fieldArm("date", fieldValueSchemas.date))), v.looseObject(tolerantEntries()(fieldArm("dueDate", fieldValueSchemas.dueDate))), v.looseObject(tolerantEntries()(fieldArm("datetime", fieldValueSchemas.datetime))), v.looseObject(tolerantEntries()(fieldArm("dueDatetime", fieldValueSchemas.dueDatetime))), v.looseObject(tolerantEntries()(fieldArm("url", fieldValueSchemas.url))), v.looseObject(tolerantEntries()(fieldArm("actor", fieldValueSchemas.actor))), v.looseObject(tolerantEntries()(fieldArm("assignee", fieldValueSchemas.assignee))), v.looseObject(tolerantEntries()(fieldArm("assignees", fieldValueSchemas.assignees))), v.looseObject(tolerantEntries()({
+})), v.looseObject(tolerantEntries()(fieldArm("release.ref", fieldValueSchemas["release.ref"]))), v.looseObject(tolerantEntries()(fieldArm("string", fieldValueSchemas.string))), v.looseObject(tolerantEntries()(fieldArm("text", fieldValueSchemas.text))), v.looseObject(tolerantEntries()(fieldArm("number", fieldValueSchemas.number))), v.looseObject(tolerantEntries()(fieldArm("progress", fieldValueSchemas.progress))), v.looseObject(tolerantEntries()(fieldArm("boolean", fieldValueSchemas.boolean))), v.looseObject(tolerantEntries()(fieldArm("date", fieldValueSchemas.date))), v.looseObject(tolerantEntries()(fieldArm("dueDate", fieldValueSchemas.dueDate))), v.looseObject(tolerantEntries()(fieldArm("datetime", fieldValueSchemas.datetime))), v.looseObject(tolerantEntries()(fieldArm("dueDatetime", fieldValueSchemas.dueDatetime))), v.looseObject(tolerantEntries()(fieldArm("url", fieldValueSchemas.url))), v.looseObject(tolerantEntries()(fieldArm("actor", fieldValueSchemas.actor))), v.looseObject(tolerantEntries()({
+    ...fieldArm("assignee", fieldValueSchemas.assignee),
+    roles: v.exactOptional(PersistedAssignmentRolesSchema)
+})), v.looseObject(tolerantEntries()({
+    ...fieldArm("assignees", fieldValueSchemas.assignees),
+    roles: v.exactOptional(PersistedAssignmentRolesSchema)
+})), v.looseObject(tolerantEntries()({
     ...fieldArm("object", v.union([ v.null(), UnknownRecord ])),
     fields: v.array(PersistedFieldShapeSchema)
 })), v.looseObject(tolerantEntries()({
@@ -4854,6 +5130,37 @@ function parseInstanceDocument(doc) {
     });
 }
 
+const WorkflowInstancePreviewEffectSchema = tolerantObject()({
+    name: NonEmpty,
+    title: v.exactOptional(v.string())
+}), WorkflowInstancePreviewSchema = v.looseObject(tolerantEntries()({
+    _id: NonEmpty,
+    _type: v.literal(WORKFLOW_INSTANCE_TYPE),
+    modelVersion: v.exactOptional(v.number()),
+    minReaderModel: v.exactOptional(v.number()),
+    workflowResource: WorkflowResourceSchema,
+    definition: NonEmpty,
+    pinnedVersion: v.number(),
+    fields: v.array(ResolvedFieldEntrySchema),
+    ancestors: v.array(GdrShape),
+    perspective: v.exactOptional(WorkflowPerspectiveSchema),
+    currentStage: NonEmpty,
+    stages: v.array(StageEntrySchema),
+    claimedEffects: v.array(WorkflowInstancePreviewEffectSchema),
+    failedEffects: v.array(WorkflowInstancePreviewEffectSchema),
+    startedAt: IsoTimestamp,
+    completedAt: v.exactOptional(IsoTimestamp),
+    abortedAt: v.exactOptional(IsoTimestamp)
+}));
+
+function parseInstancePreviewDocument(doc) {
+    return parsePersistedDoc({
+        schema: WorkflowInstancePreviewSchema,
+        doc: doc,
+        docType: WORKFLOW_INSTANCE_TYPE
+    });
+}
+
 const SYNC_COMMIT = {
     visibility: "sync"
 }, ENGINE_API_VERSION = "2026-04-29", REQUEST_TAG = {
@@ -5301,6 +5608,40 @@ function readInstanceDoc(doc) {
     return parseInstanceDocument(assertReadableModel(doc));
 }
 
+function readInstancePreviewDoc(doc) {
+    return hasDocumentId(doc) ? parseInstancePreviewDocument(withoutProjectedNulls(assertReadableModel(doc))) : parseInstancePreviewDocument(doc);
+}
+
+function hasDocumentId(doc) {
+    return typeof doc == "object" && doc !== null && typeof doc._id == "string";
+}
+
+function withoutProjectedNulls(doc) {
+    const row = withoutNullMembers(doc);
+    if (typeof row != "object" || row === null) return row;
+    const out = {
+        ...row
+    };
+    return Array.isArray(out.stages) && (out.stages = out.stages.map(withoutStageEntryNulls)), 
+    Array.isArray(out.claimedEffects) && (out.claimedEffects = out.claimedEffects.map(withoutNullMembers)), 
+    Array.isArray(out.failedEffects) && (out.failedEffects = out.failedEffects.map(withoutNullMembers)), 
+    out;
+}
+
+function withoutStageEntryNulls(entry) {
+    const stage = withoutNullMembers(entry);
+    if (typeof stage != "object" || stage === null) return stage;
+    const out = {
+        ...stage
+    };
+    return Array.isArray(out.activities) && (out.activities = out.activities.map(withoutNullMembers)), 
+    out;
+}
+
+function withoutNullMembers(value) {
+    return value === null || typeof value != "object" || Array.isArray(value) ? value : Object.fromEntries(Object.entries(value).filter(([, member]) => member !== null));
+}
+
 async function reload({client: client, instanceId: instanceId, tag: tag}) {
     const doc = await getInstanceDocument(client, instanceId);
     if (!doc) throw new InstanceNotFoundError({
@@ -5547,7 +5888,8 @@ function loadCallContext({client: client, instanceId: instanceId, options: optio
             } : {},
             ...options.telemetry ? {
                 telemetry: options.telemetry
-            } : {}
+            } : {},
+            memberRolesLoader: options.memberRolesLoader
         }
     });
 }
@@ -5592,6 +5934,7 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
         ...options.telemetry !== void 0 ? {
             telemetry: options.telemetry
         } : {},
+        memberRolesLoader: options.memberRolesLoader,
         ...options.overlay !== void 0 ? {
             overlay: options.overlay
         } : {},
@@ -5627,7 +5970,10 @@ async function ctxEvaluateCondition({ctx: ctx, condition: condition, opts: opts}
 }
 
 async function buildEngineContext(args) {
-    const {client: client, clientForGdr: clientForGdr, refSurface: refSurface, instance: instance, definition: definition} = args, clock = args.clock ?? wallClock;
+    const {client: client, clientForGdr: clientForGdr, refSurface: refSurface, instance: instance, definition: definition} = args, clock = args.clock ?? wallClock, memberRolesLoader = args.memberRolesLoader, memberRoles = await memberRolesLoader({
+        workflowResource: instance.workflowResource,
+        definition: definition
+    });
     return {
         client: client,
         clientForGdr: clientForGdr,
@@ -5644,6 +5990,10 @@ async function buildEngineContext(args) {
         } : {},
         instance: instance,
         definition: definition,
+        memberRolesLoader: memberRolesLoader,
+        ...memberRoles !== void 0 ? {
+            memberRoles: memberRoles
+        } : {},
         snapshot: await hydrateSnapshot({
             client: client,
             clientForGdr: clientForGdr,
@@ -5655,6 +6005,62 @@ async function buildEngineContext(args) {
     };
 }
 
+function createAssignmentMemberRolesLoader(client) {
+    const byProjectId = /* @__PURE__ */ new Map;
+    return async ({workflowResource: workflowResource, definition: definition}) => {
+        if (!hasRoleConstrainedAssignments(definition)) return;
+        assertRoleConstrainedAssignmentResource({
+            context: "workflow",
+            definition: definition,
+            workflowResource: workflowResource
+        });
+        const projectId = datasetResourceParts(workflowResource.id).projectId;
+        let pending = byProjectId.get(projectId);
+        return pending === void 0 && (pending = client.request === void 0 ? Promise.reject(new Error(`Definition "${definition.name}" has role-constrained assignments, which require project-directory access for project "${projectId}"; the client cannot issue requests`)) : loadProjectMemberRoles({
+            request: client.request,
+            projectId: projectId
+        }), byProjectId.set(projectId, pending)), pending;
+    };
+}
+
+async function loadProjectMemberRoles(args) {
+    const {request: request, projectId: projectId} = args, snapshot = await requestProjectMemberDirectory({
+        request: request,
+        projectId: projectId
+    }), rolesByProjectId = projectMemberRoles({
+        members: snapshot.members,
+        projectId: projectId
+    });
+    return globalizeMemberRoles({
+        snapshot: snapshot,
+        rolesByProjectId: rolesByProjectId
+    });
+}
+
+function globalizeMemberRoles(args) {
+    const {snapshot: snapshot, rolesByProjectId: rolesByProjectId} = args, humanIds = [ ...rolesByProjectId.keys() ].filter(id => classifyPrincipalId(id).namespace === "project");
+    for (const {globalId: globalId, memberId: memberId} of snapshot.globalUsers) {
+        const roles = rolesByProjectId.get(memberId);
+        roles !== void 0 && rolesByProjectId.set(globalId, roles);
+    }
+    for (const id of humanIds) rolesByProjectId.delete(id);
+    return Object.fromEntries(rolesByProjectId);
+}
+
+function projectMemberRoles(args) {
+    const result = /* @__PURE__ */ new Map;
+    for (const member of args.members) {
+        const {id: id, roles: roles} = member;
+        if (!Array.isArray(roles) || !roles.every(isProjectMemberRole)) throw new Error(`Project member role directory response is invalid for project "${args.projectId}" and member "${id}"`);
+        result.set(id, roles.map(role => role.name));
+    }
+    return result;
+}
+
+function isProjectMemberRole(role) {
+    return isRecord(role) && typeof role.name == "string";
+}
+
 function findStage(definition, stageName) {
     const stage = definition.stages.find(s => s.name === stageName);
     if (stage === void 0) throw new Error(`Stage "${stageName}" not found in definition ${definition.name}`);
@@ -5674,6 +6080,8 @@ async function resolveStageFieldEntries(args) {
             tag: instance.tag,
             stageName: stage.name,
             workflowResource: instance.workflowResource,
+            memberRoles: args.memberRoles,
+            roleAliases: args.roleAliases,
             workflowFields: instance.fields ?? [],
             ...instance.perspective !== void 0 ? {
                 perspective: instance.perspective
@@ -5700,6 +6108,8 @@ async function resolveActivityFieldEntries(args) {
             stageName: stage.name,
             workflowResource: instance.workflowResource,
             activityName: activity.name,
+            memberRoles: args.memberRoles,
+            roleAliases: args.roleAliases,
             workflowFields: instance.fields ?? [],
             ...instance.perspective !== void 0 ? {
                 perspective: instance.perspective
@@ -5855,167 +6265,6 @@ function resolveMetadata(metadata, ctx) {
     return out;
 }
 
-function userLoginProvider(user) {
-    return user?.provider ?? user?.loginProvider;
-}
-
-function optionalString(value) {
-    return value === void 0 || typeof value == "string";
-}
-
-function isClientProjectUser(value) {
-    return isRecord(value) && typeof value.id == "string" && optionalString(value.sanityUserId) && optionalString(value.displayName) && optionalString(value.email) && (value.imageUrl === null || optionalString(value.imageUrl)) && optionalString(value.provider) && optionalString(value.loginProvider);
-}
-
-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 requested = new Set(memberIds), response = await request({
-        uri: `/projects/${encodeURIComponent(projectId)}/users/${memberIds.map(encodeURIComponent).join(",")}`
-    });
-    for (const row of Array.isArray(response) ? response : [ response ]) {
-        if (!isClientProjectUser(row) || !requested.has(row.id)) continue;
-        const globalId = directoryBridgeId(row.sanityUserId);
-        globalId !== void 0 && cache.set(`${projectId}:${globalId}`, 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) ? candidate.id !== id ? {
-                    status: "inaccessible",
-                    cause: new Error(`Project-user response answered id "${candidate.id}", not the requested "${id}"`)
-                } : {
-                    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) {
@@ -6661,6 +6910,8 @@ async function buildActivityEntry({ctx: ctx, stage: stage, activity: activity, r
         activity: activity,
         now: ctx.now,
         refSurface: ctx.refSurface,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases,
         ...recordDiscard !== void 0 ? {
             recordDiscard: recordDiscard
         } : {}
@@ -6863,7 +7114,8 @@ async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, actio
         context: context,
         actor: actor,
         now: now,
-        refSurface: ctx.refSurface
+        refSurface: ctx.refSurface,
+        memberRolesLoader: ctx.memberRolesLoader
     });
     mutation.pendingCreates.push({
         body: body,
@@ -7085,13 +7337,16 @@ async function resolveDefinitionRef({client: client, ref: ref, tag: tag}) {
 }
 
 async function prepareChildInstance(args) {
-    const {client: client, parent: parent, definition: definition, initialFields: initialFields, context: context, actor: actor, now: now, refSurface: refSurface} = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = instanceDocId(childTag), childRef = {
+    const {client: client, parent: parent, definition: definition, initialFields: initialFields, context: context, actor: actor, now: now, refSurface: refSurface, memberRolesLoader: memberRolesLoader} = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = instanceDocId(childTag), childRef = {
         id: gdrFromResource(workflowResource, childDocId),
         type: WORKFLOW_INSTANCE_TYPE
     }, ancestors = [ ...parent.ancestors, {
         id: selfGdr(parent),
         type: WORKFLOW_INSTANCE_TYPE
-    } ], inheritedPerspective = parent.perspective, fieldDiscards = [], childFields = await resolveDeclaredFields({
+    } ], inheritedPerspective = parent.perspective, fieldDiscards = [], memberRoles = await memberRolesLoader({
+        workflowResource: workflowResource,
+        definition: definition
+    }), childFields = await resolveDeclaredFields({
         entryDefs: definition.fields,
         initialFields: initialFields,
         ctx: {
@@ -7102,6 +7357,8 @@ async function prepareChildInstance(args) {
             workflowResource: workflowResource,
             definitionName: definition.name,
             refSurface: refSurface,
+            memberRoles: memberRoles,
+            roleAliases: definition.roleAliases,
             inputProvenance: "definition",
             ...inheritedPerspective !== void 0 ? {
                 perspective: inheritedPerspective
@@ -7172,6 +7429,8 @@ async function enterStage({ctx: ctx, mutation: mutation, nextStage: nextStage, a
             stage: nextStage,
             now: at,
             refSurface: ctx.refSurface,
+            memberRoles: ctx.memberRoles,
+            roleAliases: ctx.definition.roleAliases,
             recordDiscard: recordFieldDiscards({
                 target: mutation.history,
                 scope: "stage",
@@ -8009,7 +8268,9 @@ async function applyActionFire({ctx: ctx, mutation: mutation, activity: activity
         self: selfGdr(ctx.instance),
         now: ctx.now,
         snapshot: ctx.snapshot,
-        refSurface: ctx.refSurface
+        refSurface: ctx.refSurface,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases
     });
     if (await queueEffects({
         ctx: ctx,
@@ -8192,6 +8453,8 @@ async function primeInitialStage(args) {
             stage: stage,
             now: now,
             refSurface: refSurface,
+            memberRoles: ctx.memberRoles,
+            roleAliases: ctx.definition.roleAliases,
             recordDiscard: recordFieldDiscards({
                 target: discards,
                 scope: "stage",
@@ -8251,7 +8514,7 @@ async function primeInitialStage(args) {
 
 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, settlingCohorts: settlingCohorts, instance: instance}) {
+async function runCascadeHop({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay, settlingCohorts: settlingCohorts, instance: instance}) {
     const contextOptions = {
         clientForGdr: clientForGdr,
         refSurface: refSurface,
@@ -8272,7 +8535,8 @@ async function runCascadeHop({client: client, instanceId: instanceId, actor: act
         } : {},
         ...settlingCohorts ? {
             settlingCohorts: settlingCohorts
-        } : {}
+        } : {},
+        memberRolesLoader: memberRolesLoader
     }, ctx = instance === void 0 ? await loadContext({
         client: client,
         instanceId: instanceId,
@@ -8311,7 +8575,7 @@ 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, settlingCohorts: settlingCohorts}) {
+async function cascadeAutoTransitions({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay, settlingCohorts: settlingCohorts}) {
     let count = 0;
     for (;;) {
         const drained = await drainCondemnedChildren({
@@ -8320,6 +8584,7 @@ async function cascadeAutoTransitions({client: client, instanceId: instanceId, a
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry
@@ -8330,6 +8595,7 @@ async function cascadeAutoTransitions({client: client, instanceId: instanceId, a
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry,
@@ -8346,7 +8612,7 @@ 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, instance: preloadedInstance}) {
+async function drainCondemnedChildren({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining = /* @__PURE__ */ new Set, instance: preloadedInstance}) {
     if (draining.has(instanceId)) return {
         instance: preloadedInstance,
         drained: !1
@@ -8369,6 +8635,7 @@ async function drainCondemnedChildren({client: client, instanceId: instanceId, a
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         clock: clock,
         executionContext: executionContext,
         telemetry: telemetry,
@@ -8386,7 +8653,7 @@ async function drainCondemnedChildren({client: client, instanceId: instanceId, a
     };
 }
 
-async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining}) {
+async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, draining: draining}) {
     const childId = toBareId(row.ref.id);
     try {
         const result = await abortInstance({
@@ -8399,6 +8666,7 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
                 } : {},
                 clientForGdr: clientForGdr,
                 refSurface: refSurface,
+                memberRolesLoader: memberRolesLoader,
                 ...clock ? {
                     clock: clock
                 } : {},
@@ -8416,6 +8684,7 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry,
@@ -8566,7 +8835,8 @@ async function buildCascadeStepContext(args, instance) {
         } : {},
         ...args.settlingCohorts ? {
             settlingCohorts: args.settlingCohorts
-        } : {}
+        } : {},
+        memberRolesLoader: args.memberRolesLoader
     });
 }
 
@@ -8794,6 +9064,7 @@ function spawnStepArgs(ctx, args) {
         actor: args.actor,
         clientForGdr: ctx.clientForGdr,
         refSurface: ctx.refSurface,
+        memberRolesLoader: ctx.memberRolesLoader,
         clock: ctx.clock,
         executionContext: ctx.executionContext,
         telemetry: ctx.telemetry,
@@ -8935,7 +9206,11 @@ function validateEffectOutputs(args) {
             issues.push(`"${key}" is not a declared output`);
             continue;
         }
-        const check = effectOutputCheck(shape, value);
+        const check = effectOutputCheck({
+            shape: shape,
+            value: value,
+            eligibility: args
+        });
         "issues" in check ? issues.push(...check.issues.map(i => `"${key}": ${i}`)) : normalized[key] = check.output;
     }
     if (issues.length > 0) throw new EffectOutputsInvalidError({
@@ -8945,7 +9220,8 @@ function validateEffectOutputs(args) {
     return normalized;
 }
 
-function effectOutputCheck(shape, value) {
+function effectOutputCheck(args) {
+    const {shape: shape, value: value, eligibility: eligibility} = args;
     return parseFieldValue({
         entryType: shape.type,
         value: value,
@@ -8960,7 +9236,12 @@ function effectOutputCheck(shape, value) {
         } : {},
         ...shape.validation !== void 0 ? {
             validation: shape.validation
-        } : {}
+        } : {},
+        ...shape.roles !== void 0 ? {
+            roles: shape.roles
+        } : {},
+        memberRoles: eligibility.memberRoles,
+        roleAliases: eligibility.roleAliases
     });
 }
 
@@ -8983,7 +9264,7 @@ function requirePendingEffect(instance, effectKey) {
     });
 }
 
-function validateCompletionInput({pending: pending, definition: definition, status: status, ops: ops, outputs: outputs}) {
+function validateCompletionInput({pending: pending, definition: definition, status: status, ops: ops, outputs: outputs, memberRoles: memberRoles, roleAliases: roleAliases}) {
     if (status === "failed" && ops !== void 0 && ops.length > 0) throw new EffectOpsInvalidError({
         effect: pending.name,
         issues: [ "ops cannot accompany a failed completion — field.set the outcome on a done completion instead" ]
@@ -8995,7 +9276,9 @@ function validateCompletionInput({pending: pending, definition: definition, stat
     const normalizedOutputs = outputs !== void 0 ? validateEffectOutputs({
         outputs: outputs,
         declared: findEffect(definition, pending.name)?.outputs ?? [],
-        effectName: pending.name
+        effectName: pending.name,
+        memberRoles: memberRoles,
+        roleAliases: roleAliases
     }) : void 0;
     return {
         ops: ops !== void 0 ? validateEffectOps(ops, pending.name) : [],
@@ -9014,7 +9297,9 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         definition: ctx.definition,
         status: status,
         ops: ops,
-        outputs: outputs
+        outputs: outputs,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases
     }), mutation = startMutation(ctx.instance);
     recordProcessedRequest({
         mutation: mutation,
@@ -9045,7 +9330,9 @@ async function commitCompleteEffect({ctx: ctx, effectKey: effectKey, status: sta
         self: selfGdr(ctx.instance),
         now: ranAt,
         snapshot: ctx.snapshot,
-        refSurface: ctx.refSurface
+        refSurface: ctx.refSurface,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases
     }), needsGuardRefresh = wroteEffectOutputs || ranOps.some(isFieldOp);
     return await persistThenMaybeRefresh({
         ctx: ctx,
@@ -9214,7 +9501,9 @@ async function commitReport({ctx: ctx, effectKey: effectKey, claimToken: claimTo
         self: selfGdr(ctx.instance),
         now: ctx.now,
         snapshot: ctx.snapshot,
-        refSurface: ctx.refSurface
+        refSurface: ctx.refSurface,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases
     }), await persistThenMaybeRefresh({
         ctx: ctx,
         mutation: mutation,
@@ -9709,6 +9998,12 @@ async function evaluateEditableFields(args) {
             ...site.validation !== void 0 ? {
                 validation: site.validation
             } : {},
+            ...site.roles !== void 0 ? {
+                roles: site.roles,
+                ...definition.roleAliases !== void 0 ? {
+                    roleAliases: definition.roleAliases
+                } : {}
+            } : {},
             value: value,
             editable: reason === void 0,
             ...reason !== void 0 ? {
@@ -10059,23 +10354,63 @@ function idsArm(filter, params) {
     }
 }
 
-function instancesQuery(args) {
-    const {tag: tag, filter: filter = {}} = args;
-    if (validateTag(tag), filter.limit !== void 0 && (!Number.isInteger(filter.limit) || filter.limit <= 0)) throw new ContractViolationError(`instancesQuery: limit must be a positive integer; got ${JSON.stringify(filter.limit)}`);
-    const conditions = [ `_type == "${WORKFLOW_INSTANCE_TYPE}"`, tagScopeFilter() ], params = {
-        tag: tag
-    };
+function beforeArm(filter, params) {
+    const before = filter.before;
+    if (before !== void 0) {
+        if (filter.limit === void 0) throw new ContractViolationError("instancesQuery: `before` requires `limit` — a cursor pages the newest-first sliced read");
+        if (before.id === "" || before.startedAt === "") throw new ContractViolationError(`instancesQuery: \`before\` needs a non-empty id and startedAt; got ${JSON.stringify(before)}`);
+        return params.beforeStartedAt = before.startedAt, params.beforeId = before.id, "(startedAt < $beforeStartedAt || (startedAt == $beforeStartedAt && _id > $beforeId))";
+    }
+}
+
+function compiledConditions(filter, params) {
+    if (filter.limit !== void 0 && (!Number.isInteger(filter.limit) || filter.limit <= 0)) throw new ContractViolationError(`instancesQuery: limit must be a positive integer; got ${JSON.stringify(filter.limit)}`);
+    const conditions = [ `_type == "${WORKFLOW_INSTANCE_TYPE}"`, tagScopeFilter() ];
     filter.includeCompleted !== !0 && conditions.push(inFlightFilter()), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
     params.definition = filter.definition), filter.stage !== void 0 && (conditions.push("currentStage == $stage"), 
     params.stage = filter.stage);
+    const cursor = beforeArm(filter, params);
+    cursor !== void 0 && conditions.push(cursor);
     const arms = [ documentArm(filter, params), idsArm(filter, params) ].filter(arm => arm !== void 0);
-    arms.length > 0 && conditions.push(`(${arms.join(" || ")})`);
-    const body = `*[${conditions.join(" && ")}]`;
-    return filter.limit !== void 0 ? {
-        query: `${body} | order(startedAt desc) [0...${filter.limit}]`,
+    return arms.length > 0 && conditions.push(`(${arms.join(" || ")})`), conditions;
+}
+
+function orderedSlice(filter) {
+    return filter.limit !== void 0 ? ` | order(startedAt desc, _id asc) [0...${filter.limit}]` : " | order(startedAt asc, _id asc)";
+}
+
+function instancesQuery(args) {
+    const {tag: tag, filter: filter = {}} = args;
+    validateTag(tag);
+    const params = {
+        tag: tag
+    };
+    return {
+        query: `*[${compiledConditions(filter, params).join(" && ")}]${orderedSlice(filter)}`,
         params: params
-    } : {
-        query: `${body} | order(startedAt asc)`,
+    };
+}
+
+function instanceChangesQuery(args) {
+    return validateTag(args.tag), {
+        query: `*[_type == "${WORKFLOW_INSTANCE_TYPE}" && ${tagScopeFilter()}]`,
+        params: {
+            tag: args.tag
+        }
+    };
+}
+
+const PREVIEW_FIELD_TYPES = [ "actor", "assignee", "assignees", "date", "datetime", "doc.ref", "doc.refs", "dueDate", "dueDatetime", "release.ref", "subject" ], PREVIEW_PROJECTION = `{\n  _id, _type, modelVersion, minReaderModel, workflowResource, definition, pinnedVersion,\n  currentStage, startedAt, completedAt, abortedAt, perspective, ancestors,\n  "fields": fields[_type in $previewFieldTypes],\n  "stages": stages[!defined(exitedAt) && name == ^.currentStage]{\n    _key, name, enteredAt,\n    "fields": fields[_type in $previewFieldTypes],\n    "activities": activities[]{\n      _key, name, status, completedBy,\n      "fields": fields[_type in $previewFieldTypes]\n    }\n  },\n  "claimedEffects": pendingEffects[defined(claim)]{name, title},\n  "failedEffects": effectHistory[status == "failed"]{name, title}\n}`.replaceAll(/\s+/g, " ").trim();
+
+function instancePreviewsQuery(args) {
+    const {tag: tag, filter: filter = {}} = args;
+    validateTag(tag);
+    const params = {
+        tag: tag,
+        previewFieldTypes: PREVIEW_FIELD_TYPES
+    };
+    return {
+        query: `*[${compiledConditions(filter, params).join(" && ")}]${orderedSlice(filter)} ${PREVIEW_PROJECTION}`,
         params: params
     };
 }
@@ -10260,6 +10595,11 @@ function hashDefinitionContent(def) {
 }
 
 function planDefinitionDeploy({def: def, latest: latest, target: target}) {
+    assertRoleConstrainedAssignmentResource({
+        context: "workflow.deployDefinitions",
+        definition: def,
+        workflowResource: target.workflowResource
+    });
     const expanded = expandResourceAliases(def, target.resourceAliases), contentHash = hashDefinitionContent(expanded), unchanged = latest !== void 0 && latest.contentHash === contentHash, version = unchanged ? latest.version : (latest?.version ?? 0) + 1, docId = definitionDocId({
         tag: target.tag,
         definition: expanded.name,
@@ -10452,7 +10792,9 @@ async function commitEdit({ctx: ctx, target: target, mode: mode, value: value, r
         self: selfGdr(ctx.instance),
         now: ctx.now,
         snapshot: ctx.snapshot,
-        refSurface: ctx.refSurface
+        refSurface: ctx.refSurface,
+        memberRoles: ctx.memberRoles,
+        roleAliases: ctx.definition.roleAliases
     });
     return await persistThenMaybeRefresh({
         ctx: ctx,
@@ -10551,6 +10893,7 @@ async function resolveOperationContext(args) {
     return {
         access: access,
         actor: access.actor,
+        memberRolesLoader: createAssignmentMemberRolesLoader(args.client),
         clientForGdr: buildClientForGdr({
             client: args.client,
             workflowResource: args.workflowResource,
@@ -10583,6 +10926,7 @@ async function runCommitVerb(params) {
         actor: context.actor,
         clientForGdr: context.clientForGdr,
         refSurface: context.refSurface,
+        memberRolesLoader: context.memberRolesLoader,
         clock: clock,
         executionContext: args.executionContext,
         telemetry: args.telemetry,
@@ -10607,7 +10951,7 @@ function requestRecordFor(args) {
 }
 
 async function runDeduped(args) {
-    const {client: client, tag: tag, instanceId: instanceId, record: record, before: before, now: now, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, run: run} = args, {clock: clock, executionContext: executionContext, telemetry: telemetry} = args, replay = async () => {
+    const {client: client, tag: tag, instanceId: instanceId, record: record, before: before, now: now, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, run: run} = args, {clock: clock, executionContext: executionContext, telemetry: telemetry} = args, replay = async () => {
         const pre = await reload({
             client: client,
             instanceId: instanceId,
@@ -10619,6 +10963,7 @@ async function runDeduped(args) {
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             executionContext: executionContext,
             telemetry: telemetry
@@ -10642,13 +10987,14 @@ async function runDeduped(args) {
     }
 }
 
-async function cascade({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
+async function cascade({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, overlay: overlay}) {
     const count = await cascadeAutoTransitions({
         client: client,
         instanceId: instanceId,
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         ...clock !== void 0 ? {
             clock: clock
         } : {},
@@ -10668,6 +11014,7 @@ async function cascade({client: client, instanceId: instanceId, actor: actor, cl
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         ...clock !== void 0 ? {
             clock: clock
         } : {},
@@ -10681,7 +11028,7 @@ async function cascade({client: client, instanceId: instanceId, actor: actor, cl
 }
 
 async function cascadeAndReload(args) {
-    const {client: client, tag: tag, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock} = args;
+    const {client: client, tag: tag, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock} = args;
     return {
         cascaded: await cascade({
             client: client,
@@ -10689,6 +11036,7 @@ async function cascadeAndReload(args) {
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             ...args.executionContext !== void 0 ? {
                 executionContext: args.executionContext
@@ -10712,6 +11060,7 @@ async function settleStart(args) {
         actor: args.actor,
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
+        memberRolesLoader: args.memberRolesLoader,
         clock: args.clock,
         ...args.executionContext !== void 0 ? {
             executionContext: args.executionContext
@@ -10754,31 +11103,20 @@ function resumeMismatch(args) {
 }
 
 async function resumeStart(args) {
-    const {existing: existing} = args, mismatch = resumeMismatch({
+    const {existing: existing, definition: definition, version: version, initialFieldCount: initialFieldCount, ...settlementArgs} = args, mismatch = resumeMismatch({
         existing: existing,
-        definition: args.definition,
-        version: args.version
+        definition: definition,
+        version: version
     });
     if (mismatch !== void 0) throw new ContractViolationError(`startInstance: instanceId "${existing._id}" already exists and ${mismatch}. A supplied instanceId is start's idempotency key — reuse one only to retry the same start.`);
     if (existing.stages.length === 0 && terminalState(existing) !== "in-flight") throw new ContractViolationError(`startInstance: instanceId "${existing._id}" belongs to a start that was discarded (aborted before it finished starting) — mint a new id to start again.`);
     const completesStart = isUnprimed(existing), emitStarted = () => resolveTelemetry(args.telemetry).log(WorkflowInstanceStarted, instanceStartedDataFor({
         instance: existing,
-        initialFieldCount: args.initialFieldCount,
+        initialFieldCount: initialFieldCount,
         viaSpawn: !1
     })), cascaded = await settleStart({
-        client: args.client,
-        tag: args.tag,
+        ...settlementArgs,
         instanceId: existing._id,
-        actor: args.actor,
-        clientForGdr: args.clientForGdr,
-        refSurface: args.refSurface,
-        clock: args.clock,
-        ...args.executionContext !== void 0 ? {
-            executionContext: args.executionContext
-        } : {},
-        ...args.telemetry !== void 0 ? {
-            telemetry: args.telemetry
-        } : {},
         ...completesStart ? {
             emitStarted: emitStarted
         } : {}
@@ -10794,7 +11132,7 @@ async function resumeStart(args) {
     };
 }
 
-function engineOptionsForActor({actor: actor, clock: clock, clientForGdr: clientForGdr, refSurface: refSurface, executionContext: executionContext, telemetry: telemetry}) {
+function engineOptionsForActor({actor: actor, clock: clock, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, executionContext: executionContext, telemetry: telemetry}) {
     return {
         ...actor !== void 0 ? {
             actor: actor
@@ -10802,6 +11140,7 @@ function engineOptionsForActor({actor: actor, clock: clock, clientForGdr: client
         clock: clock,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         ...executionContext !== void 0 ? {
             executionContext: executionContext
         } : {},
@@ -10812,7 +11151,7 @@ function engineOptionsForActor({actor: actor, clock: clock, clientForGdr: client
 }
 
 async function abortAndPropagate(args) {
-    const {client: client, instanceId: instanceId, reason: reason, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry, requestRecord: requestRecord} = args, result = await abortInstance({
+    const {client: client, instanceId: instanceId, reason: reason, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, executionContext: executionContext, telemetry: telemetry, requestRecord: requestRecord} = args, result = await abortInstance({
         client: client,
         instanceId: instanceId,
         ...reason !== void 0 ? {
@@ -10826,6 +11165,7 @@ async function abortAndPropagate(args) {
             clock: clock,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             executionContext: executionContext,
             telemetry: telemetry
         })
@@ -10835,6 +11175,7 @@ async function abortAndPropagate(args) {
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         clock: clock,
         ...executionContext !== void 0 ? {
             executionContext: executionContext
@@ -10852,6 +11193,7 @@ async function abortAndPropagate(args) {
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         clock: clock,
         ...executionContext !== void 0 ? {
             executionContext: executionContext
@@ -10893,6 +11235,7 @@ async function dispatchGatedWrite(args) {
         actor: args.actor,
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
+        memberRolesLoader: args.memberRolesLoader,
         clock: args.clock,
         executionContext: args.executionContext,
         telemetry: args.telemetry
@@ -10968,6 +11311,7 @@ function buildEngineCallOptions(args) {
         actor: args.actor,
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
+        memberRolesLoader: args.memberRolesLoader,
         ...args.localPrincipalId !== void 0 ? {
             localPrincipalId: args.localPrincipalId
         } : {},
@@ -11007,7 +11351,7 @@ async function applyAction(args) {
 }
 
 async function deleteDefinition(args) {
-    const {client: client, tag: tag, definition: definition, version: version, cascade: cascade2, reason: reason, executionContext: executionContext, telemetry: telemetry} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, versions = await loadDefinitionVersionsOrThrow({
+    const {client: client, tag: tag, definition: definition, version: version, cascade: cascade2, reason: reason, executionContext: executionContext, telemetry: telemetry} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader} = await resolveOperationContext(args), clock = args.clock ?? wallClock, versions = await loadDefinitionVersionsOrThrow({
         client: client,
         definition: definition,
         tag: tag
@@ -11046,6 +11390,7 @@ async function deleteDefinition(args) {
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         clock: clock,
         executionContext: executionContext,
         telemetry: telemetry
@@ -11104,6 +11449,7 @@ async function abortInstances(args) {
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: args.refSurface,
+        memberRolesLoader: args.memberRolesLoader,
         clock: clock,
         ...executionContext !== void 0 ? {
             executionContext: executionContext
@@ -11136,11 +11482,12 @@ async function fetchStartSlice(args) {
 
 const workflow = {
     deployDefinitions: async rawArgs => {
-        assertReaderModelAcknowledgement(rawArgs.expectedMinReaderModel);
-        const args = taggedScope(rawArgs, REQUEST_TAG.deploy), {client: client, tag: tag, resourceAliases: resourceAliases} = args;
+        const args = taggedScope(rawArgs, REQUEST_TAG.deploy), {client: client, tag: tag, workflowResource: workflowResource, resourceAliases: resourceAliases} = args;
         validateTag(tag);
         const definitions = args.definitions.map(def => parseDefinitionInput(def, "workflow.deployDefinitions"));
-        definitions.forEach(validateDefinition);
+        definitions.forEach(validateDefinition), assertReaderModelAcknowledgement(args.expectedMinReaderModel, {
+            requiredMinReaderModel: requiredDefinitionReaderModel(definitions)
+        });
         const ordered = await sortByDependencies({
             client: client,
             definitions: definitions,
@@ -11159,6 +11506,7 @@ const workflow = {
                 latest: latest,
                 target: {
                     tag: tag,
+                    workflowResource: workflowResource,
                     ...resourceAliases !== void 0 ? {
                         resourceAliases: resourceAliases
                     } : {}
@@ -11209,7 +11557,7 @@ const workflow = {
         }), result;
     },
     startInstance: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.start), {client: client, tag: tag, definition: definitionName, version: version, initialFields: initialFields, instanceId: instanceId, executionContext: executionContext} = args, operationContext = await resolveOperationContext(args), {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = operationContext, clock = args.clock ?? wallClock, seedFields = initialFields ?? [], existing = instanceId !== void 0 ? await getInstanceDocument(client, instanceId) : void 0;
+        const args = taggedScope(rawArgs, REQUEST_TAG.start), {client: client, tag: tag, definition: definitionName, version: version, initialFields: initialFields, instanceId: instanceId, executionContext: executionContext} = args, operationContext = await resolveOperationContext(args), {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader} = operationContext, clock = args.clock ?? wallClock, seedFields = initialFields ?? [], existing = instanceId !== void 0 ? await getInstanceDocument(client, instanceId) : void 0;
         return existing !== void 0 && existing.tag === tag ? resumeStart({
             client: client,
             tag: tag,
@@ -11220,6 +11568,7 @@ const workflow = {
             actor: actor,
             clientForGdr: clientForGdr,
             refSurface: refSurface,
+            memberRolesLoader: memberRolesLoader,
             clock: clock,
             ...executionContext !== void 0 ? {
                 executionContext: executionContext
@@ -11239,7 +11588,7 @@ const workflow = {
         return runCommitVerb({
             args: args,
             op: "fireAction",
-            run: async ({access: access, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+            run: async ({access: access, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, record: record, before: before}) => {
                 if (findCurrentActivityEntry(before, activity) === void 0 && idempotent === !0) return {
                     instance: before,
                     cascaded: 0,
@@ -11253,6 +11602,7 @@ const workflow = {
                     actor: actor,
                     clientForGdr: clientForGdr,
                     refSurface: refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     clock: clock,
                     before: before,
                     ...grantsFromPath !== void 0 ? {
@@ -11286,6 +11636,7 @@ const workflow = {
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
+                        memberRolesLoader: memberRolesLoader,
                         ...executionContext !== void 0 ? {
                             executionContext: executionContext
                         } : {},
@@ -11314,7 +11665,7 @@ const workflow = {
         return runCommitVerb({
             args: args,
             op: "editField",
-            run: async ({access: access, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+            run: async ({access: access, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, record: record, before: before}) => {
                 const result = await dispatchGatedWrite({
                     client: client,
                     tag: tag,
@@ -11323,6 +11674,7 @@ const workflow = {
                     actor: actor,
                     clientForGdr: clientForGdr,
                     refSurface: refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     clock: clock,
                     before: before,
                     ...grantsFromPath !== void 0 ? {
@@ -11357,6 +11709,7 @@ const workflow = {
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
+                        memberRolesLoader: memberRolesLoader,
                         ...executionContext !== void 0 ? {
                             executionContext: executionContext
                         } : {},
@@ -11377,7 +11730,7 @@ const workflow = {
         });
     },
     completeEffect: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.completeEffect), {client: client, tag: tag, instanceId: instanceId, effectKey: effectKey, status: status, outputs: outputs, ops: ops, detail: detail, error: error, durationMs: durationMs, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, record = requestRecordFor({
+        const args = taggedScope(rawArgs, REQUEST_TAG.completeEffect), {client: client, tag: tag, instanceId: instanceId, effectKey: effectKey, status: status, outputs: outputs, ops: ops, detail: detail, error: error, durationMs: durationMs, executionContext: executionContext} = args, operationContext = await resolveOperationContext(args), clock = args.clock ?? wallClock, record = requestRecordFor({
             idempotencyKey: args.idempotencyKey,
             op: "completeEffect",
             idempotencyTtlMs: args.idempotencyTtlMs
@@ -11388,9 +11741,7 @@ const workflow = {
             instanceId: instanceId,
             record: record,
             now: clock(),
-            actor: actor,
-            clientForGdr: clientForGdr,
-            refSurface: refSurface,
+            ...operationContext,
             clock: clock,
             executionContext: executionContext,
             telemetry: args.telemetry,
@@ -11419,10 +11770,8 @@ const workflow = {
                         requestRecord: record
                     } : {},
                     options: engineOptionsForActor({
-                        actor: actor,
+                        ...operationContext,
                         clock: clock,
-                        clientForGdr: clientForGdr,
-                        refSurface: refSurface,
                         executionContext: executionContext,
                         telemetry: args.telemetry
                     })
@@ -11430,9 +11779,7 @@ const workflow = {
                     client: client,
                     tag: tag,
                     instanceId: instanceId,
-                    actor: actor,
-                    clientForGdr: clientForGdr,
-                    refSurface: refSurface,
+                    ...operationContext,
                     clock: clock,
                     executionContext: executionContext,
                     telemetry: args.telemetry
@@ -11453,7 +11800,7 @@ const workflow = {
         });
     },
     commitEffectOps: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.commitEffectOps), {client: client, tag: tag, instanceId: instanceId, effectKey: effectKey, claimToken: claimToken, ops: ops, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, record = requestRecordFor({
+        const args = taggedScope(rawArgs, REQUEST_TAG.commitEffectOps), {client: client, tag: tag, instanceId: instanceId, effectKey: effectKey, claimToken: claimToken, ops: ops, executionContext: executionContext} = args, operationContext = await resolveOperationContext(args), clock = args.clock ?? wallClock, record = requestRecordFor({
             idempotencyKey: args.idempotencyKey,
             op: "commitEffectOps",
             idempotencyTtlMs: args.idempotencyTtlMs
@@ -11465,9 +11812,7 @@ const workflow = {
             instanceId: instanceId,
             record: record,
             now: clock(),
-            actor: actor,
-            clientForGdr: clientForGdr,
-            refSurface: refSurface,
+            ...operationContext,
             clock: clock,
             executionContext: executionContext,
             telemetry: args.telemetry,
@@ -11481,10 +11826,8 @@ const workflow = {
                     requestRecord: record,
                     leaseMs: args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS,
                     options: engineOptionsForActor({
-                        actor: actor,
+                        ...operationContext,
                         clock: clock,
-                        clientForGdr: clientForGdr,
-                        refSurface: refSurface,
                         executionContext: executionContext,
                         telemetry: args.telemetry
                     })
@@ -11492,9 +11835,7 @@ const workflow = {
                     client: client,
                     tag: tag,
                     instanceId: instanceId,
-                    actor: actor,
-                    clientForGdr: clientForGdr,
-                    refSurface: refSurface,
+                    ...operationContext,
                     clock: clock,
                     executionContext: executionContext,
                     telemetry: args.telemetry
@@ -11513,7 +11854,7 @@ const workflow = {
         });
     },
     tick: async rawArgs => {
-        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({
+        const args = taggedScope(rawArgs, REQUEST_TAG.tick), {client: client, tag: tag, instanceId: instanceId, executionContext: executionContext} = args, operationContext = await resolveOperationContext(args), {access: access} = operationContext, clock = args.clock ?? wallClock, current = await reload({
             client: client,
             instanceId: instanceId,
             tag: tag
@@ -11527,9 +11868,7 @@ const workflow = {
             client: client,
             tag: tag,
             instanceId: instanceId,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            refSurface: refSurface,
+            ...operationContext,
             clock: clock,
             executionContext: executionContext,
             telemetry: args.telemetry
@@ -11549,7 +11888,7 @@ const workflow = {
         return runCommitVerb({
             args: args,
             op: "setStage",
-            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, record: record, before: before}) => {
                 const result = await setStage({
                     client: client,
                     instanceId: instanceId,
@@ -11565,6 +11904,7 @@ const workflow = {
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
+                        memberRolesLoader: memberRolesLoader,
                         executionContext: executionContext,
                         telemetry: args.telemetry
                     })
@@ -11574,6 +11914,7 @@ const workflow = {
                     actor: actor,
                     clientForGdr: clientForGdr,
                     refSurface: refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     clock: clock,
                     ...executionContext !== void 0 ? {
                         executionContext: executionContext
@@ -11603,7 +11944,7 @@ const workflow = {
         return runCommitVerb({
             args: args,
             op: "abortInstance",
-            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, record: record, before: before}) => {
                 const changed = await abortAndPropagate({
                     client: client,
                     instanceId: instanceId,
@@ -11611,6 +11952,7 @@ const workflow = {
                     actor: actor,
                     clientForGdr: clientForGdr,
                     refSurface: refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     clock: clock,
                     ...executionContext !== void 0 ? {
                         executionContext: executionContext
@@ -11644,7 +11986,7 @@ const workflow = {
         return runCommitVerb({
             args: args,
             op: "resetActivity",
-            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, record: record, before: before}) => {
+            run: async ({actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, clock: clock, record: record, before: before}) => {
                 const result = await resetActivity({
                     client: client,
                     instanceId: instanceId,
@@ -11658,6 +12000,7 @@ const workflow = {
                         clock: clock,
                         clientForGdr: clientForGdr,
                         refSurface: refSurface,
+                        memberRolesLoader: memberRolesLoader,
                         executionContext: executionContext,
                         telemetry: args.telemetry
                     })
@@ -11667,6 +12010,7 @@ const workflow = {
                     actor: actor,
                     clientForGdr: clientForGdr,
                     refSurface: refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     clock: clock,
                     ...executionContext !== void 0 ? {
                         executionContext: executionContext
@@ -11972,7 +12316,7 @@ async function startRequirementVerdict(args) {
 }
 
 async function startFreshInstance(args) {
-    const {args: startArgs, operationContext: operationContext, clock: clock, seedFields: seedFields} = args, {client: client, tag: tag, workflowResource: workflowResource, definition: definitionName, version: version, ancestors: ancestors, context: context, instanceId: instanceId, perspective: perspective, executionContext: executionContext} = startArgs, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = operationContext, definition = await loadDefinition({
+    const {args: startArgs, operationContext: operationContext, clock: clock, seedFields: seedFields} = args, {client: client, tag: tag, workflowResource: workflowResource, definition: definitionName, version: version, ancestors: ancestors, context: context, instanceId: instanceId, perspective: perspective, executionContext: executionContext} = startArgs, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader} = operationContext, definition = await loadDefinition({
         client: client,
         definition: definitionName,
         version: version,
@@ -11996,6 +12340,7 @@ async function startFreshInstance(args) {
         id: id,
         now: now,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         ...perspective !== void 0 ? {
             perspective: perspective
         } : {}
@@ -12027,6 +12372,7 @@ async function startFreshInstance(args) {
         actor: actor,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
+        memberRolesLoader: memberRolesLoader,
         clock: clock,
         ...executionContext !== void 0 ? {
             executionContext: executionContext
@@ -12082,7 +12428,10 @@ async function assertStartInputs(args) {
 }
 
 async function resolveStartFields(args) {
-    const {client: client, tag: tag, workflowResource: workflowResource, definition: definition, initialFields: initialFields, id: id, now: now, refSurface: refSurface, perspective: perspective} = args, fieldDiscards = [];
+    const {client: client, tag: tag, workflowResource: workflowResource, definition: definition, initialFields: initialFields, id: id, now: now, refSurface: refSurface, memberRolesLoader: memberRolesLoader, perspective: perspective} = args, fieldDiscards = [], memberRoles = await memberRolesLoader({
+        workflowResource: workflowResource,
+        definition: definition
+    });
     return {
         resolvedFields: await resolveDeclaredFields({
             entryDefs: definition.fields ?? [],
@@ -12095,6 +12444,8 @@ async function resolveStartFields(args) {
                 workflowResource: workflowResource,
                 definitionName: definition.name,
                 refSurface: refSurface,
+                memberRoles: memberRoles,
+                roleAliases: definition.roleAliases,
                 ...perspective !== void 0 ? {
                     perspective: perspective
                 } : {},
@@ -12762,11 +13113,12 @@ function createInstanceSession(args) {
                 attributes: attributes
             } : {}
         });
-    }, settleAfterApply = async ({actor: actor, held: held, ranOps: ranOps, scope: scope}) => {
+    }, settleAfterApply = async ({actor: actor, held: held, ranOps: ranOps, scope: scope, memberRolesLoader: memberRolesLoader}) => {
         const cascaded = await cascadeHeld({
             scope: scope,
             actor: actor,
-            held: held
+            held: held,
+            memberRolesLoader: memberRolesLoader
         });
         return instance = await reload({
             client: scope.client,
@@ -12780,12 +13132,13 @@ function createInstanceSession(args) {
                 ranOps: ranOps
             } : {}
         };
-    }, cascadeHeld = ({scope: scope, actor: actor, held: held}) => cascade({
+    }, cascadeHeld = ({scope: scope, actor: actor, held: held, memberRolesLoader: memberRolesLoader}) => cascade({
         client: scope.client,
         instanceId: instance._id,
         actor: actor,
         clientForGdr: scope.clientForGdr,
         refSurface: scope.refSurface,
+        memberRolesLoader: memberRolesLoader,
         ...clock !== void 0 ? {
             clock: clock
         } : {},
@@ -12882,6 +13235,7 @@ function createInstanceSession(args) {
         },
         tick() {
             return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
+                const memberRolesLoader = createAssignmentMemberRolesLoader(tickScope.client);
                 await assertInstanceWriteAllowed({
                     instance: instance,
                     guards: heldGuards,
@@ -12897,7 +13251,8 @@ function createInstanceSession(args) {
                 }), cascaded = await cascadeHeld({
                     scope: tickScope,
                     actor: actor,
-                    held: held
+                    held: held,
+                    memberRolesLoader: memberRolesLoader
                 });
                 return instance = await reload({
                     client: tickScope.client,
@@ -12916,6 +13271,7 @@ function createInstanceSession(args) {
         },
         fireAction({activity: activity, action: action, params: params}) {
             return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
+                const memberRolesLoader = createAssignmentMemberRolesLoader(fireScope.client);
                 assertActionAllowed({
                     evaluation: await evaluateWith({
                         held: held,
@@ -12936,6 +13292,7 @@ function createInstanceSession(args) {
                     } : {},
                     clientForGdr: fireScope.clientForGdr,
                     refSurface: fireScope.refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     ...grants !== void 0 ? {
                         grants: grants
                     } : {},
@@ -12955,7 +13312,8 @@ function createInstanceSession(args) {
                     actor: actor,
                     held: held,
                     ranOps: ranOps,
-                    scope: fireScope
+                    scope: fireScope,
+                    memberRolesLoader: memberRolesLoader
                 });
                 return telemetry.log(WorkflowActionFired, actionFiredData({
                     instance: preOp,
@@ -12977,6 +13335,7 @@ function createInstanceSession(args) {
                 return Promise.reject(err);
             }
             return commit(async ({actor: actor, localPrincipalId: localPrincipalId}, held) => {
+                const memberRolesLoader = createAssignmentMemberRolesLoader(editScope.client);
                 assertEditAllowed(await evaluateWith({
                     held: held,
                     guards: heldGuards,
@@ -12998,6 +13357,7 @@ function createInstanceSession(args) {
                     } : {},
                     clientForGdr: editScope.clientForGdr,
                     refSurface: editScope.refSurface,
+                    memberRolesLoader: memberRolesLoader,
                     ...grants !== void 0 ? {
                         grants: grants
                     } : {},
@@ -13014,7 +13374,8 @@ function createInstanceSession(args) {
                     actor: actor,
                     held: held,
                     ranOps: ranOps,
-                    scope: editScope
+                    scope: editScope,
+                    memberRolesLoader: memberRolesLoader
                 });
                 return telemetry.log(WorkflowFieldEdited, fieldEditedData({
                     instance: preOp,
@@ -13333,8 +13694,11 @@ function attributeMember({member: member, group: group, chain: chain}) {
 }
 
 function diffEntry({def: rawDef, latestRaw: latestRaw, target: target}) {
-    assertReaderModelAcknowledgement(target.expectedMinReaderModel);
-    const def = parseDefinitionInput(rawDef, "diffEntry"), plan = planDefinitionDeploy({
+    const def = parseDefinitionInput(rawDef, "diffEntry");
+    assertReaderModelAcknowledgement(target.expectedMinReaderModel, {
+        requiredMinReaderModel: requiredDefinitionReaderModel([ def ])
+    });
+    const plan = planDefinitionDeploy({
         def: def,
         latest: asLatest(latestRaw),
         target: target
@@ -13365,10 +13729,13 @@ function asLatest(raw) {
 }
 
 async function computeDiffEntries({client: client, defs: defs, target: target}) {
-    assertReaderModelAcknowledgement(target.expectedMinReaderModel);
+    const definitions = defs.map(def => parseDefinitionInput(def, "computeDiffEntries"));
+    assertReaderModelAcknowledgement(target.expectedMinReaderModel, {
+        requiredMinReaderModel: requiredDefinitionReaderModel(definitions)
+    });
     const entries = [];
-    for (const rawDef of defs) {
-        const def = parseDefinitionInput(rawDef, "computeDiffEntries"), latest = await loadLatestDeployed({
+    for (const def of definitions) {
+        const latest = await loadLatestDeployed({
             client: client,
             definition: def.name,
             tag: target.tag
@@ -13693,4 +14060,4 @@ function displayDescription(typeKey) {
     if (typeKey) return DISPLAY[typeKey]?.description;
 }
 
-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, DECISION_SEMANTICS, 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, NEUTRAL_MARK, OP_DISPLAY, OUTCOME_MARKS, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, SIGNAL_SEMANTICS, 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, definitionTagsGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deployedTagsGroq, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, documentStuckCause, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartRequirement, extractDocumentId, fieldTreeShape, findActivityNode, findCurrentActivityEntry, findOpenStageEntry, findStageNode, 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, isRevisionConflict, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, lakePrincipalId, latestDefinitionsGroq, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseDefinitionSnapshotValue, 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, resolveUserAttributes, 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, userLoginProvider, 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_MAX_READER, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DECISION_SEMANTICS, 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, NEUTRAL_MARK, OP_DISPLAY, OUTCOME_MARKS, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, SIGNAL_SEMANTICS, 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, WorkflowInstancePreviewSchema, WorkflowInstanceSchema, WorkflowInstanceStarted, WorkflowInstanceTicked, WorkflowStageSet, WorkflowStageTransitioned, WorkflowStateDivergedError, abortReason, acceptsDocumentType, aclPathForResource, actionDisabledDetail, actionRendering, actionVerdict, activityAutonomyOf, actorFulfillsRole, 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, definitionTagsGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deployedTagsGroq, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, documentStuckCause, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartRequirement, extractDocumentId, fieldTreeShape, findActivityNode, findCurrentActivityEntry, findOpenStageEntry, findStageNode, formatRead, gdrFromResource, gdrRef, gdrUri, groupMembershipNames, groupSitesOf, guardMatches, guardsForDefinition, guardsForInstance, guardsForResource, guillemets2 as guillemets, hasSingleSubjectRequirement, hashDefinitionContent, humanize2 as humanize, inFlightFilter, initialFieldIssues, instanceChangesQuery, instanceDocId, instanceGuardQuery, instancePreviewsQuery, instanceWatchesDocument, instancesGuardQuery, instancesQuery, isCascadeFired, isClaimExpired, isClientProjectUser, isComparisonOp, isDefinitionApplicable, isFilterScopedOut, isGdr, isInputSourced, isNotesEntry, isProjectUserNotFoundError, isRevisionConflict, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, lakePrincipalId, latestDefinitionsGroq, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseDefinitionSnapshotValue, parseGdr, parseGuardDocument, parseInstanceDocument, parseInstancePreviewDocument, parseResourceGdr, processShellUserProperties, projectStartSliceRow, projectToWatchRef, quoted2 as quoted, readInstanceDoc, readInstancePreviewDoc, readsRaw, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, refsOf, rejectedRefTypes, releaseDocId, releaseRef, remediationsFor, requiredDefinitionReaderModel, requiredModelFeatures, requiredReaderModel, resolveAccess, resolveActor, resolveClientActor, resolveFieldEntry$1 as resolveFieldEntry, resolveUserAttributes, 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, userLoginProvider, validateDefinition, validateTag, verdictGuardsForInstance, wallClock, whatIfCondition2 as whatIfCondition, withAssignment, workflow };