@sanity/workflow-engine 0.8.0 → 0.10.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { parse, evaluate } from "groq-js";
-import { isTerminalTaskStatus, WORKFLOW_DEFINITION_TYPE, DOCUMENT_VALUE_PERMISSIONS } from "./_chunks-es/schema.js";
+import { actorFulfillsRole, isTerminalTaskStatus, WORKFLOW_DEFINITION_TYPE, andConditions, DOCUMENT_VALUE_PERMISSIONS } from "./_chunks-es/schema.js";
 import { isStartableDefinition } from "./_chunks-es/schema.js";
 import * as v from "valibot";
 function findOpenStageEntry(host) {
@@ -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,17 +134,17 @@ 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) {
+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 : (actor.roles ?? []).includes(a.role)
+    (a) => a.type === "user" ? a.id === actor.id : actorFulfillsRole(actor.roles, a.role, roleAliases)
   );
 }
 function effectsContextMap(instance) {
@@ -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,6 +663,17 @@ function isRevisionConflict(error) {
   const { statusCode, message } = error;
   return statusCode === 409 ? !0 : typeof message == "string" && message.includes("ifRevisionId check failed");
 }
+class ConcurrentEditFieldError extends Error {
+  instanceId;
+  target;
+  attempts;
+  constructor(args) {
+    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 = "ConcurrentEditFieldError", this.instanceId = args.instanceId, this.target = args.target, this.attempts = args.attempts;
+  }
+}
 class CascadeLimitError extends Error {
   instanceId;
   limit;
@@ -708,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) {
@@ -735,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"
   ) : [];
 }
@@ -795,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) {
@@ -814,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,
@@ -847,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) {
@@ -1006,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({
@@ -1081,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),
@@ -1122,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) {
@@ -1132,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
     });
@@ -1163,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,
@@ -1190,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 } : {};
@@ -1213,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) {
@@ -1282,6 +1293,12 @@ function coerceToGdr(raw, workflowResource) {
 function gdrToBareId(uri) {
   return uri.includes(":") ? extractDocumentId(uri) : uri;
 }
+function loadCallContext(client, instanceId, options) {
+  return loadContext(client, instanceId, {
+    ...options?.clock ? { clock: options.clock } : {},
+    ...options?.clientForGdr ? { clientForGdr: options.clientForGdr } : {}
+  });
+}
 async function loadContext(client, instanceId, options) {
   const instance = await client.getDocument(instanceId);
   if (!instance)
@@ -1295,14 +1312,14 @@ 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) : !1,
+    assigned: opts?.taskName !== void 0 ? assignedFor(ctx.instance, opts.taskName, opts?.actor, ctx.definition.roleAliases) : !1,
     ...opts?.vars
   };
   return { ...await evaluatePredicates({
@@ -1339,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,
@@ -1351,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,
@@ -1372,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
@@ -1454,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],
@@ -1478,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,
@@ -1491,7 +1508,7 @@ function materializeInstance(base, mutation) {
   return {
     ...base,
     currentStage: mutation.currentStage,
-    state: mutation.state,
+    fields: mutation.fields,
     stages: mutation.stages,
     effectsContext: mutation.effectsContext
   };
@@ -1613,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 } : {},
@@ -1671,7 +1688,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,
@@ -1682,7 +1699,7 @@ async function spawnSubworkflows(ctx, mutation, task, sub, actor) {
       client: ctx.client,
       parent: ctx.instance,
       definition,
-      initialState,
+      initialFields,
       effectsContext,
       actor,
       now
@@ -1695,7 +1712,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,
@@ -1711,13 +1728,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,
@@ -1772,15 +1789,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,
@@ -1791,7 +1808,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))
@@ -1810,7 +1827,7 @@ async function prepareChildInstance(args) {
     definitionName: definition.name,
     pinnedVersion: definition.version,
     definition,
-    state: childState,
+    fields: childFields,
     effectsContext: effectsContextEntries,
     ancestors,
     perspective: childPerspective,
@@ -1975,15 +1992,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 = [];
@@ -2033,41 +2050,46 @@ function runOps(args) {
   const summaries = [];
   for (const op of ops) {
     const summary = applyOp(op, { mutation, stage, taskName: origin.task, params, actor, self, now });
-    summaries.push(summary), mutation.history.push({
-      _key: randomKey(),
-      _type: "opApplied",
-      at: now,
-      stage,
-      ...origin.task !== void 0 ? { task: origin.task } : {},
-      ...origin.action !== void 0 ? { action: origin.action } : {},
-      ...origin.transition !== void 0 ? { transition: origin.transition } : {},
-      opType: summary.opType,
-      ...summary.target !== void 0 ? { target: summary.target } : {},
-      ...summary.resolved !== void 0 ? { resolved: summary.resolved } : {},
-      ...actor !== void 0 ? { actor } : {}
-    });
+    summaries.push(summary), mutation.history.push(opAppliedEntry({ origin, summary, stage, actor, now }));
   }
   return summaries;
 }
+function opAppliedEntry(args) {
+  const { origin, summary, stage, actor, now } = args;
+  return {
+    _key: randomKey(),
+    _type: "opApplied",
+    at: now,
+    stage,
+    ...origin.task !== void 0 ? { task: origin.task } : {},
+    ...origin.action !== void 0 ? { action: origin.action } : {},
+    ...origin.transition !== void 0 ? { transition: origin.transition } : {},
+    ...origin.edit === !0 ? { edit: !0 } : {},
+    opType: summary.opType,
+    ...summary.target !== void 0 ? { target: summary.target } : {},
+    ...summary.resolved !== void 0 ? { resolved: summary.resolved } : {},
+    ...actor !== void 0 ? { actor } : {}
+  };
+}
 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": [],
@@ -2075,24 +2097,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,
@@ -2101,7 +2123,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,
@@ -2111,7 +2133,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;
 }
@@ -2132,19 +2154,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);
@@ -2154,7 +2176,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;
     }
