@sanity/workflow-engine 0.27.0 → 0.28.0

package/dist/index.cjs

@@ -55,6 +55,53 @@ 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 parseDefinitionSnapshotValue(instance) {
+    try {
+        return normalizeLegacyActivityRequirements(JSON.parse(instance.definitionSnapshot));
+    } catch (err) {
+        invariants.rethrowWithContext(err, `Failed to parse definitionSnapshot on instance "${instance._id}"`);
+    }
+}
+
+function normalizeLegacyActivityRequirements(value) {
+    for (const stage of arrayMember(value, "stages")) for (const activity of arrayMember(stage, "activities")) normalizeLegacyRequirementMap(activity);
+    return value;
+}
+
+function arrayMember(value, key) {
+    if (typeof value != "object" || value === null) return [];
+    const member = value[key];
+    return Array.isArray(member) ? member : [];
+}
+
+function normalizeLegacyRequirementMap(value) {
+    if (typeof value != "object" || value === null) return;
+    const activity = value, requirements = activity.requirements;
+    typeof requirements != "object" || requirements === null || Array.isArray(requirements) || (activity.requirements = Object.entries(requirements).map(([name, query]) => ({
+        type: "groq",
+        name: name,
+        query: query
+    })));
+}
+
+function parseDefinitionSnapshot(instance) {
+    return parseDefinitionSnapshotValue(instance);
+}
+
+function parentRef(instance) {
+    return instance.ancestors.at(-1);
+}
+
 function effectiveEditable(baseline, override) {
     if (baseline === void 0) return;
     if (override === void 0) return baseline;
@@ -131,7 +178,7 @@ function resolveEditTarget(args) {
 }
 
 function fieldWindowOpen(instance, site) {
-    const terminal = invariants.terminalState(instance);
+    const terminal = terminalState(instance);
     if (terminal !== "in-flight") return {
         open: !1,
         detail: `instance ${terminal}`
@@ -198,7 +245,7 @@ function editDisabledReason(args) {
 }
 
 function instanceTerminalReason(instance) {
-    const terminal = invariants.terminalState(instance);
+    const terminal = terminalState(instance);
     if (terminal === "aborted" && instance.abortedAt !== void 0) return {
         kind: "instance-aborted",
         abortedAt: instance.abortedAt
@@ -328,7 +375,7 @@ function instanceStartedData(args) {
 function instanceStartedDataFor(args) {
     return instanceStartedData({
         definition: {
-            ...invariants.parseDefinitionSnapshot(args.instance),
+            ...parseDefinitionSnapshot(args.instance),
             ...args.instance.pinnedContentHash !== void 0 ? {
                 contentHash: args.instance.pinnedContentHash
             } : {}
@@ -356,7 +403,7 @@ function stageTransitionedData(args) {
 }
 
 function openStage$1(instance) {
-    const definition = invariants.parseDefinitionSnapshot(instance);
+    const definition = parseDefinitionSnapshot(instance);
     return {
         definition: definition,
         stage: definition.stages.find(s => s.name === instance.currentStage)
@@ -402,6 +449,240 @@ function fieldEditedData(args) {
     };
 }
 
+const DATA_MODEL_VERSION = 5, DATA_MODEL_MIN_READER = 4, READER_MODEL_ROLLOUT_URL = "https://www.sanity.io/docs/editorial-workflows/prerelease";
+
+class ReaderModelAcknowledgementError extends invariants.WorkflowError {
+    code="WORKFLOW_READER_MODEL_ACKNOWLEDGEMENT_MISMATCH";
+    expectedMinReaderModel;
+    engineMinReaderModel=DATA_MODEL_MIN_READER;
+    engineModelVersion=DATA_MODEL_VERSION;
+    documentationUrl=READER_MODEL_ROLLOUT_URL;
+    constructor(expectedMinReaderModel, context = "Deployment") {
+        const expected = expectedMinReaderModel === void 0 ? "missing" : String(expectedMinReaderModel);
+        super("reader-model-acknowledgement", `${context} expected reader floor ${expected}; the installed engine requires acknowledgement ${DATA_MODEL_MIN_READER}.\nDo not change the acknowledgement yet: accepting ${DATA_MODEL_MIN_READER} authorizes this engine to write documents that older readers will refuse.\nUpgrade every Studio, CLI, MCP server, Function, and other runtime that reads engine-owned documents; verify that rollout in every environment sharing the workflow resource; then change the literal in deployment configuration and deploy the writer.\nRollout guide: ${READER_MODEL_ROLLOUT_URL}`), 
+        this.name = "ReaderModelAcknowledgementError", this.expectedMinReaderModel = expectedMinReaderModel;
+    }
+}
+
+function assertReaderModelAcknowledgement(expectedMinReaderModel, context) {
+    if (typeof expectedMinReaderModel != "number" || !Number.isFinite(expectedMinReaderModel) || !Number.isInteger(expectedMinReaderModel) || expectedMinReaderModel < 0 || expectedMinReaderModel !== DATA_MODEL_MIN_READER) throw new ReaderModelAcknowledgementError(expectedMinReaderModel, context);
+}
+
+const DATA_MODEL_CHANGES = Object.freeze([ Object.freeze({
+    id: "governed-model-stamps",
+    introducedInModel: 1,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "unconditional",
+    summary: "Definition and instance documents carry model provenance and reader-floor stamps."
+}), Object.freeze({
+    id: "subject-field-kind",
+    introducedInModel: 2,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "A workflow-level subject field identifies the document a workflow is about."
+}), Object.freeze({
+    id: "typed-scalar-choice-lists",
+    introducedInModel: 2,
+    minReaderModel: 2,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "Scalar fields may constrain writes to a persisted typed choice list."
+}), Object.freeze({
+    id: "action-semantics",
+    introducedInModel: 2,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Ordinary actions may carry a closed bag of advisory workflow semantics."
+}), Object.freeze({
+    id: "inclusive-scalar-bounds",
+    introducedInModel: 2,
+    minReaderModel: 2,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "String, text, and number values may carry persisted inclusive bounds."
+}), Object.freeze({
+    id: "progress-field-kind",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "A progress field kind carries application-defined 0–100 completion."
+}), Object.freeze({
+    id: "effect-claim-tokens",
+    introducedInModel: 3,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Pending-effect claims carry an exact-claim token gating mid-dispatch state reports."
+}), Object.freeze({
+    id: "classified-principal-ids",
+    introducedInModel: 4,
+    minReaderModel: 4,
+    documentTypes: Object.freeze([ "instance" ]),
+    compatibility: "reader-floor",
+    applicability: "unconditional",
+    summary: "Principal ids are namespace-classified: actor and assignee writes carry the account-global user id only, and readers resolve legacy project-scoped ids through the prefix classifier at the instance read funnel."
+}), Object.freeze({
+    id: "readiness-requirements",
+    introducedInModel: 4,
+    minReaderModel: 4,
+    documentTypes: Object.freeze([ "definition" ]),
+    compatibility: "reader-floor",
+    applicability: "detectable",
+    summary: "Start and activity readiness use named polymorphic requirement arrays."
+}), Object.freeze({
+    id: "due-date-field-kinds",
+    introducedInModel: 5,
+    minReaderModel: 0,
+    documentTypes: Object.freeze([ "definition", "instance" ]),
+    compatibility: "additive",
+    applicability: "detectable",
+    summary: "Due-date field kinds (dueDate, dueDatetime) mark a level deadline, elevated aliases of date/datetime carrying the same stored value."
+}) ]);
+
+function recordOf(value) {
+    return value !== null && typeof value == "object" && !Array.isArray(value) ? value : void 0;
+}
+
+function recordsAt(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.map(recordOf).filter(item => item !== void 0) : [];
+}
+
+function nestedFieldEntries(entries) {
+    return entries.flatMap(entry => [ entry, ...nestedFieldEntries(recordsAt(entry, "fields")), ...nestedFieldEntries(recordsAt(entry, "of")) ]);
+}
+
+function parsedDefinitionSnapshot(root) {
+    if (typeof root.definitionSnapshot == "string") return recordOf(parseDefinitionSnapshotValue({
+        _id: typeof root._id == "string" ? root._id : "<unknown instance>",
+        definitionSnapshot: root.definitionSnapshot
+    }));
+}
+
+function persistedFieldEntries(document) {
+    const root = recordOf(document);
+    if (root === void 0) return [];
+    const snapshot = parsedDefinitionSnapshot(root), roots = snapshot === void 0 ? [ root ] : [ root, snapshot ], stages = roots.flatMap(candidate => recordsAt(candidate, "stages")), activities = stages.flatMap(stage => recordsAt(stage, "activities")), actions = activities.flatMap(activity => recordsAt(activity, "actions")), effects = actions.flatMap(action => recordsAt(action, "effects"));
+    return nestedFieldEntries([ ...roots.flatMap(candidate => recordsAt(candidate, "fields")), ...stages.flatMap(stage => recordsAt(stage, "fields")), ...activities.flatMap(activity => recordsAt(activity, "fields")), ...actions.flatMap(action => recordsAt(action, "params")), ...effects.flatMap(effect => recordsAt(effect, "outputs")) ]);
+}
+
+function hasChoiceList(document) {
+    return persistedFieldEntries(document).some(entry => {
+        const options = recordOf(entry.options);
+        return options !== void 0 && Array.isArray(options.list);
+    });
+}
+
+function hasFieldKind(document, kind) {
+    return persistedFieldEntries(document).some(entry => entry.type === kind || entry._type === kind);
+}
+
+function hasActionSemantics(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : recordsAt(root, "stages").flatMap(stage => recordsAt(stage, "activities")).flatMap(activity => recordsAt(activity, "actions")).some(action => Array.isArray(action.semantics));
+}
+
+function hasScalarValidation(document) {
+    return persistedFieldEntries(document).some(entry => {
+        const validation = recordOf(entry.validation);
+        return typeof validation?.min == "number" || typeof validation?.max == "number";
+    });
+}
+
+function hasClaimTokens(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : recordsAt(root, "pendingEffects").some(entry => {
+        const claim = recordOf(entry.claim);
+        return claim !== void 0 && typeof claim.claimToken == "string";
+    });
+}
+
+function hasReadinessRequirements(document) {
+    const root = recordOf(document);
+    return root === void 0 ? !1 : Array.isArray(recordOf(root.start)?.requirements) ? !0 : recordsAt(root, "stages").some(stage => recordsAt(stage, "activities").some(activity => Array.isArray(activity.requirements)));
+}
+
+const featureDetectors = {
+    "governed-model-stamps": () => !0,
+    "subject-field-kind": document => hasFieldKind(document, "subject"),
+    "typed-scalar-choice-lists": hasChoiceList,
+    "action-semantics": hasActionSemantics,
+    "inclusive-scalar-bounds": hasScalarValidation,
+    "progress-field-kind": document => hasFieldKind(document, "progress"),
+    "effect-claim-tokens": hasClaimTokens,
+    "classified-principal-ids": () => !0,
+    "readiness-requirements": hasReadinessRequirements,
+    "due-date-field-kinds": document => hasFieldKind(document, "dueDate") || hasFieldKind(document, "dueDatetime")
+};
+
+function requiredModelFeatures(documentType, document) {
+    return DATA_MODEL_CHANGES.filter(change => change.documentTypes.some(candidate => candidate === documentType) && featureDetectors[change.id](document));
+}
+
+function requiredReaderModel(documentType, document) {
+    return Math.max(0, ...requiredModelFeatures(documentType, document).map(change => change.minReaderModel));
+}
+
+function modelStampFor(args) {
+    return {
+        modelVersion: DATA_MODEL_VERSION,
+        minReaderModel: Math.max(DATA_MODEL_MIN_READER, args.storedMinReaderModel ?? 0, requiredReaderModel(args.documentType, args.document))
+    };
+}
+
+function fieldTreeShape(value) {
+    if (Array.isArray(value)) return value.map(fieldTreeShape);
+    if (value === null) return "null";
+    if (typeof value == "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).toSorted().map(key => [ key, fieldTreeShape(record[key]) ]));
+    }
+    return typeof value;
+}
+
+function modelVersionOf(doc) {
+    const stamp = doc.modelVersion;
+    return typeof stamp == "number" ? stamp : 0;
+}
+
+function minReaderModelOf(doc) {
+    const floor = doc.minReaderModel;
+    return typeof floor == "number" ? floor : modelVersionOf(doc);
+}
+
+class ModelVersionAheadError extends 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 documentReaderModel = minReaderModelOf(doc);
+    if (documentReaderModel > DATA_MODEL_VERSION) throw new ModelVersionAheadError({
+        documentId: doc._id,
+        documentModelVersion: modelVersionOf(doc),
+        requiredReaderModel: documentReaderModel
+    });
+    return doc;
+}
+
 function effectSites(def) {
     const sites = [];
     for (const stage of def.stages ?? []) for (const activity of stage.activities ?? []) for (const action of activity.actions ?? []) for (const effect of action.effects ?? []) sites.push({
@@ -1808,7 +2089,7 @@ function buildParams(args) {
     return {
         self: invariants.selfGdr(instance),
         fields: renderedFields(instance.fields ?? [], snapshot),
-        parent: invariants.parentRef(instance)?.id ?? null,
+        parent: parentRef(instance)?.id ?? null,
         ancestors: instance.ancestors.map(a => a.id),
         stage: instance.currentStage,
         now: now,
@@ -2273,6 +2554,12 @@ function isRevisionConflict(error) {
     return statusCode === 409 ? !0 : typeof message == "string" && message.includes("ifRevisionId check failed");
 }
 
+function isCreateIdCollision(error) {
+    if (typeof error != "object" || error === null) return !1;
+    const {message: message, responseBody: responseBody} = error;
+    return typeof message == "string" && message.includes("already exists") && (message.includes("Document by ID") || message.includes("create() failed")) ? !0 : typeof responseBody == "string" && responseBody.includes("documentAlreadyExistsError");
+}
+
 class ConcurrentEditFieldError extends invariants.WorkflowError {
     instanceId;
     target;
@@ -3422,7 +3709,7 @@ function noTransitionFiresCause(input) {
 }
 
 function diagnoseInstance(input) {
-    const {instance: instance} = input, terminal = invariants.terminalState(instance);
+    const {instance: instance} = input, terminal = terminalState(instance);
     if (terminal === "aborted" && instance.abortedAt !== void 0) {
         const reason = abortReason(instance);
         return {
@@ -3576,7 +3863,7 @@ function liveSubworkflowRefs(instance) {
 }
 
 function readsRaw(ref) {
-    return ref.type === invariants.WORKFLOW_INSTANCE_TYPE || ref.type === "system.release";
+    return ref.type === WORKFLOW_INSTANCE_TYPE || ref.type === "system.release";
 }
 
 const DEFAULT_CONTENT_PERSPECTIVE = "drafts";
@@ -4350,7 +4637,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(invariants.WORKFLOW_INSTANCE_TYPE),
+    _type: v__namespace.literal(WORKFLOW_INSTANCE_TYPE),
     _rev: v__namespace.string(),
     _createdAt: invariants.IsoTimestamp,
     _updatedAt: invariants.IsoTimestamp,
@@ -4383,7 +4670,7 @@ function parseInstanceDocument(doc) {
     return invariants.parsePersistedDoc({
         schema: WorkflowInstanceSchema,
         doc: doc,
-        docType: invariants.WORKFLOW_INSTANCE_TYPE
+        docType: WORKFLOW_INSTANCE_TYPE
     });
 }
 
@@ -4829,7 +5116,7 @@ async function getInstanceDocument(client, instanceId) {
 }
 
 function readInstanceDoc(doc) {
-    return parseInstanceDocument(invariants.assertReadableModel(doc));
+    return parseInstanceDocument(assertReadableModel(doc));
 }
 
 async function reload({client: client, instanceId: instanceId, tag: tag}) {
@@ -4900,7 +5187,7 @@ function buildInstanceBase(args) {
         } : {}
     }, ...args.extraHistory ?? [] ], history = executionContext !== void 0 ? stampHistoryEntries(entries, executionContext) : entries, body = {
         _id: id,
-        _type: invariants.WORKFLOW_INSTANCE_TYPE,
+        _type: WORKFLOW_INSTANCE_TYPE,
         _rev: "",
         _createdAt: now,
         _updatedAt: now,
@@ -4929,7 +5216,7 @@ function buildInstanceBase(args) {
     };
     return {
         ...body,
-        ...invariants.modelStampFor({
+        ...modelStampFor({
             documentType: "instance",
             document: body
         })
@@ -5027,7 +5314,7 @@ async function readBatch(args) {
 }
 
 function validateRawDoc(doc, perspective) {
-    return perspective !== "raw" ? doc : doc._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : invariants.assertReadableModel(doc);
+    return perspective !== "raw" ? doc : doc._type === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : assertReadableModel(doc);
 }
 
 function groupReads(reads) {
@@ -5110,7 +5397,7 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
         clientForGdr: options.clientForGdr,
         refSurface: options.refSurface,
         instance: instance,
-        definition: invariants.parseDefinitionSnapshot(instance),
+        definition: parseDefinitionSnapshot(instance),
         ...options.actor !== void 0 ? {
             actor: options.actor
         } : {},
@@ -5898,12 +6185,14 @@ function resolveGuard({guard: guard, instance: instance, stageName: stageName, n
 
 async function upsertGuard(args) {
     const {client: client, doc: doc, exists: exists} = args;
-    if (!exists) {
+    if (!exists) try {
         await client.create(doc, {
             ...SYNC_COMMIT,
             tag: REQUEST_TAG.guardDeploy
         });
         return;
+    } catch (error) {
+        if (!isCreateIdCollision(error)) throw error;
     }
     const {_id: _id, _type: _type, _rev: _rev, _createdAt: _createdAt, _updatedAt: _updatedAt, ...body} = doc;
     await client.patch(doc._id).set(body).commit({
@@ -6249,7 +6538,7 @@ async function persistThenDeploy({ctx: ctx, mutation: mutation, deploy: deploy})
         committedRev: committed._rev,
         restore: instanceStateFields({
             ...ctx.instance,
-            minReaderModel: invariants.minReaderModelOf(ctx.instance)
+            minReaderModel: minReaderModelOf(ctx.instance)
         }),
         unset: ctx.instance.completedAt === void 0 ? [ "completedAt" ] : [],
         reversible: !spawned,
@@ -6615,16 +6904,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 ? invariants.assertReadableModel(result) : null;
+    return result ? 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: invariants.WORKFLOW_INSTANCE_TYPE
+        type: WORKFLOW_INSTANCE_TYPE
     }, ancestors = [ ...parent.ancestors, {
         id: invariants.selfGdr(parent),
-        type: invariants.WORKFLOW_INSTANCE_TYPE
+        type: WORKFLOW_INSTANCE_TYPE
     } ], inheritedPerspective = parent.perspective, fieldDiscards = [], childFields = await resolveDeclaredFields({
         entryDefs: definition.fields,
         initialFields: initialFields,
@@ -7408,7 +7697,7 @@ async function runCascadeHop({client: client, instanceId: instanceId, actor: act
     }) : await buildEngineContext({
         client: client,
         instance: instance,
-        definition: invariants.parseDefinitionSnapshot(instance),
+        definition: parseDefinitionSnapshot(instance),
         ...contextOptions
     });
     if (isTerminal(ctx)) return {
@@ -7589,7 +7878,7 @@ async function loadInstancesById(client, ids) {
     const children = await client.fetch("*[_id in $ids]", {
         ids: ids
     });
-    return new Map(children.filter(child => child._type === invariants.WORKFLOW_INSTANCE_TYPE).map(child => {
+    return new Map(children.filter(child => child._type === WORKFLOW_INSTANCE_TYPE).map(child => {
         const instance = readInstanceDoc(child);
         return [ instance._id, instance ];
     }));
@@ -7649,10 +7938,10 @@ async function propagateToAncestors(args) {
 async function loadPropagationPair({client: client, instanceId: instanceId, instance: instance}) {
     const child = instance ?? await getInstanceDocument(client, instanceId);
     if (!child) return;
-    const parentGdr = invariants.parentRef(child);
+    const parentGdr = parentRef(child);
     if (parentGdr === void 0) return;
     const parentDoc = await client.getDocument(invariants.toBareId(parentGdr.id));
-    if (!(!parentDoc || parentDoc._type !== invariants.WORKFLOW_INSTANCE_TYPE)) return {
+    if (!(!parentDoc || parentDoc._type !== WORKFLOW_INSTANCE_TYPE)) return {
         child: child,
         parent: readInstanceDoc(parentDoc)
     };
@@ -7679,7 +7968,7 @@ async function buildCascadeStepContext(args, instance) {
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
         instance: instance,
-        definition: invariants.parseDefinitionSnapshot(instance),
+        definition: parseDefinitionSnapshot(instance),
         ...args.clock ? {
             clock: args.clock
         } : {},
@@ -7730,7 +8019,7 @@ function stampSpawnBatch({mutation: mutation, parent: parent, children: children
 function requireSpawnBatchChild({parent: parent, children: children, childId: childId}) {
     const child = children.get(childId);
     if (child === void 0) throw new Error(`Spawn batch child ${childId} disappeared`);
-    const expectedParent = invariants.parentRef(child);
+    const expectedParent = parentRef(child);
     if (expectedParent === void 0 || invariants.toBareId(expectedParent.id) !== parent._id) throw new Error(`Spawn batch child ${childId} does not belong to parent ${parent._id}`);
     return child;
 }
@@ -7753,7 +8042,7 @@ async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: c
         at: ctx.now,
         instanceRef: {
             id: childUri,
-            type: invariants.WORKFLOW_INSTANCE_TYPE
+            type: WORKFLOW_INSTANCE_TYPE
         },
         detail: `Instance "${child._id}" names this instance as its parent but no subworkflow-registry row matches it, so its state cannot drive any gate here.`
     }), await persist(ctx, mutation));
@@ -7761,7 +8050,7 @@ async function recordOrphanedPropagation({ctx: ctx, mutation: mutation, child: c
 
 function startMutation(instance) {
     return {
-        minReaderModel: invariants.minReaderModelOf(instance),
+        minReaderModel: minReaderModelOf(instance),
         currentStage: instance.currentStage,
         fields: (instance.fields ?? []).map(s => ({
             ...s
@@ -7828,7 +8117,7 @@ function instanceStateFields(src) {
         } : {}
     };
     return {
-        ...invariants.modelStampFor({
+        ...modelStampFor({
             documentType: "instance",
             document: state,
             storedMinReaderModel: src.minReaderModel
@@ -8704,7 +8993,7 @@ async function whatIfFireAction(args) {
 
 function replayable(args) {
     const {instance: instance, stage: stage, action: action} = args;
-    if (invariants.terminalState(instance) !== "in-flight" || (action.params ?? []).length > 0 || action.spawn !== void 0) return !1;
+    if (terminalState(instance) !== "in-flight" || (action.params ?? []).length > 0 || action.spawn !== void 0) return !1;
     const primed = new Set((findOpenStageEntry(instance)?.activities ?? []).map(e => e.name));
     return (stage.activities ?? []).every(declared => primed.has(declared.name)) ? !(stage.activities ?? []).flatMap(declared => declared.actions ?? []).some(sibling => invariants.isCascadeFired(sibling) && sibling.spawn !== void 0) : !1;
 }
@@ -8844,7 +9133,7 @@ async function evaluateInstance(args) {
         client: client,
         instanceId: instanceId,
         tag: tag
-    }) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
         client: client,
         workflowResource: workflowResource,
         resourceClients: resourceClients
@@ -9404,7 +9693,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 == "${invariants.WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ], params = {
+    const conditions = [ `_type == "${WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ], params = {
         tag: tag
     };
     filter.includeCompleted !== !0 && conditions.push(inFlightFilter()), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
@@ -9613,7 +9902,7 @@ function planDefinitionDeploy({def: def, latest: latest, target: target}) {
         tag: target.tag,
         version: version,
         contentHash: contentHash,
-        ...invariants.modelStampFor({
+        ...modelStampFor({
             documentType: "definition",
             document: expanded
         })
@@ -9690,7 +9979,7 @@ async function loadDefinition({client: client, definition: definition, version:
             definition: definition,
             version: version
         });
-        return invariants.assertReadableModel(doc);
+        return assertReadableModel(doc);
     }
     const latest = await loadLatestDeployed({
         client: client,
@@ -9708,14 +9997,14 @@ async function loadLatestDeployed({client: client, definition: definition, tag:
         definition: definition,
         tag: tag
     });
-    return doc ? invariants.assertReadableModel(doc) : void 0;
+    return doc ? assertReadableModel(doc) : void 0;
 }
 
 async function loadDefinitionVersions({client: client, definition: definition, tag: tag}) {
     return (await client.fetch(`*[_type == "${invariants.WORKFLOW_DEFINITION_TYPE}" && name == $definition && ${invariants.tagScopeFilter()}] | order(version desc)`, {
         definition: definition,
         tag: tag
-    })).map(invariants.assertReadableModel);
+    })).map(assertReadableModel);
 }
 
 async function loadDefinitionVersionsOrThrow({client: client, definition: definition, tag: tag}) {
@@ -10103,8 +10392,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 && 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({
+    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({
         instance: existing,
         initialFieldCount: args.initialFieldCount,
         viaSpawn: !1
@@ -10411,7 +10700,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(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)));
+    })).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)));
     if (referrers.length > 0) throw new invariants.DefinitionInUseError({
         definition: definition,
         blockedBy: {
@@ -10426,7 +10715,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 == "${invariants.WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && ${inFlightFilter()}${versionFilter}] | order(_id asc){_id}`, {
+    return (await client.fetch(`*[_type == "${WORKFLOW_INSTANCE_TYPE}" && definition == $definition && ${invariants.tagScopeFilter()} && ${inFlightFilter()}${versionFilter}] | order(_id asc){_id}`, {
         definition: definition,
         tag: tag,
         ...version !== void 0 ? {
@@ -10471,12 +10760,12 @@ async function fetchStartSlice(args) {
             includeCompleted: !0
         }
     });
-    return (await client.fetch(query, params)).map(invariants.assertReadableModel).map(projectStartSliceRow);
+    return (await client.fetch(query, params)).map(assertReadableModel).map(projectStartSliceRow);
 }
 
 const workflow = {
     deployDefinitions: async rawArgs => {
-        invariants.assertReaderModelAcknowledgement(rawArgs.expectedMinReaderModel);
+        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"));
@@ -11102,7 +11391,7 @@ const workflow = {
             instance: instance
         }), reserved = await renderConditionScope({
             instance: instance,
-            definition: invariants.parseDefinitionSnapshot(instance),
+            definition: parseDefinitionSnapshot(instance),
             snapshot: snapshot,
             now: clock()
         }), tree = groqJs.parse(groq, {
@@ -11181,7 +11470,7 @@ const workflow = {
         invariants.validateTag(tag);
         const clock = args.clock ?? wallClock, deployed = (await client.fetch(latestDefinitionsGroq(), {
             tag: tag
-        })).map(invariants.assertReadableModel);
+        })).map(assertReadableModel);
         let slice;
         return applicableDefinitions({
             definitions: deployed,
@@ -11563,7 +11852,7 @@ async function verifyDeployedDefinitionsInternal(args) {
     invariants.validateTag(tag);
     const log = logger("verifyDeployedDefinitions"), definitions = (await client.fetch(definitionsListGroq("asc"), {
         tag: tag
-    })).map(invariants.assertReadableModel), seen = [], missingByName = /* @__PURE__ */ new Map;
+    })).map(assertReadableModel), seen = [], missingByName = /* @__PURE__ */ new Map;
     for (const def of definitions) seen.push({
         name: def.name,
         version: def.version,
@@ -12008,7 +12297,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 !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
+            !invariants.isParseableInstant(rawStamp) || owned.doc._type !== WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
             return;
         }
         target.set(uri, owned);
@@ -12031,7 +12320,7 @@ function createInstanceSession(args) {
     let parsedDefinition;
     const definitionOf = () => (parsedDefinition?.source !== instance && (parsedDefinition = {
         source: instance,
-        definition: invariants.parseDefinitionSnapshot(instance)
+        definition: 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,
@@ -12670,7 +12959,7 @@ function attributeMember({member: member, group: group, chain: chain}) {
 }
 
 function diffEntry({def: rawDef, latestRaw: latestRaw, target: target}) {
-    invariants.assertReaderModelAcknowledgement(target.expectedMinReaderModel);
+    assertReaderModelAcknowledgement(target.expectedMinReaderModel);
     const def = parseDefinitionInput(rawDef, "diffEntry"), plan = planDefinitionDeploy({
         def: def,
         latest: asLatest(latestRaw),
@@ -12702,7 +12991,7 @@ function asLatest(raw) {
 }
 
 async function computeDiffEntries({client: client, defs: defs, target: target}) {
-    invariants.assertReaderModelAcknowledgement(target.expectedMinReaderModel);
+    assertReaderModelAcknowledgement(target.expectedMinReaderModel);
     const entries = [];
     for (const rawDef of defs) {
         const def = parseDefinitionInput(rawDef, "computeDiffEntries"), latest = await loadLatestDeployed({
@@ -12951,7 +13240,7 @@ const HISTORY_DISPLAY = {
         title: "Workflow definition",
         description: "An immutable workflow blueprint, addressed by `name` + `version`."
     },
-    [invariants.WORKFLOW_INSTANCE_TYPE]: {
+    [WORKFLOW_INSTANCE_TYPE]: {
         title: "Workflow instance",
         description: "A running (or finished) workflow against its declared fields."
     }
@@ -13030,12 +13319,6 @@ 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;
@@ -13058,16 +13341,10 @@ 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_FILTER_VARS = invariants.START_FILTER_VARS;
 
 exports.START_REQUIREMENT_VARS = invariants.START_REQUIREMENT_VARS;
@@ -13078,14 +13355,8 @@ 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.classifyPrincipalId = invariants.classifyPrincipalId;
 
 exports.clientConfigFromResource = invariants.clientConfigFromResource;
@@ -13104,8 +13375,6 @@ exports.errorMessage = invariants.errorMessage;
 
 exports.extractDocumentId = invariants.extractDocumentId;
 
-exports.fieldTreeShape = invariants.fieldTreeShape;
-
 exports.gdrFromResource = invariants.gdrFromResource;
 
 exports.gdrRef = invariants.gdrRef;
@@ -13136,20 +13405,8 @@ exports.isTodoListEntry = invariants.isTodoListEntry;
 
 exports.isTodoListItem = invariants.isTodoListItem;
 
-exports.isUnprimed = invariants.isUnprimed;
-
 exports.lakePrincipalId = invariants.lakePrincipalId;
 
-exports.minReaderModelOf = invariants.minReaderModelOf;
-
-exports.modelVersionOf = invariants.modelVersionOf;
-
-exports.parentRef = invariants.parentRef;
-
-exports.parseDefinitionSnapshot = invariants.parseDefinitionSnapshot;
-
-exports.parseDefinitionSnapshotValue = invariants.parseDefinitionSnapshotValue;
-
 exports.parseGdr = invariants.parseGdr;
 
 exports.parseResourceGdr = invariants.parseResourceGdr;
@@ -13172,10 +13429,6 @@ exports.releaseDocId = invariants.releaseDocId;
 
 exports.releaseRef = invariants.releaseRef;
 
-exports.requiredModelFeatures = invariants.requiredModelFeatures;
-
-exports.requiredReaderModel = invariants.requiredReaderModel;
-
 exports.resourceAliasesToMap = invariants.resourceAliasesToMap;
 
 exports.resourceFromParsed = invariants.resourceFromParsed;
@@ -13192,8 +13445,6 @@ exports.startKindOf = invariants.startKindOf;
 
 exports.tagScopeFilter = invariants.tagScopeFilter;
 
-exports.terminalState = invariants.terminalState;
-
 exports.toBareId = invariants.toBareId;
 
 exports.tryParseGdr = invariants.tryParseGdr;
@@ -13318,6 +13569,12 @@ exports.ConcurrentEditFieldError = ConcurrentEditFieldError;
 
 exports.ConcurrentFireActionError = ConcurrentFireActionError;
 
+exports.DATA_MODEL_CHANGES = DATA_MODEL_CHANGES;
+
+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;
@@ -13360,6 +13617,8 @@ exports.InitialFieldsInvalidError = InitialFieldsInvalidError;
 
 exports.MissingHandlerError = MissingHandlerError;
 
+exports.ModelVersionAheadError = ModelVersionAheadError;
+
 exports.MutationGuardDeniedError = MutationGuardDeniedError;
 
 exports.MutationGuardDocSchema = MutationGuardDocSchema;
@@ -13368,6 +13627,10 @@ exports.OP_DISPLAY = OP_DISPLAY;
 
 exports.PartialGuardDeployError = PartialGuardDeployError;
 
+exports.READER_MODEL_ROLLOUT_URL = READER_MODEL_ROLLOUT_URL;
+
+exports.ReaderModelAcknowledgementError = ReaderModelAcknowledgementError;
+
 exports.RefResourceUndeclaredError = RefResourceUndeclaredError;
 
 exports.RequiredFieldNotProvidedError = RequiredFieldNotProvidedError;
@@ -13380,6 +13643,8 @@ exports.StartNotPrimedError = StartNotPrimedError;
 
 exports.StartNotSettledError = StartNotSettledError;
 
+exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;
+
 exports.WorkflowActionFired = WorkflowActionFired;
 
 exports.WorkflowActivityReset = WorkflowActivityReset;
@@ -13426,6 +13691,10 @@ exports.activityAutonomyOf = activityAutonomyOf;
 
 exports.applicableDefinitions = applicableDefinitions;
 
+exports.assertReadableModel = assertReadableModel;
+
+exports.assertReaderModelAcknowledgement = assertReaderModelAcknowledgement;
+
 exports.autonomySummary = autonomySummary;
 
 exports.availableActions = availableActions;
@@ -13522,6 +13791,8 @@ exports.expandResourceAliases = expandResourceAliases;
 
 exports.explainStartRequirement = explainStartRequirement;
 
+exports.fieldTreeShape = fieldTreeShape;
+
 exports.findCurrentActivityEntry = findCurrentActivityEntry;
 
 exports.findOpenStageEntry = findOpenStageEntry;
@@ -13564,10 +13835,14 @@ exports.isFilterScopedOut = isFilterScopedOut;
 
 exports.isProjectUserNotFoundError = isProjectUserNotFoundError;
 
+exports.isRevisionConflict = isRevisionConflict;
+
 exports.isTelemetryEnvDenied = isTelemetryEnvDenied;
 
 exports.isTerminalStage = isTerminalStage;
 
+exports.isUnprimed = isUnprimed;
+
 exports.lakeGuardId = lakeGuardId;
 
 exports.latestDefinitionsGroq = latestDefinitionsGroq;
@@ -13576,14 +13851,24 @@ 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.parseDefinitionSnapshotValue = parseDefinitionSnapshotValue;
+
 exports.parseGuardDocument = parseGuardDocument;
 
 exports.parseInstanceDocument = parseInstanceDocument;
@@ -13602,6 +13887,10 @@ exports.refsOf = refsOf;
 
 exports.remediationsFor = remediationsFor;
 
+exports.requiredModelFeatures = requiredModelFeatures;
+
+exports.requiredReaderModel = requiredReaderModel;
+
 exports.resolveAccess = resolveAccess;
 
 exports.resolveActor = resolveActor;
@@ -13632,6 +13921,8 @@ exports.subscriptionDocumentsForInstance = subscriptionDocumentsForInstance;
 
 exports.sweepStaleClaims = sweepStaleClaims;
 
+exports.terminalState = terminalState;
+
 exports.unboundRequirementReads = unboundRequirementReads;
 
 exports.unsatisfiedTransitionSummaries = unsatisfiedTransitionSummaries;