@sanity/workflow-engine 0.10.0 → 0.12.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,7 +34,7 @@ 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) {
@@ -36,17 +42,17 @@ function actorFulfillsRole(actorRoles, required, aliases) {
   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"
-], 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 +68,28 @@ function picklist(options) {
     `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
   );
 }
-const SourceSchema = v__namespace.lazy(
+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),
@@ -95,12 +97,31 @@ const SourceSchema = v__namespace.lazy(
 }), AuthoringFieldRefSchema = v__namespace.strictObject({
   scope: v__namespace.optional(picklist(FIELD_SCOPES)),
   field: NonEmpty
-}), OpPredicateSchema = v__namespace.lazy(
+}), HREF_SCHEMES = ["http:", "https:"];
+function isHttpUrl(value) {
+  try {
+    return HREF_SCHEMES.includes(new URL(value).protocol);
+  } catch {
+    return !1;
+  }
+}
+const UrlString = v__namespace.pipe(
+  v__namespace.string(),
+  v__namespace.url("must be a valid URL"),
+  v__namespace.check(isHttpUrl, "must be an http(s) URL")
+);
+function manualTargetSchema(ref) {
+  return v__namespace.variant("type", [
+    v__namespace.strictObject({ type: v__namespace.literal("url"), url: UrlString }),
+    v__namespace.strictObject({ type: v__namespace.literal("field"), field: ref })
+  ]);
+}
+const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v__namespace.union([NonEmpty, AuthoringFieldRefSchema])), OpPredicateSchema = v__namespace.lazy(
   () => v__namespace.union([
     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) })
@@ -111,7 +132,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"),
@@ -120,13 +141,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"),
@@ -139,13 +160,13 @@ const 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({
   type: v__namespace.literal("audit"),
   target: AuthoringFieldRefSchema,
-  value: SourceSchema,
+  value: ValueExprSchema,
   stampFields: v__namespace.optional(
     v__namespace.strictObject({
       actor: v__namespace.optional(NonEmpty),
@@ -156,33 +177,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()),
@@ -191,20 +262,47 @@ 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({
+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 = compositeChecked(fieldEntryFields(StoredEditableSchema)), RawAuthoringFieldEntrySchema = compositeChecked(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 listSugarFields(type) {
+  return {
+    type: v__namespace.literal(type),
+    ...slotFields(AuthoringEditableSchema)
+  };
+}
+const TodoListFieldSchema = v__namespace.strictObject(listSugarFields("todoList")), NotesFieldSchema = v__namespace.strictObject(listSugarFields("notes")), AuthoringFieldEntrySchema = 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()),
@@ -245,10 +343,10 @@ 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({
+const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema)), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = v__namespace.strictObject({
   ...actionFields(AuthoringOpSchema),
   roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-  status: v__namespace.optional(TerminalTaskStatus)
+  status: v__namespace.optional(TerminalActivityStatus)
 }), ClaimActionSchema = v__namespace.strictObject({
   type: v__namespace.literal("claim"),
   name: NonEmpty,
@@ -275,17 +373,27 @@ const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema
    */
   context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema))
 });
-function taskFields(field, action, op) {
+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 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(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)
@@ -294,8 +402,8 @@ function taskFields(field, action, op) {
     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),
     /**
@@ -308,14 +416,19 @@ function taskFields(field, action, op) {
     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)
-), AuthoringTaskSchema = v__namespace.strictObject(
-  taskFields(AuthoringFieldEntrySchema, AuthoringActionSchema, AuthoringOpSchema)
+const StoredActivitySchema = v__namespace.strictObject(
+  activityFields(FieldEntrySchema, StoredActionSchema, StoredOpSchema, StoredManualTargetSchema)
+), AuthoringActivitySchema = v__namespace.strictObject(
+  activityFields(
+    AuthoringFieldEntrySchema,
+    AuthoringActionSchema,
+    AuthoringOpSchema,
+    AuthoringManualTargetSchema
+  )
 );
 function transitionFields(op, filter) {
   return {
@@ -369,12 +482,12 @@ 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
@@ -394,11 +507,11 @@ function stageFields(field, task, transition, editable) {
   };
 }
 const StoredStageSchema = v__namespace.strictObject(
-  stageFields(FieldEntrySchema, StoredTaskSchema, StoredTransitionSchema, StoredEditableSchema)
+  stageFields(FieldEntrySchema, StoredActivitySchema, StoredTransitionSchema, StoredEditableSchema)
 ), AuthoringStageSchema = v__namespace.strictObject(
   stageFields(
     AuthoringFieldEntrySchema,
-    AuthoringTaskSchema,
+    AuthoringActivitySchema,
     AuthoringTransitionSchema,
     AuthoringEditableSchema
   )
@@ -409,12 +522,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
@@ -462,14 +574,16 @@ 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;
+exports.DRIVER_KINDS = DRIVER_KINDS;
 exports.EffectSchema = EffectSchema;
 exports.GROQ_IDENTIFIER = GROQ_IDENTIFIER;
 exports.GuardSchema = GuardSchema;
@@ -479,6 +593,7 @@ 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