@sanity/workflow-engine 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { parse, evaluate } from "groq-js";
 import { actorFulfillsRole, isTerminalTaskStatus, WORKFLOW_DEFINITION_TYPE, andConditions, DOCUMENT_VALUE_PERMISSIONS } from "./_chunks-es/schema.js";
-import { isStartableDefinition } from "./_chunks-es/schema.js";
+import { DRIVER_KINDS, TASK_KINDS, isStartableDefinition } from "./_chunks-es/schema.js";
 import * as v from "valibot";
 function findOpenStageEntry(host) {
   return host.stages.find((s) => s.name === host.currentStage && s.exitedAt === void 0);
@@ -111,7 +111,7 @@ function buildParams(args) {
   const { instance, now, snapshot, extra } = args, currentTasks2 = findOpenStageEntry(instance)?.tasks ?? [];
   return {
     self: selfGdr(instance),
-    state: renderedState(instance.state ?? [], snapshot),
+    fields: renderedFields(instance.fields ?? [], snapshot),
     parent: instance.ancestors.at(-1)?.id ?? null,
     ancestors: instance.ancestors.map((a) => a.id),
     stage: instance.currentStage,
@@ -126,7 +126,7 @@ function buildParams(args) {
     ...extra
   };
 }
-function renderedState(entries, snapshot) {
+function renderedFields(entries, snapshot) {
   const out = {};
   for (const entry of entries) out[entry.name] = renderedValue(entry, snapshot);
   return out;
@@ -134,15 +134,15 @@ function renderedState(entries, snapshot) {
 function renderedValue(entry, snapshot) {
   return entry._type !== "doc.ref" || entry.value === null || snapshot === void 0 ? entry.value : snapshot.docs.find((d) => d._id === entry.value.id) ?? entry.value;
 }
-function scopedStateOverlay(instance, snapshot, taskName) {
+function scopedFieldOverlay(instance, snapshot, taskName) {
   const stageEntry = findOpenStageEntry(instance);
   if (stageEntry === void 0) return {};
-  const stageState = renderedState(stageEntry.state ?? [], snapshot), task = taskName ? stageEntry.tasks.find((t) => t.name === taskName) : void 0;
-  return { ...stageState, ...renderedState(task?.state ?? [], snapshot) };
+  const stageFields = renderedFields(stageEntry.fields ?? [], snapshot), task = taskName ? stageEntry.tasks.find((t) => t.name === taskName) : void 0;
+  return { ...stageFields, ...renderedFields(task?.fields ?? [], snapshot) };
 }
 function assignedFor(instance, taskName, actor, roleAliases) {
   if (actor === void 0) return !1;
-  const entry = findOpenStageEntry(instance)?.tasks.find((t) => t.name === taskName)?.state?.find((s) => s._type === "assignees");
+  const entry = findOpenStageEntry(instance)?.tasks.find((t) => t.name === taskName)?.fields?.find((s) => s._type === "assignees");
   return entry === void 0 ? !1 : entry.value.some(
     (a) => a.type === "user" ? a.id === actor.id : actorFulfillsRole(actor.roles, a.role, roleAliases)
   );
@@ -169,17 +169,17 @@ function paramsForLake(params) {
     self: typeof params.self == "string" ? bareId(params.self) : params.self,
     parent: typeof params.parent == "string" ? bareId(params.parent) : params.parent,
     ancestors: Array.isArray(params.ancestors) ? params.ancestors.map((a) => typeof a == "string" ? bareId(a) : a) : params.ancestors,
-    state: stripStateForLake(params.state)
+    fields: stripFieldsForLake(params.fields)
   };
 }
-function stripStateForLake(value) {
+function stripFieldsForLake(value) {
   if (value == null) return value;
   if (typeof value == "string") return bareId(value);
-  if (Array.isArray(value)) return value.map(stripStateForLake);
+  if (Array.isArray(value)) return value.map(stripFieldsForLake);
   if (typeof value == "object") {
     const out = {};
     for (const [k, v2] of Object.entries(value))
-      out[k] = stripStateForLake(v2);
+      out[k] = stripFieldsForLake(v2);
     return out;
   }
   return value;
@@ -198,17 +198,17 @@ function getPath(value, path) {
 function resourceOf(p) {
   return p.scheme === "dataset" ? { type: "dataset", id: `${p.projectId}.${p.dataset}` } : { type: p.scheme, id: p.resourceId ?? "" };
 }
-const STATE_READ = /^\$state\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
+const FIELD_READ = /^\$fields\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
 function isGuardReadExpr(expr) {
-  return expr === "$self" || expr === "$now" || STATE_READ.test(expr) || EFFECTS_READ.test(expr);
+  return expr === "$self" || expr === "$now" || FIELD_READ.test(expr) || EFFECTS_READ.test(expr);
 }
 function resolveGuardRead(expr, ctx) {
   if (expr === "$self") return selfGdr(ctx.instance);
   if (expr === "$now") return ctx.now;
-  const stateRead = STATE_READ.exec(expr);
-  if (stateRead !== null) {
-    const value = (ctx.instance.state ?? []).find((s) => s.name === stateRead[1])?.value;
-    return stateRead[2] !== void 0 ? getPath(value, stateRead[2]) : value;
+  const fieldRead = FIELD_READ.exec(expr);
+  if (fieldRead !== null) {
+    const value = (ctx.instance.fields ?? []).find((s) => s.name === fieldRead[1])?.value;
+    return fieldRead[2] !== void 0 ? getPath(value, fieldRead[2]) : value;
   }
   const effectsRead = EFFECTS_READ.exec(expr);
   if (effectsRead !== null) {
@@ -216,7 +216,7 @@ function resolveGuardRead(expr, ctx) {
     return effectsRead[2] !== void 0 ? getPath(outputs, effectsRead[2]) : outputs;
   }
   throw new Error(
-    `Guard read "${expr}" is not a supported deploy-time value \u2014 use "$self", "$now", "$state.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $state or $effects)`
+    `Guard read "${expr}" is not a supported deploy-time value \u2014 use "$self", "$now", "$fields.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $fields or $effects)`
   );
 }
 function resolveIdRefTarget(expr, ctx) {
@@ -266,8 +266,8 @@ function resolveMetadata(metadata, ctx) {
 }
 function validateDefinition(definition) {
   const v2 = createDefinitionValidator();
-  for (const entry of definition.state ?? [])
-    v2.checkEntry(entry, `workflow.state "${entry.name}"`);
+  for (const entry of definition.fields ?? [])
+    v2.checkEntry(entry, `workflow.fields "${entry.name}"`);
   for (const [name, groq] of Object.entries(definition.predicates ?? {}))
     v2.checkCondition(groq, `predicate "${name}"`);
   for (const stage of definition.stages)
@@ -289,7 +289,7 @@ function createDefinitionValidator() {
     }
   }, rejectTypeScan = (groq, where) => {
     /\*\s*\[\s*_type\b/.test(groq) && errors.push(
-      `  \xB7 ${where}: condition scans by \`_type\` \u2014 that's a discovery query, not a predicate. Conditions evaluate against the in-memory snapshot (instance + ancestors + state-declared docs). To bring extra docs in scope, declare a \`doc.ref\` (or \`doc.refs\`) state entry on the workflow or this stage. For lake scans like "all articles in this release", use \`subworkflows.forEach\` instead.`
+      `  \xB7 ${where}: condition scans by \`_type\` \u2014 that's a discovery query, not a predicate. Conditions evaluate against the in-memory snapshot (instance + ancestors + field-declared docs). To bring extra docs in scope, declare a \`doc.ref\` (or \`doc.refs\`) field entry on the workflow or this stage. For lake scans like "all articles in this release", use \`subworkflows.forEach\` instead.`
     );
   };
   return { errors, tryParse, checkCondition: (groq, where) => {
@@ -298,13 +298,13 @@ function createDefinitionValidator() {
     entry.source.type === "query" && tryParse(entry.source.query, `${label}.query`);
   }, checkGuardRead: (expr, where) => {
     isGuardReadExpr(expr) || errors.push(
-      `  \xB7 ${where}: guard read "${expr}" is not a supported deploy-time value \u2014 use "$self", "$now", "$state.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $state or $effects)`
+      `  \xB7 ${where}: guard read "${expr}" is not a supported deploy-time value \u2014 use "$self", "$now", "$fields.<name>[.path]", or "$effects['<name>'][.path]" (guards store resolved values; the lake cannot see $fields or $effects)`
     );
   } };
 }
 function validateStage(v2, stage) {
-  for (const entry of stage.state ?? [])
-    v2.checkEntry(entry, `stage "${stage.name}".state "${entry.name}"`);
+  for (const entry of stage.fields ?? [])
+    v2.checkEntry(entry, `stage "${stage.name}".fields "${entry.name}"`);
   for (const guard of stage.guards ?? [])
     validateGuardReads(v2, stage.name, guard);
   for (const t of stage.transitions ?? []) {
@@ -324,8 +324,8 @@ function validateGuardReads(v2, stageName, guard) {
 }
 function validateTask(v2, stageName, task) {
   const where = `stage "${stageName}" task "${task.name}"`;
-  for (const entry of task.state ?? [])
-    v2.checkEntry(entry, `${where}.state "${entry.name}"`);
+  for (const entry of task.fields ?? [])
+    v2.checkEntry(entry, `${where}.fields "${entry.name}"`);
   task.filter !== void 0 && v2.checkCondition(task.filter, `${where}.filter`), task.completeWhen !== void 0 && v2.checkCondition(task.completeWhen, `${where}.completeWhen`), task.failWhen !== void 0 && v2.checkCondition(task.failWhen, `${where}.failWhen`);
   for (const [name, groq] of Object.entries(task.requirements ?? {}))
     v2.checkCondition(groq, `${where}.requirements "${name}"`);
@@ -497,7 +497,7 @@ function openStage(instance) {
   return findOpenStageEntry(instance);
 }
 function assigneesOf(stage, taskName) {
-  return (stage?.tasks.find((t) => t.name === taskName)?.state ?? []).filter((s) => s._type === "assignees").flatMap((s) => s.value);
+  return (stage?.tasks.find((t) => t.name === taskName)?.fields ?? []).filter((s) => s._type === "assignees").flatMap((s) => s.value);
 }
 function isResolved(status) {
   return status === "done" || status === "skipped";
@@ -610,17 +610,17 @@ class ActionParamsInvalidError extends Error {
 ${lines}`), this.name = "ActionParamsInvalidError", this.action = args.action, this.task = args.task, this.issues = args.issues;
   }
 }
-class RequiredStateNotProvidedError extends Error {
+class RequiredFieldNotProvidedError extends Error {
   definition;
   missing;
   constructor(args) {
     const lines = args.missing.map((m) => `  - ${m.name} (${m.type})`).join(`
 `), where = args.definition !== void 0 ? ` for workflow "${args.definition}"` : "";
     super(
-      `Required init state${where} was not provided:
+      `Required init fields${where} was not provided:
 ${lines}
-Provide each via \`initialState\` when starting standalone, or via the parent's \`subworkflows.with\` when spawned.`
-    ), this.name = "RequiredStateNotProvidedError", args.definition !== void 0 && (this.definition = args.definition), this.missing = args.missing;
+Provide each via \`initialFields\` when starting standalone, or via the parent's \`subworkflows.with\` when spawned.`
+    ), this.name = "RequiredFieldNotProvidedError", args.definition !== void 0 && (this.definition = args.definition), this.missing = args.missing;
   }
 }
 class WorkflowStateDivergedError extends Error {
@@ -663,15 +663,15 @@ function isRevisionConflict(error) {
   const { statusCode, message } = error;
   return statusCode === 409 ? !0 : typeof message == "string" && message.includes("ifRevisionId check failed");
 }
-class ConcurrentEditStateError extends Error {
+class ConcurrentEditFieldError extends Error {
   instanceId;
   target;
   attempts;
   constructor(args) {
-    const where = args.target.task !== void 0 ? `${args.target.task}.${args.target.state}` : args.target.state;
+    const where = args.target.task !== void 0 ? `${args.target.task}.${args.target.field}` : args.target.field;
     super(
       `Edit of "${args.target.scope}:${where}" (instance ${args.instanceId}) lost the optimistic-locking race ${args.attempts} attempts running \u2014 a concurrent writer kept committing first. Re-read and retry, or investigate a write storm on this instance.`
-    ), this.name = "ConcurrentEditStateError", this.instanceId = args.instanceId, this.target = args.target, this.attempts = args.attempts;
+    ), this.name = "ConcurrentEditFieldError", this.instanceId = args.instanceId, this.target = args.target, this.attempts = args.attempts;
   }
 }
 class CascadeLimitError extends Error {
@@ -719,10 +719,10 @@ function collectWatchRefs(instance) {
   return [
     gdrRef(instance.workflowResource, instance._id, instance._type),
     ...instance.ancestors,
-    ...entryDocRefs(instance.state),
-    ...entryDocRefs(stage?.state),
-    ...entryReleaseRefs(instance.state),
-    ...entryReleaseRefs(stage?.state)
+    ...entryDocRefs(instance.fields),
+    ...entryDocRefs(stage?.fields),
+    ...entryReleaseRefs(instance.fields),
+    ...entryReleaseRefs(stage?.fields)
   ];
 }
 function readsRaw(ref) {
@@ -746,21 +746,21 @@ function subscriptionDocumentsForInstance(instance) {
     ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
   };
 }
-function entryDocRefs(state) {
-  return stateEntries(state).flatMap((entry) => entry._type === "doc.ref" ? isGdr(entry.value) ? [entry.value] : [] : entry._type === "doc.refs" ? Array.isArray(entry.value) ? entry.value.filter(isGdr) : [] : []);
+function entryDocRefs(entries) {
+  return fieldEntries(entries).flatMap((entry) => entry._type === "doc.ref" ? isGdr(entry.value) ? [entry.value] : [] : entry._type === "doc.refs" ? Array.isArray(entry.value) ? entry.value.filter(isGdr) : [] : []);
 }
-function entryReleaseRefs(state) {
-  return stateEntries(state).flatMap(
+function entryReleaseRefs(entries) {
+  return fieldEntries(entries).flatMap(
     (entry) => entry._type === "release.ref" && isGdr(entry.value) ? [entry.value] : []
   );
 }
-function entrySubjectRefs(state) {
-  return stateEntries(state).flatMap(
+function entrySubjectRefs(entries) {
+  return fieldEntries(entries).flatMap(
     (entry) => (entry._type === "doc.ref" || entry._type === "release.ref") && isGdr(entry.value) ? [entry.value] : []
   );
 }
-function stateEntries(state) {
-  return Array.isArray(state) ? state.filter(
+function fieldEntries(entries) {
+  return Array.isArray(entries) ? entries.filter(
     (entry) => !!entry && typeof entry == "object"
   ) : [];
 }
@@ -806,8 +806,8 @@ async function readDoc(client, id, perspective) {
 function resourceFromParsed(parsed) {
   return parsed.scheme === "dataset" ? { type: "dataset", id: `${parsed.projectId}.${parsed.dataset}` } : { type: parsed.scheme, id: parsed.resourceId ?? "" };
 }
-function collectEntryDocUris(resolvedStateEntries) {
-  return entryDocRefs(resolvedStateEntries).map((ref) => ref.id);
+function collectEntryDocUris(resolvedFieldEntries) {
+  return entryDocRefs(resolvedFieldEntries).map((ref) => ref.id);
 }
 const resourceKey = (r) => `${r.type}.${r.id}`;
 function guardsForResource(client) {
@@ -825,8 +825,8 @@ function verdictGuardsForInstance(client, instanceId) {
 }
 async function guardsForInstance(args) {
   const { client, clientForGdr, instance } = args, stateUris = [
-    ...collectEntryDocUris(instance.state),
-    ...instance.stages.flatMap((stage) => collectEntryDocUris(stage.state))
+    ...collectEntryDocUris(instance.fields),
+    ...instance.stages.flatMap((stage) => collectEntryDocUris(stage.fields))
   ], clients = resourceClientMap(
     instance.workflowResource,
     client,
@@ -858,16 +858,16 @@ function guardIdRefs(definition) {
   );
 }
 function staticIdRefGdr(idRef, stage, definition) {
-  const read = /^\$state\.([\w-]+)/.exec(idRef);
+  const read = /^\$fields\.([\w-]+)/.exec(idRef);
   if (read === null) return;
   const source = entriesInScope(stage, definition).find((e) => e.name === read[1])?.source;
   return source?.type === "literal" ? gdrFromValue(source.value) : void 0;
 }
 function entriesInScope(stage, definition) {
   return [
-    ...definition.state ?? [],
-    ...stage.state ?? [],
-    ...(stage.tasks ?? []).flatMap((task) => task.state ?? [])
+    ...definition.fields ?? [],
+    ...stage.fields ?? [],
+    ...(stage.tasks ?? []).flatMap((task) => task.fields ?? [])
   ];
 }
 function gdrFromValue(value) {
@@ -1017,15 +1017,15 @@ async function runGroq(groq, params, snapshot) {
   const tree = parse(groq, { params });
   return (await evaluate(tree, { dataset: snapshot.docs, params })).get();
 }
-class StateValueShapeError extends Error {
+class FieldValueShapeError extends Error {
   entryType;
   entryName;
   issues;
   constructor(args) {
     const issueText = args.issues.join("; ");
     super(
-      `State entry ${args.mode} shape invalid for "${args.entryName}" (${args.entryType}): ${issueText}`
-    ), this.name = "StateValueShapeError", this.entryType = args.entryType, this.entryName = args.entryName, this.issues = args.issues;
+      `Field entry ${args.mode} shape invalid for "${args.entryName}" (${args.entryType}): ${issueText}`
+    ), this.name = "FieldValueShapeError", this.entryType = args.entryType, this.entryName = args.entryName, this.issues = args.issues;
   }
 }
 const GdrShape = v.looseObject({
@@ -1092,35 +1092,35 @@ const GdrShape = v.looseObject({
 function isAppendable(entryType) {
   return entryType in itemSchemas;
 }
-function validateStateValue(args) {
+function validateFieldValue(args) {
   const schema = valueSchemas[args.entryType];
   if (schema === void 0)
-    throw new StateValueShapeError({
+    throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
-      issues: [`unknown state entry type ${args.entryType}`],
+      issues: [`unknown field entry type ${args.entryType}`],
       mode: "value"
     });
   const result = v.safeParse(schema, args.value);
   if (!result.success)
-    throw new StateValueShapeError({
+    throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
       issues: formatIssues(result.issues),
       mode: "value"
     });
 }
-function validateStateAppendItem(args) {
+function validateFieldAppendItem(args) {
   if (!isAppendable(args.entryType))
-    throw new StateValueShapeError({
+    throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
-      issues: [`state entry type ${args.entryType} does not support append`],
+      issues: [`field entry type ${args.entryType} does not support append`],
       mode: "item"
     });
   const schema = itemSchemas[args.entryType], result = v.safeParse(schema, args.item);
   if (!result.success)
-    throw new StateValueShapeError({
+    throw new FieldValueShapeError({
       entryType: args.entryType,
       entryName: args.entryName,
       issues: formatIssues(result.issues),
@@ -1133,7 +1133,7 @@ function formatIssues(issues) {
     return `${keys.length > 0 ? `at ${keys.join(".")}: ` : ""}${i.message}`;
   });
 }
-function derivePerspectiveFromState(entries) {
+function derivePerspectiveFromFields(entries) {
   if (entries !== void 0) {
     for (const entry of entries)
       if (entry._type === "release.ref" && entry.value !== null) {
@@ -1143,24 +1143,24 @@ function derivePerspectiveFromState(entries) {
       }
   }
 }
-async function resolveDeclaredState(args) {
-  const { entryDefs, initialState, ctx, randomKey: randomKey2 } = args;
+async function resolveDeclaredFields(args) {
+  const { entryDefs, initialFields, ctx, randomKey: randomKey2 } = args;
   if (entryDefs === void 0 || entryDefs.length === 0) return [];
-  assertRequiredInitProvided(entryDefs, initialState, ctx.definitionName);
+  assertRequiredInitProvided(entryDefs, initialFields, ctx.definitionName);
   const out = [];
   for (const entry of entryDefs) {
-    const scopedCtx = { ...ctx, resolvedState: out };
-    out.push(await resolveOneEntry(entry, initialState, scopedCtx, randomKey2));
+    const scopedCtx = { ...ctx, resolvedFields: out };
+    out.push(await resolveOneEntry(entry, initialFields, scopedCtx, randomKey2));
   }
   return out;
 }
-function assertRequiredInitProvided(entryDefs, initialState, definitionName) {
+function assertRequiredInitProvided(entryDefs, initialFields, definitionName) {
   const missing = entryDefs.filter((entry) => entry.required === !0 && entry.source.type === "init").filter((entry) => {
-    const match = initialState.find((s) => s.name === entry.name && s.type === entry.type);
+    const match = initialFields.find((s) => s.name === entry.name && s.type === entry.type);
     return match === void 0 || match.value === void 0 || match.value === null;
   }).map((entry) => ({ name: entry.name, type: entry.type }));
   if (missing.length !== 0)
-    throw new RequiredStateNotProvidedError({
+    throw new RequiredFieldNotProvidedError({
       ...definitionName !== void 0 ? { definition: definitionName } : {},
       missing
     });
@@ -1174,18 +1174,18 @@ const ARRAY_SLOT_TYPES = /* @__PURE__ */ new Set([
 function defaultEntryValue(entryType) {
   return ARRAY_SLOT_TYPES.has(entryType) ? [] : null;
 }
-function resolveInitValue(entry, initialState, defaultValue) {
-  const initMatch = initialState.find((s) => s.name === entry.name && s.type === entry.type);
+function resolveInitValue(entry, initialFields, defaultValue) {
+  const initMatch = initialFields.find((s) => s.name === entry.name && s.type === entry.type);
   return initMatch === void 0 ? defaultValue : (assertInitValueShape(entry, initMatch.value), initMatch.value);
 }
-function resolveStateReadValue(source, ctx, defaultValue) {
-  const target = (source.scope === "workflow" ? ctx.workflowState ?? [] : ctx.resolvedState ?? []).find((s) => s.name === source.state), targetValue = target === void 0 ? void 0 : target.value;
+function resolveFieldReadValue(source, ctx, defaultValue) {
+  const target = (source.scope === "workflow" ? ctx.workflowFields ?? [] : ctx.resolvedFields ?? []).find((s) => s.name === source.field), targetValue = target === void 0 ? void 0 : target.value;
   return (source.path !== void 0 ? getPath(targetValue, source.path) : targetValue) ?? defaultValue;
 }
 async function resolveQueryValue(entry, source, ctx, client, defaultValue) {
   const params = paramsForLake({
     self: ctx.selfId ?? null,
-    state: stateMapFromResolved(ctx.resolvedState ?? []),
+    fields: fieldMapFromResolved(ctx.resolvedFields ?? []),
     stage: ctx.stageName ?? null,
     task: ctx.taskName ?? null,
     now: ctx.now,
@@ -1201,9 +1201,9 @@ async function resolveQueryValue(entry, source, ctx, client, defaultValue) {
     );
   }
 }
-async function resolveEntryValue(entry, initialState, ctx, defaultValue) {
+async function resolveEntryValue(entry, initialFields, ctx, defaultValue) {
   const source = entry.source;
-  return source.type === "init" ? resolveInitValue(entry, initialState, defaultValue) : source.type === "literal" ? source.value ?? defaultValue : source.type === "stateRead" ? resolveStateReadValue(source, ctx, defaultValue) : source.type === "query" && ctx.client !== void 0 ? resolveQueryValue(entry, source, ctx, ctx.client, defaultValue) : defaultValue;
+  return source.type === "init" ? resolveInitValue(entry, initialFields, defaultValue) : source.type === "literal" ? source.value ?? defaultValue : source.type === "fieldRead" ? resolveFieldReadValue(source, ctx, defaultValue) : source.type === "query" && ctx.client !== void 0 ? resolveQueryValue(entry, source, ctx, ctx.client, defaultValue) : defaultValue;
 }
 function buildResolvedEntry(entry, value, _key, now) {
   const titleProp = entry.title !== void 0 ? { title: entry.title } : {}, descriptionProp = entry.description !== void 0 ? { description: entry.description } : {};
@@ -1224,36 +1224,36 @@ function buildResolvedEntry(entry, value, _key, now) {
     value
   };
 }
-async function resolveOneEntry(entry, initialState, ctx, randomKey2) {
-  const defaultValue = defaultEntryValue(entry.type), value = await resolveEntryValue(entry, initialState, ctx, defaultValue);
-  return validateStateValue({ entryType: entry.type, entryName: entry.name, value }), buildResolvedEntry(entry, value, randomKey2(), ctx.now);
+async function resolveOneEntry(entry, initialFields, ctx, randomKey2) {
+  const defaultValue = defaultEntryValue(entry.type), value = await resolveEntryValue(entry, initialFields, ctx, defaultValue);
+  return validateFieldValue({ entryType: entry.type, entryName: entry.name, value }), buildResolvedEntry(entry, value, randomKey2(), ctx.now);
 }
-function stateMapFromResolved(entries) {
+function fieldMapFromResolved(entries) {
   const out = {};
   for (const s of entries) out[s.name] = s.value;
   return out;
 }
 function assertInitValueShape(entry, value) {
   if (entry.type === "doc.ref") {
-    assertGdrShape(value, `state entry "${entry.name}" (doc.ref)`);
+    assertGdrShape(value, `field entry "${entry.name}" (doc.ref)`);
     return;
   }
   if (entry.type === "release.ref") {
-    assertGdrShape(value, `state entry "${entry.name}" (release.ref)`);
+    assertGdrShape(value, `field entry "${entry.name}" (release.ref)`);
     const v2 = value;
     if (typeof v2.releaseName != "string" || v2.releaseName.length === 0)
       throw new Error(
-        `Invalid init value for state entry "${entry.name}" (release.ref): \`releaseName\` must be a non-empty string. Got ${JSON.stringify(v2.releaseName)}.`
+        `Invalid init value for field entry "${entry.name}" (release.ref): \`releaseName\` must be a non-empty string. Got ${JSON.stringify(v2.releaseName)}.`
       );
     return;
   }
   if (entry.type === "doc.refs") {
     if (!Array.isArray(value))
       throw new Error(
-        `Invalid init value for state entry "${entry.name}" (doc.refs): expected an array of GDRs, got ${typeof value}.`
+        `Invalid init value for field entry "${entry.name}" (doc.refs): expected an array of GDRs, got ${typeof value}.`
       );
     for (const [i, item] of value.entries())
-      assertGdrShape(item, `state entry "${entry.name}" (doc.refs) item [${i}]`);
+      assertGdrShape(item, `field entry "${entry.name}" (doc.refs) item [${i}]`);
   }
 }
 function assertGdrShape(value, context) {
@@ -1312,12 +1312,12 @@ async function loadContext(client, instanceId, options) {
   return { client, clientForGdr, clock, now: clock(), instance, definition, snapshot };
 }
 async function ctxConditionParams(ctx, opts) {
-  const base = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), state = {
-    ...base.state,
-    ...scopedStateOverlay(ctx.instance, ctx.snapshot, opts?.taskName)
+  const base = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), fields = {
+    ...base.fields,
+    ...scopedFieldOverlay(ctx.instance, ctx.snapshot, opts?.taskName)
   }, params = {
     ...base,
-    state,
+    fields,
     actor: opts?.actor,
     assigned: opts?.taskName !== void 0 ? assignedFor(ctx.instance, opts.taskName, opts?.actor, ctx.definition.roleAliases) : !1,
     ...opts?.vars
@@ -1356,11 +1356,11 @@ function findStage(definition, stageName) {
     throw new Error(`Stage "${stageName}" not found in definition ${definition.name}`);
   return stage;
 }
-async function resolveStageStateEntries(args) {
-  const { client, instance, stage, now, initialState } = args;
-  return resolveDeclaredState({
-    entryDefs: stage.state,
-    initialState: initialState ?? [],
+async function resolveStageFieldEntries(args) {
+  const { client, instance, stage, now, initialFields } = args;
+  return resolveDeclaredFields({
+    entryDefs: stage.fields,
+    initialFields: initialFields ?? [],
     ctx: {
       client,
       now,
@@ -1368,19 +1368,19 @@ async function resolveStageStateEntries(args) {
       tag: instance.tag,
       stageName: stage.name,
       workflowResource: instance.workflowResource,
-      // Allow stage-scope entries' `source: { type: "stateRead", scope:
-      // "workflow", ... }` to see the already-resolved workflow-scope state.
-      workflowState: instance.state ?? [],
+      // Allow stage-scope entries' `source: { type: "fieldRead", scope:
+      // "workflow", ... }` to see the already-resolved workflow-scope fields.
+      workflowFields: instance.fields ?? [],
       ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
     },
     randomKey
   });
 }
-async function resolveTaskStateEntries(args) {
+async function resolveTaskFieldEntries(args) {
   const { client, instance, stage, task, now } = args;
-  return resolveDeclaredState({
-    entryDefs: task.state,
-    initialState: [],
+  return resolveDeclaredFields({
+    entryDefs: task.fields,
+    initialFields: [],
     ctx: {
       client,
       now,
@@ -1389,7 +1389,7 @@ async function resolveTaskStateEntries(args) {
       stageName: stage.name,
       workflowResource: instance.workflowResource,
       taskName: task.name,
-      workflowState: instance.state ?? [],
+      workflowFields: instance.fields ?? [],
       ...instance.perspective !== void 0 ? { perspective: instance.perspective } : {}
     },
     randomKey
@@ -1471,15 +1471,15 @@ function stageTransitionHistory(args) {
 function startMutation(instance) {
   return {
     currentStage: instance.currentStage,
-    // Deep-ish copy. Per-scope state entry arrays need their own copies
+    // Deep-ish copy. Per-scope field entry arrays need their own copies
     // so ops can mutate without leaking into the source.
-    state: (instance.state ?? []).map((s) => ({ ...s })),
+    fields: (instance.fields ?? []).map((s) => ({ ...s })),
     stages: instance.stages.map((s) => ({
       ...s,
-      state: (s.state ?? []).map((entry) => ({ ...entry })),
+      fields: (s.fields ?? []).map((entry) => ({ ...entry })),
       tasks: s.tasks.map((t) => ({
         ...t,
-        ...t.state !== void 0 ? { state: t.state.map((entry) => ({ ...entry })) } : {}
+        ...t.fields !== void 0 ? { fields: t.fields.map((entry) => ({ ...entry })) } : {}
       }))
     })),
     pendingEffects: [...instance.pendingEffects],
@@ -1495,7 +1495,7 @@ function startMutation(instance) {
 function instanceStateFields(src) {
   const fields = {
     currentStage: src.currentStage,
-    state: src.state,
+    fields: src.fields,
     stages: src.stages,
     pendingEffects: src.pendingEffects,
     effectHistory: src.effectHistory,
@@ -1508,7 +1508,7 @@ function materializeInstance(base, mutation) {
   return {
     ...base,
     currentStage: mutation.currentStage,
-    state: mutation.state,
+    fields: mutation.fields,
     stages: mutation.stages,
     effectsContext: mutation.effectsContext
   };
@@ -1630,7 +1630,7 @@ function buildInstanceBase(args) {
     definition: args.definitionName,
     pinnedVersion: args.pinnedVersion,
     definitionSnapshot: JSON.stringify(args.definition),
-    state: args.state,
+    fields: args.fields,
     effectsContext: args.effectsContext,
     ancestors: args.ancestors,
     ...perspective !== void 0 ? { perspective } : {},
@@ -1651,12 +1651,16 @@ function buildInstanceBase(args) {
     lastChangedAt: now
   };
 }
-const MAX_SPAWN_DEPTH = 6, SUBWORKFLOWS_ALL_DONE = "count($subworkflows[status != 'done']) == 0", FAIL_WHEN_SYSTEM_ID = "engine.failWhen", COMPLETE_WHEN_SYSTEM_ID = "engine.completeWhen";
+const ENGINE_ACTOR_ID_PREFIX = "engine.";
+function engineSystemActor(name) {
+  return { kind: "system", id: `${ENGINE_ACTOR_ID_PREFIX}${name}` };
+}
+function isEngineActor(actor) {
+  return actor.kind === "system" && actor.id.startsWith(ENGINE_ACTOR_ID_PREFIX);
+}
+const MAX_SPAWN_DEPTH = 6, SUBWORKFLOWS_ALL_DONE = "count($subworkflows[status != 'done']) == 0";
 function gateActor(outcome) {
-  return {
-    kind: "system",
-    id: outcome === "failed" ? FAIL_WHEN_SYSTEM_ID : COMPLETE_WHEN_SYSTEM_ID
-  };
+  return engineSystemActor(outcome === "failed" ? "failWhen" : "completeWhen");
 }
 function effectiveCompleteWhen(task) {
   return task.completeWhen ?? (task.subworkflows !== void 0 ? SUBWORKFLOWS_ALL_DONE : void 0);
@@ -1688,7 +1692,7 @@ async function spawnSubworkflows(ctx, mutation, task, sub, actor) {
     ...actor ? { actor } : {}
   }), { rows, discoveryResource } = await resolveSpawnRows(ctx, sub), effectsContext = await resolveContextHandoff(ctx, sub, parentScope), refs = [];
   for (const row of rows) {
-    const initialState = await projectRowState(
+    const initialFields = await projectRowFields(
       ctx,
       sub,
       definition,
@@ -1699,7 +1703,7 @@ async function spawnSubworkflows(ctx, mutation, task, sub, actor) {
       client: ctx.client,
       parent: ctx.instance,
       definition,
-      initialState,
+      initialFields,
       effectsContext,
       actor,
       now
@@ -1712,7 +1716,7 @@ async function resolveSpawnRows(ctx, sub) {
   const params = buildParams({ instance: ctx.instance, now: ctx.now, snapshot: ctx.snapshot }), groq = sub.forEach;
   let value, discoveryResource;
   if (groq.includes("*")) {
-    const routingUri = entrySubjectRefs(ctx.instance.state)[0]?.id, client = clientForDiscovery(ctx.client, ctx.clientForGdr, routingUri);
+    const routingUri = entrySubjectRefs(ctx.instance.fields)[0]?.id, client = clientForDiscovery(ctx.client, ctx.clientForGdr, routingUri);
     client !== ctx.client && routingUri !== void 0 && (discoveryResource = resourceFromGdrUri(routingUri)), value = await discoverItems({
       client,
       groq,
@@ -1728,13 +1732,13 @@ async function resolveSpawnRows(ctx, sub) {
   }
   return Array.isArray(value) ? { rows: value, discoveryResource } : value == null ? { rows: [], discoveryResource } : { rows: [value], discoveryResource };
 }
-async function projectRowState(ctx, sub, childDefinition, parentScope, row, discoveryResource) {
+async function projectRowFields(ctx, sub, childDefinition, parentScope, row, discoveryResource) {
   const out = [];
   for (const [name, groq] of Object.entries(sub.with ?? {})) {
-    const declared = (childDefinition.state ?? []).find((e) => e.name === name);
+    const declared = (childDefinition.fields ?? []).find((e) => e.name === name);
     if (declared === void 0)
       throw new Error(
-        `subworkflows.with["${name}"]: subworkflow "${childDefinition.name}" declares no state entry "${name}"`
+        `subworkflows.with["${name}"]: subworkflow "${childDefinition.name}" declares no field entry "${name}"`
       );
     const raw = await runGroq(groq, { ...parentScope, row }, ctx.snapshot), value = canonicaliseSpawnValue(declared.type, raw, {
       parentResource: ctx.instance.workflowResource,
@@ -1789,15 +1793,15 @@ async function resolveDefinitionRef(client, ref, tag) {
   ) ?? null;
 }
 async function prepareChildInstance(args) {
-  const { client, parent, definition, initialState, effectsContext, actor, now } = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = `${childTag}.wf-instance.${randomKey()}`, childRef = { id: gdrFromResource(workflowResource, childDocId), type: WORKFLOW_INSTANCE_TYPE }, ancestors = [
+  const { client, parent, definition, initialFields, effectsContext, actor, now } = args, childTag = parent.tag, workflowResource = parent.workflowResource, childDocId = `${childTag}.wf-instance.${randomKey()}`, childRef = { id: gdrFromResource(workflowResource, childDocId), type: WORKFLOW_INSTANCE_TYPE }, ancestors = [
     ...parent.ancestors,
     {
       id: selfGdr(parent),
       type: WORKFLOW_INSTANCE_TYPE
     }
-  ], inheritedPerspective = parent.perspective, childState = await resolveDeclaredState({
-    entryDefs: definition.state,
-    initialState,
+  ], inheritedPerspective = parent.perspective, childFields = await resolveDeclaredFields({
+    entryDefs: definition.fields,
+    initialFields,
     ctx: {
       client,
       now,
@@ -1808,7 +1812,7 @@ async function prepareChildInstance(args) {
       ...inheritedPerspective !== void 0 ? { perspective: inheritedPerspective } : {}
     },
     randomKey
-  }), childPerspective = derivePerspectiveFromState(childState) ?? inheritedPerspective, effectsContextEntries = Object.entries(effectsContext).map(
+  }), childPerspective = derivePerspectiveFromFields(childFields) ?? inheritedPerspective, effectsContextEntries = Object.entries(effectsContext).map(
     ([key, value]) => {
       if (typeof value == "object" && value !== null && "id" in value && "type" in value) {
         if (!isGdrUri(value.id))
@@ -1827,7 +1831,7 @@ async function prepareChildInstance(args) {
     definitionName: definition.name,
     pinnedVersion: definition.version,
     definition,
-    state: childState,
+    fields: childFields,
     effectsContext: effectsContextEntries,
     ancestors,
     perspective: childPerspective,
@@ -1992,15 +1996,15 @@ function resolveStaticSource(src, ctx) {
       return { handled: !1 };
   }
 }
-const STATE_OP_TYPES = [
-  "state.set",
-  "state.unset",
-  "state.append",
-  "state.updateWhere",
-  "state.removeWhere"
+const FIELD_OP_TYPES = [
+  "field.set",
+  "field.unset",
+  "field.append",
+  "field.updateWhere",
+  "field.removeWhere"
 ];
-function isStateOp(summary) {
-  return STATE_OP_TYPES.includes(summary.opType);
+function isFieldOp(summary) {
+  return FIELD_OP_TYPES.includes(summary.opType);
 }
 function validateActionParams(action, taskName, callerParams) {
   const declared = action.params ?? [], params = callerParams ?? {}, issues = [];
@@ -2073,23 +2077,23 @@ function opAppliedEntry(args) {
 }
 function applyOp(op, ctx) {
   switch (op.type) {
-    case "state.set":
-      return applyStateSet(op, ctx);
-    case "state.unset":
-      return applyStateUnset(op, ctx);
-    case "state.append":
-      return applyStateAppend(op, ctx);
-    case "state.updateWhere":
-      return applyStateUpdateWhere(op, ctx);
-    case "state.removeWhere":
-      return applyStateRemoveWhere(op, ctx);
+    case "field.set":
+      return applyFieldSet(op, ctx);
+    case "field.unset":
+      return applyFieldUnset(op, ctx);
+    case "field.append":
+      return applyFieldAppend(op, ctx);
+    case "field.updateWhere":
+      return applyFieldUpdateWhere(op, ctx);
+    case "field.removeWhere":
+      return applyFieldRemoveWhere(op, ctx);
     case "status.set":
       return applyStatusSet(op, ctx);
   }
 }
-function applyStateSet(op, ctx) {
+function applyFieldSet(op, ctx) {
   const value = resolveOpSource(op.value, ctx), entry = locateEntry(ctx, op.target);
-  return validateStateValue({ entryType: entry._type, entryName: entry.name, value }), setEntryValue(entry, value), { opType: op.type, target: op.target, resolved: { value } };
+  return validateFieldValue({ entryType: entry._type, entryName: entry.name, value }), setEntryValue(entry, value), { opType: op.type, target: op.target, resolved: { value } };
 }
 const EMPTY_BY_KIND = {
   "doc.refs": [],
@@ -2097,24 +2101,24 @@ const EMPTY_BY_KIND = {
   notes: [],
   assignees: []
 };
-function applyStateUnset(op, ctx) {
+function applyFieldUnset(op, ctx) {
   const entry = locateEntry(ctx, op.target);
   return setEntryValue(entry, EMPTY_BY_KIND[entry._type] ?? null), { opType: op.type, target: op.target };
 }
-function applyStateAppend(op, ctx) {
+function applyFieldAppend(op, ctx) {
   const item = resolveOpSource(op.value, ctx), entry = locateEntry(ctx, op.target);
-  validateStateAppendItem({ entryType: entry._type, entryName: entry.name, item });
+  validateFieldAppendItem({ entryType: entry._type, entryName: entry.name, item });
   const current = Array.isArray(entry.value) ? entry.value : [];
   return setEntryValue(entry, [...current, withRowKey(item)]), { opType: op.type, target: op.target, resolved: { item } };
 }
 function withRowKey(item) {
   return typeof item == "object" && item !== null && !Array.isArray(item) && !("_key" in item) ? { _key: randomKey(), ...item } : item;
 }
-function applyStateUpdateWhere(op, ctx) {
+function applyFieldUpdateWhere(op, ctx) {
   const entry = locateEntry(ctx, op.target), rows = requireArrayValue(entry, op), merge = resolveOpSource(op.value, ctx);
   if (merge === null || typeof merge != "object" || Array.isArray(merge))
     throw new Error(
-      `state.updateWhere value must resolve to an object of fields to merge (target "${op.target.state}")`
+      `field.updateWhere value must resolve to an object of fields to merge (target "${op.target.field}")`
     );
   return setEntryValue(
     entry,
@@ -2123,7 +2127,7 @@ function applyStateUpdateWhere(op, ctx) {
     )
   ), { opType: op.type, target: op.target, resolved: { merge } };
 }
-function applyStateRemoveWhere(op, ctx) {
+function applyFieldRemoveWhere(op, ctx) {
   const entry = locateEntry(ctx, op.target), rows = requireArrayValue(entry, op);
   return setEntryValue(
     entry,
@@ -2133,7 +2137,7 @@ function applyStateRemoveWhere(op, ctx) {
 function requireArrayValue(entry, op) {
   if (!Array.isArray(entry.value))
     throw new Error(
-      `${op.type} target ${op.target.scope}:"${op.target.state}" holds a non-array ${entry._type} value \u2014 where-ops operate on array entries`
+      `${op.type} target ${op.target.scope}:"${op.target.field}" holds a non-array ${entry._type} value \u2014 where-ops operate on array entries`
     );
   return entry.value;
 }
@@ -2154,19 +2158,19 @@ function setEntryValue(entry, value) {
   entry.value = value;
 }
 function locateEntry(ctx, target) {
-  const entry = stateHost(ctx, target.scope)?.find((s) => s.name === target.state);
+  const entry = fieldHost(ctx, target.scope)?.find((s) => s.name === target.field);
   if (entry === void 0)
     throw new Error(
-      `Op target ${target.scope}:"${target.state}" has no resolved state entry on this instance \u2014 the deployed definition and the instance state have diverged`
+      `Op target ${target.scope}:"${target.field}" has no resolved field entry on this instance \u2014 the deployed definition and the instance state have diverged`
     );
   return entry;
 }
-function stateHost(ctx, scope) {
-  if (scope === "workflow") return ctx.mutation.state;
+function fieldHost(ctx, scope) {
+  if (scope === "workflow") return ctx.mutation.fields;
   const stageEntry = findOpenStageEntry(ctx.mutation);
-  if (scope === "stage") return stageEntry?.state;
+  if (scope === "stage") return stageEntry?.fields;
   const task = stageEntry?.tasks.find((t) => t.name === ctx.taskName);
-  return task !== void 0 && task.state === void 0 && (task.state = []), task?.state;
+  return task !== void 0 && task.fields === void 0 && (task.fields = []), task?.fields;
 }
 function resolveOpSource(src, ctx) {
   const staticValue = resolveStaticSource(src, ctx);
@@ -2176,7 +2180,7 @@ function resolveOpSource(src, ctx) {
       return ctx.self;
     case "stage":
       return ctx.stage;
-    case "stateRead": {
+    case "fieldRead": {
       const value = readEntryFromMutation(ctx, src);
       return src.path !== void 0 ? getPath(value, src.path) : value;
     }
@@ -2187,7 +2191,7 @@ function resolveOpSource(src, ctx) {
       return out;
     }
     default:
-      throw new Error(`Source type "${src.type}" is a state-entry origin, not a value`);
+      throw new Error(`Source type "${src.type}" is a field-entry origin, not a value`);
   }
 }
 function entryValue(entries, name) {
@@ -2196,7 +2200,7 @@ function entryValue(entries, name) {
 function readEntryFromMutation(ctx, src) {
   const scopes = src.scope !== void 0 ? [src.scope] : ["stage", "workflow"], stageEntry = findOpenStageEntry(ctx.mutation);
   for (const scope of scopes) {
-    const host = scope === "workflow" ? ctx.mutation.state : stageEntry?.state, value = entryValue(host, src.state);
+    const host = scope === "workflow" ? ctx.mutation.fields : stageEntry?.fields, value = entryValue(host, src.field);
     if (value !== void 0) return value;
   }
 }
@@ -2228,9 +2232,9 @@ async function commitInvoke(ctx, taskName, actor) {
 }
 async function activateTask(ctx, mutation, task, entry, actor) {
   const now = ctx.now;
-  if (entry.status = "active", entry.startedAt = now, task.state !== void 0 && task.state.length > 0) {
+  if (entry.status = "active", entry.startedAt = now, task.fields !== void 0 && task.fields.length > 0) {
     const stage = findStage(ctx.definition, mutation.currentStage);
-    entry.state = await resolveTaskStateEntries({
+    entry.fields = await resolveTaskFieldEntries({
       client: ctx.client,
       instance: ctx.instance,
       stage,
@@ -2295,7 +2299,7 @@ function resolveMachineStep(mutation, task, entry, now) {
     stage: mutation.currentStage,
     to: "done",
     at: now,
-    actor: { kind: "system", id: "engine.machineStep" }
+    actor: engineSystemActor("machineStep")
   });
 }
 async function buildStageTasks(ctx, stage) {
@@ -2335,7 +2339,7 @@ async function enterStage(ctx, mutation, nextStage, actor, at) {
     _key: randomKey(),
     name: nextStage.name,
     enteredAt: at,
-    state: await resolveStageStateEntries({
+    fields: await resolveStageFieldEntries({
       client: ctx.client,
       instance: ctx.instance,
       stage: nextStage,
@@ -2475,7 +2479,7 @@ async function primeInitialStage(client, instanceId, actor, clientForGdr, clock)
     _key: randomKey(),
     name: stage.name,
     enteredAt: now,
-    state: await resolveStageStateEntries({ client, instance, stage, now }),
+    fields: await resolveStageFieldEntries({ client, instance, stage, now }),
     tasks: await buildStageTasks(ctx, stage)
   }, committed = await client.patch(instance._id).set({
     stages: [initialStageEntry],
@@ -2713,10 +2717,10 @@ function effectiveEditable(baseline, override) {
 }
 function slotSites(definition, stage) {
   const sites = [];
-  for (const entry of definition.state ?? []) sites.push({ scope: "workflow", entry });
-  for (const entry of stage.state ?? []) sites.push({ scope: "stage", entry });
+  for (const entry of definition.fields ?? []) sites.push({ scope: "workflow", entry });
+  for (const entry of stage.fields ?? []) sites.push({ scope: "stage", entry });
   for (const task of stage.tasks ?? [])
-    for (const entry of task.state ?? []) sites.push({ scope: "task", task: task.name, entry });
+    for (const entry of task.fields ?? []) sites.push({ scope: "task", task: task.name, entry });
   return sites;
 }
 function toResolvedSlot(site, stage) {
@@ -2726,7 +2730,7 @@ function toResolvedSlot(site, stage) {
     name: site.entry.name,
     type: site.entry.type,
     ...site.entry.title !== void 0 ? { title: site.entry.title } : {},
-    ref: { scope: site.scope, state: site.entry.name },
+    ref: { scope: site.scope, field: site.entry.name },
     effective: effectiveEditable(site.entry.editable, stage.editable?.[site.entry.name])
   };
 }
@@ -2734,7 +2738,7 @@ function editableSlotsInStage(definition, stage) {
   return slotSites(definition, stage).filter((site) => site.entry.editable !== void 0).map((site) => toResolvedSlot(site, stage));
 }
 function editTargetMatches(slot, target) {
-  return slot.name !== target.state ? !1 : target.task !== void 0 ? slot.scope === "task" && slot.task === target.task : target.scope !== void 0 ? slot.scope === target.scope : !0;
+  return slot.name !== target.field ? !1 : target.task !== void 0 ? slot.scope === "task" && slot.task === target.task : target.scope !== void 0 ? slot.scope === target.scope : !0;
 }
 const SCOPE_PRECEDENCE = { task: 0, stage: 1, workflow: 2 };
 function resolveEditTarget(args) {
@@ -2758,17 +2762,17 @@ function slotWindowOpen(instance, slot) {
   return status === "active" ? { open: !0 } : { open: !1, detail: `task "${slot.task}" is ${status ?? "not active"}` };
 }
 function readSlotValue(instance, slot) {
-  return slotStateHost(instance, slot)?.find((e) => e.name === slot.name)?.value;
+  return slotFieldHost(instance, slot)?.find((e) => e.name === slot.name)?.value;
 }
-function slotStateHost(instance, slot) {
-  if (slot.scope === "workflow") return instance.state;
+function slotFieldHost(instance, slot) {
+  if (slot.scope === "workflow") return instance.fields;
   const stageEntry = findOpenStageEntry(instance);
-  return slot.scope === "stage" ? stageEntry?.state : stageEntry?.tasks.find((t) => t.name === slot.task)?.state;
+  return slot.scope === "stage" ? stageEntry?.fields : stageEntry?.tasks.find((t) => t.name === slot.task)?.fields;
 }
 function slotProvenance(instance, ref) {
   let latest;
   for (const entry of instance.history)
-    entry._type === "opApplied" && (entry.target?.scope !== ref.scope || entry.target.state !== ref.state || (latest = { at: entry.at, ...entry.actor !== void 0 ? { actor: entry.actor } : {} }));
+    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
@@ -2783,6 +2787,18 @@ function editDisabledReason(args) {
   if (!predicateSatisfied)
     return { kind: "editor-not-permitted", predicate: effective === !0 ? "true" : effective };
 }
+function hasItems(arr) {
+  return arr !== void 0 && arr.length > 0;
+}
+function deriveTaskKind(task) {
+  return hasItems(task.actions) ? "user" : hasItems(task.effects) ? "service" : task.completeWhen !== void 0 || task.subworkflows !== void 0 ? "receive" : "script";
+}
+function taskKind(task) {
+  return task.kind ?? deriveTaskKind(task);
+}
+function driverKind(actor) {
+  return actor.kind === "user" ? "person" : actor.kind === "ai" ? "agent" : isEngineActor(actor) ? "engine" : "service";
+}
 async function evaluateInstance(args) {
   const { client, tag, instanceId, resourceClients } = args, now = (args.clock ?? wallClock)();
   validateTag(tag);
@@ -2926,9 +2942,9 @@ function taskScopeFor(args) {
   const { scope, instance, snapshot, actor, taskName, roleAliases } = args;
   return {
     ...scope,
-    state: {
-      ...scope.state,
-      ...scopedStateOverlay(instance, snapshot, taskName)
+    fields: {
+      ...scope.fields,
+      ...scopedFieldOverlay(instance, snapshot, taskName)
     },
     assigned: assignedFor(instance, taskName, actor, roleAliases)
   };
@@ -2972,10 +2988,11 @@ async function evaluateTask(args) {
   return {
     task,
     status,
+    kind: taskKind(task),
     // "pending on actor" treats both `pending` and `active` as waiting on
     // the assignee — pending tasks just haven't been activated yet, but
-    // they're still inbox items. The inbox reads the assignees-kind state
-    // entry BY KIND (who-data is state).
+    // they're still inbox items. The inbox reads the assignees-kind field
+    // entry BY KIND (who-data is fields).
     pendingOnActor: (status === "active" || status === "pending") && assigned,
     ...unmetRequirements.length > 0 ? { unmetRequirements } : {},
     actions
@@ -3226,7 +3243,7 @@ async function commitAction(ctx, taskName, actionName, callerParams, options) {
     stage: stage.name,
     task: taskName,
     action: actionName,
-    ...actor !== void 0 ? { actor } : {}
+    ...actor !== void 0 ? { actor, driverKind: driverKind(actor) } : {}
   });
   const statusBefore = mutEntry.status, ranOps = await runOps({
     ops: action.ops,
@@ -3244,7 +3261,7 @@ async function commitAction(ctx, taskName, actionName, callerParams, options) {
   }), await persistThenDeploy(
     ctx,
     mutation,
-    () => ranOps.some(isStateOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
+    () => ranOps.some(isFieldOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
   ), {
     fired: !0,
     task: taskName,
@@ -3273,11 +3290,11 @@ function formatDisabledReason(task, action, reason) {
   const detail = disabledReasonDetail[reason.kind](reason);
   return `Action "${task}:${action}" is not allowed: ${detail}`;
 }
-class EditStateDeniedError extends Error {
+class EditFieldDeniedError extends Error {
   reason;
   target;
   constructor(args) {
-    super(formatEditDisabledReason(args.target, args.reason)), this.name = "EditStateDeniedError", this.reason = args.reason, this.target = args.target;
+    super(formatEditDisabledReason(args.target, args.reason)), this.name = "EditFieldDeniedError", this.reason = args.reason, this.target = args.target;
   }
 }
 const editDisabledReasonDetail = {
@@ -3290,10 +3307,10 @@ const editDisabledReasonDetail = {
 function formatEditDisabledReason(target, reason) {
   const detail = editDisabledReasonDetail[reason.kind](
     reason
-  ), where = target.task !== void 0 ? `${target.task}.${target.state}` : target.state;
-  return `State "${target.scope}:${where}" is not editable: ${detail}`;
+  ), where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
+  return `Field "${target.scope}:${where}" is not editable: ${detail}`;
 }
-async function editState(args) {
+async function editField(args) {
   const { client, instanceId, target, mode = "set", value, options } = args;
   for (let attempt = 1; attempt <= CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS; attempt++) {
     const ctx = await loadCallContext(client, instanceId, options);
@@ -3303,7 +3320,7 @@ async function editState(args) {
       if (!isRevisionConflict(error)) throw error;
     }
   }
-  throw new ConcurrentEditStateError({
+  throw new ConcurrentEditFieldError({
     instanceId,
     target: labelTarget(target),
     attempts: CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS
@@ -3313,7 +3330,7 @@ async function commitEdit(ctx, target, mode, value, options) {
   const actor = options?.actor, stage = findStage(ctx.definition, ctx.instance.currentStage), slot = resolveEditTarget({ definition: ctx.definition, stage, target });
   if (slot === void 0)
     throw new Error(
-      `No state slot "${describeTarget(target)}" resolves in current stage "${stage.name}" of ${ctx.definition.name}`
+      `No field slot "${describeTarget(target)}" resolves in current stage "${stage.name}" of ${ctx.definition.name}`
     );
   await assertSlotEditable(ctx, slot, options);
   const op = buildEditOp(slot, mode, value), mutation = startMutation(ctx.instance), ranOps = runOps({
@@ -3332,7 +3349,7 @@ async function commitEdit(ctx, target, mode, value, options) {
   return await persistThenDeploy(
     ctx,
     mutation,
-    () => ranOps.some(isStateOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
+    () => ranOps.some(isFieldOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
   ), {
     edited: !0,
     target: slotTarget(slot),
@@ -3351,14 +3368,14 @@ async function assertSlotEditable(ctx, slot, options) {
     guardDenial: void 0,
     predicateSatisfied
   });
-  if (reason !== void 0) throw new EditStateDeniedError({ target: slotTarget(slot), reason });
+  if (reason !== void 0) throw new EditFieldDeniedError({ target: slotTarget(slot), reason });
 }
 function buildEditOp(slot, mode, value) {
-  if (mode === "unset") return { type: "state.unset", target: slot.ref };
+  if (mode === "unset") return { type: "field.unset", target: slot.ref };
   if (value === void 0)
-    throw new Error(`editState mode "${mode}" requires a value for slot "${slot.name}"`);
+    throw new Error(`editField mode "${mode}" requires a value for slot "${slot.name}"`);
   return {
-    type: mode === "append" ? "state.append" : "state.set",
+    type: mode === "append" ? "field.append" : "field.set",
     target: slot.ref,
     value: { type: "literal", value }
   };
@@ -3366,19 +3383,19 @@ function buildEditOp(slot, mode, value) {
 function slotTarget(slot) {
   return {
     scope: slot.scope,
-    state: slot.name,
+    field: slot.name,
     ...slot.task !== void 0 ? { task: slot.task } : {}
   };
 }
 function labelTarget(target) {
   return {
     scope: target.scope ?? (target.task !== void 0 ? "task" : "workflow"),
-    state: target.state,
+    field: target.field,
     ...target.task !== void 0 ? { task: target.task } : {}
   };
 }
 function describeTarget(target) {
-  const where = target.task !== void 0 ? `${target.task}.${target.state}` : target.state;
+  const where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
   return target.scope !== void 0 ? `${target.scope}:${where}` : where;
 }
 function bareIdFromSpawnRef(uri) {
@@ -3451,10 +3468,10 @@ function assertActionAllowed(evaluation, task, action) {
 function assertEditAllowed(evaluation, target) {
   const slot = evaluation.editableSlots.filter((s) => editTargetMatches(s, target)).sort((a, b) => SCOPE_PRECEDENCE[a.scope] - SCOPE_PRECEDENCE[b.scope])[0];
   if (slot !== void 0 && !slot.editable && slot.disabledReason !== void 0)
-    throw new EditStateDeniedError({
+    throw new EditFieldDeniedError({
       target: {
         scope: slot.scope,
-        state: slot.name,
+        field: slot.name,
         ...slot.task !== void 0 ? { task: slot.task } : {}
       },
       reason: slot.disabledReason
@@ -3462,7 +3479,7 @@ function assertEditAllowed(evaluation, target) {
 }
 async function applyEdit(args) {
   const { client, instance, target, mode, value, actor, grants, clock, clientForGdr } = args;
-  return (await editState({
+  return (await editField({
     client,
     instanceId: instance._id,
     target,
@@ -3635,7 +3652,7 @@ const workflow = {
       workflowResource,
       definition: definitionName,
       version,
-      initialState,
+      initialFields,
       ancestors,
       effectsContext,
       instanceId,
@@ -3645,9 +3662,9 @@ const workflow = {
       throw new Error(
         `Initial stage "${definition.initialStage}" missing in ${definitionName} v${definition.version}`
       );
-    const now = clock(), effectsContextEntries = effectsContext ? toEffectsContextEntries(effectsContext) : [], resolvedState = await resolveDeclaredState({
-      entryDefs: definition.state ?? [],
-      initialState: initialState ?? [],
+    const now = clock(), effectsContextEntries = effectsContext ? toEffectsContextEntries(effectsContext) : [], resolvedFields = await resolveDeclaredFields({
+      entryDefs: definition.fields ?? [],
+      initialFields: initialFields ?? [],
       ctx: {
         client,
         now,
@@ -3658,7 +3675,7 @@ const workflow = {
         ...perspective !== void 0 ? { perspective } : {}
       },
       randomKey
-    }), effectivePerspective = perspective ?? derivePerspectiveFromState(resolvedState), base = buildInstanceBase({
+    }), effectivePerspective = perspective ?? derivePerspectiveFromFields(resolvedFields), base = buildInstanceBase({
       id,
       now,
       tag,
@@ -3666,7 +3683,7 @@ const workflow = {
       definitionName: definition.name,
       pinnedVersion: definition.version,
       definition,
-      state: resolvedState,
+      fields: resolvedFields,
       effectsContext: effectsContextEntries,
       ancestors: ancestors ?? [],
       perspective: effectivePerspective,
@@ -3720,11 +3737,11 @@ const workflow = {
     });
   },
   /**
-   * Edit a declared-editable state slot directly — reassign, reschedule,
+   * Edit a declared-editable field slot directly — reassign, reschedule,
    * claim-by-hand, append to a running log — through the generic edit seam,
    * instead of a bespoke action per field. Soft-gates on the slot's declared
    * editability (the same projection a UI renders), applies the edit as a
-   * `state.*` op (so provenance + history are stamped by the op path),
+   * `field.*` op (so provenance + history are stamped by the op path),
    * refreshes the stage's guards, then cascades — an edit to a value a
    * transition reads can and should move the instance. Advisory like every
    * engine gate; the lake ACL + guards are the only hard locks.
@@ -3734,7 +3751,7 @@ const workflow = {
    * UI must bind it to a deliberate boundary (blur / Enter / Save / debounce),
    * never an `onChange` per keystroke.
    */
-  editState: async (args) => {
+  editField: async (args) => {
     const { client, tag, instanceId, target, mode, value, resourceClients } = args, { access, actor, clientForGdr } = await resolveOperationContext(args), clock = args.clock ?? wallClock, before = await reload(client, instanceId, tag);
     return dispatchGatedWrite({
       client,
@@ -3899,7 +3916,7 @@ const workflow = {
    * Hydrates the instance's snapshot (instance + ancestors + every doc
    * declared by a `doc.ref` / `doc.refs` entry in scope), then
    * evaluates the supplied GROQ in groq-js against that dataset. The
-   * rendered scope is auto-bound: `$self`, `$state`, `$parent`,
+   * rendered scope is auto-bound: `$self`, `$fields`, `$parent`,
    * `$ancestors`, `$stage`, `$now`, `$effects`, `$tasks`,
    * `$allTasksDone`, `$anyTaskFailed` — ids in GDR URI form to match
    * the snapshot's keying.
@@ -4054,7 +4071,7 @@ async function drainEffectsInternal(args) {
     effectHandlers,
     missingHandler,
     logger
-  } = args, drainerActor = args.access?.actor ?? { kind: "system", id: "engine.drainEffects" }, completionAccess = {
+  } = args, drainerActor = args.access?.actor ?? engineSystemActor("drainEffects"), completionAccess = {
     actor: drainerActor,
     ...args.access?.grants !== void 0 ? { grants: args.access.grants } : {}
   };
@@ -4232,7 +4249,7 @@ function createInstanceSession(args) {
         return settleAfterApply(actor, held, ranOps);
       });
     },
-    editState({ target, mode, value }) {
+    editField({ target, mode, value }) {
       return commit(async (actor, held) => {
         assertEditAllowed(await evaluateWith(held, heldGuards), target);
         const { grants } = await access(), ranOps = await applyEdit({
@@ -4294,7 +4311,7 @@ function createEngine(args) {
     deployDefinitions: (rest) => workflow.deployDefinitions(bind(rest)),
     startInstance: (rest) => workflow.startInstance(bind(rest)),
     fireAction: (rest) => workflow.fireAction(bind(rest)),
-    editState: (rest) => workflow.editState(bind(rest)),
+    editField: (rest) => workflow.editField(bind(rest)),
     completeEffect: (rest) => workflow.completeEffect(bind(rest)),
     tick: (rest) => workflow.tick(bind(rest)),
     evaluateInstance: (rest) => evaluateInstance(bind(rest)),
@@ -4453,9 +4470,9 @@ const HISTORY_DISPLAY = {
   },
   opApplied: {
     title: "Op applied",
-    description: "An inline state-mutation op (state.set / state.append / status.set / etc.) ran during an action commit."
+    description: "An inline field-mutation op (field.set / field.append / status.set / etc.) ran during an action commit."
   }
-}, STATE_SLOT_DISPLAY = {
+}, FIELD_SLOT_DISPLAY = {
   "doc.ref": {
     title: "Document reference",
     description: "Single GDR pointer at a document in this or another resource."
@@ -4509,23 +4526,23 @@ const HISTORY_DISPLAY = {
     description: "Ordered list of typed (user|role) assignees."
   }
 }, OP_DISPLAY = {
-  "state.set": {
-    title: "Set state entry",
-    description: "Overwrite a state entry's value with a resolved Source."
+  "field.set": {
+    title: "Set field entry",
+    description: "Overwrite a field entry's value with a resolved Source."
   },
-  "state.unset": {
-    title: "Unset state entry",
-    description: "Reset a state entry to its default (null for scalars, [] for array kinds)."
+  "field.unset": {
+    title: "Unset field entry",
+    description: "Reset a field entry to its default (null for scalars, [] for array kinds)."
   },
-  "state.append": {
-    title: "Append to state entry",
+  "field.append": {
+    title: "Append to field entry",
     description: "Push a resolved item onto an array-kind entry (notes, checklist, assignees, refs)."
   },
-  "state.updateWhere": {
+  "field.updateWhere": {
     title: "Update matching rows",
     description: "Merge fields into rows of an array-kind entry that match the predicate."
   },
-  "state.removeWhere": {
+  "field.removeWhere": {
     title: "Remove matching rows",
     description: "Drop rows of an array-kind entry that match the predicate."
   },
@@ -4569,11 +4586,40 @@ const HISTORY_DISPLAY = {
   },
   [WORKFLOW_INSTANCE_TYPE]: {
     title: "Workflow instance",
-    description: "A running (or finished) workflow against its declared state."
+    description: "A running (or finished) workflow against its declared fields."
+  }
+}, TASK_KIND_DISPLAY = {
+  user: {
+    title: "User task",
+    description: "A person acts via the app \u2014 renders action buttons ranked by outcome."
+  },
+  service: {
+    title: "Service task",
+    description: "An automated system or effect does the work \u2014 renders effect drain status."
+  },
+  script: {
+    title: "Script task",
+    description: "The engine runs a step inline and resolves on activation \u2014 an audit row."
+  },
+  manual: {
+    title: "Manual task",
+    description: "Work done off-system, acknowledged by a person or verified by a predicate \u2014 renders an instruction card with a deep-link."
+  },
+  receive: {
+    title: "Receive task",
+    description: 'No actor; the engine waits on a condition \u2014 renders "waiting until \u2026", no buttons.'
+  }
+}, DRIVER_KIND_DISPLAY = {
+  person: { title: "Person", description: "A human fired this action." },
+  agent: { title: "Agent", description: "An AI agent fired this action." },
+  service: { title: "Service", description: "An external system or Function fired this action." },
+  engine: {
+    title: "Engine",
+    description: "The workflow engine itself drove this \u2014 a gate, machine step, or housekeeping."
   }
 }, DISPLAY = {
   ...HISTORY_DISPLAY,
-  ...STATE_SLOT_DISPLAY,
+  ...FIELD_SLOT_DISPLAY,
   ...OP_DISPLAY,
   ...EFFECTS_CONTEXT_DISPLAY,
   ...AUTHORING_DISPLAY
@@ -4590,12 +4636,15 @@ export {
   ActionDisabledError,
   ActionParamsInvalidError,
   CascadeLimitError,
-  ConcurrentEditStateError,
+  ConcurrentEditFieldError,
   ConcurrentFireActionError,
   DEFAULT_CONTENT_PERSPECTIVE,
   DISPLAY,
+  DRIVER_KINDS,
+  DRIVER_KIND_DISPLAY,
   EFFECTS_CONTEXT_DISPLAY,
-  EditStateDeniedError,
+  EditFieldDeniedError,
+  FIELD_SLOT_DISPLAY,
   GUARD_DOC_TYPE,
   GUARD_LIFTED_PREDICATE,
   GUARD_OWNER,
@@ -4603,8 +4652,9 @@ export {
   MutationGuardDeniedError,
   OP_DISPLAY,
   PartialGuardDeployError,
-  RequiredStateNotProvidedError,
-  STATE_SLOT_DISPLAY,
+  RequiredFieldNotProvidedError,
+  TASK_KINDS,
+  TASK_KIND_DISPLAY,
   WORKFLOW_DEFINITION_TYPE,
   WORKFLOW_INSTANCE_TYPE,
   WorkflowStateDivergedError,
@@ -4620,11 +4670,13 @@ export {
   defaultLoggerFactory,
   denyingGuards,
   deployStageGuards,
+  deriveTaskKind,
   diagnoseInputFromEvaluation,
   diagnoseInstance,
   diffEntry,
   displayDescription,
   displayTitle,
+  driverKind,
   effectsContextMap,
   evaluateFromSnapshot,
   evaluateMutationGuard,
@@ -4657,6 +4709,7 @@ export {
   subscriptionDocument,
   subscriptionDocumentsForInstance,
   tagScopeFilter,
+  taskKind,
   validateDefinition,
   validateTag,
   verdictGuardsForInstance,