@@ -2165,7 +2187,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) {
@@ -2174,7 +2196,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;
   }
 }
@@ -2206,9 +2228,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,
@@ -2313,7 +2335,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,
@@ -2453,7 +2475,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],
@@ -2682,6 +2704,85 @@ async function fetchGrantsCached(requestFn, resourcePath) {
     return;
   }
 }
+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;
+}
+function slotSites(definition, stage) {
+  const sites = [];
+  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.fields ?? []) sites.push({ scope: "task", task: task.name, entry });
+  return sites;
+}
+function toResolvedSlot(site, stage) {
+  return {
+    scope: site.scope,
+    ...site.task !== void 0 ? { task: site.task } : {},
+    name: site.entry.name,
+    type: site.entry.type,
+    ...site.entry.title !== void 0 ? { title: site.entry.title } : {},
+    ref: { scope: site.scope, field: site.entry.name },
+    effective: effectiveEditable(site.entry.editable, stage.editable?.[site.entry.name])
+  };
+}
+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.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) {
+  const { definition, stage, target } = args, found = slotSites(definition, stage).filter(
+    (site) => editTargetMatches(
+      {
+        scope: site.scope,
+        name: site.entry.name,
+        ...site.task !== void 0 ? { task: site.task } : {}
+      },
+      target
+    )
+  ).sort((a, b) => SCOPE_PRECEDENCE[a.scope] - SCOPE_PRECEDENCE[b.scope])[0];
+  return found ? toResolvedSlot(found, stage) : void 0;
+}
+function slotWindowOpen(instance, slot) {
+  if (instance.completedAt !== void 0) return { open: !1, detail: "instance completed" };
+  if (instance.abortedAt !== void 0) return { open: !1, detail: "instance aborted" };
+  if (slot.scope !== "task") return { open: !0 };
+  const status = findOpenStageEntry(instance)?.tasks.find((t) => t.name === slot.task)?.status;
+  return status === "active" ? { open: !0 } : { open: !1, detail: `task "${slot.task}" is ${status ?? "not active"}` };
+}
+function readSlotValue(instance, slot) {
+  return slotFieldHost(instance, slot)?.find((e) => e.name === slot.name)?.value;
+}
+function slotFieldHost(instance, slot) {
+  if (slot.scope === "workflow") return instance.fields;
+  const stageEntry = findOpenStageEntry(instance);
+  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.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, instance, window, guardDenial, predicateSatisfied } = args;
+  if (effective === void 0) return { kind: "not-editable" };
+  if (!window.open)
+    return instance.completedAt !== void 0 ? { kind: "instance-completed", completedAt: instance.completedAt } : { 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 };
+}
 async function evaluateInstance(args) {
   const { client, tag, instanceId, resourceClients } = args, now = (args.clock ?? wallClock)();
   validateTag(tag);
@@ -2715,6 +2816,7 @@ async function evaluateFromSnapshot(args) {
         actor,
         snapshot,
         scope,
+        roleAliases: definition.roleAliases,
         stageHasExits: !isTerminalStage(stage),
         guardDenial
       })
