@sanity/workflow-engine 0.14.0 → 0.16.0

package/dist/_chunks-cjs/schema.cjs

@@ -1,1289 +0,0 @@
-"use strict";
-var v = require("valibot");
-function _interopNamespaceCompat(e) {
-  if (e && typeof e == "object" && "default" in e) return e;
-  var n = /* @__PURE__ */ Object.create(null);
-  return e && Object.keys(e).forEach(function(k) {
-    if (k !== "default") {
-      var d = Object.getOwnPropertyDescriptor(e, k);
-      Object.defineProperty(n, k, d.get ? d : {
-        enumerable: !0,
-        get: function() {
-          return e[k];
-        }
-      });
-    }
-  }), n.default = e, Object.freeze(n);
-}
-var v__namespace = /* @__PURE__ */ _interopNamespaceCompat(v);
-const KNOWN_SCHEMES = /* @__PURE__ */ new Set(["dataset", "canvas", "media-library", "dashboard"]);
-function parseGdr(uri) {
-  const colon = uri.indexOf(":");
-  if (colon < 0)
-    throw new Error(
-      `Invalid GDR "${uri}": must be a URI of form "<scheme>:<...id-parts>". Known schemes: dataset, canvas, media-library, dashboard.`
-    );
-  const scheme = uri.slice(0, colon), rest = uri.slice(colon + 1);
-  if (!KNOWN_SCHEMES.has(scheme))
-    throw new Error(
-      `Invalid GDR "${uri}": unknown scheme "${scheme}". Known: dataset, canvas, media-library, dashboard.`
-    );
-  const parts = rest.split(":");
-  if (parts.some((part) => part.length === 0))
-    throw new Error(
-      `Invalid GDR "${uri}": id parts must be non-empty (no leading, trailing, or doubled ":").`
-    );
-  if (scheme === "dataset") {
-    if (parts.length !== 3)
-      throw new Error(
-        `Invalid GDR "${uri}": dataset scheme requires <projectId>:<dataset>:<documentId> (3 parts after scheme); got ${parts.length}.`
-      );
-    return {
-      scheme: "dataset",
-      projectId: parts[0],
-      dataset: parts[1],
-      documentId: parts[2]
-    };
-  }
-  if (parts.length !== 2)
-    throw new Error(
-      `Invalid GDR "${uri}": ${scheme} scheme requires <resourceId>:<documentId> (2 parts after scheme); got ${parts.length}.`
-    );
-  return {
-    scheme,
-    resourceId: parts[0],
-    documentId: parts[1]
-  };
-}
-function tryParseGdr(uri) {
-  try {
-    return parseGdr(uri);
-  } catch {
-    return;
-  }
-}
-function gdrUri(parts) {
-  return parts.scheme === "dataset" ? `dataset:${parts.projectId}:${parts.dataset}:${parts.documentId}` : `${parts.scheme}:${parts.resourceId}:${parts.documentId}`;
-}
-function extractDocumentId(gdrUriString) {
-  return parseGdr(gdrUriString).documentId;
-}
-const RESOURCE_ALIAS_NAME_SOURCE = "[a-z0-9][a-z0-9-]*", RESOURCE_ALIAS_NAME_RE = new RegExp(`^${RESOURCE_ALIAS_NAME_SOURCE}$`);
-function validateResourceAliasName(name) {
-  if (!RESOURCE_ALIAS_NAME_RE.test(name))
-    throw new Error(
-      `Invalid resource alias name "${name}": expected lowercase letters, digits, and dashes (no leading dash).`
-    );
-}
-function toPhysicalGdr(id, home) {
-  return isGdrUri(id) ? id : gdrFromResource(home, id);
-}
-function refDataset({
-  projectId,
-  dataset,
-  documentId,
-  type
-}) {
-  return { id: gdrUri({ scheme: "dataset", projectId, dataset, documentId }), type };
-}
-function refCanvas({
-  resourceId,
-  documentId,
-  type
-}) {
-  return { id: gdrUri({ scheme: "canvas", resourceId, documentId }), type };
-}
-function refMediaLibrary({
-  resourceId,
-  documentId,
-  type
-}) {
-  return { id: gdrUri({ scheme: "media-library", resourceId, documentId }), type };
-}
-function refDashboard({
-  resourceId,
-  documentId,
-  type
-}) {
-  return { id: gdrUri({ scheme: "dashboard", resourceId, documentId }), type };
-}
-function datasetResourceParts(id) {
-  const dot = id.indexOf(".");
-  if (dot <= 0 || dot === id.length - 1)
-    throw new Error(`Invalid dataset resource id "${id}": expected "<projectId>.<dataset>".`);
-  return { projectId: id.slice(0, dot), dataset: id.slice(dot + 1) };
-}
-function gdrFromResource(res, documentId) {
-  if (res.type === "dataset") {
-    const { projectId, dataset } = datasetResourceParts(res.id);
-    return gdrUri({ scheme: "dataset", projectId, dataset, documentId });
-  }
-  return gdrUri({ scheme: res.type, resourceId: res.id, documentId });
-}
-function gdrResourcePrefix(res) {
-  const full = gdrFromResource(res, "x");
-  return full.slice(0, full.length - 1);
-}
-function resourceFromParsed(parsed) {
-  return parsed.scheme === "dataset" ? { type: "dataset", id: `${parsed.projectId}.${parsed.dataset}` } : { type: parsed.scheme, id: parsed.resourceId ?? "" };
-}
-function resourceFromGdrUri(uri) {
-  const parsed = tryParseGdr(uri);
-  return parsed === void 0 ? void 0 : resourceFromParsed(parsed);
-}
-function sameResource(a, b) {
-  return a.type === b.type && a.id === b.id;
-}
-function selfGdr(doc) {
-  return gdrFromResource(doc.workflowResource, doc._id);
-}
-function definitionDocId({
-  tag,
-  definition,
-  version
-}) {
-  return `${tag}.${definition}.v${version}`;
-}
-function isGdrUri(value) {
-  return typeof value == "string" && tryParseGdr(value) !== void 0;
-}
-function toBareId(id) {
-  return isGdrUri(id) ? extractDocumentId(id) : id;
-}
-function gdrRef({
-  res,
-  documentId,
-  type
-}) {
-  return { id: gdrFromResource(res, documentId), type };
-}
-function isGdr(value) {
-  return typeof value == "object" && value !== null && typeof value.id == "string" && typeof value.type == "string";
-}
-class WorkflowError extends Error {
-  kind;
-  // oxlint-disable-next-line max-params -- the platform `Error(message, options)` signature with the discriminant prepended
-  constructor(kind, message, options) {
-    super(message, options), this.kind = kind;
-  }
-}
-class ContractViolationError extends WorkflowError {
-  constructor(message) {
-    super("contract-violation", message), this.name = "ContractViolationError";
-  }
-}
-class InstanceNotFoundError extends WorkflowError {
-  instanceId;
-  constructor(args) {
-    super(
-      "instance-not-found",
-      `Workflow instance ${args.instanceId} not found${args.detail ? ` (${args.detail})` : ""}`
-    ), this.name = "InstanceNotFoundError", this.instanceId = args.instanceId;
-  }
-}
-class DefinitionNotFoundError extends WorkflowError {
-  definition;
-  version;
-  constructor(args) {
-    super(
-      "definition-not-found",
-      args.version !== void 0 ? `Workflow definition ${args.definition} v${args.version} not deployed` : `Workflow definition ${args.definition} has no deployed versions`
-    ), this.name = "DefinitionNotFoundError", this.definition = args.definition, args.version !== void 0 && (this.version = args.version);
-  }
-}
-class DefinitionInUseError extends WorkflowError {
-  definition;
-  blockedBy;
-  constructor(args) {
-    super("definition-in-use", definitionInUseMessage(args.definition, args.blockedBy)), this.name = "DefinitionInUseError", this.definition = args.definition, this.blockedBy = args.blockedBy;
-  }
-}
-function definitionInUseMessage(definition, blockedBy) {
-  if (blockedBy.reason === "non-terminal-instances") {
-    const head = blockedBy.instanceIds.slice(0, 3).join(", "), preview = blockedBy.instanceIds.length > 3 ? `${head}, \u2026` : head;
-    return `Cannot delete ${definition}: ${blockedBy.instanceIds.length} non-terminal instance(s) exist (${preview}). Pass cascade to abort them first \u2014 instances are aborted in place, never deleted.`;
-  }
-  const names = blockedBy.referrers.map((r) => `${r.definition} v${r.version}`).join(", ");
-  return `Cannot delete ${definition}: still spawn-referenced by deployed definition(s) ${names}. Delete or redeploy the referrer(s) first.`;
-}
-class EffectNotFoundError extends WorkflowError {
-  instanceId;
-  effectKey;
-  constructor(args) {
-    super(
-      "effect-not-found",
-      `Pending effect "${args.effectKey}" not found on instance ${args.instanceId}`
-    ), this.name = "EffectNotFoundError", this.instanceId = args.instanceId, this.effectKey = args.effectKey;
-  }
-}
-const TAG_RE = /^[a-z0-9][a-z0-9-]*$/;
-function validateTag(tag) {
-  if (!TAG_RE.test(tag))
-    throw new ContractViolationError(
-      `tag: invalid tag "${tag}" \u2014 must match ${TAG_RE.source} (ASCII lowercase + digits + dashes, no leading dash, no dots)`
-    );
-}
-function tagScopeFilter() {
-  return "tag == $tag";
-}
-const NonEmptyString = v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("must not be empty"));
-function asPredicate(validate) {
-  return (value) => {
-    try {
-      return validate(value), !0;
-    } catch {
-      return !1;
-    }
-  };
-}
-const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts), WorkflowResourceSchema = v__namespace.variant("type", [
-  v__namespace.object({
-    type: v__namespace.literal("dataset"),
-    id: v__namespace.pipe(
-      NonEmptyString,
-      v__namespace.check(isValidDatasetId, 'invalid dataset resource id \u2014 expected "<projectId>.<dataset>"')
-    )
-  }),
-  v__namespace.object({ type: v__namespace.literal("canvas"), id: NonEmptyString }),
-  v__namespace.object({ type: v__namespace.literal("media-library"), id: NonEmptyString }),
-  v__namespace.object({ type: v__namespace.literal("dashboard"), id: NonEmptyString })
-]), ResourceBindingSchema = v__namespace.object({
-  name: v__namespace.pipe(
-    NonEmptyString,
-    v__namespace.check(
-      isValidAliasName,
-      "invalid resource handle name \u2014 lowercase letters, digits and dashes only, no leading dash"
-    )
-  ),
-  resource: WorkflowResourceSchema
-}), DefinitionSchema = v__namespace.custom(
-  (input) => typeof input == "object" && input !== null && typeof input.name == "string",
-  "expected a workflow definition (an object with a string `name`)"
-), DeploymentSchema = v__namespace.object({
-  name: NonEmptyString,
-  tag: v__namespace.pipe(
-    v__namespace.string(),
-    v__namespace.nonEmpty(),
-    v__namespace.check(
-      isValidTag,
-      "invalid tag \u2014 lowercase letters, digits and dashes only, no leading dash, no dots"
-    )
-  ),
-  workflowResource: WorkflowResourceSchema,
-  // Optional — omit for a workflow whose definitions reference no `@handle:`.
-  // No valibot default: a default makes the inferred output `resourceAliases`
-  // required (poor authoring ergonomics) and diverges input from output,
-  // which the shared `parseOrThrow` can't model. resourceAliasesToMap treats
-  // an absent map as none.
-  //
-  // Handle names must be unique: resourceAliasesToMap collapses bindings into a
-  // map, so a duplicate would silently overwrite — and the dup is gone before
-  // the engine sees it. Caught here, at the only layer that still can.
-  resourceAliases: v__namespace.optional(
-    v__namespace.pipe(
-      v__namespace.array(ResourceBindingSchema),
-      v__namespace.check(
-        (bindings) => new Set(bindings.map((binding) => binding.name)).size === bindings.length,
-        "duplicate resource handle name \u2014 each binding name must be unique within a deployment"
-      )
-    )
-  ),
-  definitions: v__namespace.pipe(
-    v__namespace.array(DefinitionSchema),
-    v__namespace.minLength(1, "a deployment needs at least one definition")
-  )
-}), WorkflowConfigSchema = v__namespace.object({
-  // Tags must be unique: a tag is the environment key the CLI selects a
-  // deployment by, so two deployments sharing one make selection ambiguous.
-  // Enforced here so the ambiguity is a config error, not a deploy-time
-  // surprise — and so consumers can treat a tag as naming one deployment.
-  deployments: v__namespace.pipe(
-    v__namespace.array(DeploymentSchema),
-    v__namespace.minLength(1, "a config needs at least one deployment"),
-    v__namespace.check(
-      (deployments) => new Set(deployments.map((deployment) => deployment.tag)).size === deployments.length,
-      "duplicate deployment tag \u2014 each deployment must use a unique tag"
-    )
-  )
-});
-function resourceAliasesToMap(resourceAliases) {
-  return Object.fromEntries(
-    (resourceAliases ?? []).map((binding) => [
-      binding.name,
-      binding.resource
-    ])
-  );
-}
-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 FIELD_READ = /^\$fields\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
-function isGuardReadExpr(expr) {
-  return expr === "$self" || expr === "$now" || FIELD_READ.test(expr) || EFFECTS_READ.test(expr);
-}
-function printGuardRead(read) {
-  switch (read.type) {
-    case "self":
-      return "$self";
-    case "now":
-      return "$now";
-    case "fieldRead":
-      return read.path === void 0 ? `$fields.${read.field}` : `$fields.${read.field}.${read.path}`;
-    case "effectsRead":
-      return read.path === void 0 ? `$effects['${read.effect}']` : `$effects['${read.effect}'].${read.path}`;
-  }
-}
-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 CONDITION_VARS = [
-  {
-    name: "self",
-    binding: "always",
-    description: "GDR URI of the instance document itself \u2014 `*[_id == $self][0]` reads the instance in the snapshot."
-  },
-  {
-    name: "fields",
-    binding: "always",
-    description: "Declared field entries rendered by name (`$fields.<name>` is the value, no envelope). Stage/activity scopes overlay lexically; `doc.ref` values render the hydrated document when the snapshot holds it."
-  },
-  {
-    name: "parent",
-    binding: "always",
-    description: "The parent instance's GDR URI, `null` on a root instance."
-  },
-  {
-    name: "ancestors",
-    binding: "always",
-    description: "GDR URIs of the ancestor chain, root first."
-  },
-  { name: "stage", binding: "always", description: "The current stage's name." },
-  {
-    name: "now",
-    binding: "always",
-    description: "The ISO clock reading shared by every condition in one evaluation pass, so they agree on the time."
-  },
-  {
-    name: "effects",
-    binding: "always",
-    description: "The `effectsContext` map: stable handler params seeded at start plus completed effects' outputs namespaced by effect name (`$effects['<effect>'].<output>`). Handler fuel \u2014 transition filters should read instance/lake state (or $effectStatus) instead."
-  },
-  {
-    name: "effectStatus",
-    binding: "always",
-    description: "Effect name \u2192 `'done'` | `'failed'` of the latest completed run queued during the current stage entry; absent until the effect drains for this entry. Re-entry-safe: runs queued under a prior entry never count, so `$effectStatus['<effect>'] == 'done'` (or `defined($effectStatus['<effect>'])` for settled-either-way) waits for the fresh run."
-  },
-  {
-    name: "activities",
-    binding: "always",
-    description: "The current stage's activity rows, statuses included."
-  },
-  {
-    name: "allActivitiesDone",
-    binding: "always",
-    description: "Every current-stage activity is `done` or `skipped` \u2014 the default transition gate."
-  },
-  {
-    name: "anyActivityFailed",
-    binding: "always",
-    description: "Some current-stage activity is `failed`."
-  },
-  {
-    name: "actor",
-    binding: "caller",
-    description: "The acting identity (id + roles); `undefined` when no caller rides the evaluation."
-  },
-  {
-    name: "assigned",
-    binding: "caller",
-    description: "Whether the caller matches the activity's assignees-kind field entry (by user id, or by a role under the definition's `roleAliases`); `false` outside an activity context."
-  },
-  {
-    name: "can",
-    binding: "caller",
-    description: "Advisory per-permission booleans computed from the caller's grants; `undefined` without grants. Bound only while an action fires, so it may appear in action filters only (deploy-enforced)."
-  },
-  {
-    name: "row",
-    binding: "spawn",
-    description: "One `subworkflows.forEach` result row, bound while its `with` map evaluates \u2014 and the row under test while a where-op `where` evaluates (per row)."
-  },
-  {
-    name: "params",
-    binding: "caller",
-    description: "The firing action's args \u2014 bound while its effect bindings and where-op `where` conditions evaluate."
-  },
-  {
-    name: "subworkflows",
-    binding: "spawn",
-    description: "The spawned child rows (status included) of the spawning activity, bound for its `completeWhen`/`failWhen` \u2014 the implicit completion gate reads it."
-  }
-], RESERVED_CONDITION_VARS = CONDITION_VARS.map((v2) => v2.name), FILTER_SCOPE_VARS = CONDITION_VARS.filter(
-  (v2) => v2.binding === "always"
-).map((v2) => v2.name), GUARD_PREDICATE_VARS = [
-  {
-    name: "guard",
-    description: "The guard document itself (its `metadata` carries deploy-time resolved values)."
-  },
-  {
-    name: "mutation",
-    description: "The attempted mutation \u2014 `mutation.action` is the write kind being gated."
-  }
-], ACTOR_KINDS = ["person", "agent", "system"];
-class FieldValueShapeError extends WorkflowError {
-  entryType;
-  entryName;
-  issues;
-  constructor(args) {
-    const issueText = args.issues.join("; ");
-    super(
-      "field-value-shape",
-      `Field entry ${args.mode} shape invalid for "${args.entryName}" (${args.entryType}): ${issueText}`
-    ), this.name = "FieldValueShapeError", this.entryType = args.entryType, this.entryName = args.entryName, this.issues = args.issues;
-  }
-}
-const GdrShape = v__namespace.looseObject({
-  id: v__namespace.pipe(
-    v__namespace.string(),
-    v__namespace.check((s) => isGdrUri(s), "must be a GDR URI")
-  ),
-  type: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1))
-}), ReleaseRefShape = v__namespace.looseObject({
-  id: v__namespace.pipe(
-    v__namespace.string(),
-    v__namespace.check((s) => isGdrUri(s), "must be a GDR URI")
-  ),
-  type: v__namespace.literal("system.release"),
-  releaseName: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1))
-}), ActorShape = v__namespace.looseObject({
-  kind: v__namespace.picklist(ACTOR_KINDS),
-  id: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)),
-  roles: v__namespace.optional(v__namespace.array(v__namespace.string())),
-  onBehalfOf: v__namespace.optional(v__namespace.string())
-}), AssigneeShape = v__namespace.union([
-  v__namespace.looseObject({ type: v__namespace.literal("user"), id: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)) }),
-  v__namespace.looseObject({ type: v__namespace.literal("role"), role: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)) })
-]), NullableString = v__namespace.union([v__namespace.null(), v__namespace.string()]), NullableNumber = v__namespace.union([v__namespace.null(), v__namespace.number()]), NullableBoolean = v__namespace.union([v__namespace.null(), v__namespace.boolean()]), NullableDateTime = v__namespace.union([
-  v__namespace.null(),
-  v__namespace.pipe(
-    v__namespace.string(),
-    v__namespace.check((s) => !Number.isNaN(Date.parse(s)), "must be an ISO-8601 datetime string")
-  )
-]), NullableDate = v__namespace.union([
-  v__namespace.null(),
-  v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date"))
-]), NullableUrl = NullableString, valueSchemas = {
-  "doc.ref": v__namespace.union([v__namespace.null(), GdrShape]),
-  "doc.refs": v__namespace.array(GdrShape),
-  "release.ref": v__namespace.union([v__namespace.null(), ReleaseRefShape]),
-  query: v__namespace.any(),
-  string: NullableString,
-  text: NullableString,
-  number: NullableNumber,
-  boolean: NullableBoolean,
-  date: NullableDate,
-  datetime: NullableDateTime,
-  url: NullableUrl,
-  actor: v__namespace.union([v__namespace.null(), ActorShape]),
-  assignee: v__namespace.union([v__namespace.null(), AssigneeShape]),
-  assignees: v__namespace.array(AssigneeShape)
-};
-function shapeValueSchema(shape, leaf) {
-  return shape.type === "object" ? objectSchema(shape.fields ?? [], leaf) : shape.type === "array" ? v__namespace.array(objectSchema(shape.of ?? [], leaf)) : leaf[shape.type] ?? v__namespace.any();
-}
-function objectSchema(fields, leaf) {
-  const entries = /* @__PURE__ */ Object.create(null);
-  for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema(f, leaf));
-  return v__namespace.looseObject(entries);
-}
-function wholeValueSchema(args) {
-  const { entryType, shape, leaf } = args;
-  return entryType === "object" ? v__namespace.union([v__namespace.null(), objectSchema(shape.fields ?? [], leaf)]) : entryType === "array" ? v__namespace.array(objectSchema(shape.of ?? [], leaf)) : leaf[entryType];
-}
-function appendItemSchema(entryType, shape) {
-  if (entryType === "array") return objectSchema(shape.of ?? [], valueSchemas);
-  if (entryType === "doc.refs") return GdrShape;
-  if (entryType === "assignees") return AssigneeShape;
-}
-function checkFieldValue(args) {
-  return checkValueAgainst(args, valueSchemas);
-}
-function checkValueAgainst(args, leaf) {
-  const schema = wholeValueSchema({ entryType: args.entryType, shape: args, leaf });
-  if (schema === void 0) return [`unknown field entry type ${args.entryType}`];
-  const result = v__namespace.safeParse(schema, args.value);
-  return result.success ? void 0 : formatIssues(result.issues);
-}
-function validateFieldValue(args) {
-  const issues = checkFieldValue(args);
-  if (issues !== void 0)
-    throw new FieldValueShapeError({
-      entryType: args.entryType,
-      entryName: args.entryName,
-      issues,
-      mode: "value"
-    });
-}
-const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]*", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
-function isAuthoringRefId(id) {
-  return id.startsWith("@") ? ALIAS_REF_RE.test(id) : id.includes(":") ? isGdrUri(id) : BARE_ID_RE.test(id);
-}
-function isBareSeedId(id) {
-  return BARE_ID_RE.test(id);
-}
-const AuthoringRefId = v__namespace.pipe(
-  v__namespace.string(),
-  v__namespace.check(
-    isAuthoringRefId,
-    "must be a bare document id, a GDR URI, or a portable `@<alias>:<id>` reference"
-  )
-), AuthoringGdrShape = v__namespace.looseObject({
-  id: AuthoringRefId,
-  type: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1))
-}), seedValueSchemas = {
-  ...valueSchemas,
-  "doc.ref": v__namespace.union([v__namespace.null(), AuthoringGdrShape]),
-  "doc.refs": v__namespace.array(AuthoringGdrShape),
-  "release.ref": v__namespace.union([
-    v__namespace.null(),
-    v__namespace.looseObject({
-      id: AuthoringRefId,
-      type: v__namespace.literal("system.release"),
-      releaseName: v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1))
-    })
-  ])
-};
-function checkLiteralSeed(args) {
-  return args.value === null ? ["a literal seed cannot be null \u2014 omit `initialValue` to start the field empty"] : checkValueAgainst(args, seedValueSchemas);
-}
-function validateFieldAppendItem(args) {
-  const schema = appendItemSchema(args.entryType, args);
-  if (schema === void 0)
-    throw new FieldValueShapeError({
-      entryType: args.entryType,
-      entryName: args.entryName,
-      issues: [`field entry type ${args.entryType} does not support append`],
-      mode: "item"
-    });
-  const result = v__namespace.safeParse(schema, args.item);
-  if (!result.success)
-    throw new FieldValueShapeError({
-      entryType: args.entryType,
-      entryName: args.entryName,
-      issues: formatIssues(result.issues),
-      mode: "item"
-    });
-}
-function formatIssues(issues) {
-  return issues.map((i) => {
-    const keys = i.path?.map((p) => p.key) ?? [];
-    return `${keys.length > 0 ? `at ${keys.join(".")}: ` : ""}${i.message}`;
-  });
-}
-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__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(),
-    v__namespace.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__namespace.picklist(
-    options,
-    `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
-  );
-}
-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([
-    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("object"), fields: v__namespace.record(NonEmpty, ValueExprSchema) })
-  ])
-), StoredFieldRefSchema = v__namespace.strictObject({
-  scope: picklist(FIELD_SCOPES),
-  field: NonEmpty
-}), AuthoringFieldRefSchema = v__namespace.strictObject({
-  scope: v__namespace.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__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])), ConditionSchema = NonEmpty;
-function opSchemas(targetSchema) {
-  return [
-    v__namespace.strictObject({
-      type: v__namespace.literal("field.set"),
-      target: targetSchema,
-      value: ValueExprSchema
-    }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("field.unset"),
-      target: targetSchema
-    }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("field.append"),
-      target: targetSchema,
-      value: ValueExprSchema
-    }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("field.updateWhere"),
-      target: targetSchema,
-      where: ConditionSchema,
-      value: ValueExprSchema
-    }),
-    v__namespace.strictObject({
-      type: v__namespace.literal("field.removeWhere"),
-      target: targetSchema,
-      where: ConditionSchema
-    })
-  ];
-}
-const StoredFieldOpSchema = v__namespace.variant("type", [...opSchemas(StoredFieldRefSchema)]), StoredOpSchema = v__namespace.variant("type", [
-  ...opSchemas(StoredFieldRefSchema),
-  v__namespace.strictObject({
-    type: v__namespace.literal("status.set"),
-    activity: NonEmpty,
-    status: picklist(ACTIVITY_STATUSES)
-  })
-]), StoredTransitionOpSchema = StoredFieldOpSchema, AuditOpSchema = v__namespace.strictObject({
-  type: v__namespace.literal("audit"),
-  target: AuthoringFieldRefSchema,
-  value: ValueExprSchema,
-  stampFields: v__namespace.optional(
-    v__namespace.strictObject({
-      actor: v__namespace.optional(NonEmpty),
-      at: v__namespace.optional(NonEmpty)
-    })
-  )
-}), AuthoringOpSchema = v__namespace.variant("type", [
-  ...opSchemas(AuthoringFieldRefSchema),
-  v__namespace.strictObject({
-    type: v__namespace.literal("status.set"),
-    activity: v__namespace.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__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 fieldBase(editable) {
-  return {
-    name: FieldEntryName,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.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__namespace.optional(v__namespace.boolean()),
-    /**
-     * How this field SEEDS its value at materialisation — see
-     * {@link FieldSourceSchema}. Optional: an absent `initialValue` is working
-     * memory (the field starts empty and an op fills it later), the common case.
-     */
-    initialValue: v__namespace.optional(FieldSourceSchema),
-    /** Who-may-edit this field via the edit seam — see {@link StoredEditableSchema}. */
-    editable: v__namespace.optional(editable)
-  };
-}
-function fieldEntryFields(editable) {
-  return {
-    type: FieldKindSchema,
-    ...fieldBase(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))
-  };
-}
-function literalSeedIssues(entry) {
-  if (entry.initialValue?.type === "literal")
-    return checkLiteralSeed({
-      entryType: entry.type,
-      value: entry.initialValue.value,
-      fields: entry.fields,
-      of: entry.of
-    });
-}
-function literalSeedCheck() {
-  return v__namespace.check(
-    (entry) => literalSeedIssues(entry) === void 0,
-    (issue) => `initialValue literal does not fit the declared kind: ${(literalSeedIssues(issue.input) ?? []).join("; ")}`
-  );
-}
-const FieldEntrySchema = pinned()(
-  v__namespace.pipe(compositeChecked(fieldEntryFields(StoredEditableSchema)), literalSeedCheck())
-), RawAuthoringFieldEntrySchema = pinned()(
-  v__namespace.pipe(
-    compositeChecked(fieldEntryFields(AuthoringEditableSchema)),
-    literalSeedCheck()
-  )
-), 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),
-    ...fieldBase(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])
-), EffectSchema = v__namespace.strictObject({
-  name: NonEmpty,
-  title: v__namespace.optional(v__namespace.string()),
-  description: v__namespace.optional(v__namespace.string()),
-  /** GROQ reads over the rendered scope, resolved to concrete JSON at queue time. */
-  bindings: v__namespace.optional(v__namespace.record(v__namespace.string(), ConditionSchema)),
-  /** Static config, passed through to the handler verbatim. */
-  input: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown()))
-}), ActionParamSchema = v__namespace.strictObject({
-  type: picklist([
-    "string",
-    "number",
-    "boolean",
-    "url",
-    "dateTime",
-    "actor",
-    "doc.ref",
-    "doc.refs",
-    "json"
-  ]),
-  name: NonEmpty,
-  title: v__namespace.optional(v__namespace.string()),
-  description: v__namespace.optional(v__namespace.string()),
-  required: v__namespace.optional(v__namespace.boolean())
-});
-function actionFields(op) {
-  return {
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    /**
-     * The one gate mechanism: a condition over the rendered scope. Hard
-     * enforcement lives outside the engine; every engine-evaluated gate is
-     * authoring/UX.
-     */
-    filter: v__namespace.optional(ConditionSchema),
-    params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
-    ops: v__namespace.optional(v__namespace.array(op)),
-    effects: v__namespace.optional(v__namespace.array(EffectSchema))
-  };
-}
-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({
-  /** 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__namespace.optional(v__namespace.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__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema))
-});
-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 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. Distinct from ACL (authorization) and guards
-     * (content-write locks).
-     */
-    requirements: v__namespace.optional(v__namespace.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__namespace.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__namespace.optional(ConditionSchema),
-    ops: v__namespace.optional(v__namespace.array(op)),
-    effects: v__namespace.optional(v__namespace.array(EffectSchema)),
-    actions: v__namespace.optional(v__namespace.array(action)),
-    subworkflows: v__namespace.optional(SubworkflowsSchema),
-    /** Activity-scoped field entries. Resolved at activity activation time. */
-    fields: v__namespace.optional(v__namespace.array(field))
-  };
-}
-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) {
-  return {
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    to: NonEmpty,
-    filter,
-    /** The `field.*` subset — field-write-on-move, the stage's EXIT/ARRIVAL payload. */
-    ops: v__namespace.optional(v__namespace.array(op)),
-    effects: v__namespace.optional(v__namespace.array(EffectSchema))
-  };
-}
-const StoredTransitionSchema = pinned()(
-  v__namespace.strictObject(transitionFields(StoredTransitionOpSchema, ConditionSchema))
-), AuthoringTransitionOpSchema = v__namespace.variant("type", [
-  ...opSchemas(AuthoringFieldRefSchema),
-  AuditOpSchema
-]), AuthoringTransitionSchema = pinned()(
-  v__namespace.strictObject(transitionFields(AuthoringTransitionOpSchema, v__namespace.optional(ConditionSchema)))
-), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v__namespace.pipe(
-  NonEmpty,
-  v__namespace.check(
-    (path) => !/[\r\n\u2028\u2029]/.test(path),
-    "a guard read path cannot contain a line break"
-  )
-), GuardReadSchema = v__namespace.variant("type", [
-  v__namespace.strictObject({ type: v__namespace.literal("self") }),
-  v__namespace.strictObject({ type: v__namespace.literal("now") }),
-  v__namespace.strictObject({
-    type: v__namespace.literal("fieldRead"),
-    field: FieldEntryName,
-    path: v__namespace.optional(GuardReadPath)
-  }),
-  v__namespace.strictObject({
-    type: v__namespace.literal("effectsRead"),
-    // The stored spelling bracket-quotes the name (`$effects['<name>']`), so a
-    // quote inside it would corrupt the printed read.
-    effect: v__namespace.pipe(
-      NonEmpty,
-      v__namespace.check((name) => !name.includes("'"), "an effect name cannot contain `'`")
-    ),
-    path: v__namespace.optional(GuardReadPath)
-  })
-]);
-function guardMatchFields(read) {
-  return {
-    /** Subject `_type`(s); empty matches any type. */
-    types: v__namespace.optional(v__namespace.array(NonEmpty)),
-    /** Target docs as field reads (or the instance itself), resolved at deploy to bare ids + the resource. */
-    idRefs: v__namespace.optional(v__namespace.array(read)),
-    /** Glob id patterns (bare, resource-local). */
-    idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
-    actions: v__namespace.pipe(
-      v__namespace.array(GuardActionSchema),
-      v__namespace.minLength(1, "a guard must match at least one action")
-    )
-  };
-}
-function guardFields(read) {
-  return {
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    match: v__namespace.strictObject(guardMatchFields(read)),
-    /**
-     * 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__namespace.optional(v__namespace.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. Each value is a deploy-time read — a typed
-     * {@link GuardRead} when authoring, the printed string spelling once
-     * stored — resolved into a bare value at deploy and re-synced by the
-     * post-field-op guard refresh.
-     */
-    metadata: v__namespace.optional(v__namespace.record(NonEmpty, read))
-  };
-}
-const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty)), AuthoringGuardSchema = v__namespace.strictObject(guardFields(GuardReadSchema));
-function stageFields({
-  field,
-  activity,
-  transition,
-  guard,
-  editable
-}) {
-  return {
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    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
-     * persisted guard document deployed on stage entry and retracted on exit.
-     */
-    guards: v__namespace.optional(v__namespace.array(guard)),
-    /** Stage-scoped field entries. Resolved at stage entry. */
-    fields: v__namespace.optional(v__namespace.array(field)),
-    /**
-     * Tighten-only editability overrides for the time this stage holds, keyed
-     * by an in-scope field name. The field's own `editable` is the ceiling; a
-     * stage value is ANDed with it at runtime, so an override can only NARROW
-     * (never open a field the baseline left closed). An unlisted field inherits
-     * its baseline.
-     */
-    editable: v__namespace.optional(v__namespace.record(FieldEntryName, editable))
-  };
-}
-const StoredStageSchema = pinned()(
-  v__namespace.strictObject(
-    stageFields({
-      field: FieldEntrySchema,
-      activity: StoredActivitySchema,
-      transition: StoredTransitionSchema,
-      guard: GuardSchema,
-      editable: StoredEditableSchema
-    })
-  )
-), AuthoringStageSchema = pinned()(
-  v__namespace.strictObject(
-    stageFields({
-      field: AuthoringFieldEntrySchema,
-      activity: AuthoringActivitySchema,
-      transition: AuthoringTransitionSchema,
-      guard: AuthoringGuardSchema,
-      editable: AuthoringEditableSchema
-    })
-  )
-), RoleAliasesSchema = v__namespace.record(
-  NonEmpty,
-  v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))
-), WORKFLOW_LIFECYCLES = ["standalone", "child"];
-function workflowFields(field, stage) {
-  return {
-    name: NonEmpty,
-    title: NonEmpty,
-    description: v__namespace.optional(v__namespace.string()),
-    /**
-     * How instances of this workflow come to exist. `'child'` marks a
-     * spawn-only definition — instantiated by a parent via `activity.subworkflows`,
-     * never started cold from a picker. Omitted ⇒ `'standalone'` (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.
-     */
-    lifecycle: v__namespace.optional(picklist(WORKFLOW_LIFECYCLES)),
-    /** Reference field: named for the target, holds the stage's `name`. */
-    initialStage: NonEmpty,
-    /** Workflow-scope field entries. Persist for the instance lifetime. */
-    fields: v__namespace.optional(v__namespace.array(field)),
-    stages: v__namespace.pipe(v__namespace.array(stage), v__namespace.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__namespace.optional(v__namespace.record(groqIdentifier("`$<name>`"), ConditionSchema)),
-    /** Role aliasing for this definition — see {@link RoleAliasesSchema}. */
-    roleAliases: v__namespace.optional(RoleAliasesSchema)
-  };
-}
-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.lifecycle !== "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;
-}
-exports.ACTIVITY_KINDS = ACTIVITY_KINDS;
-exports.ACTOR_KINDS = ACTOR_KINDS;
-exports.AuthoringActionSchema = AuthoringActionSchema;
-exports.AuthoringActivitySchema = AuthoringActivitySchema;
-exports.AuthoringFieldEntrySchema = AuthoringFieldEntrySchema;
-exports.AuthoringGuardSchema = AuthoringGuardSchema;
-exports.AuthoringOpSchema = AuthoringOpSchema;
-exports.AuthoringStageSchema = AuthoringStageSchema;
-exports.AuthoringTransitionSchema = AuthoringTransitionSchema;
-exports.AuthoringWorkflowSchema = AuthoringWorkflowSchema;
-exports.CONDITION_VARS = CONDITION_VARS;
-exports.ContractViolationError = ContractViolationError;
-exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
-exports.DRIVER_KINDS = DRIVER_KINDS;
-exports.DefinitionInUseError = DefinitionInUseError;
-exports.DefinitionNotFoundError = DefinitionNotFoundError;
-exports.EFFECTS_READ = EFFECTS_READ;
-exports.EffectNotFoundError = EffectNotFoundError;
-exports.EffectSchema = EffectSchema;
-exports.FIELD_READ = FIELD_READ;
-exports.FILTER_SCOPE_VARS = FILTER_SCOPE_VARS;
-exports.FieldValueShapeError = FieldValueShapeError;
-exports.GROQ_IDENTIFIER = GROQ_IDENTIFIER;
-exports.GUARD_PREDICATE_VARS = GUARD_PREDICATE_VARS;
-exports.InstanceNotFoundError = InstanceNotFoundError;
-exports.RESERVED_CONDITION_VARS = RESERVED_CONDITION_VARS;
-exports.RESOURCE_ALIAS_NAME_SOURCE = RESOURCE_ALIAS_NAME_SOURCE;
-exports.StoredFieldOpSchema = StoredFieldOpSchema;
-exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
-exports.WorkflowConfigSchema = WorkflowConfigSchema;
-exports.WorkflowError = WorkflowError;
-exports.actorFulfillsRole = actorFulfillsRole;
-exports.andConditions = andConditions;
-exports.checkFieldValue = checkFieldValue;
-exports.datasetResourceParts = datasetResourceParts;
-exports.definitionDocId = definitionDocId;
-exports.expandRequiredRoles = expandRequiredRoles;
-exports.extractDocumentId = extractDocumentId;
-exports.formatIssues = formatIssues;
-exports.formatValidationError = formatValidationError;
-exports.gdrFromResource = gdrFromResource;
-exports.gdrRef = gdrRef;
-exports.gdrResourcePrefix = gdrResourcePrefix;
-exports.gdrUri = gdrUri;
-exports.isBareSeedId = isBareSeedId;
-exports.isGdr = isGdr;
-exports.isGdrUri = isGdrUri;
-exports.isGuardReadExpr = isGuardReadExpr;
-exports.isStartableDefinition = isStartableDefinition;
-exports.isTerminalActivityStatus = isTerminalActivityStatus;
-exports.issuesFromValibot = issuesFromValibot;
-exports.normalizeRoleAliases = normalizeRoleAliases;
-exports.parseGdr = parseGdr;
-exports.printGuardRead = printGuardRead;
-exports.refCanvas = refCanvas;
-exports.refDashboard = refDashboard;
-exports.refDataset = refDataset;
-exports.refMediaLibrary = refMediaLibrary;
-exports.resourceAliasesToMap = resourceAliasesToMap;
-exports.resourceFromGdrUri = resourceFromGdrUri;
-exports.resourceFromParsed = resourceFromParsed;
-exports.sameResource = sameResource;
-exports.selfGdr = selfGdr;
-exports.tagScopeFilter = tagScopeFilter;
-exports.toBareId = toBareId;
-exports.toPhysicalGdr = toPhysicalGdr;
-exports.tryParseGdr = tryParseGdr;
-exports.validateFieldAppendItem = validateFieldAppendItem;
-exports.validateFieldValue = validateFieldValue;
-exports.validateResourceAliasName = validateResourceAliasName;
-exports.validateTag = validateTag;
-//# sourceMappingURL=schema.cjs.map