@sanity/workflow-engine 0.13.0 → 0.15.0

package/dist/_chunks-es/schema.js

@@ -1,626 +0,0 @@
-import * as v from "valibot";
-function andConditions(parts) {
-  const present = parts.filter((p) => p !== void 0);
-  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();
-  for (const role of required) {
-    out.add(role);
-    for (const fulfiller of aliases[role] ?? []) out.add(fulfiller);
-  }
-  for (const fulfiller of aliases[UNIVERSAL_ROLE_ALIAS_KEY] ?? []) out.add(fulfiller);
-  return [...out];
-}
-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 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", "activity"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
-  "create",
-  "update",
-  "delete",
-  "publish",
-  "unpublish"
-], ACTIVITY_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function groqIdentifier(referencedAs) {
-  return v.pipe(
-    v.string(),
-    v.regex(
-      GROQ_IDENTIFIER,
-      `must be a GROQ-safe identifier (letters, digits, underscore; not starting with a digit) because it is referenced as ${referencedAs} in GROQ conditions`
-    )
-  );
-}
-function picklist(options) {
-  return v.picklist(
-    options,
-    `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
-  );
-}
-function pinned() {
-  return (schema, ..._exact) => schema;
-}
-const LiteralSchema = v.strictObject({ type: v.literal("literal"), value: v.unknown() }), FieldReadSchema = v.strictObject({
-  type: v.literal("fieldRead"),
-  scope: v.optional(v.union([v.literal("workflow"), v.literal("stage")])),
-  field: NonEmpty,
-  path: v.optional(v.string())
-}), FieldSourceSchema = v.union([
-  // The caller supplies it at start/spawn (`initialFields` / `subworkflows.with`).
-  v.strictObject({ type: v.literal("input") }),
-  // Computed once by running GROQ against the lake at materialisation.
-  v.strictObject({ type: v.literal("query"), query: NonEmpty }),
-  LiteralSchema,
-  FieldReadSchema
-]), ValueExprSchema = v.lazy(
-  () => v.union([
-    LiteralSchema,
-    FieldReadSchema,
-    v.strictObject({ type: v.literal("param"), param: NonEmpty }),
-    v.strictObject({ type: v.literal("actor") }),
-    v.strictObject({ type: v.literal("now") }),
-    v.strictObject({ type: v.literal("self") }),
-    v.strictObject({ type: v.literal("stage") }),
-    v.strictObject({ type: v.literal("object"), fields: v.record(NonEmpty, ValueExprSchema) })
-  ])
-), StoredFieldRefSchema = v.strictObject({
-  scope: picklist(FIELD_SCOPES),
-  field: NonEmpty
-}), AuthoringFieldRefSchema = v.strictObject({
-  scope: v.optional(picklist(FIELD_SCOPES)),
-  field: NonEmpty
-}), HREF_SCHEMES = ["http:", "https:"];
-function isHttpUrl(value) {
-  try {
-    return HREF_SCHEMES.includes(new URL(value).protocol);
-  } catch {
-    return !1;
-  }
-}
-const UrlString = v.pipe(
-  v.string(),
-  v.url("must be a valid URL"),
-  v.check(isHttpUrl, "must be an http(s) URL")
-);
-function manualTargetSchema(ref) {
-  return v.variant("type", [
-    v.strictObject({ type: v.literal("url"), url: UrlString }),
-    v.strictObject({ type: v.literal("field"), field: ref })
-  ]);
-}
-const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v.union([NonEmpty, AuthoringFieldRefSchema])), OpPredicateSchema = v.lazy(
-  () => v.union([
-    v.strictObject({
-      type: v.literal("field"),
-      field: NonEmpty,
-      equals: ValueExprSchema
-    }),
-    v.strictObject({ type: v.literal("all"), of: v.array(OpPredicateSchema) }),
-    v.strictObject({ type: v.literal("any"), of: v.array(OpPredicateSchema) })
-  ])
-);
-function opSchemas(targetSchema) {
-  return [
-    v.strictObject({
-      type: v.literal("field.set"),
-      target: targetSchema,
-      value: ValueExprSchema
-    }),
-    v.strictObject({
-      type: v.literal("field.unset"),
-      target: targetSchema
-    }),
-    v.strictObject({
-      type: v.literal("field.append"),
-      target: targetSchema,
-      value: ValueExprSchema
-    }),
-    v.strictObject({
-      type: v.literal("field.updateWhere"),
-      target: targetSchema,
-      where: OpPredicateSchema,
-      value: ValueExprSchema
-    }),
-    v.strictObject({
-      type: v.literal("field.removeWhere"),
-      target: targetSchema,
-      where: OpPredicateSchema
-    })
-  ];
-}
-const StoredFieldOpSchema = v.variant("type", [...opSchemas(StoredFieldRefSchema)]), StoredOpSchema = v.variant("type", [
-  ...opSchemas(StoredFieldRefSchema),
-  v.strictObject({
-    type: v.literal("status.set"),
-    activity: NonEmpty,
-    status: picklist(ACTIVITY_STATUSES)
-  })
-]), StoredTransitionOpSchema = StoredFieldOpSchema, AuditOpSchema = v.strictObject({
-  type: v.literal("audit"),
-  target: AuthoringFieldRefSchema,
-  value: ValueExprSchema,
-  stampFields: v.optional(
-    v.strictObject({
-      actor: v.optional(NonEmpty),
-      at: v.optional(NonEmpty)
-    })
-  )
-}), AuthoringOpSchema = v.variant("type", [
-  ...opSchemas(AuthoringFieldRefSchema),
-  v.strictObject({
-    type: v.literal("status.set"),
-    activity: v.optional(NonEmpty),
-    status: picklist(ACTIVITY_STATUSES)
-  }),
-  AuditOpSchema
-]), 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",
-  "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",
-  // 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.pipe(
-    v.strictObject(entries),
-    v.check(
-      (input) => compositeShapeOk(input),
-      (issue) => compositeShapeMessage(issue.input)
-    ),
-    v.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.lazy(
-  () => compositeChecked({
-    type: FieldValueKindSchema,
-    name: FieldEntryName,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    fields: v.optional(v.array(FieldShapeSchema)),
-    of: v.optional(v.array(FieldShapeSchema))
-  })
-), StoredEditableSchema = v.union([v.literal(!0), NonEmpty]), AuthoringEditableSchema = v.union([v.literal(!0), v.array(NonEmpty), NonEmpty]);
-function slotFields(editable) {
-  return {
-    name: FieldEntryName,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    /**
-     * When true, the caller MUST supply this entry at start (via
-     * `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 `input`-sourced entry (deploy invariant).
-     */
-    required: v.optional(v.boolean()),
-    /**
-     * 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.optional(FieldSourceSchema),
-    /** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
-    editable: v.optional(editable)
-  };
-}
-function fieldEntryFields(editable) {
-  return {
-    type: FieldKindSchema,
-    ...slotFields(editable),
-    /** Sub-field shapes for an `object` kind (see {@link compositeShapeOk}). */
-    fields: v.optional(v.array(FieldShapeSchema)),
-    /** Item sub-field shapes for an `array` kind (see {@link compositeShapeOk}). */
-    of: v.optional(v.array(FieldShapeSchema))
-  };
-}
-const FieldEntrySchema = pinned()(
-  compositeChecked(fieldEntryFields(StoredEditableSchema))
-), RawAuthoringFieldEntrySchema = pinned()(
-  compositeChecked(fieldEntryFields(AuthoringEditableSchema))
-), ClaimFieldSchema = pinned()(
-  v.strictObject({
-    type: v.literal("claim"),
-    name: FieldEntryName,
-    title: v.optional(v.string()),
-    description: v.optional(v.string())
-  })
-);
-function listSugarFields(type) {
-  return {
-    type: v.literal(type),
-    ...slotFields(AuthoringEditableSchema)
-  };
-}
-const TodoListFieldSchema = pinned()(v.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(
-  v.union([RawAuthoringFieldEntrySchema, ClaimFieldSchema, TodoListFieldSchema, NotesFieldSchema])
-), ConditionSchema = NonEmpty, EffectSchema = v.strictObject({
-  name: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  /** GROQ reads over the rendered scope, resolved to concrete JSON at queue time. */
-  bindings: v.optional(v.record(v.string(), ConditionSchema)),
-  /** Static config, passed through to the handler verbatim. */
-  input: v.optional(v.record(v.string(), v.unknown()))
-}), ActionParamSchema = v.strictObject({
-  type: picklist([
-    "string",
-    "number",
-    "boolean",
-    "url",
-    "dateTime",
-    "actor",
-    "doc.ref",
-    "doc.refs",
-    "json"
-  ]),
-  name: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  required: v.optional(v.boolean())
-});
-function actionFields(op) {
-  return {
-    name: NonEmpty,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    /**
-     * The one gate mechanism: a condition over the rendered scope. Hard
-     * enforcement lives outside the engine entirely (the lake ACL on the
-     * documents, and guards) — every engine-evaluated gate is authoring/UX.
-     */
-    filter: v.optional(ConditionSchema),
-    params: v.optional(v.array(ActionParamSchema)),
-    ops: v.optional(v.array(op)),
-    effects: v.optional(v.array(EffectSchema))
-  };
-}
-const StoredActionSchema = pinned()(v.strictObject(actionFields(StoredOpSchema))), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(
-  v.strictObject({
-    ...actionFields(AuthoringOpSchema),
-    roles: v.optional(v.array(NonEmpty)),
-    status: v.optional(TerminalActivityStatus)
-  })
-), ClaimActionSchema = pinned()(
-  v.strictObject({
-    type: v.literal("claim"),
-    name: NonEmpty,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    field: v.union([NonEmpty, AuthoringFieldRefSchema]),
-    roles: v.optional(v.array(NonEmpty)),
-    filter: v.optional(ConditionSchema),
-    params: v.optional(v.array(ActionParamSchema)),
-    effects: v.optional(v.array(EffectSchema))
-  })
-), AuthoringActionSchema = pinned()(
-  v.union([RawAuthoringActionSchema, ClaimActionSchema])
-), DefinitionRefSchema = v.strictObject({
-  name: NonEmpty,
-  version: v.optional(v.union([PositiveInt, v.literal("latest")]))
-}), SubworkflowsSchema = v.strictObject({
-  /** GROQ producing one row per subworkflow; each row binds as `$row`. */
-  forEach: NonEmpty,
-  definition: DefinitionRefSchema,
-  /** Initial fields for each subworkflow — entry name → GROQ over `$row` + the parent scope. */
-  with: v.optional(v.record(NonEmpty, ConditionSchema)),
-  /**
-   * Extra values evaluated in the parent's rendered scope at spawn time and
-   * delivered into each subworkflow's `$effects` bag — the parent→child
-   * handoff, read exactly like an effect output.
-   */
-  context: v.optional(v.record(NonEmpty, ConditionSchema))
-});
-function activityFields({ field, action, op, target }) {
-  return {
-    name: NonEmpty,
-    title: v.optional(v.string()),
-    description: v.optional(v.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.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.optional(target),
-    activation: v.optional(picklist(["auto", "manual"])),
-    filter: v.optional(ConditionSchema),
-    /**
-     * Readiness gates, by name — conditions over the rendered scope that must
-     * 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)
-     * and guards (content-write locks).
-     */
-    requirements: v.optional(v.record(NonEmpty, ConditionSchema)),
-    /**
-     * Auto-completion condition — evaluated at activation and on every
-     * cascade; truthy flips the activity to `done` with a system actor. On a
-     * spawning activity it typically reads `$subworkflows`.
-     */
-    completeWhen: v.optional(ConditionSchema),
-    /**
-     * Auto-failure condition — symmetric to `completeWhen`, flips to
-     * `failed`. When both are truthy on the same evaluation, `failWhen`
-     * wins — failure is the more notable signal.
-     */
-    failWhen: v.optional(ConditionSchema),
-    ops: v.optional(v.array(op)),
-    effects: v.optional(v.array(EffectSchema)),
-    actions: v.optional(v.array(action)),
-    subworkflows: v.optional(SubworkflowsSchema),
-    /** Activity-scoped field entries. Resolved at activity activation time. */
-    fields: v.optional(v.array(field))
-  };
-}
-const StoredActivitySchema = pinned()(
-  v.strictObject(
-    activityFields({
-      field: FieldEntrySchema,
-      action: StoredActionSchema,
-      op: StoredOpSchema,
-      target: StoredManualTargetSchema
-    })
-  )
-), AuthoringActivitySchema = pinned()(
-  v.strictObject(
-    activityFields({
-      field: AuthoringFieldEntrySchema,
-      action: AuthoringActionSchema,
-      op: AuthoringOpSchema,
-      target: AuthoringManualTargetSchema
-    })
-  )
-);
-function transitionFields(op, filter) {
-  return {
-    name: NonEmpty,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    to: NonEmpty,
-    filter,
-    /** The `field.*` subset — field-write-on-move, the stage's EXIT/ARRIVAL payload. */
-    ops: v.optional(v.array(op)),
-    effects: v.optional(v.array(EffectSchema))
-  };
-}
-const StoredTransitionSchema = pinned()(
-  v.strictObject(transitionFields(StoredTransitionOpSchema, ConditionSchema))
-), AuthoringTransitionOpSchema = v.variant("type", [
-  ...opSchemas(AuthoringFieldRefSchema),
-  AuditOpSchema
-]), AuthoringTransitionSchema = pinned()(
-  v.strictObject(transitionFields(AuthoringTransitionOpSchema, v.optional(ConditionSchema)))
-), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v.strictObject({
-  /** Subject `_type`(s); empty matches any type. */
-  types: v.optional(v.array(NonEmpty)),
-  /** Target docs as `$fields` reads (or `"$self"`), resolved at deploy to bare ids + the resource. */
-  idRefs: v.optional(v.array(NonEmpty)),
-  /** Glob id patterns (bare, resource-local). */
-  idPatterns: v.optional(v.array(NonEmpty)),
-  actions: v.pipe(
-    v.array(GuardActionSchema),
-    v.minLength(1, "a guard must match at least one action")
-  )
-}), GuardSchema = v.strictObject({
-  name: NonEmpty,
-  title: v.optional(v.string()),
-  description: v.optional(v.string()),
-  match: GuardMatchSchema,
-  /**
-   * Lake GROQ predicate — a distinct eval context reading
-   * `document.before`/`document.after`, `mutation`, `guard`, and
-   * `identity()`. Bare ids/fields only. Omitted or empty means
-   * UNCONDITIONAL DENY.
-   */
-  predicate: v.optional(v.string()),
-  /**
-   * Projected workflow fields the predicate reads as `guard.metadata.*` —
-   * the only bridge from the lake eval context (which cannot see `$fields`)
-   * to workflow fields. Values are NOT GROQ: each is a deploy-time read in
-   * the guard mini-language — `"$self"`, `"$now"`, or
-   * `"$fields.<name>[.path]"` — resolved into a bare value at deploy and
-   * re-synced by the post-field-op guard refresh.
-   */
-  metadata: v.optional(v.record(NonEmpty, NonEmpty))
-});
-function stageFields({
-  field,
-  activity,
-  transition,
-  editable
-}) {
-  return {
-    name: NonEmpty,
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    activities: v.optional(v.array(activity)),
-    transitions: v.optional(v.array(transition)),
-    /**
-     * Lake mutation guards active while this stage holds. Each compiles to a
-     * `temp.system.guard` doc deployed on stage entry and retracted on exit.
-     */
-    guards: v.optional(v.array(GuardSchema)),
-    /** Stage-scoped field entries. Resolved at stage entry. */
-    fields: v.optional(v.array(field)),
-    /**
-     * Tighten-only editability overrides for the time this stage holds, keyed
-     * by an in-scope slot name. The slot's own `editable` is the ceiling; a
-     * stage value is ANDed with it at runtime, so an override can only NARROW
-     * (never open a slot the baseline left closed). An unlisted slot inherits
-     * its baseline.
-     */
-    editable: v.optional(v.record(FieldEntryName, editable))
-  };
-}
-const StoredStageSchema = pinned()(
-  v.strictObject(
-    stageFields({
-      field: FieldEntrySchema,
-      activity: StoredActivitySchema,
-      transition: StoredTransitionSchema,
-      editable: StoredEditableSchema
-    })
-  )
-), AuthoringStageSchema = pinned()(
-  v.strictObject(
-    stageFields({
-      field: AuthoringFieldEntrySchema,
-      activity: AuthoringActivitySchema,
-      transition: AuthoringTransitionSchema,
-      editable: AuthoringEditableSchema
-    })
-  )
-), RoleAliasesSchema = v.record(
-  NonEmpty,
-  v.pipe(v.array(NonEmpty), v.minLength(1, "a role alias must list at least one fulfilling role"))
-), WORKFLOW_ROLES = ["workflow", "child"];
-function workflowFields(field, stage) {
-  return {
-    name: NonEmpty,
-    title: NonEmpty,
-    description: v.optional(v.string()),
-    /**
-     * Whether a human may start this workflow standalone. `'child'` marks a
-     * 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
-     * `startInstance` on a `'child'` def — load-bearing `required` field is the
-     * runtime backstop.
-     */
-    role: v.optional(picklist(WORKFLOW_ROLES)),
-    /** Reference field: named for the target, holds the stage's `name`. */
-    initialStage: NonEmpty,
-    /** Workflow-scope field entries. Persist for the instance lifetime. */
-    fields: v.optional(v.array(field)),
-    stages: v.pipe(v.array(stage), v.minLength(1, "must declare at least one stage")),
-    /**
-     * Nullary named conditions — each `name: groq` entry is pre-evaluated
-     * and bound as the boolean `$name` var, composable with native GROQ.
-     * Redefining a built-in var is a deploy error (never silently shadow).
-     */
-    predicates: v.optional(v.record(groqIdentifier("`$<name>`"), ConditionSchema)),
-    /** Role aliasing for this definition — see {@link RoleAliasesSchema}. */
-    roleAliases: v.optional(RoleAliasesSchema)
-  };
-}
-pinned()(
-  v.strictObject(workflowFields(FieldEntrySchema, StoredStageSchema))
-);
-const AuthoringWorkflowSchema = pinned()(
-  v.strictObject(workflowFields(AuthoringFieldEntrySchema, AuthoringStageSchema))
-), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
-function isStartableDefinition(definition) {
-  return definition.role !== "child";
-}
-function formatValidationError(label, issues) {
-  const lines = issues.map((issue) => `  - ${issue.path.length === 0 ? "(root)" : formatPath(issue.path)}: ${issue.message}`);
-  return `${label} failed validation (${issues.length} issue${issues.length === 1 ? "" : "s"}):
-${lines.join(`
-`)}`;
-}
-function issuesFromValibot(issues) {
-  return issues.map((issue) => ({
-    path: issue.path ? issue.path.map((item) => item.key) : [],
-    message: issue.message
-  }));
-}
-function formatPath(path) {
-  let out = "";
-  for (const seg of path)
-    typeof seg == "number" ? out += `[${seg}]` : out += out.length === 0 ? String(seg) : `.${String(seg)}`;
-  return out;
-}
-export {
-  ACTIVITY_KINDS,
-  AuthoringActionSchema,
-  AuthoringActivitySchema,
-  AuthoringFieldEntrySchema,
-  AuthoringOpSchema,
-  AuthoringStageSchema,
-  AuthoringTransitionSchema,
-  AuthoringWorkflowSchema,
-  DOCUMENT_VALUE_PERMISSIONS,
-  DRIVER_KINDS,
-  EffectSchema,
-  GROQ_IDENTIFIER,
-  GuardSchema,
-  StoredFieldOpSchema,
-  WORKFLOW_DEFINITION_TYPE,
-  actorFulfillsRole,
-  andConditions,
-  expandRequiredRoles,
-  formatValidationError,
-  isStartableDefinition,
-  isTerminalActivityStatus,
-  issuesFromValibot,
-  normalizeRoleAliases
-};
-//# sourceMappingURL=schema.js.map