@sanity/workflow-engine 0.34.0 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @sanity/workflow-engine
 
+## 0.35.0
+
+### Minor Changes
+
+- 7e24e4a: **BREAKING:** Every engine telemetry event payload now carries the engine's own view of its caller as two fields, `executionRuntime` and `executionKind`, and every event's `version` moves from `1` to `2`. Anything that pins an engine event version, or that constructs an engine event payload by hand to emit through its own `@sanity/telemetry` logger, breaks until it is updated: the payload types now require `executionRuntime`. `definitionDeployedData` returns the structural half of the deploy payload rather than the whole payload — its result no longer satisfies `WorkflowDefinitionDeployedData`, and the emit site supplies the stamp separately.
+
+  `executionRuntime` is the runtime the engine infers for itself (`browser`, `node`, `worker`, `edge`, `deno`, `bun`, `unknown`) and matches the `executionContext.runtime` the same operation stamps on its history entries. The declared `id` is never reported.
+
+  `executionKind` answers where the operation came from, which is narrower than the vocabulary a host can declare. `studio`, `sdk`, `cli`, `mcp`, and `server` report themselves. `drainer` reports `server`, because a drain runtime is a server host and that it is draining is what its own events say. `interactive`, `script`, and `test` name a role rather than a host and report `other`, as does any value outside the vocabulary. The field is absent when the host declared no kind. The exported `ReportedExecutionKind` type is that closed set, so the reported vocabulary is visible in the type rather than only in prose.
+
+  `EXECUTION_KINDS.sdkApp` now carries the value `sdk` rather than `sdk-app`, so one spelling names the App SDK across the whole Workflows event family — the engine's `executionKind`, the session event's `host`, and the shell's `surface` user property. A host that declared `sdk-app` as a literal rather than through `EXECUTION_KINDS` should switch to the constant; nothing Sanity ships ever set the old value, so no stored history carries it.
+
+  Emitting the fields is not the same as being able to query them. Analytics ingestion maps event payload keys to a fixed set of columns, so caller-based breakdowns stay unavailable until `data_execution_runtime` and `data_execution_kind` exist downstream; upgrade for the emission, and expect the analytics read to follow separately.
+
+  Hosts that pass `executionContext` to `createEngine` need no action, with one exception: a host that declared the App SDK kind as the literal `sdk-app` rather than through `EXECUTION_KINDS` now falls outside the vocabulary and reports `other`, so it should switch to the constant or to `sdk`. Every other declared kind is reported under the projection described above. A host that declares nothing emits a runtime with no kind, so declare `executionContext: {kind, id}` at `createEngine` to make its activity distinguishable in analytics. Anyone matching on event versions or hand-building payloads must update to version `2` and set the two fields themselves.
+
+  One projection is currently unexercised: the Blueprint-generated function shells declare their execution context but pass no telemetry logger, so nothing emits from the server tier and no `server` row exists yet.
+
+  **Docs impact:** Update the telemetry reference for all 13 engine events to list the two payload fields and their version `2`, and give `ReportedExecutionKind` its own entry naming each reported value and what declares it. Document the `DerivedEventData` return type that the payload builders now return. In the engine host guidance, say that declaring `executionContext` at `createEngine` is what makes a host's events attributable, and that the reference docs currently describe that field only as a history stamp. Release guidance should carry the version bump and the hand-built-payload migration.
+
+### Patch Changes
+
+- ab8754a: `deployDefinitions` now derives the reader model its submitted definitions require through one named engine function that parses each definition and measures the parsed shape, rather than inlining that sequence at the call site. Anything that needs to predict the deploy's acknowledgement verdict offline derives the floor through the same function, so an offline check and the deploy cannot reach different answers. The verdict itself is unchanged: the same definitions produce the same required floor and the same `ReaderModelAcknowledgementError`.
+
+  The data-model change rules also now state that raising any feature's reader floor raises every deployment acknowledgement whose definitions then require the higher floor, in the same change, and that a floor raised without moving those `expectedMinReaderModel` literals fails the affected definition deploys until it is. A deployment whose definitions still require less keeps its literal. The rule names the confirmation step it depends on: the runtimes sharing each workflow resource must read the new model first.
+
+  **No upgrade action required.** No engine behavior, persisted shape, or supported API changes; `DATA_MODEL_VERSION` stays at 10 and no feature floor moves. The package entry point gains one `@internal` export carrying that shared derivation, which is unsupported outside the Workflows packages and is omitted from the generated reference. Anyone maintaining their own `sanity.workflow.ts` deployments can read the rule as the sequence to follow when a Workflows upgrade raises a floor their definitions require.
+
+  **Docs impact:** The reader-floor rollout guide (`docs/reader-model-rollout.md`) carries the matching step, including how a config-declared acknowledgement is proven offline against the deploy's own derivation and why an acknowledgement passed directly to `deployDefinitions` is not; mirror that rollout sequence wherever published prerelease guidance describes `expectedMinReaderModel`.
+
 ## 0.34.0
 
 ## 0.33.0

