@sanity/workflow-engine 0.14.0 → 0.16.0

package/dist/define.cjs

@@ -1,979 +1,141 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: !0 });
-var v = require("valibot"), schema = require("./_chunks-cjs/schema.cjs");
-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);
-function groq(strings, ...values) {
-  return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
-}
-function serializeGroqValue(value) {
-  const serialized = JSON.stringify(value);
-  if (serialized === void 0)
-    throw new Error(
-      `groq tag cannot serialize ${typeof value} \u2014 interpolate JSON-representable values only`
-    );
-  return serialized;
-}
-function desugarWorkflow(authoring) {
-  const issues = [];
-  checkReservedRoleAliasKeys(authoring.roleAliases, issues);
-  const roleAliases = schema.normalizeRoleAliases(authoring.roleAliases), ctx = {
-    issues,
-    claimFields: /* @__PURE__ */ new Map(),
-    claimedFields: /* @__PURE__ */ new Set(),
-    roleAliases
-  }, workflowFields = desugarFieldEntries({ entries: authoring.fields, path: ["fields"], ctx }), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
-    const path = ["stages", i], stageFields = desugarFieldEntries({ entries: stage.fields, path: [...path, "fields"], ctx }), stageEnv = {
-      layers: [
-        { scope: "stage", entries: layerOf(stageFields) },
-        { scope: "workflow", entries: workflowLayer }
-      ]
-    }, activities = (stage.activities ?? []).map(
-      (activity, j) => desugarActivity({ activity, path: [...path, "activities", j], stageEnv, ctx })
-    ), transitions = (stage.transitions ?? []).map(
-      (transition, k) => desugarTransition({ transition, path: [...path, "transitions", k], stageEnv, ctx })
-    ), editable = desugarStageEditable({
-      overrides: stage.editable,
-      inScope: editableFieldNames({ workflowFields, stageFields, activities }),
-      path: [...path, "editable"],
-      ctx
-    });
-    return {
-      ...stripUndefined({
-        name: stage.name,
-        title: stage.title,
-        description: stage.description,
-        guards: stage.guards?.map(desugarGuard)
-      }),
-      ...stageFields ? { fields: stageFields } : {},
-      ...activities.length > 0 ? { activities } : {},
-      ...transitions.length > 0 ? { transitions } : {},
-      ...editable ? { editable } : {}
-    };
-  });
-  return checkUnclaimedClaimFields(ctx), { definition: {
-    ...stripUndefined({
-      name: authoring.name,
-      title: authoring.title,
-      description: authoring.description,
-      lifecycle: authoring.lifecycle,
-      initialStage: authoring.initialStage,
-      predicates: authoring.predicates,
-      roleAliases
-    }),
-    ...workflowFields ? { fields: workflowFields } : {},
-    stages
-  }, issues: ctx.issues };
-}
-function checkReservedRoleAliasKeys(aliases, issues) {
-  for (const key of Object.keys(aliases ?? {}))
-    key.startsWith("$") && issues.push({
-      path: ["roleAliases", key],
-      message: `role alias key "${key}" uses the reserved "$" prefix \u2014 that namespace is the engine's stored spelling for the universal fulfiller. Use "*" to mean "fulfills any gate", or rename the role.`
-    });
-}
-const TODOLIST_OF = [
-  { type: "string", name: "label", title: "Label" },
-  { type: "string", name: "status", title: "Status" },
-  { type: "assignee", name: "assignee", title: "Assignee" },
-  { type: "date", name: "dueDate", title: "Due date" }
-], NOTES_OF = [
-  { type: "text", name: "body", title: "Body" },
-  { type: "actor", name: "actor", title: "Actor" },
-  { type: "datetime", name: "at", title: "At" }
-];
-function desugarFieldEntries({
-  entries,
-  path,
-  ctx
-}) {
-  return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => desugarFieldEntry({ entry, path: [...path, i], ctx }));
-}
-function desugarFieldEntry({
-  entry,
-  path,
-  ctx
-}) {
-  if (entry.type === "claim") return desugarClaimField({ entry, path, ctx });
-  if (entry.type === "todoList" || entry.type === "notes")
-    return desugarListField({ entry, path, ctx });
-  const editable = normalizeEditable({ editable: entry.editable, path: [...path, "editable"], ctx });
-  return {
-    ...stripUndefined({
-      type: entry.type,
-      name: entry.name,
-      title: entry.title,
-      description: entry.description,
-      required: entry.required,
-      initialValue: entry.initialValue,
-      editable,
-      fields: entry.fields,
-      of: entry.of
-    })
-  };
-}
-function desugarClaimField({
-  entry,
-  path,
-  ctx
-}) {
-  const desugared = {
-    ...stripUndefined({ name: entry.name, title: entry.title, description: entry.description }),
-    type: "actor"
-  };
-  return ctx.claimFields.set(desugared, { name: entry.name, path }), desugared;
-}
-function desugarListField({
-  entry,
-  path,
-  ctx
-}) {
-  const editable = normalizeEditable({ editable: entry.editable, path: [...path, "editable"], ctx });
-  return {
-    ...stripUndefined({
-      name: entry.name,
-      title: entry.title,
-      description: entry.description,
-      required: entry.required,
-      initialValue: entry.initialValue,
-      editable
-    }),
-    type: "array",
-    of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
-  };
-}
-function normalizeEditable({
-  editable,
-  path,
-  ctx
-}) {
-  if (editable === void 0 || editable === !0) return editable;
-  if (Array.isArray(editable)) {
-    const condition = rolesCondition(editable, ctx.roleAliases);
-    if (condition === void 0) {
-      ctx.issues.push({
-        path,
-        message: "editable: [] names no roles \u2014 use `true` to open the field to anyone in its scope, or list at least one role"
-      });
-      return;
-    }
-    return condition;
-  }
-  return editable;
-}
-function editableFieldNames({
-  workflowFields,
-  stageFields,
-  activities
-}) {
-  const names = /* @__PURE__ */ new Set(), collect = (entries) => {
-    for (const entry of entries ?? []) entry.editable !== void 0 && names.add(entry.name);
-  };
-  collect(workflowFields), collect(stageFields);
-  for (const activity of activities) collect(activity.fields);
-  return names;
-}
-function desugarStageEditable({
-  overrides,
-  inScope,
-  path,
-  ctx
-}) {
-  if (overrides === void 0) return;
-  const out = {};
-  for (const [name, value] of Object.entries(overrides)) {
-    if (!inScope.has(name)) {
-      ctx.issues.push({
-        path: [...path, name],
-        message: `stage editable override "${name}" does not narrow an editable field in scope \u2014 name a workflow/stage/activity field of this stage that declares \`editable\``
-      });
-      continue;
-    }
-    const normalized = normalizeEditable({ editable: value, path: [...path, name], ctx });
-    normalized !== void 0 && (out[name] = normalized);
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function layerOf(entries) {
-  return new Map((entries ?? []).map((entry) => [entry.name, entry]));
-}
-function desugarActivity({
-  activity,
-  path,
-  stageEnv,
-  ctx
-}) {
-  const activityFields = desugarFieldEntries({
-    entries: activity.fields,
-    path: [...path, "fields"],
-    ctx
-  }), env = {
-    layers: [{ scope: "activity", entries: layerOf(activityFields) }, ...stageEnv.layers]
-  }, ops = desugarOps({
-    ops: activity.ops,
-    path: [...path, "ops"],
-    env,
-    firingActivity: activity.name,
-    ctx
-  }), actions = (activity.actions ?? []).map(
-    (action, a) => desugarAction({ action, path: [...path, "actions", a], env, activityName: activity.name, ctx })
-  ), target = desugarTarget({ target: activity.target, env, path: [...path, "target"], ctx });
-  return {
-    ...stripUndefined({
-      name: activity.name,
-      title: activity.title,
-      description: activity.description,
-      kind: activity.kind,
-      filter: activity.filter,
-      requirements: activity.requirements,
-      completeWhen: activity.completeWhen,
-      failWhen: activity.failWhen,
-      effects: activity.effects,
-      subworkflows: activity.subworkflows
-    }),
-    activation: activity.activation ?? "manual",
-    ...target ? { target } : {},
-    ...activityFields ? { fields: activityFields } : {},
-    ...ops ? { ops } : {},
-    ...actions.length > 0 ? { actions } : {}
-  };
-}
-const TARGET_DOC_KINDS = ["doc.ref", "doc.refs", "release.ref"];
-function desugarTarget({
-  target,
-  env,
-  path,
-  ctx
-}) {
-  if (target === void 0 || target.type === "url") return target;
-  const ref = typeof target.field == "string" ? { field: target.field } : target.field, field = resolveRef({ ref, env, path: [...path, "field"], ctx }) ?? fallbackRef(ref), entry = entryAt(env, field);
-  return entry && !TARGET_DOC_KINDS.includes(entry.type) && ctx.issues.push({
-    path: [...path, "field"],
-    message: `manual activity target references "${field.field}" of kind "${entry.type}" \u2014 a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
-  }), { type: "field", field };
-}
-function desugarAction({
-  action,
-  path,
-  env,
-  activityName,
-  ctx
-}) {
-  if ("type" in action)
-    return desugarClaimAction({ action, path, env, ctx });
-  const filter = schema.andConditions([rolesCondition(action.roles, ctx.roleAliases), action.filter]), ops = desugarOps({ ops: action.ops, path: [...path, "ops"], env, firingActivity: activityName, ctx }) ?? [];
-  return action.status !== void 0 && ops.push({ type: "status.set", activity: activityName, status: action.status }), {
-    ...stripUndefined({
-      name: action.name,
-      title: action.title,
-      description: action.description,
-      params: action.params,
-      effects: action.effects
-    }),
-    ...filter ? { filter } : {},
-    ...ops.length > 0 ? { ops } : {}
-  };
-}
-function desugarClaimAction({
-  action,
-  path,
-  env,
-  ctx
-}) {
-  const ref = typeof action.field == "string" ? { field: action.field } : action.field, resolved = resolveRef({ ref, env, path: [...path, "field"], ctx });
-  if (resolved) {
-    const entry = entryAt(env, resolved);
-    entry && entry.type !== "actor" && ctx.issues.push({
-      path: [...path, "field"],
-      message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" \u2014 a claim pair needs an actor-valued entry (a "claim" or "actor" field declaration)`
-    }), checkShadowedClaimTarget({
-      actionName: action.name,
-      field: ref.field,
-      resolved,
-      env,
-      path: [...path, "field"],
-      ctx
-    }), entry && ctx.claimedFields.add(entry);
-  }
-  const noSteal = `!defined($fields.${ref.field})`, filter = schema.andConditions([
-    noSteal,
-    rolesCondition(action.roles, ctx.roleAliases),
-    action.filter
-  ]), ops = resolved ? [{ type: "field.set", target: resolved, value: { type: "actor" } }] : [];
-  return {
-    ...stripUndefined({
-      name: action.name,
-      title: action.title,
-      description: action.description,
-      params: action.params,
-      effects: action.effects
-    }),
-    filter,
-    ...ops.length > 0 ? { ops } : {}
-  };
-}
-function checkShadowedClaimTarget({
-  actionName,
-  field,
-  resolved,
-  env,
-  path,
-  ctx
-}) {
-  const nearest = env.layers.find((l) => l.entries.has(field));
-  nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
-    path,
-    message: `claim action "${actionName}" targets "${field}" at scope "${resolved.scope}", but a nearer ${nearest.scope}-scope entry of the same name shadows it in $fields \u2014 the no-steal filter would read the shadowing entry while the claim writes the "${resolved.scope}" one. Rename one of the entries or claim the nearer one`
-  });
-}
-function checkUnclaimedClaimFields(ctx) {
-  for (const [entry, { name, path }] of ctx.claimFields)
-    ctx.claimedFields.has(entry) || ctx.issues.push({
-      path,
-      message: `claim field "${name}" is never referenced by a claim action \u2014 you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw actor entry`
-    });
-}
-function desugarTransition({
-  transition,
-  path,
-  stageEnv,
-  ctx
-}) {
-  const ops = desugarOps({
-    ops: transition.ops,
-    path: [...path, "ops"],
-    env: stageEnv,
-    firingActivity: void 0,
-    ctx
-  });
-  return {
-    ...stripUndefined({
-      name: transition.name,
-      title: transition.title,
-      description: transition.description,
-      to: transition.to,
-      effects: transition.effects
-    }),
-    filter: transition.filter ?? "$allActivitiesDone",
-    ...ops ? { ops } : {}
-  };
-}
-function desugarGuard(guard) {
-  const { match, metadata, ...rest } = guard, { idRefs, ...matchRest } = match;
-  return {
-    ...rest,
-    match: {
-      ...matchRest,
-      ...idRefs !== void 0 ? { idRefs: idRefs.map(schema.printGuardRead) } : {}
-    },
-    ...metadata !== void 0 ? {
-      metadata: Object.fromEntries(
-        Object.entries(metadata).map(([key, read]) => [key, schema.printGuardRead(read)])
-      )
-    } : {}
-  };
-}
-function desugarOps({
-  ops,
-  path,
-  env,
-  firingActivity,
-  ctx
-}) {
-  if (ops)
-    return ops.map((op, i) => desugarOp({ op, path: [...path, i], env, firingActivity, ctx }));
-}
-function desugarOp({
-  op,
-  path,
-  env,
-  firingActivity,
-  ctx
-}) {
-  if (op.type === "status.set") {
-    const activity = op.activity ?? firingActivity;
-    return activity === void 0 && ctx.issues.push({
-      path: [...path, "activity"],
-      message: "status.set outside an action must name its target activity"
-    }), { type: "status.set", activity: activity ?? "", status: op.status };
-  }
-  if (op.type === "audit") return desugarAuditOp({ op, path, env, ctx });
-  const target = resolveRef({ ref: op.target, env, path: [...path, "target"], ctx }) ?? fallbackRef(op.target);
-  return { ...op, target };
-}
-const AUDIT_STAMPS = { actor: { type: "actor" }, at: { type: "now" } };
-function desugarAuditOp({
-  op,
-  path,
-  env,
-  ctx
-}) {
-  const target = resolveRef({ ref: op.target, env, path: [...path, "target"], ctx }) ?? fallbackRef(op.target);
-  if (op.value.type !== "object")
-    return ctx.issues.push({
-      path: [...path, "value"],
-      message: `audit value must be an object source carrying the domain fields (got "${op.value.type}")`
-    }), { type: "field.append", target, value: op.value };
-  const actorField = op.stampFields?.actor ?? "actor", atField = op.stampFields?.at ?? "at", fields = { ...op.value.fields };
-  for (const [stamp, source] of [
-    [actorField, AUDIT_STAMPS.actor],
-    [atField, AUDIT_STAMPS.at]
-  ]) {
-    if (stamp in fields) {
-      ctx.issues.push({
-        path: [...path, "value", "fields", stamp],
-        message: `audit stamp field "${stamp}" collides with an authored domain field \u2014 rename yours or remap the stamp via stampFields`
-      });
-      continue;
-    }
-    fields[stamp] = source;
-  }
-  return { type: "field.append", target, value: { type: "object", fields } };
-}
-function resolveRef({
-  ref,
-  env,
-  path,
-  ctx
-}) {
-  const layers = ref.scope === void 0 ? env.layers : env.layers.filter((l) => l.scope === ref.scope);
-  for (const layer of layers)
-    if (layer.entries.has(ref.field)) return { scope: layer.scope, field: ref.field };
-  const reachable = env.layers.flatMap((l) => [...l.entries.keys()].map((n) => `${l.scope}:${n}`));
-  ctx.issues.push({
-    path,
-    message: `field reference "${ref.field}"${ref.scope ? ` (scope "${ref.scope}")` : ""} does not resolve to a declared entry. Reachable: ${reachable.join(", ") || "(none)"}`
-  });
-}
-function entryAt(env, ref) {
-  return env.layers.find((l) => l.scope === ref.scope)?.entries.get(ref.field);
-}
-function fallbackRef(ref) {
-  return { scope: ref.scope ?? "workflow", field: ref.field };
-}
-function rolesCondition(roles, aliases) {
-  if (!(!roles || roles.length === 0))
-    return groq`count($actor.roles[@ in ${schema.expandRequiredRoles(roles, aliases)}]) > 0`;
-}
-function stripUndefined(obj) {
-  const out = {};
-  for (const [k, value] of Object.entries(obj))
-    value !== void 0 && (out[k] = value);
-  return out;
-}
-const PREDICATE_CALLER_VARS = schema.CONDITION_VARS.filter((v2) => v2.binding === "caller").map(
-  (v2) => v2.name
-);
-function knownList(ids) {
-  return [...ids].map((s) => `"${s}"`).join(", ");
-}
-function checkDuplicates({
-  names,
-  what,
-  issues
-}) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const { name, path } of names)
-    seen.has(name) && issues.push({ path, message: `duplicate ${what} "${name}" (already declared earlier)` }), seen.add(name);
-  return seen;
-}
-function checkStages(def, issues) {
-  const stageNames = checkDuplicates({
-    names: def.stages.map((stage, i) => ({ name: stage.name, path: ["stages", i, "name"] })),
-    what: "stage name",
-    issues
-  });
-  for (const [i, stage] of def.stages.entries()) {
-    const activityNames = checkDuplicates({
-      names: (stage.activities ?? []).map((activity, j) => ({
-        name: activity.name,
-        path: ["stages", i, "activities", j, "name"]
-      })),
-      what: `activity name in stage "${stage.name}"`,
-      issues
-    });
-    checkDuplicates({
-      names: (stage.transitions ?? []).map((t, k) => ({
-        name: t.name,
-        path: ["stages", i, "transitions", k, "name"]
-      })),
-      what: `transition name in stage "${stage.name}"`,
-      issues
-    }), checkActivities({ def, i, activityNames, issues });
-  }
-  return stageNames;
-}
-function checkActivities({
-  def,
-  i,
-  activityNames,
-  issues
-}) {
-  const stage = def.stages[i];
-  for (const [j, activity] of (stage.activities ?? []).entries()) {
-    const path = ["stages", i, "activities", j];
-    checkDuplicates({
-      names: (activity.actions ?? []).map((action, a) => ({
-        name: action.name,
-        path: [...path, "actions", a, "name"]
-      })),
-      what: `action name in activity "${activity.name}"`,
-      issues
-    }), checkStatusSetTargets({ activity, activityNames, path, issues });
-  }
-}
-function checkStatusSetTargets({
-  activity,
-  activityNames,
-  path,
-  issues
-}) {
-  checkStatusSetOps({ ops: activity.ops, activityNames, path: [...path, "ops"], issues });
-  for (const [a, action] of (activity.actions ?? []).entries())
-    checkStatusSetOps({
-      ops: action.ops,
-      activityNames,
-      path: [...path, "actions", a, "ops"],
-      issues
-    });
-}
-function checkStatusSetOps({
-  ops,
-  activityNames,
-  path,
-  issues
-}) {
-  for (const [o, op] of (ops ?? []).entries())
-    op.type !== "status.set" || activityNames.has(op.activity) || issues.push({
-      path: [...path, o, "activity"],
-      message: `status.set targets activity "${op.activity}" which is not declared in this stage. Known activities: ${knownList(activityNames)}`
-    });
-}
-function checkInitialStage({
-  def,
-  stageNames,
-  issues
-}) {
-  stageNames.has(def.initialStage) || issues.push({
-    path: ["initialStage"],
-    message: `initialStage "${def.initialStage}" is not a declared stage. Known stages: ${knownList(stageNames)}`
-  });
-}
-function checkTransitionTargets({
-  def,
-  stageNames,
-  issues
-}) {
-  for (const [i, stage] of def.stages.entries())
-    for (const [k, t] of (stage.transitions ?? []).entries())
-      stageNames.has(t.to) || issues.push({
-        path: ["stages", i, "transitions", k, "to"],
-        message: `transition target "${t.to}" is not a declared stage. Known stages: ${knownList(stageNames)}`
-      });
-}
-function checkEffectNames(def, issues) {
-  const sites = [];
-  for (const [i, stage] of def.stages.entries()) {
-    for (const [j, activity] of (stage.activities ?? []).entries()) {
-      collectEffects({
-        effects: activity.effects,
-        path: ["stages", i, "activities", j, "effects"],
-        sites
-      });
-      for (const [a, action] of (activity.actions ?? []).entries())
-        collectEffects({
-          effects: action.effects,
-          path: ["stages", i, "activities", j, "actions", a, "effects"],
-          sites
-        });
-    }
-    for (const [k, t] of (stage.transitions ?? []).entries())
-      collectEffects({ effects: t.effects, path: ["stages", i, "transitions", k, "effects"], sites });
-  }
-  checkDuplicates({
-    names: sites,
-    what: "effect name (registry key \u2014 unique per definition)",
-    issues
-  });
-}
-function collectEffects({
-  effects,
-  path,
-  sites
-}) {
-  for (const [e, effect] of (effects ?? []).entries())
-    sites.push({ name: effect.name, path: [...path, e, "name"] });
-}
-function checkGuardNames(def, issues) {
-  const sites = def.stages.flatMap(
-    (stage, i) => (stage.guards ?? []).map((guard, g) => ({
-      name: guard.name,
-      path: ["stages", i, "guards", g, "name"]
-    }))
-  );
-  checkDuplicates({
-    names: sites,
-    what: "guard name (the guard lake _id derives from it \u2014 unique per definition)",
-    issues
-  });
-}
-function fieldScopes(def) {
-  const scopes = [
-    { entries: def.fields, scope: "workflow", path: ["fields"], label: "workflow fields" }
-  ];
-  for (const [i, stage] of def.stages.entries()) {
-    scopes.push({
-      entries: stage.fields,
-      scope: "stage",
-      path: ["stages", i, "fields"],
-      label: `stage "${stage.name}" fields`
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+
+var invariants = require("./_chunks-cjs/invariants.cjs");
+
+function defineWorkflow(definition) {
+    const label = invariants.labelFor("defineWorkflow", definition), parsed = invariants.parseOrThrow({
+        schema: invariants.AuthoringWorkflowSchema,
+        input: definition,
+        label: label
+    }), {definition: stored, issues: desugarIssues} = invariants.desugarWorkflow(parsed), issues = [ ...desugarIssues, ...invariants.checkWorkflowInvariants(stored) ];
+    if (issues.length > 0) throw new Error(invariants.formatValidationError(label, issues));
+    return stored;
+}
+
+function defineWorkflowConfig(config) {
+    return invariants.parseOrThrow({
+        schema: invariants.WorkflowConfigSchema,
+        input: config,
+        label: "defineWorkflowConfig"
     });
-    for (const [j, activity] of (stage.activities ?? []).entries())
-      scopes.push({
-        entries: activity.fields,
-        scope: "activity",
-        path: ["stages", i, "activities", j, "fields"],
-        label: `activity "${activity.name}" fields`
-      });
-  }
-  return scopes;
 }
-function checkRequiredField(def, issues) {
-  for (const { entries, scope, path, label } of fieldScopes(def))
-    for (const [n, entry] of (entries ?? []).entries())
-      if (entry.required === !0) {
-        if (scope !== "workflow")
-          issues.push({
-            path: [...path, n, "required"],
-            message: `${label} entry "${entry.name}" is \`required\`, but \`required\` applies only to workflow-scope \`input\` entries \u2014 only those are caller-supplied at start/spawn`
-          });
-        else if (entry.initialValue?.type !== "input") {
-          const seed = entry.initialValue?.type ?? "working memory (no initialValue)";
-          issues.push({
-            path: [...path, n, "required"],
-            message: `field entry "${entry.name}" has initialValue "${seed}" \u2014 \`required\` applies only to \`input\`-sourced entries (the caller fills them at start/spawn)`
-          });
-        }
-      }
-}
-function checkFieldEntryNames(def, issues) {
-  for (const { entries, path, label } of fieldScopes(def))
-    checkDuplicates({
-      names: (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
-      what: `field entry name in ${label}`,
-      issues
+
+function defineStage(stage) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringStageSchema,
+        input: stage,
+        label: invariants.labelFor("defineStage", stage)
     });
 }
-function checkPredicates(def, issues) {
-  const reserved = new Set(schema.RESERVED_CONDITION_VARS), names = Object.keys(def.predicates ?? {});
-  for (const name of names)
-    reserved.has(name) && issues.push({
-      path: ["predicates", name],
-      message: `predicate "${name}" shadows the built-in $${name} \u2014 pick another name`
+
+function defineActivity(activity) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringActivitySchema,
+        input: activity,
+        label: invariants.labelFor("defineActivity", activity)
     });
-  for (const [name, groq2] of Object.entries(def.predicates ?? {}))
-    checkPredicateBody({ name, groq: groq2, names, issues });
 }
-function checkPredicateBody({
-  name,
-  groq: groq2,
-  names,
-  issues
-}) {
-  for (const caller of PREDICATE_CALLER_VARS)
-    referencesVar(groq2, caller) && issues.push({
-      path: ["predicates", name],
-      message: `predicate "${name}" reads $${caller} \u2014 predicates are instance-level (pre-evaluated once, without a caller); compose caller gates at the condition site instead`
-    });
-  for (const other of names)
-    other === name || !referencesVar(groq2, other) || issues.push({
-      path: ["predicates", name],
-      message: `predicate "${name}" references predicate $${other} \u2014 predicates may read built-in vars only (no cross-references; compose at the condition site instead)`
+
+function defineAction(action) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringActionSchema,
+        input: action,
+        label: invariants.labelFor("defineAction", action)
     });
 }
-function referencesVar(groq2, name) {
-  return schema.GROQ_IDENTIFIER.test(name) ? new RegExp(`\\$${name}\\b`).test(groq2) : !1;
-}
-function checkCanOutsideActionFilters(def, issues) {
-  for (const site of nonActionFilterConditionSites(def))
-    referencesVar(site.groq, "can") && issues.push({
-      path: site.path,
-      message: `${site.label} reads $can \u2014 $can (the caller's grants) is bound only when an action fires, so it may appear in action filters only`
+
+function defineTransition(transition) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringTransitionSchema,
+        input: transition,
+        label: transitionLabel(transition)
     });
 }
-function nonActionFilterConditionSites(def) {
-  const sites = [];
-  for (const [i, stage] of def.stages.entries()) {
-    for (const [k, t] of (stage.transitions ?? []).entries())
-      sites.push({
-        groq: t.filter,
-        path: ["stages", i, "transitions", k, "filter"],
-        label: `transition "${t.name}" filter`
-      }), collectBindingSites({
-        effects: t.effects,
-        path: ["stages", i, "transitions", k, "effects"],
-        label: `transition "${t.name}"`,
-        sites
-      }), collectOpWhereSites({
-        ops: t.ops,
-        path: ["stages", i, "transitions", k, "ops"],
-        label: `transition "${t.name}"`,
-        sites
-      });
-    for (const [j, activity] of (stage.activities ?? []).entries())
-      collectActivityConditionSites({ activity, path: ["stages", i, "activities", j], sites });
-  }
-  return sites;
-}
-function collectOpWhereSites({
-  ops,
-  path,
-  label,
-  sites
-}) {
-  for (const [o, op] of (ops ?? []).entries())
-    op.where !== void 0 && sites.push({
-      groq: op.where,
-      path: [...path, o, "where"],
-      label: `${label} ${op.type} where`
+
+function defineField(entry) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringFieldEntrySchema,
+        input: entry,
+        label: invariants.labelFor("defineField", entry)
     });
 }
-function collectActivityConditionSites({
-  activity,
-  path,
-  sites
-}) {
-  for (const field of ["filter", "completeWhen", "failWhen"]) {
-    const groq2 = activity[field];
-    groq2 !== void 0 && sites.push({ groq: groq2, path: [...path, field], label: `activity "${activity.name}".${field}` });
-  }
-  collectBindingSites({
-    effects: activity.effects,
-    path: [...path, "effects"],
-    label: `activity "${activity.name}"`,
-    sites
-  }), collectOpWhereSites({
-    ops: activity.ops,
-    path: [...path, "ops"],
-    label: `activity "${activity.name}"`,
-    sites
-  });
-  for (const [a, action] of (activity.actions ?? []).entries())
-    collectBindingSites({
-      effects: action.effects,
-      path: [...path, "actions", a, "effects"],
-      label: `action "${action.name}"`,
-      sites
-    }), collectOpWhereSites({
-      ops: action.ops,
-      path: [...path, "actions", a, "ops"],
-      label: `action "${action.name}"`,
-      sites
+
+function defineOp(op) {
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringOpSchema,
+        input: op,
+        label: "defineOp"
     });
-  collectSubworkflowSites({ activity, path, sites });
 }
-function collectSubworkflowSites({
-  activity,
-  path,
-  sites
-}) {
-  const sub = activity.subworkflows;
-  if (sub === void 0) return;
-  const subPath = [...path, "subworkflows"];
-  sites.push({
-    groq: sub.forEach,
-    path: [...subPath, "forEach"],
-    label: `activity "${activity.name}".subworkflows.forEach`
-  });
-  for (const [group, record] of [
-    ["with", sub.with],
-    ["context", sub.context]
-  ])
-    for (const [key, groq2] of Object.entries(record ?? {}))
-      sites.push({
-        groq: groq2,
-        path: [...subPath, group, key],
-        label: `activity "${activity.name}".subworkflows.${group} "${key}"`
-      });
-}
-function collectBindingSites({
-  effects,
-  path,
-  label,
-  sites
-}) {
-  for (const [e, effect] of (effects ?? []).entries())
-    for (const [key, groq2] of Object.entries(effect.bindings ?? {}))
-      sites.push({
-        groq: groq2,
-        path: [...path, e, "bindings", key],
-        label: `${label} effect "${effect.name}" binding "${key}"`
-      });
-}
-function checkAssigneesEntries(def, issues) {
-  for (const { entries, path } of fieldScopes(def))
-    (entries ?? []).filter((e) => e.type === "assignees").length <= 1 || issues.push({
-      path,
-      message: "at most one assignees-kind field entry per scope \u2014 the inbox reads it by kind"
+
+function defineGroup(group) {
+    return invariants.parseOrThrow({
+        schema: invariants.GroupSchema,
+        input: group,
+        label: invariants.labelFor("defineGroup", group)
     });
 }
-function activityShape(activity) {
-  return {
-    hasActions: (activity.actions ?? []).length > 0,
-    hasEffects: (activity.effects ?? []).length > 0,
-    hasCompleteWhen: activity.completeWhen !== void 0,
-    hasSubworkflows: activity.subworkflows !== void 0
-  };
-}
-const KIND_SHAPE_RULES = {
-  user: (s) => s.hasActions ? [] : ["needs at least one action for a person to fire"],
-  service: (s) => s.hasEffects ? [] : ["needs at least one effect \u2014 the automated work it performs"],
-  manual: (s) => [
-    s.hasActions || s.hasCompleteWhen ? void 0 : "needs a way to complete \u2014 an action to acknowledge it, or a `completeWhen` predicate to verify it (otherwise it auto-resolves on activation)",
-    s.hasSubworkflows ? "is off-system work, not a fan-out \u2014 drop `subworkflows` or move it to its own activity" : void 0
-  ].filter((m) => m !== void 0),
-  receive: (s) => [
-    s.hasCompleteWhen || s.hasSubworkflows ? void 0 : "needs a `completeWhen` (or `subworkflows`) condition to wait on",
-    s.hasActions ? "has no actor, so it cannot carry actions" : void 0
-  ].filter((m) => m !== void 0),
-  script: (s) => [
-    s.hasActions ? "runs inline with no actor, so it cannot carry actions" : void 0,
-    s.hasCompleteWhen ? "resolves on activation, so it cannot carry a `completeWhen` (that is a `receive`/`service` wait)" : void 0,
-    s.hasSubworkflows ? "resolves on activation, so it cannot fan out with `subworkflows`" : void 0
-  ].filter((m) => m !== void 0)
-};
-function checkActivityKinds(def, issues) {
-  for (const [i, stage] of def.stages.entries())
-    for (const [j, activity] of (stage.activities ?? []).entries()) {
-      const path = ["stages", i, "activities", j];
-      if (activity.target !== void 0 && activity.kind !== "manual" && issues.push({
-        path: [...path, "target"],
-        message: `activity "${activity.name}" has a \`target\` but is not \`kind: "manual"\` \u2014 a target is the deep-link for off-system manual work`
-      }), activity.kind !== void 0)
-        for (const fault of KIND_SHAPE_RULES[activity.kind](activityShape(activity)))
-          issues.push({
-            path: [...path, "kind"],
-            message: `activity "${activity.name}" declares kind "${activity.kind}" but ${fault}`
-          });
-    }
-}
-function checkWorkflowInvariants(def) {
-  const issues = [], stageNames = checkStages(def, issues);
-  return checkInitialStage({ def, stageNames, issues }), checkTransitionTargets({ def, stageNames, issues }), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), checkRequiredField(def, issues), checkPredicates(def, issues), checkCanOutsideActionFilters(def, issues), checkAssigneesEntries(def, issues), checkActivityKinds(def, issues), issues;
-}
-function defineWorkflow(definition) {
-  const label = labelFor("defineWorkflow", definition), parsed = parseOrThrow({ schema: schema.AuthoringWorkflowSchema, input: definition, label }), { definition: stored, issues: desugarIssues } = desugarWorkflow(parsed), issues = [...desugarIssues, ...checkWorkflowInvariants(stored)];
-  if (issues.length > 0) throw new Error(schema.formatValidationError(label, issues));
-  return stored;
-}
-function defineWorkflowConfig(config) {
-  return parseOrThrow({ schema: schema.WorkflowConfigSchema, input: config, label: "defineWorkflowConfig" });
-}
-function defineStage(stage) {
-  return parseOrThrow({
-    schema: schema.AuthoringStageSchema,
-    input: stage,
-    label: labelFor("defineStage", stage)
-  });
-}
-function defineActivity(activity) {
-  return parseOrThrow({
-    schema: schema.AuthoringActivitySchema,
-    input: activity,
-    label: labelFor("defineActivity", activity)
-  });
-}
-function defineAction(action) {
-  return parseOrThrow({
-    schema: schema.AuthoringActionSchema,
-    input: action,
-    label: labelFor("defineAction", action)
-  });
-}
-function defineTransition(transition) {
-  return parseOrThrow({
-    schema: schema.AuthoringTransitionSchema,
-    input: transition,
-    label: transitionLabel(transition)
-  });
-}
-function defineField(entry) {
-  return parseOrThrow({
-    schema: schema.AuthoringFieldEntrySchema,
-    input: entry,
-    label: labelFor("defineField", entry)
-  });
-}
-function defineOp(op) {
-  return parseOrThrow({ schema: schema.AuthoringOpSchema, input: op, label: "defineOp" });
-}
+
 function defineGuard(guard) {
-  return parseOrThrow({
-    schema: schema.AuthoringGuardSchema,
-    input: guard,
-    label: labelFor("defineGuard", guard)
-  });
+    return invariants.parseOrThrow({
+        schema: invariants.AuthoringGuardSchema,
+        input: guard,
+        label: invariants.labelFor("defineGuard", guard)
+    });
 }
+
 function defineEffect(effect) {
-  return parseOrThrow({
-    schema: schema.EffectSchema,
-    input: effect,
-    label: labelFor("defineEffect", effect)
-  });
+    return invariants.parseOrThrow({
+        schema: invariants.EffectSchema,
+        input: effect,
+        label: invariants.labelFor("defineEffect", effect)
+    });
 }
+
 function transitionLabel(transition) {
-  const { name, to } = transition;
-  return typeof name == "string" ? `defineTransition("${name}")` : typeof to == "string" ? `defineTransition(\u2192 "${to}")` : "defineTransition";
+    const {name: name, to: to} = transition;
+    return typeof name == "string" ? `defineTransition("${name}")` : typeof to == "string" ? `defineTransition(→ "${to}")` : "defineTransition";
 }
+
 function defineEffectDescriptor(descriptor) {
-  if (!descriptor.name) throw new Error("EffectDescriptor missing name");
-  return descriptor;
-}
-function parseOrThrow({
-  schema: schema$1,
-  input,
-  label
-}) {
-  const result = v__namespace.safeParse(schema$1, input);
-  if (!result.success)
-    throw new Error(schema.formatValidationError(label, schema.issuesFromValibot(result.issues)));
-  return result.output;
-}
-function labelFor(fn, value) {
-  if (value && typeof value == "object" && "name" in value) {
-    const raw = value.name;
-    if (typeof raw == "string") return `${fn}("${raw}")`;
-  }
-  return fn;
-}
-exports.CONDITION_VARS = schema.CONDITION_VARS;
-exports.FILTER_SCOPE_VARS = schema.FILTER_SCOPE_VARS;
-exports.GUARD_PREDICATE_VARS = schema.GUARD_PREDICATE_VARS;
-exports.RESERVED_CONDITION_VARS = schema.RESERVED_CONDITION_VARS;
+    if (!descriptor.name) throw new Error("EffectDescriptor missing name");
+    return descriptor;
+}
+
+exports.CONDITION_VARS = invariants.CONDITION_VARS;
+
+exports.FILTER_SCOPE_VARS = invariants.FILTER_SCOPE_VARS;
+
+exports.GUARD_PREDICATE_VARS = invariants.GUARD_PREDICATE_VARS;
+
+exports.RESERVED_CONDITION_VARS = invariants.RESERVED_CONDITION_VARS;
+
+exports.groq = invariants.groq;
+
 exports.defineAction = defineAction;
+
 exports.defineActivity = defineActivity;
+
 exports.defineEffect = defineEffect;
+
 exports.defineEffectDescriptor = defineEffectDescriptor;
+
 exports.defineField = defineField;
+
+exports.defineGroup = defineGroup;
+
 exports.defineGuard = defineGuard;
+
 exports.defineOp = defineOp;
+
 exports.defineStage = defineStage;
+
 exports.defineTransition = defineTransition;
+
 exports.defineWorkflow = defineWorkflow;
+
 exports.defineWorkflowConfig = defineWorkflowConfig;
-exports.groq = groq;
-//# sourceMappingURL=define.cjs.map