@sanity/workflow-engine 0.17.0 → 0.18.0

package/dist/index.cjs

@@ -55,28 +55,6 @@ function findCurrentActivityEntry(host, activityName) {
     return findOpenStageEntry(host)?.activities.find(a => a.name === activityName);
 }
 
-const WORKFLOW_INSTANCE_TYPE = "sanity.workflow.instance";
-
-function terminalState(instance) {
-    return instance.abortedAt !== void 0 ? "aborted" : instance.completedAt !== void 0 ? "completed" : "in-flight";
-}
-
-function isUnprimed(instance) {
-    return instance.stages.length === 0 && terminalState(instance) === "in-flight";
-}
-
-function parseDefinitionSnapshot(instance) {
-    try {
-        return JSON.parse(instance.definitionSnapshot);
-    } catch (err) {
-        invariants.rethrowWithContext(err, `Failed to parse definitionSnapshot on instance "${instance._id}"`);
-    }
-}
-
-function parentRef(instance) {
-    return instance.ancestors.at(-1);
-}
-
 function effectiveEditable(baseline, override) {
     if (baseline === void 0) return;
     if (override === void 0) return baseline;
@@ -116,6 +94,9 @@ function resolveFieldSite(site, stage) {
         ...site.entry.title !== void 0 ? {
             title: site.entry.title
         } : {},
+        ...site.entry.validation !== void 0 ? {
+            validation: site.entry.validation
+        } : {},
         ref: {
             scope: site.scope,
             field: site.entry.name
@@ -150,7 +131,7 @@ function resolveEditTarget(args) {
 }
 
 function fieldWindowOpen(instance, site) {
-    const terminal = terminalState(instance);
+    const terminal = invariants.terminalState(instance);
     if (terminal !== "in-flight") return {
         open: !1,
         detail: `instance ${terminal}`
@@ -203,14 +184,8 @@ function editDisabledReason(args) {
         kind: "not-editable"
     };
     if (!window.open) {
-        const terminal = terminalState(instance);
-        return terminal === "aborted" && instance.abortedAt !== void 0 ? {
-            kind: "instance-aborted",
-            abortedAt: instance.abortedAt
-        } : terminal === "completed" && instance.completedAt !== void 0 ? {
-            kind: "instance-completed",
-            completedAt: instance.completedAt
-        } : {
+        const terminalReason = instanceTerminalReason(instance);
+        return terminalReason !== void 0 ? terminalReason : {
             kind: "edit-window-closed",
             detail: window.detail ?? "closed"
         };
@@ -222,6 +197,18 @@ function editDisabledReason(args) {
     };
 }
 
+function instanceTerminalReason(instance) {
+    const terminal = invariants.terminalState(instance);
+    if (terminal === "aborted" && instance.abortedAt !== void 0) return {
+        kind: "instance-aborted",
+        abortedAt: instance.abortedAt
+    };
+    if (terminal === "completed" && instance.completedAt !== void 0) return {
+        kind: "instance-completed",
+        completedAt: instance.completedAt
+    };
+}
+
 function defineWorkflowEvent(options) {
     return {
         type: "log",
@@ -332,7 +319,7 @@ function instanceStartedData(args) {
 function instanceStartedDataFor(args) {
     return instanceStartedData({
         definition: {
-            ...parseDefinitionSnapshot(args.instance),
+            ...invariants.parseDefinitionSnapshot(args.instance),
             ...args.instance.pinnedContentHash !== void 0 ? {
                 contentHash: args.instance.pinnedContentHash
             } : {}
@@ -360,7 +347,7 @@ function stageTransitionedData(args) {
 }
 
 function openStage$1(instance) {
-    const definition = parseDefinitionSnapshot(instance);
+    const definition = invariants.parseDefinitionSnapshot(instance);
     return {
         definition: definition,
         stage: definition.stages.find(s => s.name === instance.currentStage)
@@ -861,13 +848,13 @@ const checklistLines = groqConditionDescribe.checklistLines;
 function toGroqDescribeContext(ctx) {
     return {
         renderRead: read => renderWorkflowRead(read, ctx),
-        renderRequirement: workflowRequirement,
+        renderRequirement: requirement => workflowRequirement(requirement, ctx),
         atomPatterns: [ rolesGateText, claimGateText ],
         nowParam: "now"
     };
 }
 
-const VAR_LABELS = new Map(invariants.CONDITION_VARS.map(entry => [ entry.name, entry.label ]));
+const VAR_LABELS = new Map([ ...invariants.START_ALLOWED_VARS, ...invariants.CONDITION_VARS ].map(entry => [ entry.name, entry.label ]));
 
 function renderWorkflowRead(read, ctx) {
     if (read.variable === "fields" && typeof read.path[0] == "string") {
@@ -907,7 +894,7 @@ function renderWorkflowRead(read, ctx) {
     });
 }
 
-function workflowRequirement(requirement) {
+function workflowRequirement(requirement, ctx) {
     const {target: target} = requirement, clause = clauseVarRequirement(requirement);
     if (clause !== void 0) return clause;
     if (target.variable === "assigned" && target.path.length === 0) {
@@ -920,7 +907,7 @@ function workflowRequirement(requirement) {
             text: "you must not be assigned to this activity"
         });
     }
-    if (target.variable === "effectStatus" && typeof target.path[0] == "string") return effectStatusPhrase(requirement, target.path[0]);
+    return effectStatusPhrase(requirement, ctx);
 }
 
 function clauseVarRequirement(requirement) {
@@ -940,28 +927,40 @@ function clauseVarRequirement(requirement) {
             params: {},
             text: "no activity in this stage may have failed"
         });
+        if (target.variable === invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR) return kind === "truthy" ? groqConditionDescribe.phrase("requirement.subject-has-in-flight-instance", {
+            params: {},
+            text: "the subject must already have an in-flight workflow"
+        }) : groqConditionDescribe.phrase("requirement.subject-has-no-in-flight-instance", {
+            params: {},
+            text: "the subject must not already have an in-flight workflow"
+        });
     }
 }
 
-function effectStatusPhrase(requirement, effect) {
-    const name = `the ${groqConditionDescribe.quoted(effect)} automation`;
+function effectStatusPhrase(requirement, ctx) {
+    const {target: target} = requirement;
+    if (target.variable !== "effectStatus" || typeof target.path[0] != "string") return;
+    const effect = target.path[0], title = effectTitleOf(effect, ctx), name = `the ${groqConditionDescribe.quoted(title)} automation`;
     if (requirement.kind === "equals" && requirement.value === "done") return groqConditionDescribe.phrase("requirement.effect-done", {
         params: {
-            effect: effect
+            effect: effect,
+            title: title
         },
-        text: `${name} must have completed`
+        text: `${name} must have succeeded`
     });
     if (requirement.kind === "equals" && requirement.value === "failed") return groqConditionDescribe.phrase("requirement.effect-failed", {
         params: {
-            effect: effect
+            effect: effect,
+            title: title
         },
         text: `${name} must have failed`
     });
     if (requirement.kind === "defined") return groqConditionDescribe.phrase("requirement.effect-settled", {
         params: {
-            effect: effect
+            effect: effect,
+            title: title
         },
-        text: `${name} must have settled`
+        text: `${name} must have finished`
     });
 }
 
@@ -1249,12 +1248,16 @@ const WAIT_TEXTS = {
         },
         text: `waits on editor content matching ${groqConditionDescribe.quoted(wait.condition)}`
     }),
-    effect: wait => groqConditionDescribe.phrase("autonomy-wait.effect", {
-        params: {
-            effect: wait.effect
-        },
-        text: `waits on the ${groqConditionDescribe.quoted(wait.effect)} automation`
-    }),
+    effect: (wait, ctx) => {
+        const title = effectTitleOf(wait.effect, ctx);
+        return groqConditionDescribe.phrase("autonomy-wait.effect", {
+            params: {
+                effect: wait.effect,
+                title: title
+            },
+            text: `waits on the ${groqConditionDescribe.quoted(title)} automation`
+        });
+    },
     "start-input": (wait, ctx) => {
         const title = fieldTitleOf({
             path: [ wait.field ]
@@ -1367,6 +1370,10 @@ function actionTitle(site, ctx) {
     return ctx.definition.stages.flatMap(stage => stage.activities ?? []).filter(activity => activity.name === site.activity).flatMap(activity => activity.actions ?? []).find(candidate => candidate.name === site.action)?.title ?? groqConditionDescribe.humanize(site.action);
 }
 
+function effectTitleOf(name, ctx) {
+    return findEffect(ctx.definition, name)?.title ?? name;
+}
+
 function conditionSitesOf(definition) {
     const sites = [];
     for (const [predicate, condition] of Object.entries(definition.predicates ?? {})) sites.push({
@@ -1494,25 +1501,17 @@ async function applicableDefinitions(args) {
 }
 
 async function evaluateStartFilter(args) {
-    const {filter: filter, definition: definition, document: document, scope: scope} = args;
-    let parsed;
-    try {
-        parsed = {
-            tree: groqJs.parse(filter),
-            needsDataset: groqConditionDescribe.analyzeCondition(filter).readsDataset
-        };
-    } catch (err) {
-        rethrowNamingDefinition({
-            err: err,
-            definition: definition,
-            key: "filter"
-        });
-    }
-    let dataset = [];
-    if (parsed.needsDataset) {
-        if (scope?.fetchDataset === void 0) return !1;
-        dataset = await scope.fetchDataset();
-    }
+    const {filter: filter, definition: definition, document: document, scope: scope} = args, parsed = parseStartFilter({
+        filter: filter,
+        definition: definition
+    });
+    assertFilterSubject({
+        readsSubject: parsed.readsSubject,
+        definition: definition,
+        scope: scope
+    });
+    const dataset = await filterDataset(parsed.needsDataset, scope);
+    if (dataset === void 0) return !1;
     try {
         const result = await (await groqJs.evaluate(parsed.tree, {
             ...document !== void 0 ? {
@@ -1521,7 +1520,8 @@ async function evaluateStartFilter(args) {
             dataset: dataset,
             params: startContextParams({
                 definition: definition,
-                scope: scope
+                scope: scope,
+                dataset: dataset
             })
         })).get();
         return invariants.isUnevaluable(result) ? !1 : !!result;
@@ -1534,11 +1534,38 @@ async function evaluateStartFilter(args) {
     }
 }
 
+function parseStartFilter(args) {
+    const {filter: filter, definition: definition} = args;
+    try {
+        const readsSubject = readsSubjectHasInFlightInstance(filter);
+        return {
+            tree: groqJs.parse(filter),
+            needsDataset: groqConditionDescribe.analyzeCondition(filter).readsDataset || readsSubject,
+            readsSubject: readsSubject
+        };
+    } catch (err) {
+        rethrowNamingDefinition({
+            err: err,
+            definition: definition,
+            key: "filter"
+        });
+    }
+}
+
+function assertFilterSubject(args) {
+    if (!(!args.readsSubject || args.scope?.subject !== void 0)) throw new invariants.ContractViolationError(`start.filter on definition "${args.definition.name ?? "<unnamed>"}" reads $${invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR}, but the caller supplied no resource-qualified \`scope.subject\` — a loaded document alone cannot identify its project and dataset.`);
+}
+
+async function filterDataset(needsDataset, scope) {
+    if (!needsDataset) return [];
+    if (scope?.fetchDataset !== void 0) return scope.fetchDataset();
+}
+
 async function explainStartAllowed(args) {
     const {allowed: allowed, definition: definition, fields: fields, scope: scope} = args;
     let needsDataset;
     try {
-        needsDataset = groqConditionDescribe.analyzeCondition(allowed).readsDataset;
+        needsDataset = groqConditionDescribe.analyzeCondition(allowed).readsDataset || readsSubjectHasInFlightInstance(allowed);
     } catch (err) {
         rethrowNamingDefinition({
             err: err,
@@ -1558,7 +1585,8 @@ async function explainStartAllowed(args) {
             params: startContextParams({
                 definition: definition,
                 scope: scope,
-                fields: fields
+                fields: fields,
+                dataset: dataset
             })
         });
     } catch (err) {
@@ -1574,11 +1602,23 @@ function unboundAllowedReads(allowed, fields) {
     return [ ...invariants.conditionFieldReadNames(allowed) ].filter(name => !Object.hasOwn(fields, name));
 }
 
+function unboundAllowedReadsWithSubject(args) {
+    const {allowed: allowed, fields: fields, definition: definition} = args, subjectField = (definition.fields ?? []).find(invariants.isSubjectEntry)?.name, reads = unboundAllowedReads(allowed, fields);
+    return subjectField !== void 0 && readsSubjectHasInFlightInstance(allowed) && !Object.hasOwn(fields, subjectField) && !reads.includes(subjectField) && reads.push(subjectField), 
+    reads;
+}
+
 function rethrowNamingDefinition({err: err, definition: definition, key: key}) {
-    invariants.rethrowWithContext(err, `start.${key} on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (deploy validation rejects this — was the definition written around it?)`);
+    invariants.rethrowWithContext(err, `start.${key} on definition "${definition.name ?? "<unnamed>"}" failed to evaluate (check the predicate and its evaluation inputs)`);
+}
+
+function startContextParams({definition: definition, scope: scope, fields: fields, dataset: dataset}) {
+    const subject = fields === void 0 ? scope?.subject : startSubject(definition, fields) ?? scope?.subject, params = baseStartParams(definition, scope);
+    return fields !== void 0 && (params.fields = fields), subject !== void 0 && (params[invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR] = subjectHasInFlightInstance(dataset, subject)), 
+    params;
 }
 
-function startContextParams({definition: definition, scope: scope, fields: fields}) {
+function baseStartParams(definition, scope) {
     return {
         ...definition.name !== void 0 ? {
             definition: definition.name
@@ -1588,13 +1628,33 @@ function startContextParams({definition: definition, scope: scope, fields: field
         } : {},
         ...scope?.now !== void 0 ? {
             now: scope.now
-        } : {},
-        ...fields !== void 0 ? {
-            fields: fields
         } : {}
     };
 }
 
+function readsSubjectHasInFlightInstance(groq) {
+    return invariants.conditionParameterNames(groq).has(invariants.SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR);
+}
+
+function startSubject(definition, fields) {
+    const subjectEntry = (definition.fields ?? []).find(invariants.isSubjectEntry);
+    if (subjectEntry === void 0) return;
+    const value = fields[subjectEntry.name];
+    return invariants.isGdr(value) ? value.id : void 0;
+}
+
+function subjectHasInFlightInstance(dataset, subject) {
+    return dataset.some(row => {
+        if (typeof row != "object" || row === null) return !1;
+        const instance = row;
+        return instance._type !== invariants.WORKFLOW_INSTANCE_TYPE || instance.completedAt !== void 0 || !Array.isArray(instance.fields) ? !1 : instance.fields.some(entry => {
+            if (typeof entry != "object" || entry === null) return !1;
+            const field = entry;
+            return field._type === "subject" && invariants.isGdr(field.value) && field.value.id === subject;
+        });
+    });
+}
+
 async function evaluateDeclaredStartFilter(args) {
     const {definition: definition, document: document, scope: scope} = args, filter = definition.start?.filter;
     return filter === void 0 ? !0 : evaluateStartFilter({
@@ -1730,9 +1790,9 @@ function overlayInstanceInSnapshot(snapshot, instance) {
 
 function resolveFieldRead(args) {
     const {kind: kind, value: value, path: path, snapshot: snapshot, targetKind: targetKind} = args;
-    if (kind === "doc.ref") {
+    if (invariants.isSingleDocRefKind(kind)) {
         if (!invariants.isGdr(value)) return null;
-        if (path === void 0 && targetKind === "doc.ref") return value;
+        if (path === void 0 && targetKind !== void 0 && invariants.isSingleDocRefKind(targetKind)) return value;
         const base = derefBase(value, snapshot);
         return path === void 0 ? base : walkDocPath(base, path);
     }
@@ -1751,7 +1811,7 @@ function buildParams(args) {
     return {
         self: invariants.selfGdr(instance),
         fields: renderedFields(instance.fields ?? [], snapshot),
-        parent: parentRef(instance)?.id ?? null,
+        parent: invariants.parentRef(instance)?.id ?? null,
         ancestors: instance.ancestors.map(a => a.id),
         stage: instance.currentStage,
         now: now,
@@ -1905,7 +1965,7 @@ function instanceDocId(tag) {
 
 function mapFieldRefValues(args) {
     const {entryType: entryType, value: value, fields: fields, of: of, mapRef: mapRef} = args;
-    return value == null ? value : entryType === "doc.ref" || entryType === "release.ref" ? mapRef(value) : entryType === "doc.refs" ? mapItems(value, mapRef) : entryType === "object" ? mapRowRefValues({
+    return value == null ? value : invariants.isSingleDocRefKind(entryType) || entryType === "release.ref" ? mapRef(value) : entryType === "doc.refs" ? mapItems(value, mapRef) : entryType === "object" ? mapRowRefValues({
         row: value,
         shapes: fields ?? [],
         mapRef: mapRef
@@ -2112,6 +2172,27 @@ class RequiredFieldNotProvidedError extends invariants.WorkflowError {
     }
 }
 
+class InitialFieldsInvalidError extends invariants.WorkflowError {
+    definition;
+    issues;
+    constructor(args) {
+        const where = args.definition === void 0 ? "" : ` for workflow "${args.definition}"`, lines = args.issues.map(formatInitialFieldIssue).join(`\n`);
+        super("initial-fields-invalid", `Initial fields${where} contain rows the engine cannot consume:\n${lines}\nRemove or correct every listed row before retrying.`), 
+        this.name = "InitialFieldsInvalidError", args.definition !== void 0 && (this.definition = args.definition), 
+        this.issues = args.issues;
+    }
+}
+
+function formatInitialFieldIssue(issue) {
+    const row = `  - row ${issue.index}: ${issue.name} (${issue.type})`;
+    if (issue.reason === "duplicate") return `${row} duplicates rows ${issue.duplicateIndexes.join(", ")}`;
+    if (issue.reason === "undeclared") return `${row} is not declared by the workflow`;
+    if (issue.reason === "wrong-kind") return `${row} has the wrong kind; expected ${issue.expectedTypes.join(" or ")}`;
+    if (issue.reason === "not-input") return `${row} is ${issue.source}-sourced, not caller-input-sourced`;
+    const scope = issue.scope === "activity" ? `activity "${issue.activity}" in stage "${issue.stage}"` : `stage "${issue.stage}"`;
+    return `${row} targets ${scope}, not workflow scope (declared as ${issue.declaredType})`;
+}
+
 class WorkflowStateDivergedError extends invariants.WorkflowError {
     instanceId;
     guardError;
@@ -2235,10 +2316,28 @@ function validateActionParams({action: action, activityName: activityName, calle
             });
             continue;
         }
-        present && (checkParamType(value, decl) || issues.push({
+        if (!present) continue;
+        if (!checkParamType(value, decl)) {
+            issues.push({
+                param: decl.name,
+                reason: `expected type=${decl.type}, got ${typeof value}`
+            });
+            continue;
+        }
+        const choiceIssues = invariants.choiceValueIssues(decl.options, value);
+        choiceIssues !== void 0 && issues.push({
             param: decl.name,
-            reason: `expected type=${decl.type}, got ${typeof value}`
-        }));
+            reason: choiceIssues.join("; ")
+        });
+        const validationIssues = invariants.scalarValidationIssues({
+            entryType: decl.type,
+            validation: decl.validation,
+            value: value
+        });
+        validationIssues !== void 0 && issues.push({
+            param: decl.name,
+            reason: validationIssues.join("; ")
+        });
     }
     if (issues.length > 0) throw new ActionParamsInvalidError({
         action: action.name,
@@ -2348,7 +2447,10 @@ function validateEffectOps(ops, effectName) {
     const result = v__namespace.safeParse(v__namespace.array(invariants.StoredFieldOpSchema), ops);
     if (!result.success) throw new EffectOpsInvalidError({
         effect: effectName,
-        issues: invariants.formatIssues(result.issues)
+        issues: invariants.formatIssues(result.issues, issue => {
+            const path = issue.path;
+            return issue.input === void 0 && path?.at(-2)?.key === "target" && path.at(-1)?.key === "scope" ? "Effect completion field ops require target.scope: 'workflow' | 'stage'." : issue.message;
+        })
     });
     const activityScoped = result.output.find(op => op.target.scope === "activity");
     if (activityScoped !== void 0) throw new EffectOpsInvalidError({
@@ -2429,9 +2531,16 @@ function entryShape(entry) {
         fields: entry.fields
     } : entry._type === "array" ? {
         of: entry.of
-    } : entry._type === "doc.ref" || entry._type === "doc.refs" ? entry.types !== void 0 ? {
+    } : invariants.isSingleDocRefEntry(entry) || entry._type === "doc.refs" ? entry.types !== void 0 ? {
         types: entry.types
-    } : {} : {};
+    } : {} : {
+        ...entry.options !== void 0 ? {
+            options: entry.options
+        } : {},
+        ...entry.validation !== void 0 ? {
+            validation: entry.validation
+        } : {}
+    };
 }
 
 function entrySlot(entry) {
@@ -2670,10 +2779,12 @@ function resolveOpValue(args) {
 }
 
 function readEntryFromMutation(ctx, src) {
-    const scopes = src.scope !== void 0 ? [ src.scope ] : [ "stage", "workflow" ], stageEntry = findOpenStageEntry(ctx.mutation);
+    const scopes = src.scope !== void 0 ? [ src.scope ] : [ "activity", "stage", "workflow" ], stageEntry = findOpenStageEntry(ctx.mutation);
     for (const scope of scopes) {
-        const entry = (scope === "workflow" ? ctx.mutation.fields : stageEntry?.fields)?.find(s => s.name === src.field);
-        if (entry !== void 0 && entry.value !== void 0) return entry;
+        let host;
+        scope === "workflow" ? host = ctx.mutation.fields : scope === "stage" ? host = stageEntry?.fields : host = findCurrentActivityEntry(ctx.mutation, ctx.activityName)?.fields;
+        const entry = host?.find(s => s.name === src.field);
+        if (entry !== void 0) return entry;
     }
 }
 
@@ -3114,53 +3225,6 @@ async function assertInstanceWriteAllowed(args) {
     });
 }
 
-const DATA_MODEL_VERSION = 1, DATA_MODEL_MIN_READER = 0, MODEL_STAMP = {
-    modelVersion: DATA_MODEL_VERSION,
-    minReaderModel: DATA_MODEL_MIN_READER
-};
-
-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 invariants.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 requiredReaderModel = minReaderModelOf(doc);
-    if (requiredReaderModel > DATA_MODEL_VERSION) throw new ModelVersionAheadError({
-        documentId: doc._id,
-        documentModelVersion: modelVersionOf(doc),
-        requiredReaderModel: requiredReaderModel
-    });
-    return doc;
-}
-
 async function renderConditionScope(source, opts) {
     const {instance: instance, definition: definition, snapshot: snapshot, now: now} = source, base = buildParams({
         instance: instance,
@@ -3302,7 +3366,7 @@ function noTransitionFiresCause(input) {
 }
 
 function diagnoseInstance(input) {
-    const {instance: instance} = input, terminal = terminalState(instance);
+    const {instance: instance} = input, terminal = invariants.terminalState(instance);
     if (terminal === "aborted" && instance.abortedAt !== void 0) {
         const reason = abortReason(instance);
         return {
@@ -3465,7 +3529,7 @@ function liveSubworkflowRefs(instance) {
 }
 
 function readsRaw(ref) {
-    return ref.type === WORKFLOW_INSTANCE_TYPE || ref.type === "system.release";
+    return ref.type === invariants.WORKFLOW_INSTANCE_TYPE || ref.type === "system.release";
 }
 
 const DEFAULT_CONTENT_PERSPECTIVE = "drafts";
@@ -3534,7 +3598,7 @@ function instanceWatchesDocument(instance, document) {
 }
 
 function entryDocRefs(entries) {
-    return fieldEntries(entries).flatMap(entry => entry._type === "doc.ref" ? invariants.isGdr(entry.value) ? [ entry.value ] : [] : entry._type === "doc.refs" ? Array.isArray(entry.value) ? entry.value.filter(invariants.isGdr) : [] : []);
+    return fieldEntries(entries).flatMap(entry => typeof entry._type == "string" && invariants.isSingleDocRefKind(entry._type) ? invariants.isGdr(entry.value) ? [ entry.value ] : [] : entry._type === "doc.refs" ? Array.isArray(entry.value) ? entry.value.filter(invariants.isGdr) : [] : []);
 }
 
 function entryReleaseRefs(entries) {
@@ -3542,7 +3606,7 @@ function entryReleaseRefs(entries) {
 }
 
 function entrySubjectRefs(entries) {
-    return fieldEntries(entries).flatMap(entry => (entry._type === "doc.ref" || entry._type === "release.ref") && invariants.isGdr(entry.value) ? [ entry.value ] : []);
+    return fieldEntries(entries).flatMap(entry => (typeof entry._type == "string" && invariants.isSingleDocRefKind(entry._type) || entry._type === "release.ref") && invariants.isGdr(entry.value) ? [ entry.value ] : []);
 }
 
 function fieldEntries(entries) {
@@ -3565,7 +3629,13 @@ function perspectiveFromReleaseValue(value) {
 
 async function resolveDeclaredFields(args) {
     const {entryDefs: entryDefs, initialFields: initialFields, ctx: ctx, randomKey: randomKey2} = args;
-    if (entryDefs === void 0 || entryDefs.length === 0) return [];
+    if (assertInitialFieldsConsumable({
+        workflowFields: entryDefs ?? [],
+        initialFields: initialFields,
+        ...ctx.definitionName !== void 0 ? {
+            definitionName: ctx.definitionName
+        } : {}
+    }), entryDefs === void 0 || entryDefs.length === 0) return [];
     assertRequiredInputProvided({
         entryDefs: entryDefs,
         initialFields: initialFields,
@@ -3587,6 +3657,83 @@ async function resolveDeclaredFields(args) {
     return out;
 }
 
+function initialFieldIssues(args) {
+    const duplicateIndexes = /* @__PURE__ */ new Map;
+    return args.initialFields.forEach((field, index) => {
+        const key = `${field.name}\0${field.type}`, indexes = duplicateIndexes.get(key) ?? [];
+        indexes.push(index), duplicateIndexes.set(key, indexes);
+    }), args.initialFields.flatMap((field, index) => {
+        const issues = [], indexes = duplicateIndexes.get(`${field.name}\0${field.type}`) ?? [];
+        indexes.length > 1 && issues.push({
+            index: index,
+            name: field.name,
+            type: field.type,
+            reason: "duplicate",
+            duplicateIndexes: indexes.filter(candidate => candidate !== index)
+        });
+        const workflowMatches = args.workflowFields.filter(entry => entry.name === field.name);
+        if (workflowMatches.length > 0) {
+            const exact = workflowMatches.find(entry => entry.type === field.type);
+            return exact === void 0 ? issues.push({
+                index: index,
+                name: field.name,
+                type: field.type,
+                reason: "wrong-kind",
+                expectedTypes: [ ...new Set(workflowMatches.map(entry => entry.type)) ]
+            }) : exact.initialValue?.type !== "input" && issues.push({
+                index: index,
+                name: field.name,
+                type: field.type,
+                reason: "not-input",
+                source: exact.initialValue?.type ?? "working-memory"
+            }), issues;
+        }
+        const scoped = findNonWorkflowDeclaration(args.stages ?? [], field.name);
+        return scoped !== void 0 ? issues.push({
+            index: index,
+            name: field.name,
+            type: field.type,
+            reason: "invalid-scope",
+            ...scoped
+        }) : issues.push({
+            index: index,
+            name: field.name,
+            type: field.type,
+            reason: "undeclared"
+        }), issues;
+    });
+}
+
+function findNonWorkflowDeclaration(stages, name) {
+    for (const stage of stages) {
+        const stageField = stage.fields?.find(entry => entry.name === name);
+        if (stageField !== void 0) return {
+            scope: "stage",
+            stage: stage.name,
+            declaredType: stageField.type
+        };
+        for (const activity of stage.activities ?? []) {
+            const activityField = activity.fields?.find(entry => entry.name === name);
+            if (activityField !== void 0) return {
+                scope: "activity",
+                stage: stage.name,
+                activity: activity.name,
+                declaredType: activityField.type
+            };
+        }
+    }
+}
+
+function assertInitialFieldsConsumable(args) {
+    const issues = initialFieldIssues(args);
+    if (issues.length !== 0) throw new InitialFieldsInvalidError({
+        ...args.definitionName !== void 0 ? {
+            definition: args.definitionName
+        } : {},
+        issues: issues
+    });
+}
+
 function missingRequiredInputs(args) {
     return args.entryDefs.filter(entry => entry.required === !0 && invariants.isInputSourced(entry)).filter(entry => {
         const match = suppliedFieldFor(entry, args.initialFields);
@@ -3726,6 +3873,12 @@ function buildResolvedEntry({entry: entry, value: value, _key: _key, now: now})
         ...entry.description !== void 0 ? {
             description: entry.description
         } : {},
+        ...entry.options !== void 0 ? {
+            options: entry.options
+        } : {},
+        ...entry.validation !== void 0 ? {
+            validation: entry.validation
+        } : {},
         value: value,
         ...entry.initialValue?.type === "query" ? {
             resolvedAt: now
@@ -3755,7 +3908,9 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
             value: value,
             types: entry.types,
             fields: entry.fields,
-            of: entry.of
+            of: entry.of,
+            options: entry.options,
+            validation: entry.validation
         });
         return issues !== void 0 ? (ctx.recordDiscard?.({
             field: entry.name,
@@ -3778,7 +3933,9 @@ async function resolveOneEntry({entry: entry, initialFields: initialFields, ctx:
         value: value,
         types: entry.types,
         fields: entry.fields,
-        of: entry.of
+        of: entry.of,
+        options: entry.options,
+        validation: entry.validation
     }), entry.initialValue?.type === "input" && ctx.inputProvenance !== "definition" && assertRefsWithinSurface({
         entryType: entry.type,
         entryName: entry.name,
@@ -3801,8 +3958,8 @@ function fieldMapFromResolved(entries) {
 }
 
 function assertInputValueShape(entry, value) {
-    if (entry.type === "doc.ref") {
-        assertGdrShape(value, `field entry "${entry.name}" (doc.ref)`);
+    if (invariants.isSingleDocRefKind(entry.type)) {
+        assertGdrShape(value, `field entry "${entry.name}" (${entry.type})`);
         return;
     }
     if (entry.type === "release.ref") {
@@ -3825,7 +3982,7 @@ function assertGdrShape(value, context) {
 }
 
 function normalizeQueryResult({entryType: entryType, raw: raw, workflowResource: workflowResource}) {
-    return raw == null ? raw : entryType === "doc.ref" ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
+    return raw == null ? raw : invariants.isSingleDocRefKind(entryType) ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
 }
 
 function coerceGdrShape(raw, workflowResource) {
@@ -3856,11 +4013,21 @@ function coerceToGdr(raw, workflowResource) {
     } : null;
 }
 
-const EFFECT_RUN_STATUSES = [ "done", "failed", "cancelled" ], NonEmpty = invariants.NonEmptyString, UnknownRecord = v__namespace.record(v__namespace.string(), v__namespace.unknown()), PersistedFieldShapeSchema = v__namespace.lazy(() => v__namespace.looseObject(invariants.tolerantEntries()({
+const EFFECT_RUN_STATUSES = [ "done", "failed", "cancelled" ], NonEmpty = invariants.NonEmptyString, UnknownRecord = v__namespace.record(v__namespace.string(), v__namespace.unknown()), PersistedChoiceOptionsSchema = v__namespace.looseObject({
+    list: v__namespace.array(v__namespace.looseObject({
+        title: v__namespace.string(),
+        value: v__namespace.union([ v__namespace.string(), v__namespace.number() ])
+    }))
+}), PersistedScalarValidationSchema = v__namespace.looseObject({
+    min: v__namespace.optional(v__namespace.number()),
+    max: v__namespace.optional(v__namespace.number())
+}), PersistedFieldShapeSchema = v__namespace.lazy(() => v__namespace.looseObject(invariants.tolerantEntries()({
     type: v__namespace.picklist(invariants.FIELD_VALUE_KINDS),
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
+    options: v__namespace.optional(PersistedChoiceOptionsSchema),
+    validation: v__namespace.optional(PersistedScalarValidationSchema),
     fields: v__namespace.optional(v__namespace.array(PersistedFieldShapeSchema)),
     of: v__namespace.optional(v__namespace.array(PersistedFieldShapeSchema))
 }))), ExecutionContextSchema = invariants.tolerantObject()({
@@ -3890,6 +4057,8 @@ function fieldArm(kind, value) {
         name: NonEmpty,
         title: v__namespace.exactOptional(v__namespace.string()),
         description: v__namespace.exactOptional(v__namespace.string()),
+        options: v__namespace.exactOptional(PersistedChoiceOptionsSchema),
+        validation: v__namespace.exactOptional(PersistedScalarValidationSchema),
         value: value,
         resolvedAt: v__namespace.exactOptional(invariants.IsoTimestamp)
     };
@@ -3901,6 +4070,9 @@ const OptionalRefTypes = v__namespace.exactOptional(v__namespace.array(v__namesp
 })), v__namespace.looseObject(invariants.tolerantEntries()({
     ...fieldArm("doc.refs", invariants.fieldValueSchemas["doc.refs"]),
     types: OptionalRefTypes
+})), v__namespace.looseObject(invariants.tolerantEntries()({
+    ...fieldArm("subject", invariants.fieldValueSchemas.subject),
+    types: OptionalRefTypes
 })), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("release.ref", invariants.fieldValueSchemas["release.ref"]))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("string", invariants.fieldValueSchemas.string))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("text", invariants.fieldValueSchemas.text))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("number", invariants.fieldValueSchemas.number))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("boolean", invariants.fieldValueSchemas.boolean))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("date", invariants.fieldValueSchemas.date))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("datetime", invariants.fieldValueSchemas.datetime))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("url", invariants.fieldValueSchemas.url))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("actor", invariants.fieldValueSchemas.actor))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("assignee", invariants.fieldValueSchemas.assignee))), v__namespace.looseObject(invariants.tolerantEntries()(fieldArm("assignees", invariants.fieldValueSchemas.assignees))), v__namespace.looseObject(invariants.tolerantEntries()({
     ...fieldArm("object", v__namespace.union([ v__namespace.null(), UnknownRecord ])),
     fields: v__namespace.array(PersistedFieldShapeSchema)
@@ -4114,7 +4286,7 @@ const TransitionVia = v__namespace.exactOptional(v__namespace.picklist([ "transi
     _type: v__namespace.pipe(v__namespace.string(), v__namespace.check(t => !knownHistoryTypes.has(t), "must not shadow a known history variant"))
 }), HistoryEntrySchema = v__namespace.union([ v__namespace.variant("_type", HISTORY_ARMS), UnknownHistoryEntry ]), WorkflowInstanceSchema = v__namespace.looseObject(invariants.tolerantEntries()({
     _id: NonEmpty,
-    _type: v__namespace.literal(WORKFLOW_INSTANCE_TYPE),
+    _type: v__namespace.literal(invariants.WORKFLOW_INSTANCE_TYPE),
     _rev: v__namespace.string(),
     _createdAt: invariants.IsoTimestamp,
     _updatedAt: invariants.IsoTimestamp,
@@ -4147,7 +4319,7 @@ function parseInstanceDocument(doc) {
     return invariants.parsePersistedDoc({
         schema: WorkflowInstanceSchema,
         doc: doc,
-        docType: WORKFLOW_INSTANCE_TYPE
+        docType: invariants.WORKFLOW_INSTANCE_TYPE
     });
 }
 
@@ -4157,7 +4329,7 @@ async function getInstanceDocument(client, instanceId) {
 }
 
 function readInstanceDoc(doc) {
-    return parseInstanceDocument(assertReadableModel(doc));
+    return parseInstanceDocument(invariants.assertReadableModel(doc));
 }
 
 async function reload({client: client, instanceId: instanceId, tag: tag}) {
@@ -4226,14 +4398,12 @@ function buildInstanceBase(args) {
         ...actor !== void 0 ? {
             actor: actor
         } : {}
-    }, ...args.extraHistory ?? [] ], history = executionContext !== void 0 ? stampHistoryEntries(entries, executionContext) : entries;
-    return {
+    }, ...args.extraHistory ?? [] ], history = executionContext !== void 0 ? stampHistoryEntries(entries, executionContext) : entries, body = {
         _id: id,
-        _type: WORKFLOW_INSTANCE_TYPE,
+        _type: invariants.WORKFLOW_INSTANCE_TYPE,
         _rev: "",
         _createdAt: now,
         _updatedAt: now,
-        ...MODEL_STAMP,
         tag: args.tag,
         workflowResource: args.workflowResource,
         definition: args.definitionName,
@@ -4257,6 +4427,13 @@ function buildInstanceBase(args) {
         startedAt: now,
         lastChangedAt: now
     };
+    return {
+        ...body,
+        ...invariants.modelStampFor({
+            documentType: "instance",
+            document: body
+        })
+    };
 }
 
 async function hydrateSnapshot(args) {
@@ -4313,7 +4490,7 @@ async function loadByGdr({defaultClient: defaultClient, clientForGdr: clientForG
 async function readDoc({client: client, id: id, perspective: perspective}) {
     if (perspective === "raw") {
         const doc2 = await client.getDocument(id) ?? null;
-        return doc2 ? doc2._type === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : assertReadableModel(doc2) : null;
+        return doc2 ? doc2._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : invariants.assertReadableModel(doc2) : null;
     }
     const {query: query, params: params} = contentDocQuery(id);
     return await client.fetch(query, params, {
@@ -4370,7 +4547,7 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
     if (!instance) throw new invariants.InstanceNotFoundError({
         instanceId: instanceId
     });
-    const definition = parseDefinitionSnapshot(instance), {clientForGdr: clientForGdr, refSurface: refSurface} = options, clock = options.clock ?? wallClock, snapshot = await hydrateSnapshot({
+    const definition = invariants.parseDefinitionSnapshot(instance), {clientForGdr: clientForGdr, refSurface: refSurface} = options, clock = options.clock ?? wallClock, snapshot = await hydrateSnapshot({
         client: client,
         clientForGdr: clientForGdr,
         instance: instance,
@@ -4937,11 +5114,7 @@ function dedupById(guards) {
     return [ ...new Map(guards.map(g => [ g._id, g ])).values() ].sort((a, b) => a._id.localeCompare(b._id));
 }
 
-const GUARD_OWNER = "robot:workflow-engine", GUARD_LIFTED_PREDICATE = "true";
-
-function isGuardLifted(guard) {
-    return guard.predicate === GUARD_LIFTED_PREDICATE;
-}
+const GUARD_OWNER = "robot:workflow-engine";
 
 function resolveGuardRoute(guard, ctx) {
     const targets = resolveIdRefTargets(guard.match.idRefs, ctx);
@@ -5069,15 +5242,30 @@ async function deployStageGuards(args) {
 }
 
 async function retractStageGuards(args) {
+    const observed = [];
+    for (const {client: client, guardId: guardId} of resolvedStageGuardRoutes(args)) {
+        const guard = await client.getDocument(guardId, {
+            tag: REQUEST_TAG.guardRetract
+        });
+        if (guard) {
+            if (guard._rev === void 0) throw new Error(`Cannot retract guard ${guardId}: persisted document has no revision`);
+            observed.push({
+                client: client,
+                guardId: guardId,
+                predicate: guard.predicate,
+                revision: guard._rev
+            });
+        }
+    }
     const live = await committedInstance(args);
-    if (live !== void 0 && !(live.currentStage === args.stageName && live.abortedAt === void 0)) for (const {client: client, guardId: guardId} of resolvedStageGuardRoutes(args)) await client.getDocument(guardId, {
-        tag: REQUEST_TAG.guardRetract
-    }) && await client.patch(guardId).set({
-        predicate: GUARD_LIFTED_PREDICATE
-    }).commit({
-        ...SYNC_COMMIT,
-        tag: REQUEST_TAG.guardRetract
-    });
+    if (live !== void 0 && !(live.currentStage === args.stageName && live.abortedAt === void 0)) for (const {client: client, guardId: guardId, predicate: predicate, revision: revision} of observed) {
+        const revisionCheck = client.patch(guardId).set({
+            predicate: predicate
+        }).ifRevisionId(revision);
+        await client.transaction().patch(revisionCheck).delete(guardId).commit({
+            tag: REQUEST_TAG.guardRetract
+        });
+    }
 }
 
 async function deleteOrphanedDefinitionGuards(args) {
@@ -5276,7 +5464,7 @@ async function persistThenDeploy({ctx: ctx, mutation: mutation, deploy: deploy})
         committedRev: committed._rev,
         restore: instanceStateFields({
             ...ctx.instance,
-            minReaderModel: minReaderModelOf(ctx.instance)
+            minReaderModel: invariants.minReaderModelOf(ctx.instance)
         }),
         unset: ctx.instance.completedAt === void 0 ? [ "completedAt" ] : [],
         reversible: !spawned,
@@ -5607,7 +5795,7 @@ async function resolveContextHandoff({ctx: ctx, sub: sub, parentScope: parentSco
 }
 
 function canonicaliseSpawnValue({kind: kind, value: value, cx: cx}) {
-    return kind === "doc.ref" ? coerceSpawnGdr(value, cx) : kind === "doc.refs" && Array.isArray(value) ? value.map(v2 => coerceSpawnGdr(v2, cx)).filter(v2 => v2 !== null) : value;
+    return invariants.isSingleDocRefKind(kind) ? coerceSpawnGdr(value, cx) : kind === "doc.refs" && Array.isArray(value) ? value.map(v2 => coerceSpawnGdr(v2, cx)).filter(v2 => v2 !== null) : value;
 }
 
 function assertBareIdRootsCorrectly(id, cx) {
@@ -5642,16 +5830,16 @@ async function resolveDefinitionRef({client: client, ref: ref, tag: tag}) {
     };
     wantsExplicit && (params.version = ref.version);
     const result = await client.fetch(definitionLookupGroq(wantsExplicit), params);
-    return result ? assertReadableModel(result) : null;
+    return result ? invariants.assertReadableModel(result) : null;
 }
 
 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 = {
         id: invariants.gdrFromResource(workflowResource, childDocId),
-        type: WORKFLOW_INSTANCE_TYPE
+        type: invariants.WORKFLOW_INSTANCE_TYPE
     }, ancestors = [ ...parent.ancestors, {
         id: invariants.selfGdr(parent),
-        type: WORKFLOW_INSTANCE_TYPE
+        type: invariants.WORKFLOW_INSTANCE_TYPE
     } ], inheritedPerspective = parent.perspective, fieldDiscards = [], childFields = await resolveDeclaredFields({
         entryDefs: definition.fields,
         initialFields: initialFields,
@@ -6140,7 +6328,7 @@ async function evaluateInstance(args) {
         client: client,
         instanceId: instanceId,
         tag: tag
-    }), definition = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }), definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
         client: client,
         workflowResource: workflowResource,
         resourceClients: resourceClients
@@ -6334,6 +6522,9 @@ async function evaluateEditableFields(args) {
             ...site.title !== void 0 ? {
                 title: site.title
             } : {},
+            ...site.validation !== void 0 ? {
+                validation: site.validation
+            } : {},
             value: value,
             editable: reason === void 0,
             ...reason !== void 0 ? {
@@ -6559,7 +6750,7 @@ function triggeredActionVerdict({action: action, when: when, insights: insights}
         },
         ...insights
     }) : {
-        action: action,
+        ...actionEvaluationIdentity(action),
         allowed: !1,
         triggered: !0,
         disabledReason: {
@@ -6605,12 +6796,21 @@ function fireableActionVerdict({args: args, insights: insights}) {
         },
         ...insights
     }) : {
-        action: action,
+        ...actionEvaluationIdentity(action),
         allowed: !0,
         ...insights
     };
 }
 
+function actionEvaluationIdentity(action) {
+    return {
+        action: action,
+        ...action.semantics !== void 0 ? {
+            semantics: action.semantics
+        } : {}
+    };
+}
+
 async function instanceGuardReason({instance: instance, actor: actor, guards: guards}) {
     if (guards === void 0 || guards.length === 0) return;
     const denied = await instanceWriteDenials({
@@ -6625,15 +6825,8 @@ async function instanceGuardReason({instance: instance, actor: actor, guards: gu
 }
 
 function lifecycleReason({instance: instance, status: status, stageHasExits: stageHasExits}) {
-    const terminal = terminalState(instance);
-    if (terminal === "aborted" && instance.abortedAt !== void 0) return {
-        kind: "instance-aborted",
-        abortedAt: instance.abortedAt
-    };
-    if (terminal === "completed" && instance.completedAt !== void 0) return {
-        kind: "instance-completed",
-        completedAt: instance.completedAt
-    };
+    const terminalReason = instanceTerminalReason(instance);
+    if (terminalReason !== void 0) return terminalReason;
     if (!stageHasExits) return {
         kind: "stage-terminal",
         stage: instance.currentStage
@@ -6646,7 +6839,7 @@ function lifecycleReason({instance: instance, status: status, stageHasExits: sta
 
 function disabled(args) {
     return {
-        action: args.action,
+        ...actionEvaluationIdentity(args.action),
         allowed: !1,
         disabledReason: args.reason,
         ...args.insight !== void 0 ? {
@@ -7022,7 +7215,7 @@ async function fireTriggeredAction({ctx: ctx, mutation: mutation, activity: acti
 async function primeInitialStage({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
     const instance = await getInstanceDocument(client, instanceId);
     if (!instance || instance.stages.length > 0) return;
-    const definition = parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
+    const definition = invariants.parseDefinitionSnapshot(instance), stage = definition.stages.find(s => s.name === instance.currentStage);
     if (stage === void 0) return;
     const ctx = await buildEngineContext({
         client: client,
@@ -7269,7 +7462,7 @@ async function settleCondemnedRow({client: client, ownerId: ownerId, row: row, a
 async function stampDrainedRows({client: client, instance: instance, condemned: condemned, clock: clock, executionContext: executionContext}) {
     const now = (clock ?? wallClock)(), stamp = resolveExecutionContext(executionContext), ids = condemned.map(row => invariants.toBareId(row.ref.id)), children = await client.fetch("*[_id in $ids]{_id, currentStage, completedAt, abortedAt, modelVersion, minReaderModel}", {
         ids: ids
-    }), byId = new Map(children.map(c => [ assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
+    }), byId = new Map(children.map(c => [ invariants.assertReadableModel(c)._id, c ])), condemnedKeys = new Set(condemned.map(row => row._key)), history = [ ...instance.history ], subworkflows = (instance.subworkflows ?? []).map(row => {
         if (row.resolved !== void 0 || !condemnedKeys.has(row._key)) return row;
         const child = byId.get(invariants.toBareId(row.ref.id)), resolved = child !== void 0 ? terminalResolution(child) : {
             at: now,
@@ -7316,7 +7509,7 @@ function subworkflowResolvedEntry({row: row, at: at, status: status}) {
 async function propagateToAncestors({client: client, instanceId: instanceId, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, clock: clock, executionContext: executionContext, telemetry: telemetry}) {
     const loaded = await loadPropagationPair(client, instanceId);
     if (loaded === void 0) return;
-    const {child: child, parent: parent} = loaded, definition = parseDefinitionSnapshot(parent), ctx = await buildEngineContext({
+    const {child: child, parent: parent} = loaded, definition = invariants.parseDefinitionSnapshot(parent), ctx = await buildEngineContext({
         client: client,
         clientForGdr: clientForGdr,
         refSurface: refSurface,
@@ -7373,10 +7566,10 @@ async function propagateToAncestors({client: client, instanceId: instanceId, act
 async function loadPropagationPair(client, instanceId) {
     const child = await getInstanceDocument(client, instanceId);
     if (!child) return;
-    const parentGdr = parentRef(child);
+    const parentGdr = invariants.parentRef(child);
     if (parentGdr === void 0) return;
     const parentDoc = await client.getDocument(invariants.toBareId(parentGdr.id));
-    if (!(!parentDoc || parentDoc._type !== WORKFLOW_INSTANCE_TYPE)) return {
+    if (!(!parentDoc || parentDoc._type !== invariants.WORKFLOW_INSTANCE_TYPE)) return {
         child: child,
         parent: readInstanceDoc(parentDoc)
     };
@@ -7400,7 +7593,7 @@ async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: c
         at: ctx.now,
         instanceRef: {
             id: childUri,
-            type: WORKFLOW_INSTANCE_TYPE
+            type: invariants.WORKFLOW_INSTANCE_TYPE
         },
         detail: `Instance "${child._id}" names this instance as its parent but no subworkflow-registry row matches it, so its state cannot drive any gate here.`
     }), await persist(ctx, mutation));
@@ -7408,7 +7601,7 @@ async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: c
 
 function startMutation(instance) {
     return {
-        minReaderModel: minReaderModelOf(instance),
+        minReaderModel: invariants.minReaderModelOf(instance),
         currentStage: instance.currentStage,
         fields: (instance.fields ?? []).map(s => ({
             ...s
@@ -7457,9 +7650,7 @@ function startMutation(instance) {
 }
 
 function instanceStateFields(src) {
-    const fields = {
-        modelVersion: DATA_MODEL_VERSION,
-        minReaderModel: Math.max(src.minReaderModel, DATA_MODEL_MIN_READER),
+    const state = {
         currentStage: src.currentStage,
         fields: src.fields,
         stages: src.stages,
@@ -7468,10 +7659,22 @@ function instanceStateFields(src) {
         effectHistory: src.effectHistory,
         context: src.context,
         history: src.history,
-        processedRequests: src.processedRequests ?? []
+        processedRequests: src.processedRequests ?? [],
+        ...src.completedAt !== void 0 ? {
+            completedAt: src.completedAt
+        } : {},
+        ...src.abortedAt !== void 0 ? {
+            abortedAt: src.abortedAt
+        } : {}
+    };
+    return {
+        ...invariants.modelStampFor({
+            documentType: "instance",
+            document: state,
+            storedMinReaderModel: src.minReaderModel
+        }),
+        ...state
     };
-    return src.completedAt !== void 0 && (fields.completedAt = src.completedAt), src.abortedAt !== void 0 && (fields.abortedAt = src.abortedAt), 
-    fields;
 }
 
 function liveViewContext(ctx, mutation) {
@@ -7683,16 +7886,7 @@ function validateEffectOutputs(args) {
             issues.push(`"${key}" is not a declared output`);
             continue;
         }
-        const shapeIssues = invariants.checkFieldValue({
-            entryType: shape.type,
-            value: value,
-            ...shape.fields !== void 0 ? {
-                fields: shape.fields
-            } : {},
-            ...shape.of !== void 0 ? {
-                of: shape.of
-            } : {}
-        });
+        const shapeIssues = effectOutputIssues(shape, value);
         shapeIssues !== void 0 && issues.push(...shapeIssues.map(i => `"${key}": ${i}`));
     }
     if (issues.length > 0) throw new EffectOutputsInvalidError({
@@ -7701,6 +7895,25 @@ function validateEffectOutputs(args) {
     });
 }
 
+function effectOutputIssues(shape, value) {
+    return invariants.checkFieldValue({
+        entryType: shape.type,
+        value: value,
+        ...shape.fields !== void 0 ? {
+            fields: shape.fields
+        } : {},
+        ...shape.of !== void 0 ? {
+            of: shape.of
+        } : {},
+        ...shape.options !== void 0 ? {
+            options: shape.options
+        } : {},
+        ...shape.validation !== void 0 ? {
+            validation: shape.validation
+        } : {}
+    });
+}
+
 function requirePendingEffect(instance, effectKey) {
     const pending = instance.pendingEffects.find(e => e._key === effectKey);
     if (pending !== void 0) return pending;
@@ -7896,7 +8109,7 @@ function idsArm(filter, params) {
 function instancesQuery(args) {
     const {tag: tag, filter: filter = {}} = args;
     if (invariants.validateTag(tag), filter.limit !== void 0 && (!Number.isInteger(filter.limit) || filter.limit <= 0)) throw new invariants.ContractViolationError(`instancesQuery: limit must be a positive integer; got ${JSON.stringify(filter.limit)}`);
-    const conditions = [ `_type == "${WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ], params = {
+    const conditions = [ `_type == "${invariants.WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ], params = {
         tag: tag
     };
     filter.includeCompleted !== !0 && conditions.push(inFlightFilter()), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
@@ -7921,7 +8134,7 @@ async function sortByDependencies({client: client, definitions: definitions, tag
         byName.set(def.name, def);
     }
     const findInBatch = ref => findRefInBatch(byName, ref);
-    return await assertCrossBatchRefsDeployed({
+    return await assertSpawnContracts({
         client: client,
         definitions: definitions,
         ctx: {
@@ -7937,31 +8150,76 @@ function findRefInBatch(byName, ref) {
     if (typeof ref.version != "number") return byName.get(ref.name);
 }
 
-async function assertCrossBatchRefsDeployed({client: client, definitions: definitions, ctx: ctx}) {
-    const missing = [];
-    for (const def of definitions) for (const ref of refsOf(def)) {
-        if (ctx.findInBatch(ref) !== void 0) continue;
-        const label = await resolveDeployedRefLabel({
+async function assertSpawnContracts({client: client, definitions: definitions, ctx: ctx}) {
+    const missing = [], invalidHandoffs = [];
+    for (const def of definitions) for (const spawn of spawnSitesOf(def)) {
+        const ref = logicalRefOf(spawn.definition), child = ctx.findInBatch(ref) ?? await resolveDeployedRef({
             client: client,
             ref: ref,
             tag: ctx.tag
         });
-        label !== void 0 && missing.push({
-            from: def.name,
-            ref: label
-        });
+        if (child === void 0) {
+            missing.push({
+                reason: "unresolved-definition",
+                from: def.name,
+                ref: logicalRefLabel(ref)
+            });
+            continue;
+        }
+        for (const field of Object.keys(spawn.with ?? {})) {
+            const entry = (child.fields ?? []).find(candidate => candidate.name === field);
+            entry === void 0 ? invalidHandoffs.push({
+                reason: "unconsumable-field",
+                from: def.name,
+                child: child.name,
+                field: field,
+                detail: "the child declares no workflow field with that name"
+            }) : invariants.isInputSourced(entry) || invalidHandoffs.push({
+                reason: "unconsumable-field",
+                from: def.name,
+                child: child.name,
+                field: field,
+                detail: `the child field is ${entry.initialValue?.type ?? "working-memory"}-sourced, not input-sourced`
+            });
+        }
     }
-    if (missing.length === 0) return;
-    const lines = missing.map(m => `  - ${m.from} → ${m.ref} (neither in batch nor deployed)`);
-    throw new Error(`workflow.deployDefinitions: ${missing.length} unresolved reference${missing.length === 1 ? "" : "s"}:\n` + lines.join(`\n`));
+    if (missing.length === 0 && invalidHandoffs.length === 0) return;
+    if (invalidHandoffs.length === 0) {
+        const lines2 = missing.map(issue => `  - ${issue.from} → ${issue.ref} (neither in batch nor deployed)`);
+        throw new Error(`workflow.deployDefinitions: ${missing.length} unresolved reference${missing.length === 1 ? "" : "s"}:\n` + lines2.join(`\n`));
+    }
+    const issues = [ ...missing, ...invalidHandoffs ], lines = [ ...missing.map(m => `  - ${m.from} → ${m.ref} (neither in batch nor deployed)`), ...invalidHandoffs.map(issue => `  - ${issue.from} → ${issue.child}: spawn.with["${issue.field}"] cannot be consumed — ${issue.detail}`) ], count = lines.length;
+    throw new invariants.SpawnContractsInvalidError({
+        issues: issues,
+        message: `workflow.deployDefinitions: ${count} invalid spawn contract${count === 1 ? "" : "s"}:\n` + lines.join(`\n`)
+    });
 }
 
-async function resolveDeployedRefLabel({client: client, ref: ref, tag: tag}) {
+async function resolveDeployedRef({client: client, ref: ref, tag: tag}) {
     const wantsExplicit = typeof ref.version == "number", params = {
         definition: ref.name,
         tag: tag
     };
-    if (wantsExplicit && (params.version = ref.version), !await client.fetch(definitionLookupGroq(wantsExplicit), params)) return wantsExplicit ? `${ref.name} v${ref.version}` : ref.name;
+    wantsExplicit && (params.version = ref.version);
+    const doc = await client.fetch(definitionLookupGroq(wantsExplicit), params);
+    if (doc) return parseDefinitionInput(doc, `workflow.deployDefinitions child "${logicalRefLabel(ref)}"`);
+}
+
+function logicalRefLabel(ref) {
+    return typeof ref.version == "number" ? `${ref.name} v${ref.version}` : ref.name;
+}
+
+function logicalRefOf(ref) {
+    return {
+        name: ref.name,
+        ...ref.version !== void 0 ? {
+            version: ref.version
+        } : {}
+    };
+}
+
+function spawnSitesOf(def) {
+    return def.stages.flatMap(stage => stage.activities ?? []).flatMap(activity => activity.actions ?? []).flatMap(action => action.spawn === void 0 ? [] : [ action.spawn ]);
 }
 
 function topoSortDefinitions(definitions, ctx) {
@@ -7981,12 +8239,7 @@ function topoSortDefinitions(definitions, ctx) {
 }
 
 function refsOf(def) {
-    return def.stages.flatMap(stage => stage.activities ?? []).flatMap(activity => activity.actions ?? []).flatMap(action => action.spawn === void 0 ? [] : [ action.spawn.definition ]).map(ref => ({
-        name: ref.name,
-        ...ref.version !== void 0 ? {
-            version: ref.version
-        } : {}
-    }));
+    return spawnSitesOf(def).map(spawn => logicalRefOf(spawn.definition));
 }
 
 function hashDefinitionContent(def) {
@@ -8009,7 +8262,10 @@ function planDefinitionDeploy({def: def, latest: latest, target: target}) {
         tag: target.tag,
         version: version,
         contentHash: contentHash,
-        ...MODEL_STAMP
+        ...invariants.modelStampFor({
+            documentType: "definition",
+            document: expanded
+        })
     };
     return {
         status: unchanged ? "unchanged" : "create",
@@ -8083,7 +8339,7 @@ async function loadDefinition({client: client, definition: definition, version:
             definition: definition,
             version: version
         });
-        return assertReadableModel(doc);
+        return invariants.assertReadableModel(doc);
     }
     const latest = await loadLatestDeployed({
         client: client,
@@ -8101,14 +8357,14 @@ async function loadLatestDeployed({client: client, definition: definition, tag:
         definition: definition,
         tag: tag
     });
-    return doc ? assertReadableModel(doc) : void 0;
+    return doc ? invariants.assertReadableModel(doc) : void 0;
 }
 
 async function loadDefinitionVersions({client: client, definition: definition, tag: tag}) {
     return (await client.fetch(`*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${invariants.tagScopeFilter()}] | order(version desc)`, {
         definition: definition,
         tag: tag
-    })).map(assertReadableModel);
+    })).map(invariants.assertReadableModel);
 }
 
 async function loadDefinitionVersionsOrThrow({client: client, definition: definition, tag: tag}) {
@@ -8497,8 +8753,8 @@ async function resumeStart(args) {
         version: args.version
     });
     if (mismatch !== void 0) throw new invariants.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 invariants.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({
+    if (existing.stages.length === 0 && invariants.terminalState(existing) !== "in-flight") throw new invariants.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 = invariants.isUnprimed(existing), emitStarted = () => resolveTelemetry(args.telemetry).log(WorkflowInstanceStarted, instanceStartedDataFor({
         instance: existing,
         initialFieldCount: args.initialFieldCount,
         viaSpawn: !1
@@ -8796,7 +9052,7 @@ async function deleteDefinition(args) {
 async function assertNoSpawnReferrers({client: client, tag: tag, definition: definition, targets: targets, lastVersionGoes: lastVersionGoes}) {
     const deployed = (await client.fetch(`*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && ${invariants.tagScopeFilter()}]`, {
         tag: tag
-    })).map(assertReadableModel), targetIds = new Set(targets.map(d => d._id)), targetVersions = new Set(targets.map(d => d.version)), referrers = deployed.filter(d => !targetIds.has(d._id)).filter(d => refsOf(d).some(ref => ref.name === definition && (typeof ref.version == "number" ? targetVersions.has(ref.version) : lastVersionGoes)));
+    })).map(invariants.assertReadableModel), targetIds = new Set(targets.map(d => d._id)), targetVersions = new Set(targets.map(d => d.version)), referrers = deployed.filter(d => !targetIds.has(d._id)).filter(d => refsOf(d).some(ref => ref.name === definition && (typeof ref.version == "number" ? targetVersions.has(ref.version) : lastVersionGoes)));
     if (referrers.length > 0) throw new invariants.DefinitionInUseError({
         definition: definition,
         blockedBy: {
@@ -8811,7 +9067,7 @@ async function assertNoSpawnReferrers({client: client, tag: tag, definition: def
 
 async function nonTerminalInstanceIds({client: client, tag: tag, definition: definition, version: version}) {
     const versionFilter = version === void 0 ? "" : " && pinnedVersion == $version";
-    return (await client.fetch(`*[_type == "${WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && ${inFlightFilter()}${versionFilter}] | order(_id asc){_id}`, {
+    return (await client.fetch(`*[_type == "${invariants.WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && ${inFlightFilter()}${versionFilter}] | order(_id asc){_id}`, {
         definition: definition,
         tag: tag,
         ...version !== void 0 ? {
@@ -8847,11 +9103,12 @@ async function fetchStartSlice(args) {
             includeCompleted: !0
         }
     });
-    return (await client.fetch(query, params)).map(assertReadableModel);
+    return (await client.fetch(query, params)).map(invariants.assertReadableModel);
 }
 
 const workflow = {
     deployDefinitions: async rawArgs => {
+        invariants.assertReaderModelAcknowledgement(rawArgs.expectedMinReaderModel);
         const args = taggedScope(rawArgs, REQUEST_TAG.deploy), {client: client, tag: tag, resourceAliases: resourceAliases} = args;
         invariants.validateTag(tag);
         const definitions = args.definitions.map(def => parseDefinitionInput(def, "workflow.deployDefinitions"));
@@ -8924,8 +9181,8 @@ const workflow = {
         }), result;
     },
     startInstance: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.start), {client: client, tag: tag, workflowResource: workflowResource, definition: definitionName, version: version, initialFields: initialFields, ancestors: ancestors, context: context, instanceId: instanceId, perspective: perspective, executionContext: executionContext} = args, {actor: actor, clientForGdr: clientForGdr, refSurface: refSurface} = await resolveOperationContext(args), clock = args.clock ?? wallClock, seedFields = initialFields ?? [], existing = instanceId !== void 0 ? await getInstanceDocument(client, instanceId) : void 0;
-        if (existing !== void 0 && existing.tag === tag) return resumeStart({
+        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;
+        return existing !== void 0 && existing.tag === tag ? resumeStart({
             client: client,
             tag: tag,
             existing: existing,
@@ -8942,105 +9199,12 @@ const workflow = {
             ...args.telemetry !== void 0 ? {
                 telemetry: args.telemetry
             } : {}
-        });
-        const definition = await loadDefinition({
-            client: client,
-            definition: definitionName,
-            version: version,
-            tag: tag
-        }), id = instanceId ?? instanceDocId(tag);
-        if (definition.stages.find(s => s.name === definition.initialStage) === void 0) throw new Error(`Initial stage "${definition.initialStage}" missing in ${definitionName} v${definition.version}`);
-        const now = clock();
-        if (assertRequiredInputProvided({
-            entryDefs: definition.fields ?? [],
-            initialFields: seedFields,
-            definitionName: definition.name
-        }), definition.start?.allowed !== void 0) {
-            const insight = await startAllowedInsight({
-                client: client,
-                tag: tag,
-                definition: definition,
-                allowed: definition.start.allowed,
-                initialFields: seedFields,
-                now: now
-            });
-            if (insight.outcome !== "satisfied") throw new StartNotAllowedError({
-                definition: definition.name,
-                insight: insight
-            });
-        }
-        const contextEntries = context ? toContextEntries(context) : [], fieldDiscards = [], resolvedFields = await resolveDeclaredFields({
-            entryDefs: definition.fields ?? [],
-            initialFields: seedFields,
-            ctx: {
-                client: client,
-                now: now,
-                selfId: id,
-                tag: tag,
-                workflowResource: workflowResource,
-                definitionName: definition.name,
-                refSurface: refSurface,
-                ...perspective !== void 0 ? {
-                    perspective: perspective
-                } : {},
-                recordDiscard: recordFieldDiscards({
-                    target: fieldDiscards,
-                    scope: "workflow",
-                    at: now
-                })
-            },
-            randomKey: randomKey
-        }), effectivePerspective = perspective ?? derivePerspectiveFromFields(resolvedFields), base = buildInstanceBase({
-            id: id,
-            now: now,
-            tag: tag,
-            workflowResource: workflowResource,
-            definitionName: definition.name,
-            pinnedVersion: definition.version,
-            pinnedContentHash: definition.contentHash,
-            definition: definition,
-            fields: resolvedFields,
-            context: contextEntries,
-            ancestors: ancestors ?? [],
-            perspective: effectivePerspective,
-            initialStage: definition.initialStage,
-            actor: actor,
-            executionContext: resolveExecutionContext(executionContext),
-            ...fieldDiscards.length > 0 ? {
-                extraHistory: fieldDiscards
-            } : {}
-        });
-        await client.create(base, SYNC_COMMIT);
-        const cascaded = await settleStart({
-            client: client,
-            tag: tag,
-            instanceId: id,
-            actor: actor,
-            clientForGdr: clientForGdr,
-            refSurface: refSurface,
+        }) : startFreshInstance({
+            args: args,
+            operationContext: operationContext,
             clock: clock,
-            ...executionContext !== void 0 ? {
-                executionContext: executionContext
-            } : {},
-            ...args.telemetry !== void 0 ? {
-                telemetry: args.telemetry
-            } : {},
-            emitStarted: () => resolveTelemetry(args.telemetry).log(WorkflowInstanceStarted, instanceStartedData({
-                definition: definition,
-                instanceId: id,
-                initialFieldCount: seedFields.length,
-                viaSpawn: !1
-            }))
+            seedFields: seedFields
         });
-        return {
-            instance: await reload({
-                client: client,
-                instanceId: id,
-                tag: tag
-            }),
-            cascaded: cascaded,
-            changed: !0
-        };
     },
     fireAction: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.fireAction), {client: client, tag: tag, workflowResource: workflowResource, instanceId: instanceId, activity: activity, action: action, params: params, idempotent: idempotent, resourceClients: resourceClients, grantsFromPath: grantsFromPath, executionContext: executionContext} = args;
@@ -9451,7 +9615,7 @@ const workflow = {
             instance: instance
         }), reserved = await renderConditionScope({
             instance: instance,
-            definition: parseDefinitionSnapshot(instance),
+            definition: invariants.parseDefinitionSnapshot(instance),
             snapshot: snapshot,
             now: clock()
         }), tree = groqJs.parse(groq, {
@@ -9526,11 +9690,11 @@ const workflow = {
         return (await client.fetch(query, params)).map(readInstanceDoc).filter(instance => instanceWatchesDocument(instance, document));
     },
     definitionsForDocument: async rawArgs => {
-        const args = taggedScope(rawArgs, REQUEST_TAG.definitionsForDocument), {client: client, tag: tag, document: document} = args;
+        const args = taggedScope(rawArgs, REQUEST_TAG.definitionsForDocument), {client: client, tag: tag, document: document, subject: subject} = args;
         invariants.validateTag(tag);
         const clock = args.clock ?? wallClock, deployed = (await client.fetch(definitionsListGroq("desc"), {
             tag: tag
-        })).map(assertReadableModel), latest = latestDeployedDefinitions(deployed);
+        })).map(invariants.assertReadableModel), latest = latestDeployedDefinitions(deployed);
         let slice;
         return applicableDefinitions({
             definitions: latest,
@@ -9538,6 +9702,9 @@ const workflow = {
             scope: {
                 tag: tag,
                 now: clock(),
+                ...subject !== void 0 ? {
+                    subject: subject
+                } : {},
                 fetchDataset: () => slice ??= fetchStartSlice({
                     client: client,
                     tag: tag
@@ -9553,20 +9720,29 @@ const workflow = {
             definition: definitionName,
             version: version,
             tag: tag
+        }), invalidInitialFields = initialFieldIssues({
+            workflowFields: definition.fields ?? [],
+            stages: definition.stages,
+            initialFields: initialFields ?? []
         }), missingRequired = missingRequiredInputs({
             entryDefs: definition.fields ?? [],
             initialFields: initialFields ?? []
         }), allowed = definition.start?.allowed;
         if (allowed === void 0) return {
-            allowed: !0,
+            allowed: invalidInitialFields.length === 0,
             outcome: "satisfied",
             unboundReads: [],
-            missingRequired: missingRequired
+            missingRequired: missingRequired,
+            invalidInitialFields: invalidInitialFields
         };
-        const unboundReads = unboundAllowedReads(allowed, startFieldsParam({
-            entryDefs: definition.fields ?? [],
-            initialFields: initialFields ?? []
-        })), insight = await startAllowedInsight({
+        const unboundReads = unboundAllowedReadsWithSubject({
+            allowed: allowed,
+            fields: startFieldsParam({
+                entryDefs: definition.fields ?? [],
+                initialFields: initialFields ?? []
+            }),
+            definition: definition
+        }), insight = await startAllowedInsight({
             client: client,
             tag: tag,
             definition: definition,
@@ -9575,11 +9751,12 @@ const workflow = {
             now: clock()
         }), provisional = unboundReads.length > 0;
         return {
-            allowed: !provisional && insight.outcome === "satisfied",
+            allowed: invalidInitialFields.length === 0 && !provisional && insight.outcome === "satisfied",
             outcome: provisional ? "unevaluable" : insight.outcome,
             insight: insight,
             unboundReads: unboundReads,
-            missingRequired: missingRequired
+            missingRequired: missingRequired,
+            invalidInitialFields: invalidInitialFields
         };
     },
     permissions: {
@@ -9609,6 +9786,239 @@ async function startAllowedInsight(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({
+        client: client,
+        definition: definitionName,
+        version: version,
+        tag: tag
+    }), id = instanceId ?? instanceDocId(tag);
+    assertInitialStageExists(definition);
+    const now = clock();
+    await assertStartInputs({
+        client: client,
+        tag: tag,
+        definition: definition,
+        initialFields: seedFields,
+        now: now
+    });
+    const {resolvedFields: resolvedFields, fieldDiscards: fieldDiscards} = await resolveStartFields({
+        client: client,
+        tag: tag,
+        workflowResource: workflowResource,
+        definition: definition,
+        initialFields: seedFields,
+        id: id,
+        now: now,
+        refSurface: refSurface,
+        ...perspective !== void 0 ? {
+            perspective: perspective
+        } : {}
+    }), base = buildInstanceBase({
+        id: id,
+        now: now,
+        tag: tag,
+        workflowResource: workflowResource,
+        definitionName: definition.name,
+        pinnedVersion: definition.version,
+        pinnedContentHash: definition.contentHash,
+        definition: definition,
+        fields: resolvedFields,
+        context: context ? toContextEntries(context) : [],
+        ancestors: ancestors ?? [],
+        perspective: perspective ?? derivePerspectiveFromFields(resolvedFields),
+        initialStage: definition.initialStage,
+        actor: actor,
+        executionContext: resolveExecutionContext(executionContext),
+        ...fieldDiscards.length > 0 ? {
+            extraHistory: fieldDiscards
+        } : {}
+    });
+    await client.create(base, SYNC_COMMIT);
+    const cascaded = await settleStart({
+        client: client,
+        tag: tag,
+        instanceId: id,
+        actor: actor,
+        clientForGdr: clientForGdr,
+        refSurface: refSurface,
+        clock: clock,
+        ...executionContext !== void 0 ? {
+            executionContext: executionContext
+        } : {},
+        ...startArgs.telemetry !== void 0 ? {
+            telemetry: startArgs.telemetry
+        } : {},
+        emitStarted: () => resolveTelemetry(startArgs.telemetry).log(WorkflowInstanceStarted, instanceStartedData({
+            definition: definition,
+            instanceId: id,
+            initialFieldCount: seedFields.length,
+            viaSpawn: !1
+        }))
+    });
+    return {
+        instance: await reload({
+            client: client,
+            instanceId: id,
+            tag: tag
+        }),
+        cascaded: cascaded,
+        changed: !0
+    };
+}
+
+function assertInitialStageExists(definition) {
+    if (!definition.stages.some(stage => stage.name === definition.initialStage)) throw new Error(`Initial stage "${definition.initialStage}" missing in ${definition.name} v${definition.version}`);
+}
+
+async function assertStartInputs(args) {
+    const {client: client, tag: tag, definition: definition, initialFields: initialFields, now: now} = args;
+    assertInitialFieldsConsumable({
+        workflowFields: definition.fields ?? [],
+        stages: definition.stages,
+        initialFields: initialFields,
+        definitionName: definition.name
+    }), assertRequiredInputProvided({
+        entryDefs: definition.fields ?? [],
+        initialFields: initialFields,
+        definitionName: definition.name
+    });
+    const allowed = definition.start?.allowed;
+    if (allowed === void 0) return;
+    const insight = await startAllowedInsight({
+        client: client,
+        tag: tag,
+        definition: definition,
+        allowed: allowed,
+        initialFields: initialFields,
+        now: now
+    });
+    if (insight.outcome !== "satisfied") throw new StartNotAllowedError({
+        definition: definition.name,
+        insight: insight
+    });
+}
+
+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 = [];
+    return {
+        resolvedFields: await resolveDeclaredFields({
+            entryDefs: definition.fields ?? [],
+            initialFields: initialFields,
+            ctx: {
+                client: client,
+                now: now,
+                selfId: id,
+                tag: tag,
+                workflowResource: workflowResource,
+                definitionName: definition.name,
+                refSurface: refSurface,
+                ...perspective !== void 0 ? {
+                    perspective: perspective
+                } : {},
+                recordDiscard: recordFieldDiscards({
+                    target: fieldDiscards,
+                    scope: "workflow",
+                    at: now
+                })
+            },
+            randomKey: randomKey
+        }),
+        fieldDiscards: fieldDiscards
+    };
+}
+
+function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+
+function isClientProjectUser(value) {
+    return isRecord(value) && typeof value.id == "string" && (value.displayName === void 0 || typeof value.displayName == "string") && (value.email === void 0 || typeof value.email == "string") && (value.imageUrl === void 0 || value.imageUrl === null || typeof value.imageUrl == "string");
+}
+
+function objectProperty(value, property) {
+    if (!isRecord(value)) return;
+    const propertyValue = value[property];
+    return typeof propertyValue == "object" && propertyValue !== null ? propertyValue : void 0;
+}
+
+function stringProperty(value, property) {
+    const propertyValue = Reflect.get(value, property);
+    return typeof propertyValue == "string" ? propertyValue : void 0;
+}
+
+function apiErrorType(error) {
+    const response = objectProperty(error, "response"), body = objectProperty(response, "body");
+    if (!body) return;
+    const nestedError = objectProperty(body, "error");
+    return (nestedError ? stringProperty(nestedError, "type") : void 0) ?? stringProperty(body, "type");
+}
+
+function isProjectUserNotFoundError(error) {
+    return apiErrorType(error) === "projectUserNotFoundError";
+}
+
+function clientProjectUserDirectory(client, projectId) {
+    return {
+        findById: async id => {
+            if (!client.request) return {
+                status: "inaccessible",
+                cause: new Error("Project-user resolution requires WorkflowClient.request")
+            };
+            try {
+                const response = await client.request({
+                    uri: `/projects/${encodeURIComponent(projectId)}/users/${encodeURIComponent(id)}`
+                }), candidate = Array.isArray(response) ? response[0] : response;
+                return candidate == null ? {
+                    status: "missing"
+                } : isClientProjectUser(candidate) ? {
+                    status: "resolved",
+                    user: candidate
+                } : {
+                    status: "inaccessible",
+                    cause: new Error("Project-user response had an invalid shape")
+                };
+            } catch (cause) {
+                return isProjectUserNotFoundError(cause) ? {
+                    status: "missing"
+                } : {
+                    status: "inaccessible",
+                    cause: cause
+                };
+            }
+        }
+    };
+}
+
+function resolveClientActor(client, args) {
+    return resolveActor(clientProjectUserDirectory(client, args.projectId), args.actor);
+}
+
+async function resolveActor(directory, actor) {
+    if (actor.kind !== "person") return {
+        status: "not-person",
+        actor: actor
+    };
+    const personActor = {
+        ...actor,
+        kind: "person"
+    }, lookup = await directory.findById(personActor.id);
+    return lookup.status === "resolved" ? {
+        status: "resolved",
+        actor: personActor,
+        user: lookup.user
+    } : lookup.status === "inaccessible" ? {
+        status: "inaccessible",
+        actor: personActor,
+        ...lookup.cause === void 0 ? {} : {
+            cause: lookup.cause
+        }
+    } : {
+        status: "missing",
+        actor: personActor
+    };
+}
+
 const DEFAULT_EFFECT_LEASE_MS = 300 * 1e3;
 
 function isClaimExpired(claim, now) {
@@ -9686,7 +10096,7 @@ async function verifyDeployedDefinitionsInternal(args) {
     invariants.validateTag(tag);
     const log = logger("verifyDeployedDefinitions"), definitions = (await client.fetch(definitionsListGroq("asc"), {
         tag: tag
-    })).map(assertReadableModel), seen = [], missingByName = /* @__PURE__ */ new Map;
+    })).map(invariants.assertReadableModel), seen = [], missingByName = /* @__PURE__ */ new Map;
     for (const def of definitions) seen.push({
         name: def.name,
         version: def.version,
@@ -9751,11 +10161,11 @@ function isCancelledCompletion(data) {
 }
 
 async function drainEffectsInternal(args) {
-    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, routeGdr = buildClientForGdr({
-        client: client,
+    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger, handlerClient: handlerClient, handlerResourceClients: handlerResourceClients} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, routeGdr = buildClientForGdr({
+        client: handlerClient,
         workflowResource: workflowResource,
-        resourceClients: resourceClients
-    }), clientFor = ref => withRequestTag(routeGdr(invariants.parseGdr(typeof ref == "string" ? ref : ref.id)), REQUEST_TAG.effect), {actor: drainerActor} = await resolveAccess(client), executionContext = args.executionContext;
+        resourceClients: handlerResourceClients
+    }), clientFor = ref => routeGdr(invariants.parseGdr(typeof ref == "string" ? ref : ref.id)), {actor: drainerActor} = await resolveAccess(client), executionContext = args.executionContext;
     invariants.validateTag(tag);
     const log = logger("drainEffects"), buckets = {
         drained: [],
@@ -9801,6 +10211,7 @@ async function drainEffectsInternal(args) {
             handler: handler,
             candidate: candidate,
             client: client,
+            handlerClient: handlerClient,
             tag: tag,
             workflowResource: workflowResource,
             ...resourceClients !== void 0 ? {
@@ -9826,11 +10237,11 @@ function findClaimableCandidate({instance: instance, now: now, skippedKeys: skip
 }
 
 async function dispatchAndReport(args) {
-    const {handler: handler, candidate: candidate, client: client, tag: tag, workflowResource: workflowResource, resourceClients: resourceClients, instanceId: instanceId, clientFor: clientFor, logger: logger, log: log, executionContext: executionContext, telemetry: telemetry, clock: clock} = args, {outputs: outputs, ops: ops, dispatchError: dispatchError} = await dispatchEffect({
+    const {handler: handler, candidate: candidate, client: client, handlerClient: handlerClient, tag: tag, workflowResource: workflowResource, resourceClients: resourceClients, instanceId: instanceId, clientFor: clientFor, logger: logger, log: log, executionContext: executionContext, telemetry: telemetry, clock: clock} = args, {outputs: outputs, ops: ops, dispatchError: dispatchError} = await dispatchEffect({
         handler: handler,
         candidate: candidate,
         ctx: {
-            client: client,
+            client: handlerClient,
             clientFor: clientFor,
             instanceId: instanceId,
             logger: logger
@@ -9936,7 +10347,7 @@ async function claimPendingEffect({client: client, instance: instance, candidate
 async function dispatchEffect({handler: handler, candidate: candidate, ctx: ctx}) {
     try {
         const result = await handler(candidate.params, {
-            client: withRequestTag(ctx.client, REQUEST_TAG.effect),
+            client: ctx.client,
             clientFor: ctx.clientFor,
             instanceId: ctx.instanceId,
             effectKey: candidate._key,
@@ -10052,7 +10463,7 @@ function createInstanceSession(args) {
             }, uri = invariants.gdrFromResource(owned.resource, owned.doc._id);
             if (uri === selfUri()) {
                 const rawStamp = owned.doc._updatedAt;
-                !invariants.isParseableInstant(rawStamp) || owned.doc._type !== WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
+                !invariants.isParseableInstant(rawStamp) || owned.doc._type !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
                 continue;
             }
             next.set(uri, owned);
@@ -10071,7 +10482,7 @@ function createInstanceSession(args) {
     let parsedDefinition;
     const definitionOf = () => (parsedDefinition?.source !== instance && (parsedDefinition = {
         source: instance,
-        definition: parseDefinitionSnapshot(instance)
+        definition: invariants.parseDefinitionSnapshot(instance)
     }), parsedDefinition.definition), siteKey = site => JSON.stringify([ site.scope, site.activity ?? null, site.name ]), stagePreview = ({target: target, mode: mode, value: value}) => {
         const site = previewSiteOf({
             instance: instance,
@@ -10430,6 +10841,7 @@ function createEngine(args) {
         missingHandler: missingHandler,
         logger: logger,
         telemetry: telemetry,
+        resolveActor: rest => resolveClientActor(client, rest),
         deployDefinitions: async rest => {
             const result = await workflow.deployDefinitions(withScope(rest));
             return logDeployWarnings(result, logger), result;
@@ -10470,6 +10882,10 @@ function createEngine(args) {
         drainEffects: async ({instanceId: instanceId}) => {
             const result = await drainEffectsInternal({
                 client: client,
+                handlerClient: args.client,
+                ...args.resourceClients !== void 0 ? {
+                    handlerResourceClients: args.resourceClients
+                } : {},
                 tag: tag,
                 workflowResource: workflowResource,
                 ...optionalScope,
@@ -10666,6 +11082,7 @@ function attributeMember({member: member, group: group, chain: chain}) {
 }
 
 function diffEntry({def: rawDef, latestRaw: latestRaw, target: target}) {
+    invariants.assertReaderModelAcknowledgement(target.expectedMinReaderModel);
     const def = parseDefinitionInput(rawDef, "diffEntry"), plan = planDefinitionDeploy({
         def: def,
         latest: asLatest(latestRaw),
@@ -10697,6 +11114,7 @@ function asLatest(raw) {
 }
 
 async function computeDiffEntries({client: client, defs: defs, target: target}) {
+    invariants.assertReaderModelAcknowledgement(target.expectedMinReaderModel);
     const entries = [];
     for (const rawDef of defs) {
         const def = parseDefinitionInput(rawDef, "computeDiffEntries"), latest = await loadLatestDeployed({
@@ -10718,7 +11136,7 @@ function buildInitialFields({declared: declared, values: values}) {
     return Object.entries(values).map(([name, value]) => {
         const entry = declared.find(f => f.name === name);
         if (entry === void 0) throw new Error(settable.length > 0 ? `workflow declares no field "${name}" — input fields: ${settableNames}` : `workflow declares no field "${name}" — it declares no input fields at all`);
-        if (entry.initialValue?.type !== "input") throw new Error(`field "${name}" is not input-sourced — the engine would silently ignore the value. ` + (settable.length > 0 ? `Input fields: ${settableNames}` : "This workflow has no input fields."));
+        if (entry.initialValue?.type !== "input") throw new Error(`field "${name}" is not input-sourced and cannot accept a start value. ` + (settable.length > 0 ? `Input fields: ${settableNames}` : "This workflow has no input fields."));
         return {
             type: entry.type,
             name: name,
@@ -10782,7 +11200,7 @@ const HISTORY_DISPLAY = {
     },
     aborted: {
         title: "Instance aborted",
-        description: "An admin hard-stopped the instance — pending effects cancelled, stage guards lifted, abortedAt + completedAt stamped."
+        description: "An admin hard-stopped the instance — pending effects cancelled, stage guards removed, abortedAt + completedAt stamped."
     },
     opApplied: {
         title: "Op applied",
@@ -10818,6 +11236,10 @@ const HISTORY_DISPLAY = {
         title: "Document references",
         description: "Ordered list of GDR pointers — multi-doc selection."
     },
+    subject: {
+        title: "Subject document",
+        description: "Single GDR pointer at THE document the workflow is about — same value as a document reference, elevated so surfaces identify the subject by kind."
+    },
     "release.ref": {
         title: "Content Release reference",
         description: "GDR pointer at a Content Release system doc, carrying the release name the engine derives the instance's read perspective from."
@@ -10929,7 +11351,7 @@ const HISTORY_DISPLAY = {
         title: "Workflow definition",
         description: "An immutable workflow blueprint, addressed by `name` + `version`."
     },
-    [WORKFLOW_INSTANCE_TYPE]: {
+    [invariants.WORKFLOW_INSTANCE_TYPE]: {
         title: "Workflow instance",
         description: "A running (or finished) workflow against its declared fields."
     }
@@ -10996,6 +11418,8 @@ function displayDescription(typeKey) {
     if (typeKey) return DISPLAY[typeKey]?.description;
 }
 
+exports.ACTION_SEMANTICS = invariants.ACTION_SEMANTICS;
+
 exports.ACTIVITY_KINDS = invariants.ACTIVITY_KINDS;
 
 exports.ACTOR_KINDS = invariants.ACTOR_KINDS;
@@ -11004,6 +11428,12 @@ exports.CONDITION_VARS = invariants.CONDITION_VARS;
 
 exports.ContractViolationError = invariants.ContractViolationError;
 
+exports.DATA_MODEL_CHANGES = invariants.DATA_MODEL_CHANGES;
+
+exports.DATA_MODEL_MIN_READER = invariants.DATA_MODEL_MIN_READER;
+
+exports.DATA_MODEL_VERSION = invariants.DATA_MODEL_VERSION;
+
 exports.DEFAULT_TRANSITION_WHEN = invariants.DEFAULT_TRANSITION_WHEN;
 
 exports.DRIVER_KINDS = invariants.DRIVER_KINDS;
@@ -11026,18 +11456,32 @@ exports.GUARD_PREDICATE_VARS = invariants.GUARD_PREDICATE_VARS;
 
 exports.InstanceNotFoundError = invariants.InstanceNotFoundError;
 
+exports.ModelVersionAheadError = invariants.ModelVersionAheadError;
+
 exports.PersistedDocShapeError = invariants.PersistedDocShapeError;
 
+exports.READER_MODEL_ROLLOUT_URL = invariants.READER_MODEL_ROLLOUT_URL;
+
 exports.RESERVED_CONDITION_VARS = invariants.RESERVED_CONDITION_VARS;
 
+exports.ReaderModelAcknowledgementError = invariants.ReaderModelAcknowledgementError;
+
 exports.START_ALLOWED_VARS = invariants.START_ALLOWED_VARS;
 
 exports.START_FILTER_VARS = invariants.START_FILTER_VARS;
 
+exports.SpawnContractsInvalidError = invariants.SpawnContractsInvalidError;
+
 exports.WORKFLOW_DEFINITION_TYPE = invariants.WORKFLOW_DEFINITION_TYPE;
 
+exports.WORKFLOW_INSTANCE_TYPE = invariants.WORKFLOW_INSTANCE_TYPE;
+
 exports.WorkflowError = invariants.WorkflowError;
 
+exports.assertReadableModel = invariants.assertReadableModel;
+
+exports.assertReaderModelAcknowledgement = invariants.assertReaderModelAcknowledgement;
+
 exports.clientConfigFromResource = invariants.clientConfigFromResource;
 
 exports.conditionFieldReadNames = invariants.conditionFieldReadNames;
@@ -11054,6 +11498,8 @@ exports.errorMessage = invariants.errorMessage;
 
 exports.extractDocumentId = invariants.extractDocumentId;
 
+exports.fieldTreeShape = invariants.fieldTreeShape;
+
 exports.gdrFromResource = invariants.gdrFromResource;
 
 exports.gdrRef = invariants.gdrRef;
@@ -11066,8 +11512,14 @@ exports.isCascadeFired = invariants.isCascadeFired;
 
 exports.isGdr = invariants.isGdr;
 
+exports.isInputSourced = invariants.isInputSourced;
+
 exports.isNotesEntry = invariants.isNotesEntry;
 
+exports.isSingleDocRefEntry = invariants.isSingleDocRefEntry;
+
+exports.isSingleDocRefKind = invariants.isSingleDocRefKind;
+
 exports.isStartableDefinition = invariants.isStartableDefinition;
 
 exports.isSubjectEntry = invariants.isSubjectEntry;
@@ -11078,6 +11530,16 @@ exports.isTodoListEntry = invariants.isTodoListEntry;
 
 exports.isTodoListItem = invariants.isTodoListItem;
 
+exports.isUnprimed = invariants.isUnprimed;
+
+exports.minReaderModelOf = invariants.minReaderModelOf;
+
+exports.modelVersionOf = invariants.modelVersionOf;
+
+exports.parentRef = invariants.parentRef;
+
+exports.parseDefinitionSnapshot = invariants.parseDefinitionSnapshot;
+
 exports.parseGdr = invariants.parseGdr;
 
 exports.parseResourceGdr = invariants.parseResourceGdr;
@@ -11090,6 +11552,8 @@ exports.refDashboard = invariants.refDashboard;
 
 exports.refDataset = invariants.refDataset;
 
+exports.refKindAcceptsTypes = invariants.refKindAcceptsTypes;
+
 exports.refMediaLibrary = invariants.refMediaLibrary;
 
 exports.rejectedRefTypes = invariants.rejectedRefTypes;
@@ -11098,6 +11562,10 @@ exports.releaseDocId = invariants.releaseDocId;
 
 exports.releaseRef = invariants.releaseRef;
 
+exports.requiredModelFeatures = invariants.requiredModelFeatures;
+
+exports.requiredReaderModel = invariants.requiredReaderModel;
+
 exports.resourceAliasesToMap = invariants.resourceAliasesToMap;
 
 exports.resourceFromParsed = invariants.resourceFromParsed;
@@ -11106,12 +11574,16 @@ exports.resourceGdr = invariants.resourceGdr;
 
 exports.sameResource = invariants.sameResource;
 
+exports.scalarValidationIssues = invariants.scalarValidationIssues;
+
 exports.schemaTreeShape = invariants.schemaTreeShape;
 
 exports.startKindOf = invariants.startKindOf;
 
 exports.tagScopeFilter = invariants.tagScopeFilter;
 
+exports.terminalState = invariants.terminalState;
+
 exports.toBareId = invariants.toBareId;
 
 exports.tryParseGdr = invariants.tryParseGdr;
@@ -11220,10 +11692,6 @@ exports.ConcurrentEditFieldError = ConcurrentEditFieldError;
 
 exports.ConcurrentFireActionError = ConcurrentFireActionError;
 
-exports.DATA_MODEL_MIN_READER = DATA_MODEL_MIN_READER;
-
-exports.DATA_MODEL_VERSION = DATA_MODEL_VERSION;
-
 exports.DEFAULT_CONTENT_PERSPECTIVE = DEFAULT_CONTENT_PERSPECTIVE;
 
 exports.DEFAULT_EFFECT_LEASE_MS = DEFAULT_EFFECT_LEASE_MS;
@@ -11252,15 +11720,13 @@ exports.GROUP_KIND_DISPLAY = GROUP_KIND_DISPLAY;
 
 exports.GUARD_DOC_TYPE = GUARD_DOC_TYPE;
 
-exports.GUARD_LIFTED_PREDICATE = GUARD_LIFTED_PREDICATE;
-
 exports.GUARD_OWNER = GUARD_OWNER;
 
 exports.HISTORY_DISPLAY = HISTORY_DISPLAY;
 
-exports.MissingHandlerError = MissingHandlerError;
+exports.InitialFieldsInvalidError = InitialFieldsInvalidError;
 
-exports.ModelVersionAheadError = ModelVersionAheadError;
+exports.MissingHandlerError = MissingHandlerError;
 
 exports.MutationGuardDeniedError = MutationGuardDeniedError;
 
@@ -11280,8 +11746,6 @@ exports.StartNotPrimedError = StartNotPrimedError;
 
 exports.StartNotSettledError = StartNotSettledError;
 
-exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;
-
 exports.WorkflowActionFired = WorkflowActionFired;
 
 exports.WorkflowDefinitionDeleted = WorkflowDefinitionDeleted;
@@ -11324,8 +11788,6 @@ exports.activityAutonomyOf = activityAutonomyOf;
 
 exports.applicableDefinitions = applicableDefinitions;
 
-exports.assertReadableModel = assertReadableModel;
-
 exports.autonomySummary = autonomySummary;
 
 exports.availableActions = availableActions;
@@ -11336,6 +11798,8 @@ exports.buildSnapshot = buildSnapshot;
 
 exports.checklistLines = checklistLines;
 
+exports.clientProjectUserDirectory = clientProjectUserDirectory;
+
 exports.compileGuard = compileGuard;
 
 exports.computeDiffEntries = computeDiffEntries;
@@ -11412,9 +11876,9 @@ exports.evaluateMutationGuard = evaluateMutationGuard;
 
 exports.evaluateStartFilter = evaluateStartFilter;
 
-exports.explainStartAllowed = explainStartAllowed;
+exports.expandResourceAliases = expandResourceAliases;
 
-exports.fieldTreeShape = fieldTreeShape;
+exports.explainStartAllowed = explainStartAllowed;
 
 exports.findCurrentActivityEntry = findCurrentActivityEntry;
 
@@ -11434,6 +11898,8 @@ exports.hashDefinitionContent = hashDefinitionContent;
 
 exports.inFlightFilter = inFlightFilter;
 
+exports.initialFieldIssues = initialFieldIssues;
+
 exports.instanceDocId = instanceDocId;
 
 exports.instanceGuardQuery = instanceGuardQuery;
@@ -11448,36 +11914,26 @@ exports.isDefinitionApplicable = isDefinitionApplicable;
 
 exports.isFilterScopedOut = isFilterScopedOut;
 
-exports.isGuardLifted = isGuardLifted;
+exports.isProjectUserNotFoundError = isProjectUserNotFoundError;
 
 exports.isTelemetryEnvDenied = isTelemetryEnvDenied;
 
 exports.isTerminalStage = isTerminalStage;
 
-exports.isUnprimed = isUnprimed;
-
 exports.lakeGuardId = lakeGuardId;
 
 exports.latestDeployedDefinitions = latestDeployedDefinitions;
 
 exports.lintEffectOutputs = lintEffectOutputs;
 
-exports.minReaderModelOf = minReaderModelOf;
-
 exports.missingRequiredInputs = missingRequiredInputs;
 
-exports.modelVersionOf = modelVersionOf;
-
 exports.narrateAutonomyWaits = narrateAutonomyWaits;
 
 exports.noopTelemetry = noopTelemetry;
 
-exports.parentRef = parentRef;
-
 exports.parseDefinitionInput = parseDefinitionInput;
 
-exports.parseDefinitionSnapshot = parseDefinitionSnapshot;
-
 exports.parseGuardDocument = parseGuardDocument;
 
 exports.parseInstanceDocument = parseInstanceDocument;
@@ -11490,10 +11946,16 @@ exports.readInstanceDoc = readInstanceDoc;
 
 exports.readsRaw = readsRaw;
 
+exports.refsOf = refsOf;
+
 exports.remediationsFor = remediationsFor;
 
 exports.resolveAccess = resolveAccess;
 
+exports.resolveActor = resolveActor;
+
+exports.resolveClientActor = resolveClientActor;
+
 exports.resolveFieldEntry = resolveFieldEntry$1;
 
 exports.retractStageGuards = retractStageGuards;
@@ -11516,8 +11978,6 @@ exports.subscriptionDocumentsForInstance = subscriptionDocumentsForInstance;
 
 exports.sweepStaleClaims = sweepStaleClaims;
 
-exports.terminalState = terminalState;
-
 exports.unboundAllowedReads = unboundAllowedReads;
 
 exports.unsatisfiedTransitionSummaries = unsatisfiedTransitionSummaries;