package/DATAMODEL.md

@@ -288,6 +288,19 @@ retained model-4 baseline.
    ledger instead of opening a new number, so one release carries one model.
    Reworking a ledger that has not shipped is the one exception to
    append-only; once a model is released its entry and ledger are frozen.
+10. **Raising any feature's reader floor raises every acknowledgement whose
+    definitions now require it, in the same change.** Each app under `apps/*` that deploys
+    definitions submits them with a reviewed `expectedMinReaderModel` literal,
+    so a feature whose floor those definitions now require breaks that app's
+    definition deploy until the literal moves with it. Raise every affected
+    literal in the same pull request, after confirming the runtimes sharing
+    that workflow resource read the new model. `pnpm test` proves it for every
+    app that declares its deployments in a `sanity.workflow.ts`: each runs an
+    offline guard deriving the required floor over its own definitions and
+    fails when its literal is below it. A script passing an acknowledgement
+    directly to `deployDefinitions` follows the same rule with no guard
+    covering it. The rollout order and the guard's wiring are in
+    `docs/reader-model-rollout.md`.
 
 ## Model log
 

package/dist/_chunks-cjs/invariants.cjs

@@ -81,11 +81,433 @@ function rethrowWithContext(err, context) {
     });
 }
 
+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) {
+        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 andConditions(parts) {
     const present = parts.filter(p => p !== void 0);
     if (present.length !== 0) return present.length === 1 ? present[0] : present.map(p => `(${p})`).join(" && ");
 }
 
+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 andConditions(parts) ?? !0;
+}
+
+const DEFAULT_EDIT_MODE = "set";
+
+function _fieldTargetLabel(target) {
+    return [ target.scope, target.activity, target.field ].filter(Boolean).join(".");
+}
+
+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;
+}
+
+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
+        } : {},
+        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
+        } : {}
+    }, 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 = 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(instance, site)?.value;
+}
+
+function resolveFieldEntry(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 = 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
+        } : {}
+    }));
+    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: 2,
+    description: "A definition went through a deploy — status distinguishes a newly minted version from an unchanged redeploy"
+}), WorkflowInstanceStarted = defineWorkflowEvent({
+    name: "Workflows Instance Started",
+    version: 2,
+    description: "A workflow instance was started from a deployed definition"
+}), WorkflowStageTransitioned = defineWorkflowEvent({
+    name: "Workflows Stage Transitioned",
+    version: 2,
+    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: 2,
+    description: "An action was fired against an activity"
+}), WorkflowFieldEdited = defineWorkflowEvent({
+    name: "Workflows Field Edited",
+    version: 2,
+    description: "A declared-editable field was edited through the generic edit seam",
+    maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
+}), WorkflowInstanceTicked = defineWorkflowEvent({
+    name: "Workflows Instance Ticked",
+    version: 2,
+    description: "An instance was re-evaluated for auto-transitions and due waits",
+    maxSampleRate: HIGH_FREQUENCY_SAMPLE_MS
+}), WorkflowEffectsDrained = defineWorkflowEvent({
+    name: "Workflows Effects Drained",
+    version: 2,
+    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: 2,
+    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: 2,
+    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: 2,
+    description: "The abort admin override was invoked (changed: false = instance already terminal)"
+}), WorkflowStageSet = defineWorkflowEvent({
+    name: "Workflows Stage Set",
+    version: 2,
+    description: "The set-stage admin override was invoked (changed: false = already at the target stage)"
+}), WorkflowActivityReset = defineWorkflowEvent({
+    name: "Workflows Activity Reset",
+    version: 2,
+    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: 2,
+    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 ?? []), fieldEntries = [ ...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: fieldEntries.length,
+        activityKinds: [ ...new Set(activities.map(deriveActivityKind)) ].sort(),
+        fieldKinds: [ ...new Set(fieldEntries.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
+    } : {};
+}
+
+const REPORTED_BY_DECLARED_KIND = {
+    studio: "studio",
+    sdk: "sdk",
+    cli: "cli",
+    mcp: "mcp",
+    server: "server",
+    drainer: "server",
+    interactive: "other",
+    script: "other",
+    test: "other"
+}, REPORTED_KIND_LOOKUP = new Map(Object.entries(REPORTED_BY_DECLARED_KIND));
+
+function executionContextFragment(context) {
+    return context.kind === void 0 ? {
+        executionRuntime: context.runtime
+    } : {
+        executionRuntime: context.runtime,
+        executionKind: REPORTED_KIND_LOOKUP.get(context.kind) ?? "other"
+    };
+}
+
+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 = 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(instance) {
+    const definition = parseDefinitionSnapshot(instance);
+    return {
+        definition: definition,
+        stage: definition.stages.find(s => s.name === instance.currentStage)
+    };
+}
+
+function firedActivityKind(instance, activity) {
+    const node = openStage(instance).stage?.activities?.find(a => a.name === activity);
+    return node === void 0 ? void 0 : deriveActivityKind(node);
+}
+
+function editedFieldKind(instance, target) {
+    const {definition: definition, stage: stage} = openStage(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
+    };
+}
+
 const KNOWN_SCHEMES = /* @__PURE__ */ new Set([ "dataset", "canvas", "media-library", "dashboard" ]), KNOWN_SCHEMES_TEXT = [ ...KNOWN_SCHEMES ].join(", ");
 
 class VersionSpecificDatasetGdrError extends Error {
@@ -4192,6 +4614,8 @@ exports.ContractViolationError = ContractViolationError;
 
 exports.DECISION_SEMANTICS = DECISION_SEMANTICS;
 
+exports.DEFAULT_EDIT_MODE = DEFAULT_EDIT_MODE;
+
 exports.DEFAULT_TRANSITION_WHEN = DEFAULT_TRANSITION_WHEN;
 
 exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
@@ -4246,6 +4670,8 @@ exports.RESERVED_CONDITION_VARS = RESERVED_CONDITION_VARS;
 
 exports.RESOURCE_ALIAS_NAME_SOURCE = RESOURCE_ALIAS_NAME_SOURCE;
 
+exports.SCOPE_PRECEDENCE = SCOPE_PRECEDENCE;
+
 exports.SIGNAL_SEMANTICS = SIGNAL_SEMANTICS;
 
 exports.START_FILTER_VARS = START_FILTER_VARS;
@@ -4264,18 +4690,48 @@ exports.VersionSpecificDatasetGdrError = VersionSpecificDatasetGdrError;
 
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
 
+exports.WORKFLOW_INSTANCE_TYPE = WORKFLOW_INSTANCE_TYPE;
+
+exports.WorkflowActionFired = WorkflowActionFired;
+
+exports.WorkflowActivityReset = WorkflowActivityReset;
+
 exports.WorkflowConfigSchema = WorkflowConfigSchema;
 
+exports.WorkflowDefinitionDeleted = WorkflowDefinitionDeleted;
+
+exports.WorkflowDefinitionDeployed = WorkflowDefinitionDeployed;
+
+exports.WorkflowEffectCompleted = WorkflowEffectCompleted;
+
+exports.WorkflowEffectStateReported = WorkflowEffectStateReported;
+
+exports.WorkflowEffectsDrained = WorkflowEffectsDrained;
+
 exports.WorkflowError = WorkflowError;
 
+exports.WorkflowFieldEdited = WorkflowFieldEdited;
+
+exports.WorkflowInstanceAborted = WorkflowInstanceAborted;
+
+exports.WorkflowInstanceStarted = WorkflowInstanceStarted;
+
+exports.WorkflowInstanceTicked = WorkflowInstanceTicked;
+
+exports.WorkflowStageSet = WorkflowStageSet;
+
+exports.WorkflowStageTransitioned = WorkflowStageTransitioned;
+
+exports._fieldTargetLabel = _fieldTargetLabel;
+
+exports.actionFiredData = actionFiredData;
+
 exports.activeAssignmentMembers = activeAssignmentMembers;
 
 exports.actorFulfillsRole = actorFulfillsRole;
 
 exports.actorMatchesAssignment = actorMatchesAssignment;
 
-exports.andConditions = andConditions;
-
 exports.assignmentKindAcceptsRoles = assignmentKindAcceptsRoles;
 
 exports.assignmentMatch = assignmentMatch;
@@ -4308,8 +4764,12 @@ exports.conditionSyntaxIssues = conditionSyntaxIssues;
 
 exports.datasetResourceParts = datasetResourceParts;
 
+exports.definitionDeployedData = definitionDeployedData;
+
 exports.definitionDocId = definitionDocId;
 
+exports.definitionHashFragment = definitionHashFragment;
+
 exports.deriveActivityKind = deriveActivityKind;
 
 exports.deriveExecutorClassification = deriveExecutorClassification;
@@ -4320,6 +4780,12 @@ exports.directoryBridgeId = directoryBridgeId;
 
 exports.driverKind = driverKind;
 
+exports.editDisabledReason = editDisabledReason;
+
+exports.editTargetMatches = editTargetMatches;
+
+exports.editableFieldsInStage = editableFieldsInStage;
+
 exports.effectBackoffMs = effectBackoffMs;
 
 exports.errorMessage = errorMessage;
@@ -4330,10 +4796,18 @@ exports.evaluateConditionOutcome = evaluateConditionOutcome;
 
 exports.evaluatePredicates = evaluatePredicates;
 
+exports.executionContextFragment = executionContextFragment;
+
 exports.extractDocumentId = extractDocumentId;
 
+exports.fieldEditedData = fieldEditedData;
+
+exports.fieldProvenance = fieldProvenance;
+
 exports.fieldValueSchemas = fieldValueSchemas;
 
+exports.fieldWindowOpen = fieldWindowOpen;
+
 exports.findCurrentActivityEntry = findCurrentActivityEntry;
 
 exports.findOpenStageEntry = findOpenStageEntry;
@@ -4362,6 +4836,12 @@ exports.identityMatchesAssignment = identityMatchesAssignment;
 
 exports.instanceAssignmentStateCounts = instanceAssignmentStateCounts;
 
+exports.instanceStartedData = instanceStartedData;
+
+exports.instanceStartedDataFor = instanceStartedDataFor;
+
+exports.instanceTerminalReason = instanceTerminalReason;
+
 exports.isAlwaysArrayFieldKind = isAlwaysArrayFieldKind;
 
 exports.isAssignmentFieldEntry = isAssignmentFieldEntry;
@@ -4404,6 +4884,8 @@ exports.isTodoListItem = isTodoListItem;
 
 exports.isUnevaluable = isUnevaluable;
 
+exports.isUnprimed = isUnprimed;
+
 exports.labelFor = labelFor;
 
 exports.lakePrincipalId = lakePrincipalId;
@@ -4414,10 +4896,18 @@ exports.mutationGuardActionIdSpace = mutationGuardActionIdSpace;
 
 exports.mutationGuardRequiresSplitEmission = mutationGuardRequiresSplitEmission;
 
+exports.noopTelemetry = noopTelemetry;
+
 exports.normalizeAssignmentMembers = normalizeAssignmentMembers;
 
 exports.openActivityAssignments = openActivityAssignments;
 
+exports.parentRef = parentRef;
+
+exports.parseDefinitionSnapshot = parseDefinitionSnapshot;
+
+exports.parseDefinitionSnapshotValue = parseDefinitionSnapshotValue;
+
 exports.parseFieldValue = parseFieldValue;
 
 exports.parseGdr = parseGdr;
@@ -4430,6 +4920,8 @@ exports.parseResourceGdr = parseResourceGdr;
 
 exports.parseStoredDefinition = parseStoredDefinition;
 
+exports.readFieldValue = readFieldValue;
+
 exports.readsRootDocument = readsRootDocument;
 
 exports.refCanvas = refCanvas;
@@ -4450,6 +4942,12 @@ exports.releaseDocId = releaseDocId;
 
 exports.releaseRef = releaseRef;
 
+exports.resolveEditTarget = resolveEditTarget;
+
+exports.resolveFieldEntry = resolveFieldEntry;
+
+exports.resolveTelemetry = resolveTelemetry;
+
 exports.resolvedChildStatus = resolvedChildStatus;
 
 exports.resourceAliasesToMap = resourceAliasesToMap;
@@ -4472,10 +4970,14 @@ exports.schemaTreeShape = schemaTreeShape;
 
 exports.selfGdr = selfGdr;
 
+exports.stageTransitionedData = stageTransitionedData;
+
 exports.startKindOf = startKindOf;
 
 exports.tagScopeFilter = tagScopeFilter;
 
+exports.terminalState = terminalState;
+
 exports.toBareId = toBareId;
 
 exports.toPhysicalGdr = toPhysicalGdr;