@@ -2736,16 +2838,65 @@ async function evaluateFromSnapshot(args) {
     stage,
     tasks: taskEvaluations,
     transitions: transitionEvaluations
-  }, pendingOnYou = taskEvaluations.filter((t) => t.pendingOnActor), canInteract = taskEvaluations.some((t) => t.actions.some((a) => a.allowed));
+  }, pendingOnYou = taskEvaluations.filter((t) => t.pendingOnActor), canInteract = taskEvaluations.some((t) => t.actions.some((a) => a.allowed)), editGuardDenial = guardDenial?.kind === "mutation-guard-denied" ? guardDenial : void 0, editableSlots = await evaluateEditableSlots({
+    instance,
+    definition,
+    stage,
+    actor,
+    snapshot,
+    scope,
+    guardDenial: editGuardDenial
+  });
   return {
     instance,
     definition,
     actor,
     currentStage,
     pendingOnYou,
-    canInteract
+    canInteract,
+    editableSlots
   };
 }
+async function evaluateEditableSlots(args) {
+  const { instance, definition, stage, actor, snapshot, scope, guardDenial } = args, slots = [];
+  for (const slot of editableSlotsInStage(definition, stage)) {
+    const window = slotWindowOpen(instance, slot), predicateSatisfied = await editPredicateSatisfied({
+      slot,
+      window,
+      guardDenial,
+      instance,
+      snapshot,
+      scope,
+      actor,
+      roleAliases: definition.roleAliases
+    }), reason = editDisabledReason({
+      effective: slot.effective,
+      instance,
+      window,
+      guardDenial,
+      predicateSatisfied
+    }), value = readSlotValue(instance, slot);
+    slots.push({
+      scope: slot.scope,
+      ...slot.task !== void 0 ? { task: slot.task } : {},
+      name: slot.name,
+      type: slot.type,
+      ...slot.title !== void 0 ? { title: slot.title } : {},
+      value,
+      editable: reason === void 0,
+      ...reason !== void 0 ? { disabledReason: reason } : {},
+      ...slotProvenance(instance, slot.ref)
+    });
+  }
+  return slots;
+}
+async function editPredicateSatisfied(args) {
+  const { slot, window, guardDenial, instance, snapshot, scope, actor, roleAliases } = args;
+  if (!window.open || guardDenial !== void 0) return !1;
+  if (slot.effective === !0) return !0;
+  const params = slot.scope === "task" && slot.task !== void 0 ? taskScopeFor({ scope, instance, snapshot, actor, taskName: slot.task, roleAliases }) : scope;
+  return evaluateCondition({ condition: slot.effective, snapshot, params });
+}
 async function renderScope(args) {
   const { instance, definition, actor, grants, snapshot, now } = args, params = {
     ...buildParams({ instance, now, snapshot }),
@@ -2771,15 +2922,36 @@ async function advisoryCan(instance, actor, grants) {
     });
   return can;
 }
