@sanity/workflow-engine 0.11.0 → 0.13.0

package/dist/_chunks-cjs/schema.cjs

@@ -21,6 +21,12 @@ function andConditions(parts) {
   if (present.length !== 0)
     return present.length === 1 ? present[0] : present.map((p) => `(${p})`).join(" && ");
 }
+const UNIVERSAL_ROLE_ALIAS_KEY = "$all";
+function normalizeRoleAliases(aliases) {
+  if (aliases === void 0 || !("*" in aliases)) return aliases;
+  const { ["*"]: universal, ...perRole } = aliases;
+  return { ...perRole, [UNIVERSAL_ROLE_ALIAS_KEY]: universal };
+}
 function expandRequiredRoles(required, aliases) {
   if (aliases === void 0) return [...required];
   const out = /* @__PURE__ */ new Set();
@@ -28,25 +34,29 @@ function expandRequiredRoles(required, aliases) {
     out.add(role);
     for (const fulfiller of aliases[role] ?? []) out.add(fulfiller);
   }
-  for (const fulfiller of aliases["*"] ?? []) out.add(fulfiller);
+  for (const fulfiller of aliases[UNIVERSAL_ROLE_ALIAS_KEY] ?? []) out.add(fulfiller);
   return [...out];
 }
-function actorFulfillsRole(actorRoles, required, aliases) {
+function actorFulfillsRole({
+  actorRoles,
+  required,
+  aliases
+}) {
   if (actorRoles === void 0 || actorRoles.length === 0) return !1;
   const accepted = new Set(expandRequiredRoles([required], aliases));
   return actorRoles.some((role) => accepted.has(role));
 }
-const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMINAL_TASK_STATUSES = ["done", "skipped", "failed"];
-function isTerminalTaskStatus(status) {
-  return TERMINAL_TASK_STATUSES.includes(status);
+const ACTIVITY_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMINAL_ACTIVITY_STATUSES = ["done", "skipped", "failed"];
+function isTerminalActivityStatus(status) {
+  return TERMINAL_ACTIVITY_STATUSES.includes(status);
 }
-const FIELD_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
+const FIELD_SCOPES = ["workflow", "stage", "activity"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
   "create",
   "update",
   "delete",
   "publish",
   "unpublish"
-], TASK_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+], ACTIVITY_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function groqIdentifier(referencedAs) {
   return v__namespace.pipe(
     v__namespace.string(),
@@ -62,32 +72,31 @@ function picklist(options) {
     `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
   );
 }
-const SourceSchema = v__namespace.lazy(
+function pinned() {
+  return (schema, ..._exact) => schema;
+}
+const LiteralSchema = v__namespace.strictObject({ type: v__namespace.literal("literal"), value: v__namespace.unknown() }), FieldReadSchema = v__namespace.strictObject({
+  type: v__namespace.literal("fieldRead"),
+  scope: v__namespace.optional(v__namespace.union([v__namespace.literal("workflow"), v__namespace.literal("stage")])),
+  field: NonEmpty,
+  path: v__namespace.optional(v__namespace.string())
+}), FieldSourceSchema = v__namespace.union([
+  // The caller supplies it at start/spawn (`initialFields` / `subworkflows.with`).
+  v__namespace.strictObject({ type: v__namespace.literal("input") }),
+  // Computed once by running GROQ against the lake at materialisation.
+  v__namespace.strictObject({ type: v__namespace.literal("query"), query: NonEmpty }),
+  LiteralSchema,
+  FieldReadSchema
+]), ValueExprSchema = v__namespace.lazy(
   () => v__namespace.union([
-    // Field-entry origins: who fills the entry, and when.
-    v__namespace.strictObject({ type: v__namespace.literal("init") }),
-    v__namespace.strictObject({ type: v__namespace.literal("write") }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("query"),
-      query: NonEmpty
-    }),
-    // Value sources: resolved to concrete JSON when an op or seed applies.
-    v__namespace.strictObject({ type: v__namespace.literal("literal"), value: v__namespace.unknown() }),
+    LiteralSchema,
+    FieldReadSchema,
     v__namespace.strictObject({ type: v__namespace.literal("param"), param: NonEmpty }),
     v__namespace.strictObject({ type: v__namespace.literal("actor") }),
     v__namespace.strictObject({ type: v__namespace.literal("now") }),
     v__namespace.strictObject({ type: v__namespace.literal("self") }),
     v__namespace.strictObject({ type: v__namespace.literal("stage") }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("fieldRead"),
-      scope: v__namespace.optional(v__namespace.union([v__namespace.literal("workflow"), v__namespace.literal("stage")])),
-      field: NonEmpty,
-      path: v__namespace.optional(v__namespace.string())
-    }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("object"),
-      fields: v__namespace.record(NonEmpty, SourceSchema)
-    })
+    v__namespace.strictObject({ type: v__namespace.literal("object"), fields: v__namespace.record(NonEmpty, ValueExprSchema) })
   ])
 ), StoredFieldRefSchema = v__namespace.strictObject({
   scope: picklist(FIELD_SCOPES),
@@ -119,7 +128,7 @@ const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), Autho
     v__namespace.strictObject({
       type: v__namespace.literal("field"),
       field: NonEmpty,
-      equals: SourceSchema
+      equals: ValueExprSchema
     }),
     v__namespace.strictObject({ type: v__namespace.literal("all"), of: v__namespace.array(OpPredicateSchema) }),
     v__namespace.strictObject({ type: v__namespace.literal("any"), of: v__namespace.array(OpPredicateSchema) })
@@ -130,7 +139,7 @@ function opSchemas(targetSchema) {
     v__namespace.strictObject({
       type: v__namespace.literal("field.set"),
       target: targetSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v__namespace.strictObject({
       type: v__namespace.literal("field.unset"),
@@ -139,13 +148,13 @@ function opSchemas(targetSchema) {
     v__namespace.strictObject({
       type: v__namespace.literal("field.append"),
       target: targetSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v__namespace.strictObject({
       type: v__namespace.literal("field.updateWhere"),
       target: targetSchema,
       where: OpPredicateSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v__namespace.strictObject({
       type: v__namespace.literal("field.removeWhere"),
@@ -154,17 +163,17 @@ function opSchemas(targetSchema) {
     })
   ];
 }
-const StoredOpSchema = v__namespace.variant("type", [
+const StoredFieldOpSchema = v__namespace.variant("type", [...opSchemas(StoredFieldRefSchema)]), StoredOpSchema = v__namespace.variant("type", [
   ...opSchemas(StoredFieldRefSchema),
   v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
-    task: NonEmpty,
-    status: picklist(TASK_STATUSES)
+    activity: NonEmpty,
+    status: picklist(ACTIVITY_STATUSES)
   })
-]), StoredTransitionOpSchema = v__namespace.variant("type", [...opSchemas(StoredFieldRefSchema)]), AuditOpSchema = v__namespace.strictObject({
+]), StoredTransitionOpSchema = StoredFieldOpSchema, AuditOpSchema = v__namespace.strictObject({
   type: v__namespace.literal("audit"),
   target: AuthoringFieldRefSchema,
-  value: SourceSchema,
+  value: ValueExprSchema,
   stampFields: v__namespace.optional(
     v__namespace.strictObject({
       actor: v__namespace.optional(NonEmpty),
@@ -175,33 +184,83 @@ const StoredOpSchema = v__namespace.variant("type", [
   ...opSchemas(AuthoringFieldRefSchema),
   v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
-    task: v__namespace.optional(NonEmpty),
-    status: picklist(TASK_STATUSES)
+    activity: v__namespace.optional(NonEmpty),
+    status: picklist(ACTIVITY_STATUSES)
   }),
   AuditOpSchema
-]), FieldKindSchema = picklist([
+]), FIELD_VALUE_KINDS = [
   "doc.ref",
   "doc.refs",
   // Release reference. A workflow declares this entry to say "I target a
   // Content Release"; the runtime fills it at start time and auto-derives
   // the instance's read perspective from it.
   "release.ref",
-  "query",
-  "value.string",
-  "value.url",
-  "value.number",
-  "value.boolean",
-  "value.dateTime",
-  "value.actor",
-  "checklist",
-  "notes",
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "url",
+  "actor",
+  // A single {@link Assignee} — the singular of `assignees`.
+  "assignee",
   // The WHO-FOR entry: the inbox reverse-query reads it by kind, and the
   // rendered `$assigned` gate matches the caller against it.
-  "assignees"
-]), FieldEntryName = groqIdentifier("`$fields.<name>`"), StoredEditableSchema = v__namespace.union([v__namespace.literal(!0), NonEmpty]), AuthoringEditableSchema = v__namespace.union([v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty]);
-function fieldEntryFields(editable) {
+  "assignees",
+  // Compositional kinds — mirror Sanity's `object.fields` / `array.of`.
+  "object",
+  "array"
+], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), FieldEntryName = groqIdentifier("`$fields.<name>`");
+function asShape(input) {
+  return typeof input == "object" && input !== null ? input : {};
+}
+function compositeShapeOk(input) {
+  const shape = asShape(input);
+  return shape.type === "object" ? Array.isArray(shape.fields) && shape.fields.length > 0 && shape.of === void 0 : shape.type === "array" ? Array.isArray(shape.of) && shape.of.length > 0 && shape.fields === void 0 : shape.fields === void 0 && shape.of === void 0;
+}
+function compositeShapeMessage(input) {
+  const shape = asShape(input);
+  return shape.type === "object" ? shape.of !== void 0 ? "an `object` kind declares its sub-fields with `fields`, not `of`" : "an `object` kind needs a non-empty `fields` list of sub-field shapes" : shape.type === "array" ? shape.fields !== void 0 ? "an `array` kind declares its item shape with `of`, not `fields`" : "an `array` kind needs a non-empty `of` list of sub-field shapes" : `\`fields\` / \`of\` are only valid on the \`object\` / \`array\` kinds, not "${String(shape.type)}"`;
+}
+function duplicateSubfieldName(input) {
+  const shape = asShape(input);
+  let list = [];
+  Array.isArray(shape.fields) ? list = shape.fields : Array.isArray(shape.of) && (list = shape.of);
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    const name = asShape(item).name;
+    if (typeof name == "string") {
+      if (seen.has(name)) return name;
+      seen.add(name);
+    }
+  }
+}
+function compositeChecked(entries) {
+  return v__namespace.pipe(
+    v__namespace.strictObject(entries),
+    v__namespace.check(
+      (input) => compositeShapeOk(input),
+      (issue) => compositeShapeMessage(issue.input)
+    ),
+    v__namespace.check(
+      (input) => duplicateSubfieldName(input) === void 0,
+      (issue) => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" \u2014 sub-field names must be unique within \`fields\` / \`of\``
+    )
+  );
+}
+const FieldShapeSchema = v__namespace.lazy(
+  () => compositeChecked({
+    type: FieldValueKindSchema,
+    name: FieldEntryName,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string()),
+    fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
+    of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+  })
+), StoredEditableSchema = v__namespace.union([v__namespace.literal(!0), NonEmpty]), AuthoringEditableSchema = v__namespace.union([v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty]);
+function slotFields(editable) {
   return {
-    type: FieldKindSchema,
     name: FieldEntryName,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
@@ -210,20 +269,50 @@ function fieldEntryFields(editable) {
      * `initialFields`) or spawn (via the parent's `subworkflows.with`). A
      * missing required entry throws rather than silently defaulting to
      * `null`/`[]` — the same fail-fast an action's `required` param gets.
-     * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+     * Valid only on a workflow-scope `input`-sourced entry (deploy invariant).
      */
     required: v__namespace.optional(v__namespace.boolean()),
-    source: SourceSchema,
+    /**
+     * How this field SEEDS its value at materialisation — see
+     * {@link FieldSourceSchema}. Optional: an absent `initialValue` is working
+     * memory (the slot starts empty and an op fills it later), the common case.
+     */
+    initialValue: v__namespace.optional(FieldSourceSchema),
     /** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
     editable: v__namespace.optional(editable)
   };
 }
-const FieldEntrySchema = v__namespace.strictObject(fieldEntryFields(StoredEditableSchema)), RawAuthoringFieldEntrySchema = v__namespace.strictObject(fieldEntryFields(AuthoringEditableSchema)), ClaimFieldSchema = v__namespace.strictObject({
-  type: v__namespace.literal("claim"),
-  name: FieldEntryName,
-  title: v__namespace.optional(v__namespace.string()),
-  description: v__namespace.optional(v__namespace.string())
-}), AuthoringFieldEntrySchema = v__namespace.union([RawAuthoringFieldEntrySchema, ClaimFieldSchema]), ConditionSchema = NonEmpty, EffectSchema = v__namespace.strictObject({
+function fieldEntryFields(editable) {
+  return {
+    type: FieldKindSchema,
+    ...slotFields(editable),
+    /** Sub-field shapes for an `object` kind (see {@link compositeShapeOk}). */
+    fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
+    /** Item sub-field shapes for an `array` kind (see {@link compositeShapeOk}). */
+    of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+  };
+}
+const FieldEntrySchema = pinned()(
+  compositeChecked(fieldEntryFields(StoredEditableSchema))
+), RawAuthoringFieldEntrySchema = pinned()(
+  compositeChecked(fieldEntryFields(AuthoringEditableSchema))
+), ClaimFieldSchema = pinned()(
+  v__namespace.strictObject({
+    type: v__namespace.literal("claim"),
+    name: FieldEntryName,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string())
+  })
+);
+function listSugarFields(type) {
+  return {
+    type: v__namespace.literal(type),
+    ...slotFields(AuthoringEditableSchema)
+  };
+}
+const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(
+  v__namespace.union([RawAuthoringFieldEntrySchema, ClaimFieldSchema, TodoListFieldSchema, NotesFieldSchema])
+), ConditionSchema = NonEmpty, EffectSchema = v__namespace.strictObject({
   name: NonEmpty,
   title: v__namespace.optional(v__namespace.string()),
   description: v__namespace.optional(v__namespace.string()),
@@ -264,21 +353,27 @@ function actionFields(op) {
     effects: v__namespace.optional(v__namespace.array(EffectSchema))
   };
 }
-const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema)), TerminalTaskStatus = picklist(TERMINAL_TASK_STATUSES), RawAuthoringActionSchema = v__namespace.strictObject({
-  ...actionFields(AuthoringOpSchema),
-  roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-  status: v__namespace.optional(TerminalTaskStatus)
-}), ClaimActionSchema = v__namespace.strictObject({
-  type: v__namespace.literal("claim"),
-  name: NonEmpty,
-  title: v__namespace.optional(v__namespace.string()),
-  description: v__namespace.optional(v__namespace.string()),
-  field: v__namespace.union([NonEmpty, AuthoringFieldRefSchema]),
-  roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-  filter: v__namespace.optional(ConditionSchema),
-  params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
-  effects: v__namespace.optional(v__namespace.array(EffectSchema))
-}), AuthoringActionSchema = v__namespace.union([RawAuthoringActionSchema, ClaimActionSchema]), DefinitionRefSchema = v__namespace.strictObject({
+const StoredActionSchema = pinned()(v__namespace.strictObject(actionFields(StoredOpSchema))), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(
+  v__namespace.strictObject({
+    ...actionFields(AuthoringOpSchema),
+    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
+    status: v__namespace.optional(TerminalActivityStatus)
+  })
+), ClaimActionSchema = pinned()(
+  v__namespace.strictObject({
+    type: v__namespace.literal("claim"),
+    name: NonEmpty,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string()),
+    field: v__namespace.union([NonEmpty, AuthoringFieldRefSchema]),
+    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
+    filter: v__namespace.optional(ConditionSchema),
+    params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
+    effects: v__namespace.optional(v__namespace.array(EffectSchema))
+  })
+), AuthoringActionSchema = pinned()(
+  v__namespace.union([RawAuthoringActionSchema, ClaimActionSchema])
+), DefinitionRefSchema = v__namespace.strictObject({
   name: NonEmpty,
   version: v__namespace.optional(v__namespace.union([PositiveInt, v__namespace.literal("latest")]))
 }), SubworkflowsSchema = v__namespace.strictObject({
@@ -294,27 +389,27 @@ const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema
    */
   context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema))
 });
