@sanity/workflow-engine 0.11.0 → 0.13.0

package/dist/define.js

@@ -1,5 +1,5 @@
 import * as v from "valibot";
-import { andConditions, expandRequiredRoles, GROQ_IDENTIFIER, formatValidationError, issuesFromValibot, AuthoringWorkflowSchema, AuthoringStageSchema, AuthoringTaskSchema, AuthoringActionSchema, AuthoringTransitionSchema, AuthoringFieldEntrySchema, AuthoringOpSchema, GuardSchema, EffectSchema } from "./_chunks-es/schema.js";
+import { andConditions, expandRequiredRoles, normalizeRoleAliases, GROQ_IDENTIFIER, formatValidationError, issuesFromValibot, AuthoringWorkflowSchema, AuthoringStageSchema, AuthoringActivitySchema, AuthoringActionSchema, AuthoringTransitionSchema, AuthoringFieldEntrySchema, AuthoringOpSchema, GuardSchema, EffectSchema } from "./_chunks-es/schema.js";
 function groq(strings, ...values) {
   return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
 }
@@ -12,27 +12,29 @@ function serializeGroqValue(value) {
   return serialized;
 }
 function desugarWorkflow(authoring) {
-  const ctx = {
-    issues: [],
+  const issues = [];
+  checkReservedRoleAliasKeys(authoring.roleAliases, issues);
+  const roleAliases = normalizeRoleAliases(authoring.roleAliases), ctx = {
+    issues,
     claimFields: /* @__PURE__ */ new Map(),
     claimedFields: /* @__PURE__ */ new Set(),
-    roleAliases: authoring.roleAliases
-  }, workflowFields = desugarFieldEntries(authoring.fields, ["fields"], ctx), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
-    const path = ["stages", i], stageFields = desugarFieldEntries(stage.fields, [...path, "fields"], ctx), stageEnv = {
+    roleAliases
+  }, workflowFields = desugarFieldEntries({ entries: authoring.fields, path: ["fields"], ctx }), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
+    const path = ["stages", i], stageFields = desugarFieldEntries({ entries: stage.fields, path: [...path, "fields"], ctx }), stageEnv = {
       layers: [
         { scope: "stage", entries: layerOf(stageFields) },
         { scope: "workflow", entries: workflowLayer }
       ]
-    }, tasks = (stage.tasks ?? []).map(
-      (task, j) => desugarTask(task, [...path, "tasks", j], stageEnv, ctx)
+    }, activities = (stage.activities ?? []).map(
+      (activity, j) => desugarActivity({ activity, path: [...path, "activities", j], stageEnv, ctx })
     ), transitions = (stage.transitions ?? []).map(
-      (transition, k) => desugarTransition(transition, [...path, "transitions", k], stageEnv, ctx)
-    ), editable = desugarStageEditable(
-      stage.editable,
-      editableSlotNames(workflowFields, stageFields, tasks),
-      [...path, "editable"],
+      (transition, k) => desugarTransition({ transition, path: [...path, "transitions", k], stageEnv, ctx })
+    ), editable = desugarStageEditable({
+      overrides: stage.editable,
+      inScope: editableSlotNames({ workflowFields, stageFields, activities }),
+      path: [...path, "editable"],
       ctx
-    );
+    });
     return {
       ...stripUndefined({
         name: stage.name,
@@ -41,7 +43,7 @@ function desugarWorkflow(authoring) {
         guards: stage.guards
       }),
       ...stageFields ? { fields: stageFields } : {},
-      ...tasks.length > 0 ? { tasks } : {},
+      ...activities.length > 0 ? { activities } : {},
       ...transitions.length > 0 ? { transitions } : {},
       ...editable ? { editable } : {}
     };
@@ -49,43 +51,99 @@ function desugarWorkflow(authoring) {
   return checkUnclaimedClaimFields(ctx), { definition: {
     ...stripUndefined({
       name: authoring.name,
-      version: authoring.version,
       title: authoring.title,
       description: authoring.description,
       role: authoring.role,
       initialStage: authoring.initialStage,
       predicates: authoring.predicates,
-      roleAliases: authoring.roleAliases
+      roleAliases
     }),
     ...workflowFields ? { fields: workflowFields } : {},
     stages
   }, issues: ctx.issues };
 }
-function desugarFieldEntries(entries, path, ctx) {
-  return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => {
-    if (entry.type === "claim") {
-      const desugared = {
-        ...stripUndefined({ name: entry.name, title: entry.title, description: entry.description }),
-        type: "value.actor",
-        source: { type: "write" }
-      };
-      return ctx.claimFields.set(desugared, { name: entry.name, path: [...path, i] }), desugared;
-    }
-    const editable = normalizeEditable(entry.editable, [...path, i, "editable"], ctx);
-    return {
-      ...stripUndefined({
-        type: entry.type,
-        name: entry.name,
-        title: entry.title,
-        description: entry.description,
-        required: entry.required,
-        editable
-      }),
-      source: entry.source
-    };
-  });
+function checkReservedRoleAliasKeys(aliases, issues) {
+  for (const key of Object.keys(aliases ?? {}))
+    key.startsWith("$") && issues.push({
+      path: ["roleAliases", key],
+      message: `role alias key "${key}" uses the reserved "$" prefix \u2014 that namespace is the engine's stored spelling for the universal fulfiller. Use "*" to mean "fulfills any gate", or rename the role.`
+    });
 }
-function normalizeEditable(editable, path, ctx) {
+const TODOLIST_OF = [
+  { type: "string", name: "label", title: "Label" },
+  { type: "string", name: "status", title: "Status" },
+  { type: "assignee", name: "assignee", title: "Assignee" },
+  { type: "date", name: "dueDate", title: "Due date" }
+], NOTES_OF = [
+  { type: "text", name: "body", title: "Body" },
+  { type: "actor", name: "actor", title: "Actor" },
+  { type: "datetime", name: "at", title: "At" }
+];
+function desugarFieldEntries({
+  entries,
+  path,
+  ctx
+}) {
+  return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => desugarFieldEntry({ entry, path: [...path, i], ctx }));
+}
+function desugarFieldEntry({
+  entry,
+  path,
+  ctx
+}) {
+  if (entry.type === "claim") return desugarClaimField({ entry, path, ctx });
+  if (entry.type === "todoList" || entry.type === "notes")
+    return desugarListField({ entry, path, ctx });
+  const editable = normalizeEditable({ editable: entry.editable, path: [...path, "editable"], ctx });
+  return {
+    ...stripUndefined({
+      type: entry.type,
+      name: entry.name,
+      title: entry.title,
+      description: entry.description,
+      required: entry.required,
+      initialValue: entry.initialValue,
+      editable,
+      fields: entry.fields,
+      of: entry.of
+    })
+  };
+}
+function desugarClaimField({
+  entry,
+  path,
+  ctx
+}) {
+  const desugared = {
+    ...stripUndefined({ name: entry.name, title: entry.title, description: entry.description }),
+    type: "actor"
+  };
+  return ctx.claimFields.set(desugared, { name: entry.name, path }), desugared;
+}
+function desugarListField({
+  entry,
+  path,
+  ctx
+}) {
+  const editable = normalizeEditable({ editable: entry.editable, path: [...path, "editable"], ctx });
+  return {
+    ...stripUndefined({
+      name: entry.name,
+      title: entry.title,
+      description: entry.description,
+      required: entry.required,
+      initialValue: entry.initialValue,
+      editable
+    }),
+    type: "array",
+    of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
+  };
+}
+function normalizeEditable({
+  editable,
+  path,
+  ctx
+}) {
   if (editable === void 0 || editable === !0) return editable;
   if (Array.isArray(editable)) {
     const condition = rolesCondition(editable, ctx.roleAliases);
@@ -100,26 +158,35 @@ function normalizeEditable(editable, path, ctx) {
   }
   return editable;
 }
-function editableSlotNames(workflowFields, stageFields, tasks) {
+function editableSlotNames({
+  workflowFields,
+  stageFields,
+  activities
+}) {
   const names = /* @__PURE__ */ new Set(), collect = (entries) => {
     for (const entry of entries ?? []) entry.editable !== void 0 && names.add(entry.name);
   };
   collect(workflowFields), collect(stageFields);
-  for (const task of tasks) collect(task.fields);
+  for (const activity of activities) collect(activity.fields);
   return names;
 }
-function desugarStageEditable(overrides, inScope, path, ctx) {
+function desugarStageEditable({
+  overrides,
+  inScope,
+  path,
+  ctx
+}) {
   if (overrides === void 0) return;
   const out = {};
   for (const [name, value] of Object.entries(overrides)) {
     if (!inScope.has(name)) {
       ctx.issues.push({
         path: [...path, name],
-        message: `stage editable override "${name}" does not narrow an editable slot in scope \u2014 name a workflow/stage/task slot of this stage that declares \`editable\``
+        message: `stage editable override "${name}" does not narrow an editable slot in scope \u2014 name a workflow/stage/activity slot of this stage that declares \`editable\``
       });
       continue;
     }
-    const normalized = normalizeEditable(value, [...path, name], ctx);
+    const normalized = normalizeEditable({ editable: value, path: [...path, name], ctx });
     normalized !== void 0 && (out[name] = normalized);
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -127,46 +194,72 @@ function desugarStageEditable(overrides, inScope, path, ctx) {
 function layerOf(entries) {
   return new Map((entries ?? []).map((entry) => [entry.name, entry]));
 }
-function desugarTask(task, path, stageEnv, ctx) {
-  const taskFields = desugarFieldEntries(task.fields, [...path, "fields"], ctx), env = {
-    layers: [{ scope: "task", entries: layerOf(taskFields) }, ...stageEnv.layers]
-  }, ops = desugarOps(task.ops, [...path, "ops"], env, task.name, ctx), actions = (task.actions ?? []).map(
-    (action, a) => desugarAction(action, [...path, "actions", a], env, task.name, ctx)
-  ), target = desugarTarget(task.target, env, [...path, "target"], ctx);
+function desugarActivity({
+  activity,
+  path,
+  stageEnv,
+  ctx
+}) {
+  const activityFields = desugarFieldEntries({
+    entries: activity.fields,
+    path: [...path, "fields"],
+    ctx
+  }), env = {
+    layers: [{ scope: "activity", entries: layerOf(activityFields) }, ...stageEnv.layers]
+  }, ops = desugarOps({
+    ops: activity.ops,
+    path: [...path, "ops"],
+    env,
+    firingActivity: activity.name,
+    ctx
+  }), actions = (activity.actions ?? []).map(
+    (action, a) => desugarAction({ action, path: [...path, "actions", a], env, activityName: activity.name, ctx })
+  ), target = desugarTarget({ target: activity.target, env, path: [...path, "target"], ctx });
   return {
     ...stripUndefined({
-      name: task.name,
-      title: task.title,
-      description: task.description,
-      kind: task.kind,
-      filter: task.filter,
-      requirements: task.requirements,
-      completeWhen: task.completeWhen,
-      failWhen: task.failWhen,
-      effects: task.effects,
-      subworkflows: task.subworkflows
+      name: activity.name,
+      title: activity.title,
+      description: activity.description,
+      kind: activity.kind,
+      filter: activity.filter,
+      requirements: activity.requirements,
+      completeWhen: activity.completeWhen,
+      failWhen: activity.failWhen,
+      effects: activity.effects,
+      subworkflows: activity.subworkflows
     }),
-    activation: task.activation ?? "manual",
+    activation: activity.activation ?? "manual",
     ...target ? { target } : {},
-    ...taskFields ? { fields: taskFields } : {},
+    ...activityFields ? { fields: activityFields } : {},
     ...ops ? { ops } : {},
     ...actions.length > 0 ? { actions } : {}
   };
 }
 const TARGET_DOC_KINDS = ["doc.ref", "doc.refs", "release.ref"];
-function desugarTarget(target, env, path, ctx) {
+function desugarTarget({
+  target,
+  env,
+  path,
+  ctx
+}) {
   if (target === void 0 || target.type === "url") return target;
-  const ref = typeof target.field == "string" ? { field: target.field } : target.field, field = resolveRef(ref, env, [...path, "field"], ctx) ?? fallbackRef(ref), entry = entryAt(env, field);
+  const ref = typeof target.field == "string" ? { field: target.field } : target.field, field = resolveRef({ ref, env, path: [...path, "field"], ctx }) ?? fallbackRef(ref), entry = entryAt(env, field);
   return entry && !TARGET_DOC_KINDS.includes(entry.type) && ctx.issues.push({
     path: [...path, "field"],
-    message: `manual task target references "${field.field}" of kind "${entry.type}" \u2014 a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
+    message: `manual activity target references "${field.field}" of kind "${entry.type}" \u2014 a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
   }), { type: "field", field };
 }
-function desugarAction(action, path, env, taskName, ctx) {
+function desugarAction({
+  action,
+  path,
+  env,
+  activityName,
+  ctx
+}) {
   if ("type" in action)
-    return desugarClaimAction(action, path, env, ctx);
-  const filter = andConditions([rolesCondition(action.roles, ctx.roleAliases), action.filter]), ops = desugarOps(action.ops, [...path, "ops"], env, taskName, ctx) ?? [];
-  return action.status !== void 0 && ops.push({ type: "status.set", task: taskName, status: action.status }), {
+    return desugarClaimAction({ action, path, env, ctx });
+  const filter = andConditions([rolesCondition(action.roles, ctx.roleAliases), action.filter]), ops = desugarOps({ ops: action.ops, path: [...path, "ops"], env, firingActivity: activityName, ctx }) ?? [];
+  return action.status !== void 0 && ops.push({ type: "status.set", activity: activityName, status: action.status }), {
     ...stripUndefined({
       name: action.name,
       title: action.title,
@@ -178,14 +271,26 @@ function desugarAction(action, path, env, taskName, ctx) {
     ...ops.length > 0 ? { ops } : {}
   };
 }
-function desugarClaimAction(action, path, env, ctx) {
-  const ref = typeof action.field == "string" ? { field: action.field } : action.field, resolved = resolveRef(ref, env, [...path, "field"], ctx);
+function desugarClaimAction({
+  action,
+  path,
+  env,
+  ctx
+}) {
+  const ref = typeof action.field == "string" ? { field: action.field } : action.field, resolved = resolveRef({ ref, env, path: [...path, "field"], ctx });
   if (resolved) {
     const entry = entryAt(env, resolved);
-    entry && entry.type !== "value.actor" && ctx.issues.push({
+    entry && entry.type !== "actor" && ctx.issues.push({
+      path: [...path, "field"],
+      message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" \u2014 a claim pair needs an actor-valued entry (a "claim" or "actor" field declaration)`
+    }), checkShadowedClaimTarget({
+      actionName: action.name,
+      field: ref.field,
+      resolved,
+      env,
       path: [...path, "field"],
-      message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" \u2014 a claim pair needs an actor-valued entry (a "claim" or "value.actor" field declaration)`
-    }), checkShadowedClaimTarget(action.name, ref.field, resolved, env, [...path, "field"], ctx), entry && ctx.claimedFields.add(entry);
+      ctx
+    }), entry && ctx.claimedFields.add(entry);
   }
   const noSteal = `!defined($fields.${ref.field})`, filter = andConditions([
     noSteal,
@@ -204,7 +309,14 @@ function desugarClaimAction(action, path, env, ctx) {
     ...ops.length > 0 ? { ops } : {}
   };
 }
-function checkShadowedClaimTarget(actionName, field, resolved, env, path, ctx) {
+function checkShadowedClaimTarget({
+  actionName,
+  field,
+  resolved,
+  env,
+  path,
+  ctx
+}) {
   const nearest = env.layers.find((l) => l.entries.has(field));
   nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
     path,
@@ -215,11 +327,22 @@ function checkUnclaimedClaimFields(ctx) {
   for (const [entry, { name, path }] of ctx.claimFields)
     ctx.claimedFields.has(entry) || ctx.issues.push({
       path,
-      message: `claim field "${name}" is never referenced by a claim action \u2014 you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw value.actor entry`
+      message: `claim field "${name}" is never referenced by a claim action \u2014 you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw actor entry`
     });
 }
-function desugarTransition(transition, path, stageEnv, ctx) {
-  const ops = desugarOps(transition.ops, [...path, "ops"], stageEnv, void 0, ctx);
+function desugarTransition({
+  transition,
+  path,
+  stageEnv,
+  ctx
+}) {
+  const ops = desugarOps({
+    ops: transition.ops,
+    path: [...path, "ops"],
+    env: stageEnv,
+    firingActivity: void 0,
+    ctx
+  });
   return {
     ...stripUndefined({
       name: transition.name,
@@ -228,29 +351,46 @@ function desugarTransition(transition, path, stageEnv, ctx) {
       to: transition.to,
       effects: transition.effects
     }),
-    filter: transition.filter ?? "$allTasksDone",
+    filter: transition.filter ?? "$allActivitiesDone",
     ...ops ? { ops } : {}
   };
 }
-function desugarOps(ops, path, env, firingTask, ctx) {
+function desugarOps({
+  ops,
+  path,
+  env,
+  firingActivity,
+  ctx
+}) {
   if (ops)
-    return ops.map((op, i) => desugarOp(op, [...path, i], env, firingTask, ctx));
-}
-function desugarOp(op, path, env, firingTask, ctx) {
+    return ops.map((op, i) => desugarOp({ op, path: [...path, i], env, firingActivity, ctx }));
+}
+function desugarOp({
+  op,
+  path,
+  env,
+  firingActivity,
+  ctx
+}) {
   if (op.type === "status.set") {
-    const task = op.task ?? firingTask;
-    return task === void 0 && ctx.issues.push({
-      path: [...path, "task"],
-      message: "status.set outside an action must name its target task"
-    }), { type: "status.set", task: task ?? "", status: op.status };
+    const activity = op.activity ?? firingActivity;
+    return activity === void 0 && ctx.issues.push({
+      path: [...path, "activity"],
+      message: "status.set outside an action must name its target activity"
+    }), { type: "status.set", activity: activity ?? "", status: op.status };
   }
-  if (op.type === "audit") return desugarAuditOp(op, path, env, ctx);
-  const target = resolveRef(op.target, env, [...path, "target"], ctx) ?? fallbackRef(op.target);
+  if (op.type === "audit") return desugarAuditOp({ op, path, env, ctx });
+  const target = resolveRef({ ref: op.target, env, path: [...path, "target"], ctx }) ?? fallbackRef(op.target);
   return { ...op, target };
 }
 const AUDIT_STAMPS = { actor: { type: "actor" }, at: { type: "now" } };
-function desugarAuditOp(op, path, env, ctx) {
-  const target = resolveRef(op.target, env, [...path, "target"], ctx) ?? fallbackRef(op.target);
+function desugarAuditOp({
+  op,
+  path,
+  env,
+  ctx
+}) {
+  const target = resolveRef({ ref: op.target, env, path: [...path, "target"], ctx }) ?? fallbackRef(op.target);
   if (op.value.type !== "object")
     return ctx.issues.push({
       path: [...path, "value"],
@@ -272,7 +412,12 @@ function desugarAuditOp(op, path, env, ctx) {
   }
   return { type: "field.append", target, value: { type: "object", fields } };
 }
-function resolveRef(ref, env, path, ctx) {
+function resolveRef({
+  ref,
+  env,
+  path,
+  ctx
+}) {
   const layers = ref.scope === void 0 ? env.layers : env.layers.filter((l) => l.scope === ref.scope);
   for (const layer of layers)
     if (layer.entries.has(ref.field)) return { scope: layer.scope, field: ref.field };
@@ -306,83 +451,115 @@ const RESERVED_CONDITION_VARS = [
   "row",
   "now",
   "effects",
-  "tasks",
+  "activities",
   "subworkflows",
   "self",
   "stage",
   "parent",
   "ancestors",
-  "allTasksDone",
-  "anyTaskFailed"
+  "allActivitiesDone",
+  "anyActivityFailed"
 ], PREDICATE_CALLER_VARS = ["actor", "assigned", "can"];
 function knownList(ids) {
   return [...ids].map((s) => `"${s}"`).join(", ");
 }
-function checkDuplicates(names, what, issues) {
+function checkDuplicates({
+  names,
+  what,
+  issues
+}) {
   const seen = /* @__PURE__ */ new Set();
   for (const { name, path } of names)
     seen.has(name) && issues.push({ path, message: `duplicate ${what} "${name}" (already declared earlier)` }), seen.add(name);
   return seen;
 }
 function checkStages(def, issues) {
-  const stageNames = checkDuplicates(
-    def.stages.map((stage, i) => ({ name: stage.name, path: ["stages", i, "name"] })),
-    "stage name",
+  const stageNames = checkDuplicates({
+    names: def.stages.map((stage, i) => ({ name: stage.name, path: ["stages", i, "name"] })),
+    what: "stage name",
     issues
-  );
+  });
   for (const [i, stage] of def.stages.entries()) {
-    const taskNames = checkDuplicates(
-      (stage.tasks ?? []).map((task, j) => ({
-        name: task.name,
-        path: ["stages", i, "tasks", j, "name"]
+    const activityNames = checkDuplicates({
+      names: (stage.activities ?? []).map((activity, j) => ({
+        name: activity.name,
+        path: ["stages", i, "activities", j, "name"]
       })),
-      `task name in stage "${stage.name}"`,
+      what: `activity name in stage "${stage.name}"`,
       issues
-    );
-    checkDuplicates(
-      (stage.transitions ?? []).map((t, k) => ({
+    });
+    checkDuplicates({
+      names: (stage.transitions ?? []).map((t, k) => ({
         name: t.name,
         path: ["stages", i, "transitions", k, "name"]
       })),
-      `transition name in stage "${stage.name}"`,
+      what: `transition name in stage "${stage.name}"`,
       issues
-    ), checkTasks(def, i, taskNames, issues);
+    }), checkActivities({ def, i, activityNames, issues });
   }
   return stageNames;
 }
-function checkTasks(def, i, taskNames, issues) {
+function checkActivities({
+  def,
+  i,
+  activityNames,
+  issues
+}) {
   const stage = def.stages[i];
-  for (const [j, task] of (stage.tasks ?? []).entries()) {
-    const path = ["stages", i, "tasks", j];
-    checkDuplicates(
-      (task.actions ?? []).map((action, a) => ({
+  for (const [j, activity] of (stage.activities ?? []).entries()) {
+    const path = ["stages", i, "activities", j];
+    checkDuplicates({
+      names: (activity.actions ?? []).map((action, a) => ({
         name: action.name,
         path: [...path, "actions", a, "name"]
       })),
-      `action name in task "${task.name}"`,
+      what: `action name in activity "${activity.name}"`,
       issues
-    ), checkStatusSetTargets(task, taskNames, path, issues);
+    }), checkStatusSetTargets({ activity, activityNames, path, issues });
   }
 }
-function checkStatusSetTargets(task, taskNames, path, issues) {
-  checkStatusSetOps(task.ops, taskNames, [...path, "ops"], issues);
-  for (const [a, action] of (task.actions ?? []).entries())
-    checkStatusSetOps(action.ops, taskNames, [...path, "actions", a, "ops"], issues);
+function checkStatusSetTargets({
+  activity,
+  activityNames,
+  path,
+  issues
+}) {
+  checkStatusSetOps({ ops: activity.ops, activityNames, path: [...path, "ops"], issues });
+  for (const [a, action] of (activity.actions ?? []).entries())
+    checkStatusSetOps({
+      ops: action.ops,
+      activityNames,
+      path: [...path, "actions", a, "ops"],
+      issues
+    });
 }
-function checkStatusSetOps(ops, taskNames, path, issues) {
+function checkStatusSetOps({
+  ops,
+  activityNames,
+  path,
+  issues
+}) {
   for (const [o, op] of (ops ?? []).entries())
-    op.type !== "status.set" || taskNames.has(op.task) || issues.push({
-      path: [...path, o, "task"],
-      message: `status.set targets task "${op.task}" which is not declared in this stage. Known tasks: ${knownList(taskNames)}`
+    op.type !== "status.set" || activityNames.has(op.activity) || issues.push({
+      path: [...path, o, "activity"],
+      message: `status.set targets activity "${op.activity}" which is not declared in this stage. Known activities: ${knownList(activityNames)}`
     });
 }
-function checkInitialStage(def, stageNames, issues) {
+function checkInitialStage({
+  def,
+  stageNames,
+  issues
+}) {
   stageNames.has(def.initialStage) || issues.push({
     path: ["initialStage"],
     message: `initialStage "${def.initialStage}" is not a declared stage. Known stages: ${knownList(stageNames)}`
   });
 }
-function checkTransitionTargets(def, stageNames, issues) {
+function checkTransitionTargets({
+  def,
+  stageNames,
+  issues
+}) {
   for (const [i, stage] of def.stages.entries())
     for (const [k, t] of (stage.transitions ?? []).entries())
       stageNames.has(t.to) || issues.push({
@@ -393,17 +570,33 @@ function checkTransitionTargets(def, stageNames, issues) {
 function checkEffectNames(def, issues) {
   const sites = [];
   for (const [i, stage] of def.stages.entries()) {
-    for (const [j, task] of (stage.tasks ?? []).entries()) {
-      collectEffects(task.effects, ["stages", i, "tasks", j, "effects"], sites);
-      for (const [a, action] of (task.actions ?? []).entries())
-        collectEffects(action.effects, ["stages", i, "tasks", j, "actions", a, "effects"], sites);
+    for (const [j, activity] of (stage.activities ?? []).entries()) {
+      collectEffects({
+        effects: activity.effects,
+        path: ["stages", i, "activities", j, "effects"],
+        sites
+      });
+      for (const [a, action] of (activity.actions ?? []).entries())
+        collectEffects({
+          effects: action.effects,
+          path: ["stages", i, "activities", j, "actions", a, "effects"],
+          sites
+        });
     }
     for (const [k, t] of (stage.transitions ?? []).entries())
-      collectEffects(t.effects, ["stages", i, "transitions", k, "effects"], sites);
+      collectEffects({ effects: t.effects, path: ["stages", i, "transitions", k, "effects"], sites });
   }
-  checkDuplicates(sites, "effect name (registry key \u2014 unique per definition)", issues);
+  checkDuplicates({
+    names: sites,
+    what: "effect name (registry key \u2014 unique per definition)",
+    issues
+  });
 }
-function collectEffects(effects, path, sites) {
+function collectEffects({
+  effects,
+  path,
+  sites
+}) {
   for (const [e, effect] of (effects ?? []).entries())
     sites.push({ name: effect.name, path: [...path, e, "name"] });
 }
@@ -414,11 +607,11 @@ function checkGuardNames(def, issues) {
       path: ["stages", i, "guards", g, "name"]
     }))
   );
-  checkDuplicates(
-    sites,
-    "guard name (the guard lake _id derives from it \u2014 unique per definition)",
+  checkDuplicates({
+    names: sites,
+    what: "guard name (the guard lake _id derives from it \u2014 unique per definition)",
     issues
-  );
+  });
 }
 function fieldScopes(def) {
   const scopes = [
@@ -431,12 +624,12 @@ function fieldScopes(def) {
       path: ["stages", i, "fields"],
       label: `stage "${stage.name}" fields`
     });
-    for (const [j, task] of (stage.tasks ?? []).entries())
+    for (const [j, activity] of (stage.activities ?? []).entries())
       scopes.push({
-        entries: task.fields,
-        scope: "task",
-        path: ["stages", i, "tasks", j, "fields"],
-        label: `task "${task.name}" fields`
+        entries: activity.fields,
+        scope: "activity",
+        path: ["stages", i, "activities", j, "fields"],
+        label: `activity "${activity.name}" fields`
       });
   }
   return scopes;
@@ -444,21 +637,28 @@ function fieldScopes(def) {
 function checkRequiredField(def, issues) {
   for (const { entries, scope, path, label } of fieldScopes(def))
     for (const [n, entry] of (entries ?? []).entries())
-      entry.required === !0 && (scope !== "workflow" ? issues.push({
-        path: [...path, n, "required"],
-        message: `${label} entry "${entry.name}" is \`required\`, but \`required\` applies only to workflow-scope \`init\` entries \u2014 only those are caller-supplied at start/spawn`
-      }) : entry.source.type !== "init" && issues.push({
-        path: [...path, n, "required"],
-        message: `field entry "${entry.name}" is \`required\` but its source is "${entry.source.type}" \u2014 \`required\` applies only to \`init\`-sourced entries (the caller fills them at start/spawn)`
-      }));
+      if (entry.required === !0) {
+        if (scope !== "workflow")
+          issues.push({
+            path: [...path, n, "required"],
+            message: `${label} entry "${entry.name}" is \`required\`, but \`required\` applies only to workflow-scope \`input\` entries \u2014 only those are caller-supplied at start/spawn`
+          });
+        else if (entry.initialValue?.type !== "input") {
+          const seed = entry.initialValue?.type ?? "working memory (no initialValue)";
+          issues.push({
+            path: [...path, n, "required"],
+            message: `field entry "${entry.name}" has initialValue "${seed}" \u2014 \`required\` applies only to \`input\`-sourced entries (the caller fills them at start/spawn)`
+          });
+        }
+      }
 }
 function checkFieldEntryNames(def, issues) {
   for (const { entries, path, label } of fieldScopes(def))
-    checkDuplicates(
-      (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
-      `field entry name in ${label}`,
+    checkDuplicates({
+      names: (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
+      what: `field entry name in ${label}`,
       issues
-    );
+    });
 }
 function checkPredicates(def, issues) {
   const reserved = new Set(RESERVED_CONDITION_VARS), names = Object.keys(def.predicates ?? {});
@@ -468,9 +668,14 @@ function checkPredicates(def, issues) {
       message: `predicate "${name}" shadows the built-in $${name} \u2014 pick another name`
     });
   for (const [name, groq2] of Object.entries(def.predicates ?? {}))
-    checkPredicateBody(name, groq2, names, issues);
-}
-function checkPredicateBody(name, groq2, names, issues) {
+    checkPredicateBody({ name, groq: groq2, names, issues });
+}
+function checkPredicateBody({
+  name,
+  groq: groq2,
+  names,
+  issues
+}) {
   for (const caller of PREDICATE_CALLER_VARS)
     referencesVar(groq2, caller) && issues.push({
       path: ["predicates", name],
@@ -500,40 +705,53 @@ function nonActionFilterConditionSites(def) {
         groq: t.filter,
         path: ["stages", i, "transitions", k, "filter"],
         label: `transition "${t.name}" filter`
-      }), collectBindingSites(
-        t.effects,
-        ["stages", i, "transitions", k, "effects"],
-        `transition "${t.name}"`,
+      }), collectBindingSites({
+        effects: t.effects,
+        path: ["stages", i, "transitions", k, "effects"],
+        label: `transition "${t.name}"`,
         sites
-      );
-    for (const [j, task] of (stage.tasks ?? []).entries())
-      collectTaskConditionSites(task, ["stages", i, "tasks", j], sites);
+      });
+    for (const [j, activity] of (stage.activities ?? []).entries())
+      collectActivityConditionSites({ activity, path: ["stages", i, "activities", j], sites });
   }
   return sites;
 }
-function collectTaskConditionSites(task, path, sites) {
+function collectActivityConditionSites({
+  activity,
+  path,
+  sites
+}) {
   for (const field of ["filter", "completeWhen", "failWhen"]) {
-    const groq2 = task[field];
-    groq2 !== void 0 && sites.push({ groq: groq2, path: [...path, field], label: `task "${task.name}".${field}` });
+    const groq2 = activity[field];
+    groq2 !== void 0 && sites.push({ groq: groq2, path: [...path, field], label: `activity "${activity.name}".${field}` });
   }
-  collectBindingSites(task.effects, [...path, "effects"], `task "${task.name}"`, sites);
-  for (const [a, action] of (task.actions ?? []).entries())
-    collectBindingSites(
-      action.effects,
-      [...path, "actions", a, "effects"],
-      `action "${action.name}"`,
+  collectBindingSites({
+    effects: activity.effects,
+    path: [...path, "effects"],
+    label: `activity "${activity.name}"`,
+    sites
+  });
+  for (const [a, action] of (activity.actions ?? []).entries())
+    collectBindingSites({
+      effects: action.effects,
+      path: [...path, "actions", a, "effects"],
+      label: `action "${action.name}"`,
       sites
-    );
-  collectSubworkflowSites(task, path, sites);
-}
-function collectSubworkflowSites(task, path, sites) {
-  const sub = task.subworkflows;
+    });
+  collectSubworkflowSites({ activity, path, sites });
+}
+function collectSubworkflowSites({
+  activity,
+  path,
+  sites
+}) {
+  const sub = activity.subworkflows;
   if (sub === void 0) return;
   const subPath = [...path, "subworkflows"];
   sites.push({
     groq: sub.forEach,
     path: [...subPath, "forEach"],
-    label: `task "${task.name}".subworkflows.forEach`
+    label: `activity "${activity.name}".subworkflows.forEach`
   });
   for (const [group, record] of [
     ["with", sub.with],
@@ -543,10 +761,15 @@ function collectSubworkflowSites(task, path, sites) {
       sites.push({
         groq: groq2,
         path: [...subPath, group, key],
-        label: `task "${task.name}".subworkflows.${group} "${key}"`
+        label: `activity "${activity.name}".subworkflows.${group} "${key}"`
       });
 }
-function collectBindingSites(effects, path, label, sites) {
+function collectBindingSites({
+  effects,
+  path,
+  label,
+  sites
+}) {
   for (const [e, effect] of (effects ?? []).entries())
     for (const [key, groq2] of Object.entries(effect.bindings ?? {}))
       sites.push({
@@ -562,12 +785,12 @@ function checkAssigneesEntries(def, issues) {
       message: "at most one assignees-kind field entry per scope \u2014 the inbox reads it by kind"
     });
 }
-function taskShape(task) {
+function activityShape(activity) {
   return {
-    hasActions: (task.actions ?? []).length > 0,
-    hasEffects: (task.effects ?? []).length > 0,
-    hasCompleteWhen: task.completeWhen !== void 0,
-    hasSubworkflows: task.subworkflows !== void 0
+    hasActions: (activity.actions ?? []).length > 0,
+    hasEffects: (activity.effects ?? []).length > 0,
+    hasCompleteWhen: activity.completeWhen !== void 0,
+    hasSubworkflows: activity.subworkflows !== void 0
   };
 }
 const KIND_SHAPE_RULES = {
@@ -575,7 +798,7 @@ const KIND_SHAPE_RULES = {
   service: (s) => s.hasEffects ? [] : ["needs at least one effect \u2014 the automated work it performs"],
   manual: (s) => [
     s.hasActions || s.hasCompleteWhen ? void 0 : "needs a way to complete \u2014 an action to acknowledge it, or a `completeWhen` predicate to verify it (otherwise it auto-resolves on activation)",
-    s.hasSubworkflows ? "is off-system work, not a fan-out \u2014 drop `subworkflows` or move it to its own task" : void 0
+    s.hasSubworkflows ? "is off-system work, not a fan-out \u2014 drop `subworkflows` or move it to its own activity" : void 0
   ].filter((m) => m !== void 0),
   receive: (s) => [
     s.hasCompleteWhen || s.hasSubworkflows ? void 0 : "needs a `completeWhen` (or `subworkflows`) condition to wait on",
@@ -587,53 +810,77 @@ const KIND_SHAPE_RULES = {
     s.hasSubworkflows ? "resolves on activation, so it cannot fan out with `subworkflows`" : void 0
   ].filter((m) => m !== void 0)
 };
-function checkTaskKinds(def, issues) {
+function checkActivityKinds(def, issues) {
   for (const [i, stage] of def.stages.entries())
-    for (const [j, task] of (stage.tasks ?? []).entries()) {
-      const path = ["stages", i, "tasks", j];
-      if (task.target !== void 0 && task.kind !== "manual" && issues.push({
+    for (const [j, activity] of (stage.activities ?? []).entries()) {
+      const path = ["stages", i, "activities", j];
+      if (activity.target !== void 0 && activity.kind !== "manual" && issues.push({
         path: [...path, "target"],
-        message: `task "${task.name}" has a \`target\` but is not \`kind: "manual"\` \u2014 a target is the deep-link for off-system manual work`
-      }), task.kind !== void 0)
-        for (const fault of KIND_SHAPE_RULES[task.kind](taskShape(task)))
+        message: `activity "${activity.name}" has a \`target\` but is not \`kind: "manual"\` \u2014 a target is the deep-link for off-system manual work`
+      }), activity.kind !== void 0)
+        for (const fault of KIND_SHAPE_RULES[activity.kind](activityShape(activity)))
           issues.push({
             path: [...path, "kind"],
-            message: `task "${task.name}" declares kind "${task.kind}" but ${fault}`
+            message: `activity "${activity.name}" declares kind "${activity.kind}" but ${fault}`
           });
     }
 }
 function checkWorkflowInvariants(def) {
   const issues = [], stageNames = checkStages(def, issues);
-  return checkInitialStage(def, stageNames, issues), checkTransitionTargets(def, stageNames, issues), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), checkRequiredField(def, issues), checkPredicates(def, issues), checkCanOutsideActionFilters(def, issues), checkAssigneesEntries(def, issues), checkTaskKinds(def, issues), issues;
+  return checkInitialStage({ def, stageNames, issues }), checkTransitionTargets({ def, stageNames, issues }), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), checkRequiredField(def, issues), checkPredicates(def, issues), checkCanOutsideActionFilters(def, issues), checkAssigneesEntries(def, issues), checkActivityKinds(def, issues), issues;
 }
 function defineWorkflow(definition) {
-  const label = labelFor("defineWorkflow", definition), parsed = parseOrThrow(AuthoringWorkflowSchema, definition, label), { definition: stored, issues: desugarIssues } = desugarWorkflow(parsed), issues = [...desugarIssues, ...checkWorkflowInvariants(stored)];
+  const label = labelFor("defineWorkflow", definition), parsed = parseOrThrow({ schema: AuthoringWorkflowSchema, input: definition, label }), { definition: stored, issues: desugarIssues } = desugarWorkflow(parsed), issues = [...desugarIssues, ...checkWorkflowInvariants(stored)];
   if (issues.length > 0) throw new Error(formatValidationError(label, issues));
   return stored;
 }
 function defineStage(stage) {
-  return parseOrThrow(AuthoringStageSchema, stage, labelFor("defineStage", stage));
+  return parseOrThrow({
+    schema: AuthoringStageSchema,
+    input: stage,
+    label: labelFor("defineStage", stage)
+  });
 }
-function defineTask(task) {
-  return parseOrThrow(AuthoringTaskSchema, task, labelFor("defineTask", task));
+function defineActivity(activity) {
+  return parseOrThrow({
+    schema: AuthoringActivitySchema,
+    input: activity,
+    label: labelFor("defineActivity", activity)
+  });
 }
 function defineAction(action) {
-  return parseOrThrow(AuthoringActionSchema, action, labelFor("defineAction", action));
+  return parseOrThrow({
+    schema: AuthoringActionSchema,
+    input: action,
+    label: labelFor("defineAction", action)
+  });
 }
 function defineTransition(transition) {
-  return parseOrThrow(AuthoringTransitionSchema, transition, transitionLabel(transition));
+  return parseOrThrow({
+    schema: AuthoringTransitionSchema,
+    input: transition,
+    label: transitionLabel(transition)
+  });
 }
 function defineField(entry) {
-  return parseOrThrow(AuthoringFieldEntrySchema, entry, labelFor("defineField", entry));
+  return parseOrThrow({
+    schema: AuthoringFieldEntrySchema,
+    input: entry,
+    label: labelFor("defineField", entry)
+  });
 }
 function defineOp(op) {
-  return parseOrThrow(AuthoringOpSchema, op, "defineOp");
+  return parseOrThrow({ schema: AuthoringOpSchema, input: op, label: "defineOp" });
 }
 function defineGuard(guard) {
-  return parseOrThrow(GuardSchema, guard, labelFor("defineGuard", guard));
+  return parseOrThrow({ schema: GuardSchema, input: guard, label: labelFor("defineGuard", guard) });
 }
 function defineEffect(effect) {
-  return parseOrThrow(EffectSchema, effect, labelFor("defineEffect", effect));
+  return parseOrThrow({
+    schema: EffectSchema,
+    input: effect,
+    label: labelFor("defineEffect", effect)
+  });
 }
 function transitionLabel(transition) {
   const { name, to } = transition;
@@ -643,7 +890,11 @@ function defineEffectDescriptor(descriptor) {
   if (!descriptor.name) throw new Error("EffectDescriptor missing name");
   return descriptor;
 }
-function parseOrThrow(schema, input, label) {
+function parseOrThrow({
+  schema,
+  input,
+  label
+}) {
   const result = v.safeParse(schema, input);
   if (!result.success)
     throw new Error(formatValidationError(label, issuesFromValibot(result.issues)));
@@ -658,13 +909,13 @@ function labelFor(fn, value) {
 }
 export {
   defineAction,
+  defineActivity,
   defineEffect,
   defineEffectDescriptor,
   defineField,
   defineGuard,
   defineOp,
   defineStage,
-  defineTask,
   defineTransition,
   defineWorkflow,
   groq