@sanity/workflow-engine 0.12.0 → 0.14.0

package/dist/define.cjs

@@ -36,28 +36,28 @@ function desugarWorkflow(authoring) {
     claimFields: /* @__PURE__ */ new Map(),
     claimedFields: /* @__PURE__ */ new Set(),
     roleAliases
-  }, workflowFields = desugarFieldEntries(authoring.fields, ["fields"], ctx), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
-    const path = ["stages", i], stageFields = desugarFieldEntries(stage.fields, [...path, "fields"], ctx), stageEnv = {
+  }, 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, "activities", j], stageEnv, ctx)
+      (activity, j) => desugarActivity({ activity, path: [...path, "activities", j], stageEnv, ctx })
     ), transitions = (stage.transitions ?? []).map(
-      (transition, k) => desugarTransition(transition, [...path, "transitions", k], stageEnv, ctx)
-    ), editable = desugarStageEditable(
-      stage.editable,
-      editableSlotNames(workflowFields, stageFields, activities),
-      [...path, "editable"],
+      (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
+        guards: stage.guards?.map(desugarGuard)
       }),
       ...stageFields ? { fields: stageFields } : {},
       ...activities.length > 0 ? { activities } : {},
@@ -70,7 +70,7 @@ function desugarWorkflow(authoring) {
       name: authoring.name,
       title: authoring.title,
       description: authoring.description,
-      role: authoring.role,
+      lifecycle: authoring.lifecycle,
       initialStage: authoring.initialStage,
       predicates: authoring.predicates,
       roleAliases
@@ -96,13 +96,22 @@ const TODOLIST_OF = [
   { 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, 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(entry.editable, [...path, "editable"], ctx);
+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,
@@ -117,15 +126,23 @@ function desugarFieldEntry(entry, path, ctx) {
     })
   };
 }
-function desugarClaimField(entry, path, ctx) {
+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(entry.editable, [...path, "editable"], ctx);
+function desugarListField({
+  entry,
+  path,
+  ctx
+}) {
+  const editable = normalizeEditable({ editable: entry.editable, path: [...path, "editable"], ctx });
   return {
     ...stripUndefined({
       name: entry.name,
@@ -139,14 +156,18 @@ function desugarListField(entry, path, ctx) {
     of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
   };
 }
-function normalizeEditable(editable, path, ctx) {
+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 slot to anyone in its scope, or list at least one role"
+        message: "editable: [] names no roles \u2014 use `true` to open the field to anyone in its scope, or list at least one role"
       });
       return;
     }
@@ -154,7 +175,11 @@ function normalizeEditable(editable, path, ctx) {
   }
   return editable;
 }
-function editableSlotNames(workflowFields, stageFields, activities) {
+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);
   };
@@ -162,18 +187,23 @@ function editableSlotNames(workflowFields, stageFields, activities) {
   for (const activity of activities) collect(activity.fields);
   return names;
 }
-function desugarStageEditable(overrides, inScope, path, ctx) {
+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 slot in scope \u2014 name a workflow/stage/activity slot of this stage that declares \`editable\``
+        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(value, [...path, name], ctx);
+    const normalized = normalizeEditable({ editable: value, path: [...path, name], ctx });
     normalized !== void 0 && (out[name] = normalized);
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -181,12 +211,27 @@ function desugarStageEditable(overrides, inScope, path, ctx) {
 function layerOf(entries) {
   return new Map((entries ?? []).map((entry) => [entry.name, entry]));
 }
-function desugarActivity(activity, path, stageEnv, ctx) {
-  const activityFields = desugarFieldEntries(activity.fields, [...path, "fields"], ctx), env = {
+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(activity.ops, [...path, "ops"], env, activity.name, ctx), actions = (activity.actions ?? []).map(
-    (action, a) => desugarAction(action, [...path, "actions", a], env, activity.name, ctx)
-  ), target = desugarTarget(activity.target, env, [...path, "target"], ctx);
+  }, 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,
@@ -208,18 +253,29 @@ function desugarActivity(activity, path, stageEnv, ctx) {
   };
 }
 const TARGET_DOC_KINDS = ["doc.ref", "doc.refs", "release.ref"];
-function desugarTarget(target, env, path, ctx) {
+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, "field"], ctx) ?? fallbackRef(ref), entry = entryAt(env, field);
+  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) {
+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(action.ops, [...path, "ops"], env, activityName, ctx) ?? [];
+    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,
@@ -232,14 +288,26 @@ function desugarAction(action, path, env, activityName, ctx) {
     ...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, "field"], ctx);