-function taskFields(field, action, op, target) {
+function activityFields({ field, action, op, target }) {
   return {
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
     /**
-     * Advisory BPMN-aligned classification of this task by its executor (see
-     * {@link TASK_KINDS}). Optional and derived from the task's shape when
+     * Advisory BPMN-aligned classification of this activity by its executor (see
+     * {@link ACTIVITY_KINDS}). Optional and derived from the activity's shape when
      * omitted; declaring it lets deploy check the shape matches the lane.
      * Changes no gating or resolution — a label for tooling, like `assignees`.
      */
-    kind: v__namespace.optional(picklist(TASK_KINDS)),
-    /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
-     *  metadata; only valid on a manual task (deploy-checked). */
+    kind: v__namespace.optional(picklist(ACTIVITY_KINDS)),
+    /** Deep-link target for a `kind: "manual"` activity (off-system work). Render-only
+     *  metadata; only valid on a manual activity (deploy-checked). */
     target: v__namespace.optional(target),
     activation: v__namespace.optional(picklist(["auto", "manual"])),
     filter: v__namespace.optional(ConditionSchema),
     /**
      * Readiness gates, by name — conditions over the rendered scope that must
-     * hold for the task to be *executable*, orthogonal to `filter`
-     * (visibility). An unmet requirement keeps the task visible but disables
+     * hold for the activity to be *executable*, orthogonal to `filter`
+     * (visibility). An unmet requirement keeps the activity visible but disables
      * its actions with a `requirements-unmet` verdict naming the unmet keys;
      * all must hold (any-of lives inside one condition). Advisory like every
      * engine gate — the lake still enforces. Distinct from ACL (authorization)
@@ -323,8 +418,8 @@ function taskFields(field, action, op, target) {
     requirements: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
     /**
      * Auto-completion condition — evaluated at activation and on every
-     * cascade; truthy flips the task to `done` with a system actor. On a
-     * spawning task it typically reads `$subworkflows`.
+     * cascade; truthy flips the activity to `done` with a system actor. On a
+     * spawning activity it typically reads `$subworkflows`.
      */
     completeWhen: v__namespace.optional(ConditionSchema),
     /**
@@ -337,18 +432,27 @@ function taskFields(field, action, op, target) {
     effects: v__namespace.optional(v__namespace.array(EffectSchema)),
     actions: v__namespace.optional(v__namespace.array(action)),
     subworkflows: v__namespace.optional(SubworkflowsSchema),
-    /** Task-scoped field entries. Resolved at task activation time. */
+    /** Activity-scoped field entries. Resolved at activity activation time. */
     fields: v__namespace.optional(v__namespace.array(field))
   };
 }
-const StoredTaskSchema = v__namespace.strictObject(
-  taskFields(FieldEntrySchema, StoredActionSchema, StoredOpSchema, StoredManualTargetSchema)
-), AuthoringTaskSchema = v__namespace.strictObject(
-  taskFields(
-    AuthoringFieldEntrySchema,
-    AuthoringActionSchema,
-    AuthoringOpSchema,
-    AuthoringManualTargetSchema
+const StoredActivitySchema = pinned()(
+  v__namespace.strictObject(
+    activityFields({
+      field: FieldEntrySchema,
+      action: StoredActionSchema,
+      op: StoredOpSchema,
+      target: StoredManualTargetSchema
+    })
+  )
+), AuthoringActivitySchema = pinned()(
+  v__namespace.strictObject(
+    activityFields({
+      field: AuthoringFieldEntrySchema,
+      action: AuthoringActionSchema,
+      op: AuthoringOpSchema,
+      target: AuthoringManualTargetSchema
+    })
   )
 );
 function transitionFields(op, filter) {
@@ -363,13 +467,13 @@ function transitionFields(op, filter) {
     effects: v__namespace.optional(v__namespace.array(EffectSchema))
   };
 }
-const StoredTransitionSchema = v__namespace.strictObject(
-  transitionFields(StoredTransitionOpSchema, ConditionSchema)
+const StoredTransitionSchema = pinned()(
+  v__namespace.strictObject(transitionFields(StoredTransitionOpSchema, ConditionSchema))
 ), AuthoringTransitionOpSchema = v__namespace.variant("type", [
   ...opSchemas(AuthoringFieldRefSchema),
   AuditOpSchema
-]), AuthoringTransitionSchema = v__namespace.strictObject(
-  transitionFields(AuthoringTransitionOpSchema, v__namespace.optional(ConditionSchema))
+]), AuthoringTransitionSchema = pinned()(
+  v__namespace.strictObject(transitionFields(AuthoringTransitionOpSchema, v__namespace.optional(ConditionSchema)))
 ), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v__namespace.strictObject({
   /** Subject `_type`(s); empty matches any type. */
   types: v__namespace.optional(v__namespace.array(NonEmpty)),
@@ -403,12 +507,17 @@ const StoredTransitionSchema = v__namespace.strictObject(
    */
   metadata: v__namespace.optional(v__namespace.record(NonEmpty, NonEmpty))
 });
-function stageFields(field, task, transition, editable) {
+function stageFields({
+  field,
+  activity,
+  transition,
+  editable
+}) {
   return {
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
-    tasks: v__namespace.optional(v__namespace.array(task)),
+    activities: v__namespace.optional(v__namespace.array(activity)),
     transitions: v__namespace.optional(v__namespace.array(transition)),
     /**
      * Lake mutation guards active while this stage holds. Each compiles to a
@@ -427,14 +536,23 @@ function stageFields(field, task, transition, editable) {
     editable: v__namespace.optional(v__namespace.record(FieldEntryName, editable))
   };
 }
-const StoredStageSchema = v__namespace.strictObject(
-  stageFields(FieldEntrySchema, StoredTaskSchema, StoredTransitionSchema, StoredEditableSchema)
-), AuthoringStageSchema = v__namespace.strictObject(
-  stageFields(
-    AuthoringFieldEntrySchema,
-    AuthoringTaskSchema,
-    AuthoringTransitionSchema,
-    AuthoringEditableSchema
+const StoredStageSchema = pinned()(
+  v__namespace.strictObject(
+    stageFields({
+      field: FieldEntrySchema,
+      activity: StoredActivitySchema,
+      transition: StoredTransitionSchema,
+      editable: StoredEditableSchema
+    })
+  )
+), AuthoringStageSchema = pinned()(
+  v__namespace.strictObject(
+    stageFields({
+      field: AuthoringFieldEntrySchema,
+      activity: AuthoringActivitySchema,
+      transition: AuthoringTransitionSchema,
+      editable: AuthoringEditableSchema
+    })
   )
 ), RoleAliasesSchema = v__namespace.record(
   NonEmpty,
@@ -443,12 +561,11 @@ const StoredStageSchema = v__namespace.strictObject(
 function workflowFields(field, stage) {
   return {
     name: NonEmpty,
-    version: PositiveInt,
     title: NonEmpty,
     description: v__namespace.optional(v__namespace.string()),
     /**
      * Whether a human may start this workflow standalone. `'child'` marks a
-     * spawn-only definition — instantiated by a parent via `task.subworkflows`,
+     * spawn-only definition — instantiated by a parent via `activity.subworkflows`,
      * never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
      * Advisory: consumers filter their start pickers on it (see
      * {@link isStartableDefinition}); the engine does NOT refuse a
@@ -471,9 +588,11 @@ function workflowFields(field, stage) {
     roleAliases: v__namespace.optional(RoleAliasesSchema)
   };
 }
-v__namespace.strictObject(workflowFields(FieldEntrySchema, StoredStageSchema));
-const AuthoringWorkflowSchema = v__namespace.strictObject(
-  workflowFields(AuthoringFieldEntrySchema, AuthoringStageSchema)
+pinned()(
+  v__namespace.strictObject(workflowFields(FieldEntrySchema, StoredStageSchema))
+);
+const AuthoringWorkflowSchema = pinned()(
+  v__namespace.strictObject(workflowFields(AuthoringFieldEntrySchema, AuthoringStageSchema))
 ), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
 function isStartableDefinition(definition) {
   return definition.role !== "child";
@@ -496,11 +615,12 @@ function formatPath(path) {
     typeof seg == "number" ? out += `[${seg}]` : out += out.length === 0 ? String(seg) : `.${String(seg)}`;
   return out;
 }
+exports.ACTIVITY_KINDS = ACTIVITY_KINDS;
 exports.AuthoringActionSchema = AuthoringActionSchema;
+exports.AuthoringActivitySchema = AuthoringActivitySchema;
 exports.AuthoringFieldEntrySchema = AuthoringFieldEntrySchema;
 exports.AuthoringOpSchema = AuthoringOpSchema;
 exports.AuthoringStageSchema = AuthoringStageSchema;
-exports.AuthoringTaskSchema = AuthoringTaskSchema;
 exports.AuthoringTransitionSchema = AuthoringTransitionSchema;
 exports.AuthoringWorkflowSchema = AuthoringWorkflowSchema;
 exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
@@ -508,13 +628,14 @@ exports.DRIVER_KINDS = DRIVER_KINDS;
 exports.EffectSchema = EffectSchema;
 exports.GROQ_IDENTIFIER = GROQ_IDENTIFIER;
 exports.GuardSchema = GuardSchema;
-exports.TASK_KINDS = TASK_KINDS;
+exports.StoredFieldOpSchema = StoredFieldOpSchema;
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
 exports.actorFulfillsRole = actorFulfillsRole;
 exports.andConditions = andConditions;
 exports.expandRequiredRoles = expandRequiredRoles;
 exports.formatValidationError = formatValidationError;
 exports.isStartableDefinition = isStartableDefinition;
-exports.isTerminalTaskStatus = isTerminalTaskStatus;
+exports.isTerminalActivityStatus = isTerminalActivityStatus;
 exports.issuesFromValibot = issuesFromValibot;
+exports.normalizeRoleAliases = normalizeRoleAliases;
 //# sourceMappingURL=schema.cjs.map