-async function evaluateTask(args) {
-  const { task, statusEntry, instance, actor, snapshot, scope, stageHasExits, guardDenial } = args, status = statusEntry?.status ?? "pending", assigned = assignedFor(instance, task.name, actor), taskScope = {
+function taskScopeFor(args) {
+  const { scope, instance, snapshot, actor, taskName, roleAliases } = args;
+  return {
     ...scope,
-    state: {
-      ...scope.state,
-      ...scopedStateOverlay(instance, snapshot, task.name)
+    fields: {
+      ...scope.fields,
+      ...scopedFieldOverlay(instance, snapshot, taskName)
     },
-    assigned
-  }, unmetRequirements = await evaluateRequirements({
+    assigned: assignedFor(instance, taskName, actor, roleAliases)
+  };
+}
+async function evaluateTask(args) {
+  const {
+    task,
+    statusEntry,
+    instance,
+    actor,
+    snapshot,
+    scope,
+    roleAliases,
+    stageHasExits,
+    guardDenial
+  } = args, status = statusEntry?.status ?? "pending", taskScope = taskScopeFor({
+    scope,
+    instance,
+    snapshot,
+    actor,
+    taskName: task.name,
+    roleAliases
+  }), assigned = taskScope.assigned === !0, unmetRequirements = await evaluateRequirements({
     requirements: task.requirements,
     snapshot,
     params: taskScope
@@ -2802,8 +2974,8 @@ async function evaluateTask(args) {
     status,
     // "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
@@ -3006,10 +3178,7 @@ async function commitAbort(ctx, reason, actor) {
 async function fireAction(args) {
   const { client, instanceId, task, action, params, options } = args;
   for (let attempt = 1; attempt <= CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS; attempt++) {
-    const ctx = await loadContext(client, instanceId, {
-      ...options?.clock ? { clock: options.clock } : {},
-      ...options?.clientForGdr ? { clientForGdr: options.clientForGdr } : {}
-    });
+    const ctx = await loadCallContext(client, instanceId, options);
     try {
       return await commitAction(ctx, task, action, params, options);
     } catch (error) {
@@ -3075,7 +3244,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,
@@ -3104,6 +3273,114 @@ function formatDisabledReason(task, action, reason) {
   const detail = disabledReasonDetail[reason.kind](reason);
   return `Action "${task}:${action}" is not allowed: ${detail}`;
 }
+class EditFieldDeniedError extends Error {
+  reason;
+  target;
+  constructor(args) {
+    super(formatEditDisabledReason(args.target, args.reason)), this.name = "EditFieldDeniedError", this.reason = args.reason, this.target = args.target;
+  }
+}
+const editDisabledReasonDetail = {
+  "not-editable": () => "slot is not declared editable",
+  "instance-completed": (r) => `instance completed at ${r.completedAt}`,
+  "edit-window-closed": (r) => `edit window closed (${r.detail})`,
+  "editor-not-permitted": (r) => `editor not permitted (${r.predicate})`,
+  "mutation-guard-denied": (r) => `blocked by mutation guard(s) [${r.guardIds.join(", ")}]${r.detail ? ` (${r.detail})` : ""}`
+};
+function formatEditDisabledReason(target, reason) {
+  const detail = editDisabledReasonDetail[reason.kind](
+    reason
+  ), where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
+  return `Field "${target.scope}:${where}" is not editable: ${detail}`;
+}
+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);
+    try {
+      return await commitEdit(ctx, target, mode, value, options);
+    } catch (error) {
+      if (!isRevisionConflict(error)) throw error;
+    }
+  }
+  throw new ConcurrentEditFieldError({
+    instanceId,
+    target: labelTarget(target),
+    attempts: CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS
+  });
+}
+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 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({
+    ops: [op],
+    mutation,
+    stage: stage.name,
+    origin: {
+      edit: !0,
+      ...slot.scope === "task" && slot.task !== void 0 ? { task: slot.task } : {}
+    },
+    params: {},
+    actor,
+    self: selfGdr(ctx.instance),
+    now: ctx.now
+  });
+  return await persistThenDeploy(
+    ctx,
+    mutation,
+    () => ranOps.some(isFieldOp) ? refreshStageGuards(ctx, mutation, stage.name) : Promise.resolve()
+  ), {
+    edited: !0,
+    target: slotTarget(slot),
+    ...ranOps.length > 0 ? { ranOps } : {}
+  };
+}
+async function assertSlotEditable(ctx, slot, options) {
+  const actor = options?.actor, window = slotWindowOpen(ctx.instance, slot), can = options?.grants !== void 0 && actor !== void 0 ? await advisoryCan(ctx.instance, actor, options.grants) : void 0, predicateSatisfied = window.open && slot.effective !== !0 && slot.effective !== void 0 ? await ctxEvaluateCondition(ctx, slot.effective, {
+    ...slot.task !== void 0 ? { taskName: slot.task } : {},
+    ...actor !== void 0 ? { actor } : {},
+    ...can !== void 0 ? { vars: { can } } : {}
+  }) : slot.effective === !0, reason = editDisabledReason({
+    effective: slot.effective,
+    instance: ctx.instance,
+    window,
+    guardDenial: void 0,
+    predicateSatisfied
+  });
+  if (reason !== void 0) throw new EditFieldDeniedError({ target: slotTarget(slot), reason });
+}
+function buildEditOp(slot, mode, value) {
+  if (mode === "unset") return { type: "field.unset", target: slot.ref };
+  if (value === void 0)
+    throw new Error(`editField mode "${mode}" requires a value for slot "${slot.name}"`);
+  return {
+    type: mode === "append" ? "field.append" : "field.set",
+    target: slot.ref,
+    value: { type: "literal", value }
+  };
+}
+function slotTarget(slot) {
+  return {
+    scope: slot.scope,
+    field: slot.name,
+    ...slot.task !== void 0 ? { task: slot.task } : {}
+  };
+}
+function labelTarget(target) {
+  return {
+    scope: target.scope ?? (target.task !== void 0 ? "task" : "workflow"),
+    field: target.field,
+    ...target.task !== void 0 ? { task: target.task } : {}
+  };
+}
+function describeTarget(target) {
+  const where = target.task !== void 0 ? `${target.task}.${target.field}` : target.field;
+  return target.scope !== void 0 ? `${target.scope}:${where}` : where;
+}
 function bareIdFromSpawnRef(uri) {
   if (!uri.includes(":")) return [uri];
   try {
@@ -3150,18 +3427,60 @@ function buildClientForGdr(defaultClient, resolver) {
 function toEffectsContextEntries(ctx) {
   return Object.entries(ctx).map(([id, value]) => effectsContextEntry(id, value));
 }
+async function dispatchGatedWrite(args) {
+  const { client, tag, instanceId, resourceClients, access, apply } = args, evaluation = await evaluateInstance({
+    client,
+    tag,
+    instanceId,
+    access,
+    clock: args.clock,
+    ...resourceClients !== void 0 ? { resourceClients } : {}
+  }), ranOps = await apply(args.before, evaluation), cascaded = await cascade(client, instanceId, args.actor, args.clientForGdr, args.clock);
+  return {
+    instance: await reload(client, instanceId, tag),
+    cascaded,
+    fired: !0,
+    ...ranOps !== void 0 ? { ranOps } : {}
+  };
+}
 function assertActionAllowed(evaluation, task, action) {
   const actionEval = evaluation.currentStage.tasks.find((t) => t.task.name === task)?.actions.find((a) => a.action.name === action);
   if (actionEval?.allowed === !1 && actionEval.disabledReason)
     throw new ActionDisabledError({ task, action, reason: actionEval.disabledReason });
 }
-async function applyAction(args) {
-  const { client, instance, task, action, params, actor, grants, clock, clientForGdr } = args, options = {
-    actor,
-    ...grants !== void 0 ? { grants } : {},
-    ...clock !== void 0 ? { clock } : {},
-    ...clientForGdr !== void 0 ? { clientForGdr } : {}
+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 EditFieldDeniedError({
+      target: {
+        scope: slot.scope,
+        field: slot.name,
+        ...slot.task !== void 0 ? { task: slot.task } : {}
+      },
+      reason: slot.disabledReason
+    });
+}
+async function applyEdit(args) {
+  const { client, instance, target, mode, value, actor, grants, clock, clientForGdr } = args;
+  return (await editField({
+    client,
+    instanceId: instance._id,
+    target,
+    ...mode !== void 0 ? { mode } : {},
+    ...value !== void 0 ? { value } : {},
+    options: buildEngineCallOptions({ actor, grants, clock, clientForGdr })
+  })).ranOps;
+}
+function buildEngineCallOptions(args) {
+  return {
+    actor: args.actor,
+    ...args.grants !== void 0 ? { grants: args.grants } : {},
+    ...args.clock !== void 0 ? { clock: args.clock } : {},
+    ...args.clientForGdr !== void 0 ? { clientForGdr: args.clientForGdr } : {}
   };
+}
+async function applyAction(args) {
+  const { client, instance, task, action, params, actor, grants, clock, clientForGdr } = args, options = buildEngineCallOptions({ actor, grants, clock, clientForGdr });
   return findOpenStageEntry(instance)?.tasks.find((t) => t.name === task)?.status === "pending" && await invokeTask({ client, instanceId: instance._id, task, options }), (await fireAction({
     client,
     instanceId: instance._id,
@@ -3316,7 +3635,7 @@ const workflow = {
       workflowResource,
       definition: definitionName,
       version,
-      initialState,
+      initialFields,
       ancestors,
       effectsContext,
       instanceId,
@@ -3326,9 +3645,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,
@@ -3339,7 +3658,7 @@ const workflow = {
         ...perspective !== void 0 ? { perspective } : {}
       },
       randomKey
-    }), effectivePerspective = perspective ?? derivePerspectiveFromState(resolvedState), base = buildInstanceBase({
+    }), effectivePerspective = perspective ?? derivePerspectiveFromFields(resolvedFields), base = buildInstanceBase({
       id,
       now,
       tag,
@@ -3347,7 +3666,7 @@ const workflow = {
       definitionName: definition.name,
       pinnedVersion: definition.version,
       definition,
-      state: resolvedState,
+      fields: resolvedFields,
       effectsContext: effectsContextEntries,
       ancestors: ancestors ?? [],
       perspective: effectivePerspective,
@@ -3377,34 +3696,68 @@ const workflow = {
       idempotent,
       resourceClients
     } = args, { access, actor, clientForGdr } = await resolveOperationContext(args), clock = args.clock ?? wallClock, before = await reload(client, instanceId, tag);
-    if (findOpenStageEntry(before)?.tasks.find((t) => t.name === task) === void 0 && idempotent === !0)
-      return { instance: before, cascaded: 0, fired: !1 };
-    const evaluation = await evaluateInstance({
+    return findOpenStageEntry(before)?.tasks.find((t) => t.name === task) === void 0 && idempotent === !0 ? { instance: before, cascaded: 0, fired: !1 } : dispatchGatedWrite({
       client,
       tag,
       instanceId,
       access,
+      actor,
+      clientForGdr,
       clock,
-      ...resourceClients !== void 0 ? { resourceClients } : {}
+      before,
+      ...resourceClients !== void 0 ? { resourceClients } : {},
+      apply: (instance, evaluation) => (assertActionAllowed(evaluation, task, action), applyAction({
+        client,
+        instance,
+        task,
+        action,
+        actor,
+        ...access.grants !== void 0 ? { grants: access.grants } : {},
+        clock,
+        clientForGdr,
+        ...params !== void 0 ? { params } : {}
+      }))
     });
-    assertActionAllowed(evaluation, task, action);
-    const ranOps = await applyAction({
+  },
+  /**
+   * 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
+   * `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.
+   *
+   * Each call is a discrete COMMIT (a history entry, a guard refresh, a
+   * cascade, an `ifRevisionId` write), not a draft patch — so an inline-field
+   * UI must bind it to a deliberate boundary (blur / Enter / Save / debounce),
+   * never an `onChange` per keystroke.
+   */
+  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,
-      instance: before,
-      task,
-      action,
+      tag,
+      instanceId,
+      access,
       actor,
-      ...access.grants !== void 0 ? { grants: access.grants } : {},
-      clock,
       clientForGdr,
-      ...params !== void 0 ? { params } : {}
-    }), cascaded = await cascade(client, instanceId, actor, clientForGdr, clock);
-    return {
-      instance: await reload(client, instanceId, tag),
-      cascaded,
-      fired: !0,
-      ...ranOps !== void 0 ? { ranOps } : {}
-    };
+      clock,
+      before,
+      ...resourceClients !== void 0 ? { resourceClients } : {},
+      apply: (instance, evaluation) => (assertEditAllowed(evaluation, target), applyEdit({
+        client,
+        instance,
+        target,
+        ...mode !== void 0 ? { mode } : {},
+        ...value !== void 0 ? { value } : {},
+        actor,
+        ...access.grants !== void 0 ? { grants: access.grants } : {},
+        clock,
+        clientForGdr
+      }))
+    });
   },
   /**
    * Report a queued effect's outcome. Drains it from `pendingEffects`,
@@ -3546,7 +3899,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.
@@ -3822,6 +4175,9 @@ function createInstanceSession(args) {
       ...clock !== void 0 ? { now: clock() } : {},
       ...grants !== void 0 ? { grants } : {}
     });
+  }, settleAfterApply = async (actor, held, ranOps) => {
+    const cascaded = await cascade(client, instance._id, actor, clientForGdr, clock, held);
+    return instance = await reload(client, instance._id, tag), { instance, cascaded, fired: !0, ...ranOps !== void 0 ? { ranOps } : {} };
   }, commit = async (run) => {
     committing = !0;
     const held = new Map(overlay);
@@ -3872,8 +4228,25 @@ function createInstanceSession(args) {
           ...grants !== void 0 ? { grants } : {},
           ...clock !== void 0 ? { clock } : {},
           ...params !== void 0 ? { params } : {}
-        }), cascaded = await cascade(client, instance._id, actor, clientForGdr, clock, held);
-        return instance = await reload(client, instance._id, tag), { instance, cascaded, fired: !0, ...ranOps !== void 0 ? { ranOps } : {} };
+        });
+        return settleAfterApply(actor, held, ranOps);
+      });
+    },
+    editField({ target, mode, value }) {
+      return commit(async (actor, held) => {
+        assertEditAllowed(await evaluateWith(held, heldGuards), target);
+        const { grants } = await access(), ranOps = await applyEdit({
+          client,
+          instance,
+          target,
+          ...mode !== void 0 ? { mode } : {},
+          ...value !== void 0 ? { value } : {},
+          actor,
+          clientForGdr,
+          ...grants !== void 0 ? { grants } : {},
+          ...clock !== void 0 ? { clock } : {}
+        });
+        return settleAfterApply(actor, held, ranOps);
       });
     }
   };
@@ -3921,6 +4294,7 @@ function createEngine(args) {
     deployDefinitions: (rest) => workflow.deployDefinitions(bind(rest)),
     startInstance: (rest) => workflow.startInstance(bind(rest)),
     fireAction: (rest) => workflow.fireAction(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)),
@@ -4079,9 +4453,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."
@@ -4135,23 +4509,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."
   },
@@ -4195,11 +4569,11 @@ 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."
   }
 }, DISPLAY = {
   ...HISTORY_DISPLAY,
-  ...STATE_SLOT_DISPLAY,
+  ...FIELD_SLOT_DISPLAY,
   ...OP_DISPLAY,
   ...EFFECTS_CONTEXT_DISPLAY,
   ...AUTHORING_DISPLAY
@@ -4216,10 +4590,13 @@ export {
   ActionDisabledError,
   ActionParamsInvalidError,
   CascadeLimitError,
+  ConcurrentEditFieldError,
   ConcurrentFireActionError,
   DEFAULT_CONTENT_PERSPECTIVE,
   DISPLAY,
   EFFECTS_CONTEXT_DISPLAY,
+  EditFieldDeniedError,
+  FIELD_SLOT_DISPLAY,
   GUARD_DOC_TYPE,
   GUARD_LIFTED_PREDICATE,
   GUARD_OWNER,
@@ -4227,8 +4604,7 @@ export {
   MutationGuardDeniedError,
   OP_DISPLAY,
   PartialGuardDeployError,
-  RequiredStateNotProvidedError,
-  STATE_SLOT_DISPLAY,
+  RequiredFieldNotProvidedError,
   WORKFLOW_DEFINITION_TYPE,
   WORKFLOW_INSTANCE_TYPE,
   WorkflowStateDivergedError,