+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(action.name, ref.field, resolved, env, [...path, "field"], ctx), entry && ctx.claimedFields.add(entry);
+    }), 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,
@@ -258,7 +326,14 @@ function desugarClaimAction(action, path, env, ctx) {
     ...ops.length > 0 ? { ops } : {}
   };
 }
-function checkShadowedClaimTarget(actionName, field, resolved, env, path, ctx) {
+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,
@@ -272,8 +347,19 @@ function checkUnclaimedClaimFields(ctx) {
       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(transition.ops, [...path, "ops"], stageEnv, void 0, ctx);
+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,
@@ -286,11 +372,38 @@ function desugarTransition(transition, path, stageEnv, ctx) {
     ...ops ? { ops } : {}
   };
 }
-function desugarOps(ops, path, env, firingActivity, ctx) {
-  if (ops)
-    return ops.map((op, i) => desugarOp(op, [...path, i], env, firingActivity, ctx));
+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 desugarOp(op, path, env, firingActivity, ctx) {
+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({
@@ -298,13 +411,18 @@ function desugarOp(op, path, env, firingActivity, ctx) {
       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(op.target, env, [...path, "target"], ctx) ?? fallbackRef(op.target);
+  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(op.target, env, [...path, "target"], ctx) ?? fallbackRef(op.target);
+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"],
@@ -326,7 +444,12 @@ function desugarAuditOp(op, path, env, ctx) {
   }
   return { type: "field.append", target, value: { type: "object", fields } };
 }
-function resolveRef(ref, env, path, ctx) {
+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 };
@@ -352,91 +475,109 @@ function stripUndefined(obj) {
     value !== void 0 && (out[k] = value);
   return out;
 }
-const RESERVED_CONDITION_VARS = [
-  "fields",
-  "actor",
-  "assigned",
-  "can",
-  "row",
-  "now",
-  "effects",
-  "activities",
-  "subworkflows",
-  "self",
-  "stage",
-  "parent",
-  "ancestors",
-  "allActivitiesDone",
-  "anyActivityFailed"
-], PREDICATE_CALLER_VARS = ["actor", "assigned", "can"];
+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) {
+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(
-    def.stages.map((stage, i) => ({ name: stage.name, path: ["stages", i, "name"] })),
-    "stage name",
+  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(
-      (stage.activities ?? []).map((activity, j) => ({
+    const activityNames = checkDuplicates({
+      names: (stage.activities ?? []).map((activity, j) => ({
         name: activity.name,
         path: ["stages", i, "activities", j, "name"]
       })),
-      `activity name in stage "${stage.name}"`,
+      what: `activity name in stage "${stage.name}"`,
       issues
-    );
-    checkDuplicates(
-      (stage.transitions ?? []).map((t, k) => ({
+    });
+    checkDuplicates({
+      names: (stage.transitions ?? []).map((t, k) => ({
         name: t.name,
         path: ["stages", i, "transitions", k, "name"]
       })),
-      `transition name in stage "${stage.name}"`,
+      what: `transition name in stage "${stage.name}"`,
       issues
-    ), checkActivities(def, i, activityNames, issues);
+    }), checkActivities({ def, i, activityNames, issues });
   }
   return stageNames;
 }
-function checkActivities(def, i, activityNames, issues) {
+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(
-      (activity.actions ?? []).map((action, a) => ({
+    checkDuplicates({
+      names: (activity.actions ?? []).map((action, a) => ({
         name: action.name,
         path: [...path, "actions", a, "name"]
       })),
-      `action name in activity "${activity.name}"`,
+      what: `action name in activity "${activity.name}"`,
       issues
-    ), checkStatusSetTargets(activity, activityNames, path, issues);
+    }), checkStatusSetTargets({ activity, activityNames, path, issues });
   }
 }
-function checkStatusSetTargets(activity, activityNames, path, issues) {
-  checkStatusSetOps(activity.ops, activityNames, [...path, "ops"], 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(action.ops, activityNames, [...path, "actions", a, "ops"], issues);
+    checkStatusSetOps({
+      ops: action.ops,
+      activityNames,
+      path: [...path, "actions", a, "ops"],
+      issues
+    });
 }
-function checkStatusSetOps(ops, activityNames, path, 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) {
+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) {
+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({
@@ -448,20 +589,32 @@ function checkEffectNames(def, issues) {
   const sites = [];
   for (const [i, stage] of def.stages.entries()) {
     for (const [j, activity] of (stage.activities ?? []).entries()) {
-      collectEffects(activity.effects, ["stages", i, "activities", j, "effects"], sites);
+      collectEffects({
+        effects: activity.effects,
+        path: ["stages", i, "activities", j, "effects"],
+        sites
+      });
       for (const [a, action] of (activity.actions ?? []).entries())
-        collectEffects(
-          action.effects,
-          ["stages", i, "activities", j, "actions", a, "effects"],
+        collectEffects({
+          effects: action.effects,
+          path: ["stages", i, "activities", j, "actions", a, "effects"],
           sites
-        );
+        });
     }
     for (const [k, t] of (stage.transitions ?? []).entries())
-      collectEffects(t.effects, ["stages", i, "transitions", k, "effects"], sites);
+      collectEffects({ effects: t.effects, path: ["stages", i, "transitions", k, "effects"], sites });
   }
-  checkDuplicates(sites, "effect name (registry key \u2014 unique per definition)", issues);
+  checkDuplicates({
+    names: sites,
+    what: "effect name (registry key \u2014 unique per definition)",
+    issues
+  });
 }
-function collectEffects(effects, path, sites) {
+function collectEffects({
+  effects,
+  path,
+  sites
+}) {
   for (const [e, effect] of (effects ?? []).entries())
     sites.push({ name: effect.name, path: [...path, e, "name"] });
 }
@@ -472,11 +625,11 @@ function checkGuardNames(def, issues) {
       path: ["stages", i, "guards", g, "name"]
     }))
   );
-  checkDuplicates(
-    sites,
-    "guard name (the guard lake _id derives from it \u2014 unique per definition)",
+  checkDuplicates({
+    names: sites,
+    what: "guard name (the guard lake _id derives from it \u2014 unique per definition)",
     issues
-  );
+  });
 }
 function fieldScopes(def) {
   const scopes = [
@@ -519,23 +672,28 @@ function checkRequiredField(def, issues) {
 }
 function checkFieldEntryNames(def, issues) {
   for (const { entries, path, label } of fieldScopes(def))
-    checkDuplicates(
-      (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
-      `field entry name in ${label}`,
+    checkDuplicates({
+      names: (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
+      what: `field entry name in ${label}`,
       issues
-    );
+    });
 }
 function checkPredicates(def, issues) {
-  const reserved = new Set(RESERVED_CONDITION_VARS), names = Object.keys(def.predicates ?? {});
+  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`
     });
   for (const [name, groq2] of Object.entries(def.predicates ?? {}))
-    checkPredicateBody(name, groq2, names, issues);
-}
-function checkPredicateBody(name, groq2, names, issues) {
+    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],
@@ -565,33 +723,74 @@ function nonActionFilterConditionSites(def) {
         groq: t.filter,
         path: ["stages", i, "transitions", k, "filter"],
         label: `transition "${t.name}" filter`
-      }), collectBindingSites(
-        t.effects,
-        ["stages", i, "transitions", k, "effects"],
-        `transition "${t.name}"`,
+      }), 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, ["stages", i, "activities", j], sites);
+      collectActivityConditionSites({ activity, path: ["stages", i, "activities", j], sites });
   }
   return sites;
 }
-function collectActivityConditionSites(activity, path, 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 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(activity.effects, [...path, "effects"], `activity "${activity.name}"`, sites);
+  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(
-      action.effects,
-      [...path, "actions", a, "effects"],
-      `action "${action.name}"`,
+    collectBindingSites({
+      effects: action.effects,
+      path: [...path, "actions", a, "effects"],
+      label: `action "${action.name}"`,
       sites
-    );
-  collectSubworkflowSites(activity, path, sites);
+    }), collectOpWhereSites({
+      ops: action.ops,
+      path: [...path, "actions", a, "ops"],
+      label: `action "${action.name}"`,
+      sites
+    });
+  collectSubworkflowSites({ activity, path, sites });
 }
-function collectSubworkflowSites(activity, path, sites) {
+function collectSubworkflowSites({
+  activity,
+  path,
+  sites
+}) {
   const sub = activity.subworkflows;
   if (sub === void 0) return;
   const subPath = [...path, "subworkflows"];
@@ -611,7 +810,12 @@ function collectSubworkflowSites(activity, path, sites) {
         label: `activity "${activity.name}".subworkflows.${group} "${key}"`
       });
 }
-function collectBindingSites(effects, path, label, sites) {
+function collectBindingSites({
+  effects,
+  path,
+  label,
+  sites
+}) {
   for (const [e, effect] of (effects ?? []).entries())
     for (const [key, groq2] of Object.entries(effect.bindings ?? {}))
       sites.push({
@@ -669,36 +873,67 @@ function checkActivityKinds(def, issues) {
 }
 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;
+  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.AuthoringWorkflowSchema, definition, label), { definition: stored, issues: desugarIssues } = desugarWorkflow(parsed), issues = [...desugarIssues, ...checkWorkflowInvariants(stored)];
+  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.AuthoringStageSchema, stage, labelFor("defineStage", stage));
+  return parseOrThrow({
+    schema: schema.AuthoringStageSchema,
+    input: stage,
+    label: labelFor("defineStage", stage)
+  });
 }
 function defineActivity(activity) {
-  return parseOrThrow(schema.AuthoringActivitySchema, activity, labelFor("defineActivity", activity));
+  return parseOrThrow({
+    schema: schema.AuthoringActivitySchema,
+    input: activity,
+    label: labelFor("defineActivity", activity)
+  });
 }
 function defineAction(action) {
-  return parseOrThrow(schema.AuthoringActionSchema, action, labelFor("defineAction", action));
+  return parseOrThrow({
+    schema: schema.AuthoringActionSchema,
+    input: action,
+    label: labelFor("defineAction", action)
+  });
 }
 function defineTransition(transition) {
-  return parseOrThrow(schema.AuthoringTransitionSchema, transition, transitionLabel(transition));
+  return parseOrThrow({
+    schema: schema.AuthoringTransitionSchema,
+    input: transition,
+    label: transitionLabel(transition)
+  });
 }
 function defineField(entry) {
-  return parseOrThrow(schema.AuthoringFieldEntrySchema, entry, labelFor("defineField", entry));
+  return parseOrThrow({
+    schema: schema.AuthoringFieldEntrySchema,
+    input: entry,
+    label: labelFor("defineField", entry)
+  });
 }
 function defineOp(op) {
-  return parseOrThrow(schema.AuthoringOpSchema, op, "defineOp");
+  return parseOrThrow({ schema: schema.AuthoringOpSchema, input: op, label: "defineOp" });
 }
 function defineGuard(guard) {
-  return parseOrThrow(schema.GuardSchema, guard, labelFor("defineGuard", guard));
+  return parseOrThrow({
+    schema: schema.AuthoringGuardSchema,
+    input: guard,
+    label: labelFor("defineGuard", guard)
+  });
 }
 function defineEffect(effect) {
-  return parseOrThrow(schema.EffectSchema, effect, labelFor("defineEffect", effect));
+  return parseOrThrow({
+    schema: schema.EffectSchema,
+    input: effect,
+    label: labelFor("defineEffect", effect)
+  });
 }
 function transitionLabel(transition) {
   const { name, to } = transition;
@@ -708,7 +943,11 @@ function defineEffectDescriptor(descriptor) {
   if (!descriptor.name) throw new Error("EffectDescriptor missing name");
   return descriptor;
 }
-function parseOrThrow(schema$1, input, label) {
+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)));
@@ -721,6 +960,10 @@ function labelFor(fn, value) {
   }
   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;
 exports.defineAction = defineAction;
 exports.defineActivity = defineActivity;
 exports.defineEffect = defineEffect;
@@ -731,5 +974,6 @@ exports.defineOp = defineOp;
 exports.defineStage = defineStage;
 exports.defineTransition = defineTransition;
 exports.defineWorkflow = defineWorkflow;
+exports.defineWorkflowConfig = defineWorkflowConfig;
 exports.groq = groq;
 //# sourceMappingURL=define.cjs.map