@sanity/workflow-engine 0.34.0 → 0.35.0

package/dist/index.cjs

@@ -24,405 +24,48 @@ function _interopNamespaceCompat(e) {
 
 var v__namespace = /* @__PURE__ */ _interopNamespaceCompat(v);
 
-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;
-    if (baseline === !0 && override === !0) return !0;
-    const parts = [ baseline, override ].map(e => e === !0 ? void 0 : e);
-    return invariants.andConditions(parts) ?? !0;
-}
-
-const DEFAULT_EDIT_MODE = "set";
+const EXECUTION_KINDS = {
+    interactive: "interactive",
+    server: "server",
+    cli: "cli",
+    mcp: "mcp",
+    drainer: "drainer",
+    script: "script",
+    test: "test",
+    studio: "studio",
+    sdkApp: "sdk"
+};
 
-function _fieldTargetLabel(target) {
-    return [ target.scope, target.activity, target.field ].filter(Boolean).join(".");
+function detectRuntime() {
+    const g = globalThis;
+    if (g.Deno !== void 0) return "deno";
+    if (g.Bun !== void 0) return "bun";
+    if (g.EdgeRuntime !== void 0) return "edge";
+    if (g.window !== void 0 && g.document !== void 0) return "browser";
+    if (g.WorkerGlobalScope !== void 0 && g.self !== void 0) return "worker";
+    const proc = g.process;
+    return typeof proc == "object" && proc !== null && typeof proc.versions?.node == "string" ? "node" : "unknown";
 }
 
-function fieldSites(definition, stage) {
-    const sites = [];
-    for (const entry of definition.fields ?? []) sites.push({
-        scope: "workflow",
-        entry: entry
-    });
-    for (const entry of stage.fields ?? []) sites.push({
-        scope: "stage",
-        entry: entry
-    });
-    for (const activity of stage.activities ?? []) for (const entry of activity.fields ?? []) sites.push({
-        scope: "activity",
-        activity: activity.name,
-        entry: entry
-    });
-    return sites;
-}
+let inferredRuntime;
 
-function resolveFieldSite(site, stage) {
-    return {
-        scope: site.scope,
-        ...site.activity !== void 0 ? {
-            activity: site.activity
-        } : {},
-        name: site.entry.name,
-        type: site.entry.type,
-        ...site.entry.title !== void 0 ? {
-            title: site.entry.title
-        } : {},
-        ...site.entry.validation !== void 0 ? {
-            validation: site.entry.validation
-        } : {},
-        ...site.entry.roles !== void 0 ? {
-            roles: site.entry.roles
+function resolveExecutionContext(declared) {
+    return inferredRuntime ??= detectRuntime(), {
+        runtime: inferredRuntime,
+        ...declared?.kind !== void 0 ? {
+            kind: declared.kind
         } : {},
-        ref: {
-            scope: site.scope,
-            field: site.entry.name
-        },
-        effective: effectiveEditable(site.entry.editable, stage.editable?.[site.entry.name])
-    };
-}
-
-function editableFieldsInStage(definition, stage) {
-    return fieldSites(definition, stage).filter(site => site.entry.editable !== void 0).map(site => resolveFieldSite(site, stage));
-}
-
-function editTargetMatches(site, target) {
-    return site.name !== target.field ? !1 : target.activity !== void 0 ? site.scope === "activity" && site.activity === target.activity : target.scope !== void 0 ? site.scope === target.scope : !0;
-}
-
-const SCOPE_PRECEDENCE = {
-    activity: 0,
-    stage: 1,
-    workflow: 2
-};
-
-function resolveEditTarget(args) {
-    const {definition: definition, stage: stage, target: target} = args, found = fieldSites(definition, stage).filter(site => editTargetMatches({
-        scope: site.scope,
-        name: site.entry.name,
-        ...site.activity !== void 0 ? {
-            activity: site.activity
+        ...declared?.id !== void 0 ? {
+            id: declared.id
         } : {}
-    }, target)).sort((a, b) => SCOPE_PRECEDENCE[a.scope] - SCOPE_PRECEDENCE[b.scope])[0];
-    return found ? resolveFieldSite(found, stage) : void 0;
-}
-
-function fieldWindowOpen(instance, site) {
-    const terminal = terminalState(instance);
-    if (terminal !== "in-flight") return {
-        open: !1,
-        detail: `instance ${terminal}`
     };
-    if (site.scope !== "activity") return {
-        open: !0
-    };
-    const status = invariants.findCurrentActivityEntry(instance, site.activity)?.status;
-    return status === "active" ? {
-        open: !0
-    } : {
-        open: !1,
-        detail: `activity "${site.activity}" is ${status ?? "not active"}`
-    };
-}
-
-function readFieldValue(instance, site) {
-    return resolveFieldEntry$1(instance, site)?.value;
-}
-
-function resolveFieldEntry$1(instance, site) {
-    return fieldEntryHost(instance, site)?.find(e => e.name === site.name);
-}
-
-function fieldEntryHost(instance, site) {
-    if (site.scope === "workflow") return instance.fields;
-    const stageEntry = invariants.findOpenStageEntry(instance);
-    return site.scope === "stage" ? stageEntry?.fields : stageEntry?.activities.find(t => t.name === site.activity)?.fields;
 }
 
-function fieldProvenance(instance, ref) {
-    let latest;
-    for (const entry of instance.history) entry._type === "opApplied" && (entry.target?.scope !== ref.scope || entry.target.field !== ref.field || (latest = {
-        at: entry.at,
-        ...entry.actor !== void 0 ? {
-            actor: entry.actor
-        } : {}
+function stampHistoryEntries(entries, stamp) {
+    return entries.map(entry => ({
+        ...entry,
+        executionContext: stamp
     }));
-    return latest === void 0 ? {} : {
-        ...latest.actor !== void 0 ? {
-            setBy: latest.actor
-        } : {},
-        setAt: latest.at
-    };
-}
-
-function editDisabledReason(args) {
-    const {effective: effective, instance: instance, window: window, guardDenial: guardDenial, predicateSatisfied: predicateSatisfied} = args;
-    if (effective === void 0) return {
-        kind: "not-editable"
-    };
-    if (!window.open) {
-        const terminalReason = instanceTerminalReason(instance);
-        return terminalReason !== void 0 ? terminalReason : {
-            kind: "edit-window-closed",
-            detail: window.detail ?? "closed"
-        };
-    }
-    if (guardDenial !== void 0) return guardDenial;
-    if (!predicateSatisfied) return {
-        kind: "editor-not-permitted",
-        predicate: effective === !0 ? "true" : effective
-    };
-}
-
-function instanceTerminalReason(instance) {
-    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
-    };
-}
-
-function defineWorkflowEvent(options) {
-    return {
-        type: "log",
-        ...options
-    };
-}
-
-const noopTelemetry = {
-    log: () => {}
-};
-
-function resolveTelemetry(telemetry) {
-    return telemetry === void 0 ? noopTelemetry : {
-        log: (event, data) => {
-            try {
-                telemetry.log(event, data);
-            } catch (error) {
-                console.warn(`[workflow-engine] telemetry logger threw while logging "${event.name}" — event dropped`, error);
-            }
-        }
-    };
-}
-
-const HIGH_FREQUENCY_SAMPLE_MS = 6e4, WorkflowDefinitionDeployed = defineWorkflowEvent({
-    name: "Workflows Definition Deployed",
-    version: 1,
-    description: "A definition went through a deploy — status distinguishes a newly minted version from an unchanged redeploy"
-}), WorkflowInstanceStarted = defineWorkflowEvent({
-    name: "Workflows Instance Started",
-    version: 1,
-    description: "A workflow instance was started from a deployed definition"
-}), WorkflowStageTransitioned = defineWorkflowEvent({
-    name: "Workflows Stage Transitioned",
-    version: 1,
-    description: "A committed stage move — one event per hop, cascades included, whichever verb drove it. Unsampled: funnel and dwell reads need complete counts, and volume is bounded by actual movement"
-}), WorkflowActionFired = defineWorkflowEvent({
-    name: "Workflows Action Fired",
-    version: 1,
-    description: "An action was fired against an activity"
-}), WorkflowFieldEdited = defineWorkflowEvent({
-    name: "Workflows Field Edited",
-    version: 1,
-    description: "A declared-editable field was edited through the generic edit seam",
-    maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
-}), WorkflowInstanceTicked = defineWorkflowEvent({
-    name: "Workflows Instance Ticked",
-    version: 1,
-    description: "An instance was re-evaluated for auto-transitions and due waits",
-    maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
-}), WorkflowEffectsDrained = defineWorkflowEvent({
-    name: "Workflows Effects Drained",
-    version: 1,
-    description: "A drain pass ran — drainedCount/drainedEffects report the successful dispatches. Unsampled when non-empty (outcome counts must be complete; volume is bounded by real effect work); empty polls are machine-cadence noise, throttled engine-side to at most one per minute"
-}), WorkflowEffectStateReported = defineWorkflowEvent({
-    name: "Workflows Effect State Reported",
-    version: 1,
-    description: "A running effect handler committed mid-dispatch field state through commitEffectOps. Sampled (high-frequency by design — a dispatch may report many times): an adoption and usage signal, not an exact per-run report count",
-    maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
-}), WorkflowEffectCompleted = defineWorkflowEvent({
-    name: "Workflows Effect Completed",
-    version: 1,
-    description: "An effect outcome was recorded — reported directly through completeEffect, or cancelled by the abort verb (external runtimes; engine-drained effects surface via Workflows Effects Drained instead — each outcome counts once)"
-}), WorkflowInstanceAborted = defineWorkflowEvent({
-    name: "Workflows Instance Aborted",
-    version: 1,
-    description: "The abort admin override was invoked (changed: false = instance already terminal)"
-}), WorkflowStageSet = defineWorkflowEvent({
-    name: "Workflows Stage Set",
-    version: 1,
-    description: "The set-stage admin override was invoked (changed: false = already at the target stage)"
-}), WorkflowActivityReset = defineWorkflowEvent({
-    name: "Workflows Activity Reset",
-    version: 1,
-    description: "The reset-activity admin override was invoked (changed: false = already at the target status, or the instance was terminal)"
-}), WorkflowDefinitionDeleted = defineWorkflowEvent({
-    name: "Workflows Definition Deleted",
-    version: 1,
-    description: "A deployed definition (or one version of it) was removed via the admin verb"
-});
-
-function definitionDeployedData(definition, outcome) {
-    const stages = definition.stages, activities = stages.flatMap(stage => stage.activities ?? []), actions = activities.flatMap(activity => activity.actions ?? []), transitions = stages.flatMap(stage => stage.transitions ?? []), fieldEntries2 = [ ...definition.fields ?? [], ...stages.flatMap(stage => stage.fields ?? []), ...activities.flatMap(activity => activity.fields ?? []) ];
-    return {
-        contentHash: outcome.contentHash,
-        status: outcome.status,
-        deployId: outcome.deployId,
-        stageCount: stages.length,
-        activityCount: activities.length,
-        actionCount: actions.length,
-        transitionCount: transitions.length,
-        fieldCount: fieldEntries2.length,
-        activityKinds: [ ...new Set(activities.map(invariants.deriveActivityKind)) ].sort(),
-        fieldKinds: [ ...new Set(fieldEntries2.map(entry => entry.type)) ].sort(),
-        guardCount: stages.reduce((n, stage) => n + (stage.guards ?? []).length, 0),
-        effectCount: actions.reduce((n, action) => n + (action.effects ?? []).length, 0),
-        subworkflowCount: actions.filter(action => action.spawn !== void 0).length,
-        lifecycle: definition.lifecycle ?? "standalone"
-    };
-}
-
-function definitionHashFragment(contentHash) {
-    return contentHash !== void 0 ? {
-        definitionContentHash: contentHash
-    } : {};
-}
-
-function instanceStartedData(args) {
-    return {
-        ...definitionHashFragment(args.definition.contentHash),
-        instanceId: args.instanceId,
-        initialFieldCount: args.initialFieldCount,
-        viaSpawn: args.viaSpawn,
-        lifecycle: args.definition.lifecycle ?? "standalone"
-    };
-}
-
-function instanceStartedDataFor(args) {
-    return instanceStartedData({
-        definition: {
-            ...parseDefinitionSnapshot(args.instance),
-            ...args.instance.pinnedContentHash !== void 0 ? {
-                contentHash: args.instance.pinnedContentHash
-            } : {}
-        },
-        instanceId: args.instance._id,
-        initialFieldCount: args.initialFieldCount,
-        viaSpawn: args.viaSpawn
-    });
-}
-
-function stageTransitionedData(args) {
-    const stageIndex = name => args.definition.stages.findIndex(stage => stage.name === name), openEntry = invariants.findOpenStageEntry(args.instance), dwellMs = openEntry !== void 0 ? Date.parse(args.at) - Date.parse(openEntry.enteredAt) : Number.NaN;
-    return {
-        ...definitionHashFragment(args.instance.pinnedContentHash),
-        instanceId: args.instance._id,
-        fromStageIndex: stageIndex(args.instance.currentStage),
-        toStageIndex: stageIndex(args.toStage),
-        toIsTerminal: args.toIsTerminal,
-        isRevisit: args.instance.stages.some(entry => entry.name === args.toStage),
-        ...Number.isFinite(dwellMs) ? {
-            dwellMs: dwellMs
-        } : {},
-        via: args.via
-    };
-}
-
-function openStage$1(instance) {
-    const definition = parseDefinitionSnapshot(instance);
-    return {
-        definition: definition,
-        stage: definition.stages.find(s => s.name === instance.currentStage)
-    };
-}
-
-function firedActivityKind(instance, activity) {
-    const node = openStage$1(instance).stage?.activities?.find(a => a.name === activity);
-    return node === void 0 ? void 0 : invariants.deriveActivityKind(node);
-}
-
-function editedFieldKind(instance, target) {
-    const {definition: definition, stage: stage} = openStage$1(instance);
-    return stage === void 0 ? void 0 : resolveEditTarget({
-        definition: definition,
-        stage: stage,
-        target: target
-    })?.type;
-}
-
-function actionFiredData(args) {
-    const kind = firedActivityKind(args.instance, args.activity);
-    return {
-        ...definitionHashFragment(args.instance.pinnedContentHash),
-        instanceId: args.instance._id,
-        ...kind !== void 0 ? {
-            activityKind: kind
-        } : {},
-        hasParams: args.params !== void 0,
-        cascaded: args.cascaded
-    };
-}
-
-function fieldEditedData(args) {
-    const kind = editedFieldKind(args.instance, args.target);
-    return {
-        ...definitionHashFragment(args.instance.pinnedContentHash),
-        instanceId: args.instance._id,
-        ...kind !== void 0 ? {
-            fieldKind: kind
-        } : {},
-        mode: args.mode ?? DEFAULT_EDIT_MODE
-    };
 }
 
 function effectSites(def) {
@@ -1420,7 +1063,7 @@ function stageSites(stage, definition) {
         condition: transition.when
     });
     for (const activity of stage.activities ?? []) sites.push(...activitySites(activity, stage.name));
-    for (const site of editableFieldsInStage(definition, stage)) typeof site.effective == "string" && sites.push({
+    for (const site of invariants.editableFieldsInStage(definition, stage)) typeof site.effective == "string" && sites.push({
         stage: stage.name,
         address: {
             kind: "editable-field",
@@ -2125,7 +1768,7 @@ function isAssignmentListModel(modelVersion) {
 
 function definitionAssignmentModel(instance) {
     if (typeof instance.definitionSnapshot != "string") return 0;
-    const modelVersion = parseDefinitionSnapshotValue({
+    const modelVersion = invariants.parseDefinitionSnapshotValue({
         _id: instance._id,
         definitionSnapshot: instance.definitionSnapshot
     }).modelVersion;
@@ -2298,7 +1941,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,
@@ -3968,7 +3611,7 @@ function nestedFieldEntries(entries) {
 }
 
 function parsedDefinitionSnapshot(root) {
-    if (typeof root.definitionSnapshot == "string") return recordOf(parseDefinitionSnapshotValue({
+    if (typeof root.definitionSnapshot == "string") return recordOf(invariants.parseDefinitionSnapshotValue({
         _id: typeof root._id == "string" ? root._id : "<unknown instance>",
         definitionSnapshot: root.definitionSnapshot
     }));
@@ -4462,7 +4105,7 @@ function documentStuckCause(args) {
 }
 
 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 {
@@ -4758,50 +4401,6 @@ function assertRoleConstrainedAssignmentResource(args) {
     if (hasRoleConstrainedAssignments(args.definition) && args.workflowResource.type !== "dataset") throw new Error(`${args.context}: definition "${args.definition.name}" uses role-constrained assignment fields, which require a dataset workflow resource; received resource type "${args.workflowResource.type}"`);
 }
 
-const EXECUTION_KINDS = {
-    interactive: "interactive",
-    server: "server",
-    cli: "cli",
-    mcp: "mcp",
-    drainer: "drainer",
-    script: "script",
-    test: "test",
-    studio: "studio",
-    sdkApp: "sdk-app"
-};
-
-function detectRuntime() {
-    const g = globalThis;
-    if (g.Deno !== void 0) return "deno";
-    if (g.Bun !== void 0) return "bun";
-    if (g.EdgeRuntime !== void 0) return "edge";
-    if (g.window !== void 0 && g.document !== void 0) return "browser";
-    if (g.WorkerGlobalScope !== void 0 && g.self !== void 0) return "worker";
-    const proc = g.process;
-    return typeof proc == "object" && proc !== null && typeof proc.versions?.node == "string" ? "node" : "unknown";
-}
-
-let inferredRuntime;
-
-function resolveExecutionContext(declared) {
-    return inferredRuntime ??= detectRuntime(), {
-        runtime: inferredRuntime,
-        ...declared?.kind !== void 0 ? {
-            kind: declared.kind
-        } : {},
-        ...declared?.id !== void 0 ? {
-            id: declared.id
-        } : {}
-    };
-}
-
-function stampHistoryEntries(entries, stamp) {
-    return entries.map(entry => ({
-        ...entry,
-        executionContext: stamp
-    }));
-}
-
 function collectWatchRefs(instance) {
     return [ invariants.gdrRef({
         res: instance.workflowResource,
@@ -4855,7 +4454,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";
@@ -5737,7 +5336,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,
@@ -5770,7 +5369,7 @@ function parseInstanceDocument(doc) {
     return invariants.parsePersistedDoc({
         schema: WorkflowInstanceSchema,
         doc: doc,
-        docType: WORKFLOW_INSTANCE_TYPE
+        docType: invariants.WORKFLOW_INSTANCE_TYPE
     });
 }
 
@@ -5779,7 +5378,7 @@ const WorkflowInstancePreviewEffectSchema = invariants.tolerantObject()({
     title: v__namespace.exactOptional(v__namespace.string())
 }), WorkflowInstancePreviewSchema = v__namespace.looseObject(invariants.tolerantEntries()({
     _id: NonEmpty,
-    _type: v__namespace.literal(WORKFLOW_INSTANCE_TYPE),
+    _type: v__namespace.literal(invariants.WORKFLOW_INSTANCE_TYPE),
     modelVersion: v__namespace.exactOptional(v__namespace.number()),
     minReaderModel: v__namespace.exactOptional(v__namespace.number()),
     workflowResource: WorkflowResourceSchema,
@@ -5801,7 +5400,7 @@ function parseInstancePreviewDocument(doc) {
     return invariants.parsePersistedDoc({
         schema: WorkflowInstancePreviewSchema,
         doc: doc,
-        docType: WORKFLOW_INSTANCE_TYPE
+        docType: invariants.WORKFLOW_INSTANCE_TYPE
     });
 }
 
@@ -6354,7 +5953,7 @@ function buildInstanceBase(args) {
         } : {}
     }, ...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,
@@ -6506,7 +6105,7 @@ async function readBatch(args) {
 }
 
 function validateRawDoc(doc, perspective) {
-    return perspective !== "raw" ? doc : doc._type === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : assertReadableModel(doc);
+    return perspective !== "raw" ? doc : doc._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : assertReadableModel(doc);
 }
 
 function groupReads(reads) {
@@ -6594,7 +6193,7 @@ async function loadContext({client: client, instanceId: instanceId, options: opt
         clientForGdr: options.clientForGdr,
         refSurface: options.refSurface,
         instance: instance,
-        definition: parseDefinitionSnapshot(instance),
+        definition: invariants.parseDefinitionSnapshot(instance),
         ...options.actor !== void 0 ? {
             actor: options.actor
         } : {},
@@ -6670,7 +6269,7 @@ async function buildEngineContext(args) {
         clock: clock,
         now: clock(),
         executionContext: resolveExecutionContext(args.executionContext),
-        telemetry: resolveTelemetry(args.telemetry),
+        telemetry: invariants.resolveTelemetry(args.telemetry),
         ...args.settlingCohorts !== void 0 ? {
             settlingCohorts: args.settlingCohorts
         } : {},
@@ -7602,8 +7201,9 @@ async function commitAbort({ctx: ctx, reason: reason, requestRecord: requestReco
         now: ctx.now,
         snapshot: ctx.snapshot
     });
-    for (const {effect: effect, origin: origin} of cancelled) ctx.telemetry.log(WorkflowEffectCompleted, {
-        ...definitionHashFragment(ctx.instance.pinnedContentHash),
+    for (const {effect: effect, origin: origin} of cancelled) ctx.telemetry.log(invariants.WorkflowEffectCompleted, {
+        ...invariants.executionContextFragment(ctx.executionContext),
+        ...invariants.definitionHashFragment(ctx.instance.pinnedContentHash),
         instanceId: ctx.instance._id,
         effect: effect,
         status: "cancelled",
@@ -7887,7 +7487,7 @@ async function spawnRow({ctx: ctx, mutation: mutation, activity: activity, actio
     });
     mutation.pendingCreates.push({
         body: body,
-        started: instanceStartedData({
+        started: invariants.instanceStartedData({
             definition: definition,
             instanceId: body._id,
             initialFieldCount: initialFields.length,
@@ -8108,10 +7708,10 @@ async function resolveDefinitionRef({client: client, ref: ref, tag: tag}) {
 async function prepareChildInstance(args) {
     const {client: client, parent: parent, definition: definition, initialFields: initialFields, context: context, actor: actor, now: now, refSurface: refSurface, memberRolesLoader: memberRolesLoader} = 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 = [], memberRoles = await memberRolesLoader({
         workflowResource: workflowResource,
         definition: definition
@@ -8298,14 +7898,17 @@ async function commitStageMove({ctx: ctx, mutation: mutation, fromStage: fromSta
 }
 
 function emitStageTransitioned({ctx: ctx, nextStage: nextStage, at: at, via: via}) {
-    ctx.telemetry.log(WorkflowStageTransitioned, stageTransitionedData({
-        instance: ctx.instance,
-        definition: ctx.definition,
-        toStage: nextStage.name,
-        toIsTerminal: isTerminalStage(nextStage),
-        at: at,
-        via: via
-    }));
+    ctx.telemetry.log(invariants.WorkflowStageTransitioned, {
+        ...invariants.executionContextFragment(ctx.executionContext),
+        ...invariants.stageTransitionedData({
+            instance: ctx.instance,
+            definition: ctx.definition,
+            toStage: nextStage.name,
+            toIsTerminal: isTerminalStage(nextStage),
+            at: at,
+            via: via
+        })
+    });
 }
 
 function exitOpenStage({mutation: mutation, stage: stage, at: at}) {
@@ -9261,7 +8864,7 @@ async function runCascadeHop({client: client, instanceId: instanceId, actor: act
             return preloadedInstance = void 0, buildEngineContext({
                 client: client,
                 instance: loaded,
-                definition: parseDefinitionSnapshot(loaded),
+                definition: invariants.parseDefinitionSnapshot(loaded),
                 ...contextOptions
             });
         },
@@ -9473,7 +9076,7 @@ async function loadInstancesById(client, ids) {
     const children = await client.fetch("*[_id in $ids]", {
         ids: ids
     });
-    return new Map(children.filter(child => child._type === WORKFLOW_INSTANCE_TYPE).map(child => {
+    return new Map(children.filter(child => child._type === invariants.WORKFLOW_INSTANCE_TYPE).map(child => {
         const instance = readInstanceDoc(child);
         return [ instance._id, instance ];
     }));
@@ -9533,10 +9136,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 = 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)
     };
@@ -9563,7 +9166,7 @@ async function buildCascadeStepContext(args, instance) {
         clientForGdr: args.clientForGdr,
         refSurface: args.refSurface,
         instance: instance,
-        definition: parseDefinitionSnapshot(instance),
+        definition: invariants.parseDefinitionSnapshot(instance),
         ...args.clock ? {
             clock: args.clock
         } : {},
@@ -9615,7 +9218,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 = parentRef(child);
+    const expectedParent = invariants.parentRef(child);
     if (expectedParent === void 0 || invariants.toBareId(expectedParent.id) !== parent._id) throw new Error(`Spawn batch child ${childId} does not belong to parent ${parent._id}`);
     return child;
 }
@@ -9638,7 +9241,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));
@@ -9786,7 +9389,10 @@ async function persist(ctx, mutation) {
         actor: actorForPriming,
         settlingCohorts: settlingCohorts
     });
-    for (const {started: started} of pendingCreates) ctx.telemetry.log(WorkflowInstanceStarted, started);
+    for (const {started: started} of pendingCreates) ctx.telemetry.log(invariants.WorkflowInstanceStarted, {
+        ...invariants.executionContextFragment(ctx.executionContext),
+        ...started
+    });
     const reloaded = await getInstanceDocument(ctx.client, ctx.instance._id);
     if (!reloaded) throw new Error(`Instance ${ctx.instance._id} disappeared after transaction commit`);
     return reloaded;
@@ -10478,7 +10084,7 @@ async function whatIfFireAction(args) {
 
 function replayable(args) {
     const {instance: instance, stage: stage, action: action} = args;
-    if (terminalState(instance) !== "in-flight" || (action.params ?? []).length > 0 || action.spawn !== void 0) return !1;
+    if (invariants.terminalState(instance) !== "in-flight" || (action.params ?? []).length > 0 || action.spawn !== void 0) return !1;
     const primed = new Set((invariants.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;
 }
@@ -10623,7 +10229,7 @@ function contentTargets({atoms: atoms, fields: fields, activity: activity}) {
             entry: field.entry,
             read: read,
             atom: atom
-        }) ? [ _fieldTargetLabel(field.target) ] : [];
+        }) ? [ invariants._fieldTargetLabel(field.target) ] : [];
     }));
 }
 
@@ -10650,8 +10256,8 @@ async function blockingMissingDocuments(args) {
         atoms: await blockingAtoms(condition, args),
         fields: fields,
         activity: condition.activity
-    })))).flat(), blocked = /* @__PURE__ */ new Set([ ...targets, ...missingRequiredDocuments(args).map(({target: target}) => _fieldTargetLabel(target)) ]);
-    return args.missingDocuments.filter(({target: target}) => blocked.has(_fieldTargetLabel(target)));
+    })))).flat(), blocked = /* @__PURE__ */ new Set([ ...targets, ...missingRequiredDocuments(args).map(({target: target}) => invariants._fieldTargetLabel(target)) ]);
+    return args.missingDocuments.filter(({target: target}) => blocked.has(invariants._fieldTargetLabel(target)));
 }
 
 async function subjectResourceGrants(args) {
@@ -10696,7 +10302,7 @@ async function evaluateInstance(args) {
         client: client,
         instanceId: instanceId,
         tag: tag
-    }), resolveUserAttributes(client) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }), resolveUserAttributes(client) ]), {actor: actor, grants: grants, localPrincipalId: localPrincipalId} = access, definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
         client: client,
         workflowResource: workflowResource,
         resourceClients: resourceClients
@@ -10760,7 +10366,7 @@ async function callerBoundProjectionScopes(args) {
 }
 
 function clockSitesOf(instance, sites) {
-    return terminalState(instance) !== "in-flight" ? [] : sites.filter(entry => readsNowIn(entry.insight.analysis.reads));
+    return invariants.terminalState(instance) !== "in-flight" ? [] : sites.filter(entry => readsNowIn(entry.insight.analysis.reads));
 }
 
 function currentStageOf(instance, definition) {
@@ -10949,18 +10555,18 @@ function autonomyOf(definition) {
 
 async function evaluateEditableFields(args) {
     const fields = [];
-    for (const site of editableFieldsInStage(args.definition, args.stage)) fields.push(await evaluateEditableField(args, site));
+    for (const site of invariants.editableFieldsInStage(args.definition, args.stage)) fields.push(await evaluateEditableField(args, site));
     return fields;
 }
 
 async function evaluateEditableField(args, site) {
-    const {instance: instance, definition: definition, snapshot: snapshot, scope: scope, scopeForActivity: scopeForActivity, guardDenial: guardDenial, sites: sites} = args, window = fieldWindowOpen(instance, site), insight = await editPredicateInsight({
+    const {instance: instance, definition: definition, snapshot: snapshot, scope: scope, scopeForActivity: scopeForActivity, guardDenial: guardDenial, sites: sites} = args, window = invariants.fieldWindowOpen(instance, site), insight = await editPredicateInsight({
         site: site,
         snapshot: snapshot,
         scope: scope,
         scopeForActivity: scopeForActivity,
         sites: sites
-    }), predicateSatisfied = insight === void 0 || insight.outcome === "satisfied", reason = editDisabledReason({
+    }), predicateSatisfied = insight === void 0 || insight.outcome === "satisfied", reason = invariants.editDisabledReason({
         effective: site.effective,
         instance: instance,
         window: window,
@@ -10986,12 +10592,12 @@ async function evaluateEditableField(args, site) {
                 roleAliases: definition.roleAliases
             } : {}
         } : {},
-        value: readFieldValue(instance, site),
+        value: invariants.readFieldValue(instance, site),
         editable: reason === void 0,
         ...reason !== void 0 ? {
             disabledReason: reason
         } : {},
-        ...fieldProvenance(instance, site.ref),
+        ...invariants.fieldProvenance(instance, site.ref),
         ...insight !== void 0 ? {
             insight: insight
         } : {}
@@ -11293,7 +10899,7 @@ async function instanceGuardReason({instance: instance, identity: identity, guar
 }
 
 function lifecycleReason({instance: instance, status: status, stageHasExits: stageHasExits}) {
-    const terminalReason = instanceTerminalReason(instance);
+    const terminalReason = invariants.instanceTerminalReason(instance);
     if (terminalReason !== void 0) return terminalReason;
     if (!stageHasExits) return {
         kind: "stage-terminal",
@@ -11374,7 +10980,7 @@ function beforeArm(filter, params) {
 
 function compiledConditions(filter, params) {
     if (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() ];
+    const conditions = [ `_type == "${invariants.WORKFLOW_INSTANCE_TYPE}"`, invariants.tagScopeFilter() ];
     filter.includeCompleted !== !0 && conditions.push(inFlightFilter()), filter.definition !== void 0 && (conditions.push("definition == $definition"), 
     params.definition = filter.definition), filter.stage !== void 0 && (conditions.push("currentStage == $stage"), 
     params.stage = filter.stage), filter.assignment !== void 0 && conditions.push(assignmentPrefilter(filter.assignment, params));
@@ -11402,7 +11008,7 @@ function instancesQuery(args) {
 
 function instanceChangesQuery(args) {
     return invariants.validateTag(args.tag), {
-        query: `*[_type == "${WORKFLOW_INSTANCE_TYPE}" && ${invariants.tagScopeFilter()}]`,
+        query: `*[_type == "${invariants.WORKFLOW_INSTANCE_TYPE}" && ${invariants.tagScopeFilter()}]`,
         params: {
             tag: args.tag
         }
@@ -11936,6 +11542,14 @@ function parseDefinitionInput(def, caller) {
     return invariants.parseStoredDefinition(content, label);
 }
 
+function _parseDefinitionsWithReaderModel(definitions, caller) {
+    const parsed = definitions.map(def => parseDefinitionInput(def, caller));
+    return {
+        definitions: parsed,
+        requiredMinReaderModel: requiredDefinitionReaderModel(parsed)
+    };
+}
+
 function stripSystemFields(doc) {
     const out = {};
     for (const [k, v2] of Object.entries(doc)) k === "_rev" || k === "_createdAt" || k === "_updatedAt" || (out[k] = v2);
@@ -12001,7 +11615,7 @@ async function loadDefinitionVersionsOrThrow({client: client, definition: defini
 }
 
 async function editField(args) {
-    const {client: client, instanceId: instanceId, target: target, mode: mode = DEFAULT_EDIT_MODE, value: value, requestRecord: requestRecord, options: options} = args;
+    const {client: client, instanceId: instanceId, target: target, mode: mode = invariants.DEFAULT_EDIT_MODE, value: value, requestRecord: requestRecord, options: options} = args;
     return retryOnRevisionConflict({
         client: client,
         instanceId: instanceId,
@@ -12028,7 +11642,7 @@ async function commitEdit({ctx: ctx, target: target, mode: mode, value: value, r
         record: requestRecord,
         now: ctx.now
     });
-    const actor = options?.actor, stage = findStage(ctx.definition, ctx.instance.currentStage), site = resolveEditTarget({
+    const actor = options?.actor, stage = findStage(ctx.definition, ctx.instance.currentStage), site = invariants.resolveEditTarget({
         definition: ctx.definition,
         stage: stage,
         target: target
@@ -12083,7 +11697,7 @@ async function commitEdit({ctx: ctx, target: target, mode: mode, value: value, r
 }
 
 async function assertFieldEditable({ctx: ctx, site: site, options: options}) {
-    const actor = options?.actor, window = fieldWindowOpen(ctx.instance, site), vars = await callerBoundVarsForCall({
+    const actor = options?.actor, window = invariants.fieldWindowOpen(ctx.instance, site), vars = await callerBoundVarsForCall({
         client: ctx.client,
         instance: ctx.instance,
         options: options
@@ -12101,7 +11715,7 @@ async function assertFieldEditable({ctx: ctx, site: site, options: options}) {
                 vars: vars
             } : {}
         }
-    }) : site.effective === !0, reason = editDisabledReason({
+    }) : site.effective === !0, reason = invariants.editDisabledReason({
         effective: site.effective,
         instance: ctx.instance,
         window: window,
@@ -12327,11 +11941,11 @@ async function cascadeAndReload(args) {
 
 async function unchangedNextEvaluationAt(args) {
     const {client: client, instance: instance, actor: actor, clientForGdr: clientForGdr, refSurface: refSurface, memberRolesLoader: memberRolesLoader, now: now} = args;
-    if (terminalState(instance) !== "in-flight") return;
+    if (invariants.terminalState(instance) !== "in-flight") return;
     const ctx = await buildEngineContext({
         client: client,
         instance: instance,
-        definition: parseDefinitionSnapshot(instance),
+        definition: invariants.parseDefinitionSnapshot(instance),
         clientForGdr: clientForGdr,
         refSurface: refSurface,
         memberRolesLoader: memberRolesLoader,
@@ -12459,12 +12073,15 @@ async function resumeStart(args) {
         version: 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({
-        instance: existing,
-        initialFieldCount: initialFieldCount,
-        viaSpawn: !1
-    })), settled = await settleStart({
+    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 = () => invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowInstanceStarted, {
+        ...invariants.executionContextFragment(resolveExecutionContext(args.executionContext)),
+        ...invariants.instanceStartedDataFor({
+            instance: existing,
+            initialFieldCount: initialFieldCount,
+            viaSpawn: !1
+        })
+    }), settled = await settleStart({
         ...settlementArgs,
         instanceId: existing._id,
         ...completesStart ? {
@@ -12620,7 +12237,7 @@ function assertActionAllowed({evaluation: evaluation, activity: activity, action
 }
 
 function assertEditAllowed(evaluation, target) {
-    const field = evaluation.editableFields.filter(s => editTargetMatches(s, target)).sort((a, b) => SCOPE_PRECEDENCE[a.scope] - SCOPE_PRECEDENCE[b.scope])[0];
+    const field = evaluation.editableFields.filter(s => invariants.editTargetMatches(s, target)).sort((a, b) => invariants.SCOPE_PRECEDENCE[a.scope] - invariants.SCOPE_PRECEDENCE[b.scope])[0];
     if (field !== void 0 && !field.editable && field.disabledReason !== void 0) {
         const reason = field.disabledReason;
         throw reason.kind === "mutation-guard-denied" ? guardDeniedError(evaluation.instance._id, reason) : new EditFieldDeniedError({
@@ -12780,7 +12397,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 ? {
@@ -12837,9 +12454,9 @@ const workflow = {
     deployDefinitions: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.deploy), {client: client, tag: tag, workflowResource: workflowResource, resourceAliases: resourceAliases} = args;
         invariants.validateTag(tag);
-        const definitions = args.definitions.map(def => parseDefinitionInput(def, "workflow.deployDefinitions"));
+        const {definitions: definitions, requiredMinReaderModel: requiredMinReaderModel} = _parseDefinitionsWithReaderModel(args.definitions, "workflow.deployDefinitions");
         definitions.forEach(validateDefinition), assertReaderModelAcknowledgement(args.expectedMinReaderModel, {
-            requiredMinReaderModel: requiredDefinitionReaderModel(definitions)
+            requiredMinReaderModel: requiredMinReaderModel
         });
         const roleWarnings = await validateDefinitionRoles({
             client: client,
@@ -12894,12 +12511,15 @@ const workflow = {
             });
         }
         hasWrites && await tx.commit();
-        const deployId = randomKey(), telemetry = resolveTelemetry(args.telemetry);
-        for (const {def: def, contentHash: contentHash, status: status} of deployed) telemetry.log(WorkflowDefinitionDeployed, definitionDeployedData(def, {
-            contentHash: contentHash,
-            status: status,
-            deployId: deployId
-        }));
+        const deployId = randomKey(), telemetry = invariants.resolveTelemetry(args.telemetry), execution = resolveExecutionContext(args.executionContext);
+        for (const {def: def, contentHash: contentHash, status: status} of deployed) telemetry.log(invariants.WorkflowDefinitionDeployed, {
+            ...invariants.executionContextFragment(execution),
+            ...invariants.definitionDeployedData(def, {
+                contentHash: contentHash,
+                status: status,
+                deployId: deployId
+            })
+        });
         return {
             results: results,
             deployId: deployId
@@ -12907,7 +12527,8 @@ const workflow = {
     },
     deleteDefinition: async rawArgs => {
         const args = taggedScope(rawArgs, REQUEST_TAG.deleteDefinition), result = await deleteDefinition(args);
-        return resolveTelemetry(args.telemetry).log(WorkflowDefinitionDeleted, {
+        return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowDefinitionDeleted, {
+            ...invariants.executionContextFragment(resolveExecutionContext(args.executionContext)),
             deletedVersionCount: result.deletedVersions.length,
             cascadeAbortedCount: result.abortedInstanceIds.length,
             deletedGuardCount: result.deletedGuardCount
@@ -13023,12 +12644,15 @@ const workflow = {
                         } : {}
                     }))
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowActionFired, actionFiredData({
-                    instance: before,
-                    activity: activity,
-                    params: params,
-                    cascaded: result.cascaded
-                })), result;
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowActionFired, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.actionFiredData({
+                        instance: before,
+                        activity: activity,
+                        params: params,
+                        cascaded: result.cascaded
+                    })
+                }), result;
             }
         });
     },
@@ -13093,11 +12717,14 @@ const workflow = {
                         } : {}
                     }))
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowFieldEdited, fieldEditedData({
-                    instance: before,
-                    target: target,
-                    mode: mode
-                })), result;
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowFieldEdited, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.fieldEditedData({
+                        instance: before,
+                        target: target,
+                        mode: mode
+                    })
+                }), result;
             }
         });
     },
@@ -13156,8 +12783,9 @@ const workflow = {
                     executionContext: executionContext,
                     telemetry: args.telemetry
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowEffectCompleted, {
-                    ...definitionHashFragment(settled.instance.pinnedContentHash),
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowEffectCompleted, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.definitionHashFragment(settled.instance.pinnedContentHash),
                     instanceId: instanceId,
                     effect: completion.effect,
                     status: status,
@@ -13211,8 +12839,9 @@ const workflow = {
                     executionContext: executionContext,
                     telemetry: args.telemetry
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowEffectStateReported, {
-                    ...definitionHashFragment(settled.instance.pinnedContentHash),
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowEffectStateReported, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.definitionHashFragment(settled.instance.pinnedContentHash),
                     instanceId: instanceId,
                     effect: report.effect,
                     cascaded: settled.cascaded
@@ -13244,8 +12873,9 @@ const workflow = {
             executionContext: executionContext,
             telemetry: args.telemetry
         });
-        return resolveTelemetry(args.telemetry).log(WorkflowInstanceTicked, {
-            ...definitionHashFragment(settled.instance.pinnedContentHash),
+        return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowInstanceTicked, {
+            ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+            ...invariants.definitionHashFragment(settled.instance.pinnedContentHash),
             instanceId: instanceId,
             cascaded: settled.cascaded
         }), settledResult({
@@ -13279,8 +12909,9 @@ const workflow = {
                         telemetry: args.telemetry
                     })
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowStageSet, {
-                    ...definitionHashFragment(before.pinnedContentHash),
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowStageSet, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.definitionHashFragment(before.pinnedContentHash),
                     instanceId: instanceId,
                     changed: result.fired
                 }), adminOverrideResult({
@@ -13329,8 +12960,9 @@ const workflow = {
                         requestRecord: record
                     } : {}
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowInstanceAborted, {
-                    ...definitionHashFragment(before.pinnedContentHash),
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowInstanceAborted, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.definitionHashFragment(before.pinnedContentHash),
                     instanceId: instanceId,
                     changed: changed
                 }), settledResult({
@@ -13370,8 +13002,9 @@ const workflow = {
                         telemetry: args.telemetry
                     })
                 });
-                return resolveTelemetry(args.telemetry).log(WorkflowActivityReset, {
-                    ...definitionHashFragment(before.pinnedContentHash),
+                return invariants.resolveTelemetry(args.telemetry).log(invariants.WorkflowActivityReset, {
+                    ...invariants.executionContextFragment(resolveExecutionContext(executionContext)),
+                    ...invariants.definitionHashFragment(before.pinnedContentHash),
                     instanceId: instanceId,
                     changed: result.fired
                 }), adminOverrideResult({
@@ -13466,7 +13099,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, {
@@ -13683,7 +13316,7 @@ async function startFreshInstance(args) {
         tag: tag
     }), id = instanceId ?? instanceDocId(tag);
     assertInitialStageExists(definition);
-    const now = clock();
+    const now = clock(), execution = resolveExecutionContext(executionContext);
     await assertStartInputs({
         client: client,
         tag: tag,
@@ -13719,7 +13352,7 @@ async function startFreshInstance(args) {
         perspective: perspective ?? derivePerspectiveFromFields(resolvedFields),
         initialStage: definition.initialStage,
         actor: actor,
-        executionContext: resolveExecutionContext(executionContext),
+        executionContext: execution,
         ...fieldDiscards.length > 0 ? {
             extraHistory: fieldDiscards
         } : {}
@@ -13740,12 +13373,15 @@ async function startFreshInstance(args) {
         ...startArgs.telemetry !== void 0 ? {
             telemetry: startArgs.telemetry
         } : {},
-        emitStarted: () => resolveTelemetry(startArgs.telemetry).log(WorkflowInstanceStarted, instanceStartedData({
-            definition: definition,
-            instanceId: id,
-            initialFieldCount: seedFields.length,
-            viaSpawn: !1
-        }))
+        emitStarted: () => invariants.resolveTelemetry(startArgs.telemetry).log(invariants.WorkflowInstanceStarted, {
+            ...invariants.executionContextFragment(execution),
+            ...invariants.instanceStartedData({
+                definition: definition,
+                instanceId: id,
+                initialFieldCount: seedFields.length,
+                viaSpawn: !1
+            })
+        })
     });
     return settledResult({
         ...settled,
@@ -14012,7 +13648,7 @@ function noteDrainedInstanceHash(buckets, instance) {
 function drainCascadeTelemetry(telemetry) {
     if (telemetry !== void 0) return {
         log: (event, data) => {
-            event.name === WorkflowEffectCompleted.name && !isCancelledCompletion(data) || telemetry.log(event, data);
+            event.name === invariants.WorkflowEffectCompleted.name && !isCancelledCompletion(data) || telemetry.log(event, data);
         }
     };
 }
@@ -14094,7 +13730,7 @@ async function drainOneCandidate(pass) {
         } : {}
     });
     if (claimed === void 0) return !0;
-    const retry = effectRetryPolicy(parseDefinitionSnapshot(before), candidate.name), outcome = await dispatchAndReport({
+    const retry = effectRetryPolicy(invariants.parseDefinitionSnapshot(before), candidate.name), outcome = await dispatchAndReport({
         handler: handler,
         candidate: candidate,
         claimToken: claimed.claimToken,
@@ -14425,18 +14061,18 @@ async function applyMissingHandler({policy: policy, info: info, log: log}) {
 }
 
 function previewSiteOf(args) {
-    const stage = findStage(args.definition, args.instance.currentStage), site = resolveEditTarget({
+    const stage = findStage(args.definition, args.instance.currentStage), site = invariants.resolveEditTarget({
         definition: args.definition,
         stage: stage,
         target: args.target
     });
-    if (site !== void 0) return fieldWindowOpen(args.instance, site).open ? site : void 0;
+    if (site !== void 0) return invariants.fieldWindowOpen(args.instance, site).open ? site : void 0;
 }
 
 function previewOp(site, preview) {
     return buildEditOp({
         site: site,
-        mode: preview.mode ?? DEFAULT_EDIT_MODE,
+        mode: preview.mode ?? invariants.DEFAULT_EDIT_MODE,
         value: preview.value
     });
 }
@@ -14472,7 +14108,7 @@ async function applyEditPreviews(args) {
 }
 
 function createInstanceSession(args) {
-    const {client: client, tag: tag, clock: clock, executionContext: executionContext} = args, telemetry = resolveTelemetry(args.telemetry);
+    const {client: client, tag: tag, clock: clock, executionContext: executionContext} = args, telemetry = invariants.resolveTelemetry(args.telemetry), execution = resolveExecutionContext(executionContext);
     let instance = asHeldInstance(args.instance);
     const opScope = opTag => {
         const scoped = taggedScope(args, opTag);
@@ -14505,7 +14141,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));
             return;
         }
         target.set(uri, owned);
@@ -14528,7 +14164,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,
@@ -14749,8 +14385,9 @@ function createInstanceSession(args) {
                     client: tickScope.client,
                     instanceId: instance._id,
                     tag: tag
-                }), telemetry.log(WorkflowInstanceTicked, {
-                    ...definitionHashFragment(instance.pinnedContentHash),
+                }), telemetry.log(invariants.WorkflowInstanceTicked, {
+                    ...invariants.executionContextFragment(execution),
+                    ...invariants.definitionHashFragment(instance.pinnedContentHash),
                     instanceId: instance._id,
                     cascaded: settled.cascaded
                 }), settledResult({
@@ -14806,12 +14443,15 @@ function createInstanceSession(args) {
                     scope: fireScope,
                     memberRolesLoader: memberRolesLoader
                 });
-                return telemetry.log(WorkflowActionFired, actionFiredData({
-                    instance: preOp,
-                    activity: activity,
-                    params: params,
-                    cascaded: result.cascaded
-                })), result;
+                return telemetry.log(invariants.WorkflowActionFired, {
+                    ...invariants.executionContextFragment(execution),
+                    ...invariants.actionFiredData({
+                        instance: preOp,
+                        activity: activity,
+                        params: params,
+                        cascaded: result.cascaded
+                    })
+                }), result;
             });
         },
         editField({target: target, mode: mode, value: value}) {
@@ -14868,11 +14508,14 @@ function createInstanceSession(args) {
                     scope: editScope,
                     memberRolesLoader: memberRolesLoader
                 });
-                return telemetry.log(WorkflowFieldEdited, fieldEditedData({
-                    instance: preOp,
-                    target: target,
-                    mode: mode
-                })), result;
+                return telemetry.log(invariants.WorkflowFieldEdited, {
+                    ...invariants.executionContextFragment(execution),
+                    ...invariants.fieldEditedData({
+                        instance: preOp,
+                        target: target,
+                        mode: mode
+                    })
+                }), result;
             }).finally(() => {
                 stagedKey !== void 0 && previews.delete(stagedKey);
             });
@@ -14910,7 +14553,7 @@ function createEngine(args) {
     const effects = {
         handlers: args.effects?.handlers ?? {},
         missingHandler: args.effects?.missingHandler ?? "fail"
-    }, logger = args.loggerFactory ?? defaultLoggerFactory, telemetry = resolveTelemetry(args.telemetry), EMPTY_DRAIN_LOG_INTERVAL_MS = 6e4;
+    }, logger = args.loggerFactory ?? defaultLoggerFactory, telemetry = invariants.resolveTelemetry(args.telemetry), execution = resolveExecutionContext(executionContext), EMPTY_DRAIN_LOG_INTERVAL_MS = 6e4;
     let lastEmptyDrainLoggedAt;
     const emptyDrainDue = () => {
         const now = Date.parse((clock ?? wallClock)());
@@ -15005,8 +14648,9 @@ function createEngine(args) {
                     sleep: args.sleep
                 } : {}
             }), drained = result.drained;
-            return (drained.length > 0 || emptyDrainDue()) && telemetry.log(WorkflowEffectsDrained, {
-                ...definitionHashFragment(result.definitionContentHash),
+            return (drained.length > 0 || emptyDrainDue()) && telemetry.log(invariants.WorkflowEffectsDrained, {
+                ...invariants.executionContextFragment(execution),
+                ...invariants.definitionHashFragment(result.definitionContentHash),
                 instanceId: instanceId,
                 drainedCount: drained.length,
                 drainedEffects: drained.map(entry => entry.name)
@@ -15513,7 +15157,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."
     }
@@ -15634,8 +15278,38 @@ exports.SpawnContractsInvalidError = invariants.SpawnContractsInvalidError;
 
 exports.WORKFLOW_DEFINITION_TYPE = invariants.WORKFLOW_DEFINITION_TYPE;
 
+exports.WORKFLOW_INSTANCE_TYPE = invariants.WORKFLOW_INSTANCE_TYPE;
+
+exports.WorkflowActionFired = invariants.WorkflowActionFired;
+
+exports.WorkflowActivityReset = invariants.WorkflowActivityReset;
+
+exports.WorkflowDefinitionDeleted = invariants.WorkflowDefinitionDeleted;
+
+exports.WorkflowDefinitionDeployed = invariants.WorkflowDefinitionDeployed;
+
+exports.WorkflowEffectCompleted = invariants.WorkflowEffectCompleted;
+
+exports.WorkflowEffectStateReported = invariants.WorkflowEffectStateReported;
+
+exports.WorkflowEffectsDrained = invariants.WorkflowEffectsDrained;
+
 exports.WorkflowError = invariants.WorkflowError;
 
+exports.WorkflowFieldEdited = invariants.WorkflowFieldEdited;
+
+exports.WorkflowInstanceAborted = invariants.WorkflowInstanceAborted;
+
+exports.WorkflowInstanceStarted = invariants.WorkflowInstanceStarted;
+
+exports.WorkflowInstanceTicked = invariants.WorkflowInstanceTicked;
+
+exports.WorkflowStageSet = invariants.WorkflowStageSet;
+
+exports.WorkflowStageTransitioned = invariants.WorkflowStageTransitioned;
+
+exports._fieldTargetLabel = invariants._fieldTargetLabel;
+
 exports.activeAssignmentMembers = invariants.activeAssignmentMembers;
 
 exports.actorFulfillsRole = invariants.actorFulfillsRole;
@@ -15658,6 +15332,8 @@ exports.conditionFieldReadNames = invariants.conditionFieldReadNames;
 
 exports.datasetResourceParts = invariants.datasetResourceParts;
 
+exports.definitionDeployedData = invariants.definitionDeployedData;
+
 exports.deriveActivityKind = invariants.deriveActivityKind;
 
 exports.deriveExecutorClassification = invariants.deriveExecutorClassification;
@@ -15708,10 +15384,20 @@ exports.isTodoListEntry = invariants.isTodoListEntry;
 
 exports.isTodoListItem = invariants.isTodoListItem;
 
+exports.isUnprimed = invariants.isUnprimed;
+
 exports.lakePrincipalId = invariants.lakePrincipalId;
 
+exports.noopTelemetry = invariants.noopTelemetry;
+
 exports.openActivityAssignments = invariants.openActivityAssignments;
 
+exports.parentRef = invariants.parentRef;
+
+exports.parseDefinitionSnapshot = invariants.parseDefinitionSnapshot;
+
+exports.parseDefinitionSnapshotValue = invariants.parseDefinitionSnapshotValue;
+
 exports.parseGdr = invariants.parseGdr;
 
 exports.parseResourceGdr = invariants.parseResourceGdr;
@@ -15734,6 +15420,8 @@ exports.releaseDocId = invariants.releaseDocId;
 
 exports.releaseRef = invariants.releaseRef;
 
+exports.resolveFieldEntry = invariants.resolveFieldEntry;
+
 exports.resourceAliasesToMap = invariants.resourceAliasesToMap;
 
 exports.resourceFromParsed = invariants.resourceFromParsed;
@@ -15750,6 +15438,8 @@ exports.startKindOf = invariants.startKindOf;
 
 exports.tagScopeFilter = invariants.tagScopeFilter;
 
+exports.terminalState = invariants.terminalState;
+
 exports.toBareId = invariants.toBareId;
 
 exports.tryParseGdr = invariants.tryParseGdr;
@@ -15952,46 +15642,18 @@ exports.StartNotPrimedError = StartNotPrimedError;
 
 exports.StartNotSettledError = StartNotSettledError;
 
-exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;
-
-exports.WorkflowActionFired = WorkflowActionFired;
-
-exports.WorkflowActivityReset = WorkflowActivityReset;
-
-exports.WorkflowDefinitionDeleted = WorkflowDefinitionDeleted;
-
-exports.WorkflowDefinitionDeployed = WorkflowDefinitionDeployed;
-
-exports.WorkflowEffectCompleted = WorkflowEffectCompleted;
-
-exports.WorkflowEffectStateReported = WorkflowEffectStateReported;
-
-exports.WorkflowEffectsDrained = WorkflowEffectsDrained;
-
-exports.WorkflowFieldEdited = WorkflowFieldEdited;
-
-exports.WorkflowInstanceAborted = WorkflowInstanceAborted;
-
 exports.WorkflowInstancePreviewSchema = WorkflowInstancePreviewSchema;
 
 exports.WorkflowInstanceSchema = WorkflowInstanceSchema;
 
-exports.WorkflowInstanceStarted = WorkflowInstanceStarted;
-
-exports.WorkflowInstanceTicked = WorkflowInstanceTicked;
-
-exports.WorkflowStageSet = WorkflowStageSet;
-
-exports.WorkflowStageTransitioned = WorkflowStageTransitioned;
-
 exports.WorkflowStateDivergedError = WorkflowStateDivergedError;
 
 exports._additionalMissingDocuments = _additionalMissingDocuments;
 
-exports._fieldTargetLabel = _fieldTargetLabel;
-
 exports._missingDocumentsSummary = _missingDocumentsSummary;
 
+exports._parseDefinitionsWithReaderModel = _parseDefinitionsWithReaderModel;
+
 exports._requestProjectMembers = _requestProjectMembers;
 
 exports._resolveTelemetryEnvironment = _resolveTelemetryEnvironment;
@@ -16052,8 +15714,6 @@ exports.createTelemetryIntake = createTelemetryIntake;
 
 exports.defaultLoggerFactory = defaultLoggerFactory;
 
-exports.definitionDeployedData = definitionDeployedData;
-
 exports.definitionLookupGroq = definitionLookupGroq;
 
 exports.definitionRoleNames = definitionRoleNames;
@@ -16174,8 +15834,6 @@ exports.isTelemetryEnvDenied = isTelemetryEnvDenied;
 
 exports.isTerminalStage = isTerminalStage;
 
-exports.isUnprimed = isUnprimed;
-
 exports.lakeGuardId = lakeGuardId;
 
 exports.latestDefinitionsGroq = latestDefinitionsGroq;
@@ -16192,16 +15850,8 @@ 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;
@@ -16236,8 +15886,6 @@ exports.resolveActor = resolveActor;
 
 exports.resolveClientActor = resolveClientActor;
 
-exports.resolveFieldEntry = resolveFieldEntry$1;
-
 exports.resolveUserAttributes = resolveUserAttributes;
 
 exports.retractStageGuards = retractStageGuards;
@@ -16264,8 +15912,6 @@ exports.subscriptionDocumentsForInstance = subscriptionDocumentsForInstance;
 
 exports.sweepStaleClaims = sweepStaleClaims;
 
-exports.terminalState = terminalState;
-
 exports.unboundRequirementReads = unboundRequirementReads;
 
 exports.unsatisfiedTransitionSummaries = unsatisfiedTransitionSummaries;