@sanity/workflow-engine 0.28.0 → 0.29.0

package/dist/_chunks-cjs/invariants.cjs

@@ -539,6 +539,7 @@ function desugarWorkflow(authoring) {
         return {
             ...stripUndefined({
                 name: stage.name,
+                semantics: stage.semantics,
                 title: stage.title,
                 description: stage.description,
                 groups: stage.groups,
@@ -562,6 +563,7 @@ function desugarWorkflow(authoring) {
         definition: {
             ...stripUndefined({
                 name: authoring.name,
+                semantics: authoring.semantics,
                 title: authoring.title,
                 description: authoring.description,
                 groups: authoring.groups,
@@ -788,6 +790,7 @@ function desugarActivity({activity: activity, path: path, stageEnv: stageEnv, ct
     return {
         ...stripUndefined({
             name: activity.name,
+            semantics: activity.semantics,
             title: activity.title,
             description: activity.description,
             groups: activity.groups,
@@ -1259,7 +1262,58 @@ function isTerminalActivityStatus(status) {
     return TERMINAL_ACTIVITY_STATUSES.includes(status);
 }
 
-const ACTION_SEMANTICS = [ "decision.accept", "decision.decline" ], 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" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ], CONDITION_VARS = [ {
+const SIGNAL_SEMANTICS = [ "signal.positive", "signal.caution", "signal.critical" ], DECISION_SEMANTICS = [ "decision.accept", "decision.decline" ], ACTION_SEMANTICS = [ ...DECISION_SEMANTICS, ...SIGNAL_SEMANTICS ], 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" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ];
+
+function releaseDocId(releaseName) {
+    return `_.releases.${releaseName}`;
+}
+
+function releaseRef({res: res, releaseName: releaseName}) {
+    if (releaseName.length === 0) throw new ContractViolationError("releaseRef: releaseName must be a non-empty release name");
+    return {
+        id: gdrFromResource(res, releaseDocId(releaseName)),
+        type: "system.release",
+        releaseName: releaseName
+    };
+}
+
+function isAlwaysArrayFieldKind(kind) {
+    return kind === "doc.refs" || kind === "assignees" || kind === "array";
+}
+
+function isSingleDocRefKind(kind) {
+    return kind === "doc.ref" || kind === "subject";
+}
+
+function refKindAcceptsTypes(kind) {
+    return isSingleDocRefKind(kind) || kind === "doc.refs";
+}
+
+function isSingleDocRefEntry(entry) {
+    return isSingleDocRefKind(entry._type);
+}
+
+function isTodoListItem(row) {
+    if (typeof row != "object" || row === null) return !1;
+    const candidate = row, status = candidate.status;
+    return typeof candidate._key == "string" && typeof candidate.label == "string" && (status == null || typeof status == "string");
+}
+
+function declaredRowColumns(entry) {
+    if (("_type" in entry ? entry._type : entry.type) === "array") return new Set((("of" in entry ? entry.of : void 0) ?? []).map(shape => shape.name));
+}
+
+function isTodoListEntry(entry) {
+    const columns = declaredRowColumns(entry);
+    return columns !== void 0 && columns.has("label") && columns.has("status");
+}
+
+function isNotesEntry(entry) {
+    const columns = declaredRowColumns(entry);
+    return columns !== void 0 && columns.has("body") && columns.has("actor") && columns.has("at");
+}
+
+const CONDITION_VARS = [ {
     name: "self",
     binding: "always",
     label: "this workflow instance",
@@ -1334,6 +1388,11 @@ const ACTION_SEMANTICS = [ "decision.accept", "decision.decline" ], FIELD_SCOPES
     binding: "caller",
     label: "your permissions",
     description: "Advisory per-permission booleans computed from the caller's grants; `undefined` without grants. Bound wherever grants ride the evaluation: the projection's rendered scope (fireAction-action filters, activity requirements, editability predicates) and the fireAction/editField commit gates. Deploy rejects it at every site that evaluates without grants: transition `when`s, activity filters, cascade-fired actions' `when`/`filter`, effect bindings, where-op `where`s, and the spawn `forEach`/`with`/`context` sites."
+}, {
+    name: "attributes",
+    binding: "caller",
+    label: "your attributes",
+    description: "Advisory org-level User Attributes for the caller (Enterprise — same values as lake `user::attributes()`), keyed by attribute name with each active scalar or array value. `undefined` on expected HTTP absence; unexpected fetch failures throw; empty page binds `{}`. Bound wherever grants ride the evaluation (same sites as `$can`). Soft-gate paths fetch at most 100 attributes (no further pages) and warn when the envelope reports `hasMore: true` (partial bag still binds). Not a security boundary — the Content Lake remains the only enforcement point."
 }, {
     name: "row",
     binding: "spawn",
@@ -1499,54 +1558,7 @@ function documentIdOf(doc) {
     return "(unknown id)";
 }
 
-const ACTOR_KINDS = [ "person", "agent", "system" ];
-
-function releaseDocId(releaseName) {
-    return `_.releases.${releaseName}`;
-}
-
-function releaseRef({res: res, releaseName: releaseName}) {
-    if (releaseName.length === 0) throw new ContractViolationError("releaseRef: releaseName must be a non-empty release name");
-    return {
-        id: gdrFromResource(res, releaseDocId(releaseName)),
-        type: "system.release",
-        releaseName: releaseName
-    };
-}
-
-function isSingleDocRefKind(kind) {
-    return kind === "doc.ref" || kind === "subject";
-}
-
-function refKindAcceptsTypes(kind) {
-    return isSingleDocRefKind(kind) || kind === "doc.refs";
-}
-
-function isSingleDocRefEntry(entry) {
-    return isSingleDocRefKind(entry._type);
-}
-
-function isTodoListItem(row) {
-    if (typeof row != "object" || row === null) return !1;
-    const candidate = row, status = candidate.status;
-    return typeof candidate._key == "string" && typeof candidate.label == "string" && (status == null || typeof status == "string");
-}
-
-function declaredRowColumns(entry) {
-    if (("_type" in entry ? entry._type : entry.type) === "array") return new Set((("of" in entry ? entry.of : void 0) ?? []).map(shape => shape.name));
-}
-
-function isTodoListEntry(entry) {
-    const columns = declaredRowColumns(entry);
-    return columns !== void 0 && columns.has("label") && columns.has("status");
-}
-
-function isNotesEntry(entry) {
-    const columns = declaredRowColumns(entry);
-    return columns !== void 0 && columns.has("body") && columns.has("actor") && columns.has("at");
-}
-
-const ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
+const ACTOR_KINDS = [ "person", "agent", "system" ], ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
 
 function classifyPrincipalId(id) {
     if (id === ANONYMOUS_IDENTITY || id === SYSTEM_IDENTITY) return {
@@ -1975,6 +1987,10 @@ function opSchemas(targetSchema) {
         type: v__namespace.literal("field.set"),
         target: targetSchema,
         value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.setIfMissing"),
+        target: targetSchema,
+        value: ValueExprSchema
     }), v__namespace.strictObject({
         type: v__namespace.literal("field.unset"),
         target: targetSchema
@@ -1982,6 +1998,14 @@ function opSchemas(targetSchema) {
         type: v__namespace.literal("field.append"),
         target: targetSchema,
         value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.inc"),
+        target: targetSchema,
+        value: v__namespace.optional(ValueExprSchema)
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.dec"),
+        target: targetSchema,
+        value: v__namespace.optional(ValueExprSchema)
     }), v__namespace.strictObject({
         type: v__namespace.literal("field.updateWhere"),
         target: targetSchema,
@@ -2198,17 +2222,27 @@ const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("
     required: v__namespace.optional(v__namespace.boolean()),
     options: v__namespace.optional(ChoiceOptionsSchema),
     validation: v__namespace.optional(ScalarValidationSchema)
-}), choiceOptionsCheck(), scalarValidationCheck());
+}), choiceOptionsCheck(), scalarValidationCheck()), CUSTOM_SEMANTIC_HINT = "`custom.<camelCaseMeaning>`", CustomSemanticSchema = v__namespace.custom(input => typeof input == "string" && /^custom\.[a-z][a-zA-Z0-9]*$/.test(input)), SemanticSchema = v__namespace.union([ picklist(SIGNAL_SEMANTICS), CustomSemanticSchema ], `expected ${SIGNAL_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`), ActionSemanticSchema = v__namespace.union([ picklist(ACTION_SEMANTICS), CustomSemanticSchema ], `expected ${ACTION_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`);
+
+function semanticNamespace(semantic) {
+    return semantic.startsWith("custom.") ? semantic : semantic.split(".", 1)[0] ?? semantic;
+}
 
 function hasUniqueSemanticNamespaces(semantics) {
-    const namespaces = semantics.map(semantic => semantic.split(".", 1)[0]);
+    const namespaces = semantics.map(semanticNamespace);
     return new Set(namespaces).size === namespaces.length;
 }
 
+function semanticsFieldSchema(semantic) {
+    return v__namespace.optional(v__namespace.pipe(v__namespace.array(semantic), v__namespace.minLength(1, "declare at least one semantic, or omit `semantics`"), v__namespace.check(hasUniqueSemanticNamespaces, "declare at most one semantic from each namespace")));
+}
+
+const SemanticsFieldSchema = semanticsFieldSchema(SemanticSchema), ActionSemanticsFieldSchema = semanticsFieldSchema(ActionSemanticSchema);
+
 function actionFields(op, group) {
     return {
         name: NonEmpty,
-        semantics: v__namespace.optional(v__namespace.pipe(v__namespace.array(picklist(ACTION_SEMANTICS)), v__namespace.minLength(1, "declare at least one semantic, or omit `semantics`"), v__namespace.check(hasUniqueSemanticNamespaces, "declare at most one semantic from each namespace"))),
+        semantics: ActionSemanticsFieldSchema,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         group: v__namespace.optional(group),
@@ -2255,6 +2289,7 @@ const StoredActionSchema = pinned()(v__namespace.strictObject({
 function activityFields({field: field, action: action, target: target, group: group}) {
     return {
         name: NonEmpty,
+        semantics: SemanticsFieldSchema,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         groups: v__namespace.optional(v__namespace.array(GroupSchema)),
@@ -2328,6 +2363,7 @@ const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty)), AuthoringG
 function stageFields({field: field, activity: activity, transition: transition, guard: guard, editable: editable}) {
     return {
         name: NonEmpty,
+        semantics: SemanticsFieldSchema,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
         groups: v__namespace.optional(v__namespace.array(GroupSchema)),
@@ -2366,6 +2402,7 @@ const StoredStartSchema = pinned()(v__namespace.strictObject(startFields(picklis
 function workflowFields({field: field, stage: stage, start: start}) {
     return {
         name: NonEmpty,
+        semantics: SemanticsFieldSchema,
         title: NonEmpty,
         description: v__namespace.optional(v__namespace.string()),
         groups: v__namespace.optional(v__namespace.array(GroupSchema)),
@@ -2562,11 +2599,20 @@ function checkStageReachability({def: def, stageNames: stageNames, issues: issue
     });
 }
 
+function actionSites(def) {
+    return def.stages.flatMap((stage, i) => (stage.activities ?? []).flatMap((activity, j) => (activity.actions ?? []).map((action, a) => ({
+        action: action,
+        activity: activity,
+        stage: stage,
+        path: [ "stages", i, "activities", j, "actions", a ]
+    }))));
+}
+
 function effectNameSites(def) {
     const sites = [];
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) collectEffects({
+    for (const {action: action, path: path} of actionSites(def)) collectEffects({
         effects: action.effects,
-        path: [ "stages", i, "activities", j, "actions", a, "effects" ],
+        path: [ ...path, "effects" ],
         sites: sites
     });
     return sites;
@@ -2697,13 +2743,22 @@ function checkUnboundConditionVars(def, issues) {
     }
 }
 
+const SOFT_GATE_VARS = {
+    can: {
+        noun: "the caller's grants"
+    },
+    attributes: {
+        noun: "the caller's org-level user attributes"
+    }
+}, SOFT_GATE_VAR_NAMES = Object.keys(SOFT_GATE_VARS);
+
 function unboundVarsAt(site) {
     const callerVars = unboundCallerVars(site.policy);
     return site.bindsRow === !0 ? callerVars : [ ...callerVars, "row" ];
 }
 
 function unboundCallerVars(policy) {
-    return policy === "cascade" ? CALLER_BOUND_VARS : policy === "caller-bound" ? [ "params" ] : policy === "triggered-payload" ? [ "can", "params" ] : [ "can" ];
+    return policy === "cascade" ? CALLER_BOUND_VARS : policy === "caller-bound" ? [ "params" ] : policy === "triggered-payload" ? [ ...SOFT_GATE_VAR_NAMES, "params" ] : SOFT_GATE_VAR_NAMES;
 }
 
 const ROW_BINDING_CLAUSE = "$row (the discovered row in a spawn projection; the stored row under test in a where-op) is bound only while a spawn `with` projection or a where-op `where` evaluates";
@@ -2713,7 +2768,12 @@ function rowVarMessage(site) {
 }
 
 function callerVarMessage(site, name) {
-    return site.policy === "cascade" ? `${site.label} reads $${name} — cascade gates (transition \`when\`s, activity \`filter\`s, a cascade-fired action's \`when\`/\`filter\`) must resolve identically no matter whose token drives the cascade ($assigned is constant false, the other caller vars hold no value); gate on instance state (e.g. a field an action wrote), or pin executing identities with \`roles\`` : site.policy === "caller-bound" ? `${site.label} reads $${name} — $params (the firing action's args) is bound only while the action's effect bindings and where-op \`where\`s evaluate; this site never binds it, so the condition could never pass. Bind $params in an effect binding or a where-op instead, or gate on a field an action wrote` : site.policy === "triggered-payload" && name === "params" ? `${site.label} reads $params — a cascade-fired action has no caller to supply args, so $params never holds a value in its payload; read fields or effect outputs instead` : `${site.label} reads $can — $can (the caller's grants) is bound only in the caller-bound projection (action filters, requirements, editable predicates) and never holds a value in cascade conditions; move the check to one of those sites or drop $can`;
+    if (site.policy === "cascade") return `${site.label} reads $${name} — cascade gates (transition \`when\`s, activity \`filter\`s, a cascade-fired action's \`when\`/\`filter\`) must resolve identically no matter whose token drives the cascade ($assigned is constant false, the other caller vars hold no value); gate on instance state (e.g. a field an action wrote), or pin executing identities with \`roles\``;
+    if (site.policy === "caller-bound") return `${site.label} reads $${name} — $params (the firing action's args) is bound only while the action's effect bindings and where-op \`where\`s evaluate; this site never binds it, so the condition could never pass. Bind $params in an effect binding or a where-op instead, or gate on a field an action wrote`;
+    if (site.policy === "triggered-payload" && name === "params") return `${site.label} reads $params — a cascade-fired action has no caller to supply args, so $params never holds a value in its payload; read fields or effect outputs instead`;
+    const softGate = SOFT_GATE_VARS[name];
+    if (softGate !== void 0) return `${site.label} reads $${name} — $${name} (${softGate.noun}) is bound only in the caller-bound projection (action filters, requirements, editable predicates); this site never binds it. Move the check to one of those sites or drop $${name}`;
+    throw new Error(`callerVarMessage: unreachable for $${name} at ${site.label} (policy ${site.policy})`);
 }
 
 function conditionSites(def) {
@@ -2968,9 +3028,9 @@ function belowScopeNestedSites(args) {
 }
 
 function checkLevelKindEffectOutputs(def, issues) {
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) pushOutputIssues({
+    for (const {action: action, path: path} of actionSites(def)) pushOutputIssues({
         action: action,
-        path: [ "stages", i, "activities", j, "actions", a ],
+        path: path,
         issues: issues
     });
 }
@@ -3052,18 +3112,18 @@ function storedRolesIssue(action) {
 }
 
 function checkStoredRolesPlacement(def, issues) {
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) {
+    for (const {action: action, path: path} of actionSites(def)) {
         const message = storedRolesIssue(action);
         message !== void 0 && issues.push({
-            path: [ "stages", i, "activities", j, "actions", a, "roles" ],
+            path: [ ...path, "roles" ],
             message: message
         });
     }
 }
 
 function checkTriggeredActionParams(def, issues) {
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) action.when === void 0 || (action.params ?? []).length === 0 || issues.push({
-        path: [ "stages", i, "activities", j, "actions", a, "params" ],
+    for (const {action: action, path: path} of actionSites(def)) action.when === void 0 || (action.params ?? []).length === 0 || issues.push({
+        path: [ ...path, "params" ],
         message: `action "${action.name}" declares params but is cascade-fired (\`when\`) — no caller ever supplies args to a trigger. Drop the params, or drop \`when\` to make it a fireAction-fired action`
     });
 }
@@ -3108,13 +3168,20 @@ function checkSingleSubjectRequirements(def, issues) {
 
 function checkStartFilterReads(def, issues) {
     const filter = def.start?.filter;
-    filter !== void 0 && (conditionParameterNames(filter).has("fields") && issues.push({
+    if (filter === void 0) return;
+    const params = conditionParameterNames(filter);
+    params.has("fields") && issues.push({
         path: [ "start", "filter" ],
         message: "start.filter reads $fields, but the filter is browse-time-pure — a start surface evaluates it per document, before any inputs exist, so $fields cannot be bound. Move the input-dependent rule to a start requirement, the start-time readiness predicate that binds $fields and is enforced by startInstance"
-    }), readsRootDocument(filter) && !(def.fields ?? []).some(isSubjectEntry) && issues.push({
+    });
+    for (const name of CALLER_BOUND_VARS) params.has(name) && issues.push({
+        path: [ "start", "filter" ],
+        message: `start.filter reads $${name} — start.filter is a read-side document-visibility rule (definitionsForDocument / start controls); startInstance never evaluates it, and no caller bag binds there, so the read is GROQ null and the filter can never match. Drop $${name} from start.filter. A "who may start" rule belongs in a start requirement, not in the browse-time filter`
+    });
+    readsRootDocument(filter) && !(def.fields ?? []).some(isSubjectEntry) && issues.push({
         path: [ "start", "filter" ],
         message: "start.filter reads the candidate document (its root), but the definition declares no `subject` entry — a read surface would never have a document to bind as root, so every root read is GROQ null and the filter silently misevaluates. Declare a `subject` entry (the document the workflow is about), or gate on the dataset instead"
-    }));
+    });
 }
 
 function checkStartRequirementReads(def, issues) {
@@ -3410,15 +3477,13 @@ function seedEarlierSiblingTarget(args) {
 }
 
 function opSites(def) {
-    const sites = [];
-    for (const [i, stage] of def.stages.entries()) for (const [j, activity] of (stage.activities ?? []).entries()) for (const [a, action] of (activity.actions ?? []).entries()) sites.push({
+    return actionSites(def).map(({action: action, activity: activity, stage: stage, path: path}) => ({
         ops: action.ops,
-        path: [ "stages", i, "activities", j, "actions", a, "ops" ],
+        path: [ ...path, "ops" ],
         label: `action "${action.name}"`,
         stage: stage,
         activity: activity
-    });
-    return sites;
+    }));
 }
 
 function checkFieldReadOpValues(def, issues) {
@@ -3435,7 +3500,7 @@ function checkFieldReadOpValues(def, issues) {
 }
 
 function checkOpsFieldReads({ops: ops, path: path, label: label, ...ctx}) {
-    for (const [o, op] of (ops ?? []).entries()) if ("value" in op) for (const {read: read, path: readPath} of fieldReadsIn(op.value, [ ...path, o, "value" ])) checkOpFieldRead({
+    for (const [o, op] of (ops ?? []).entries()) if (!(!("value" in op) || op.value === void 0)) for (const {read: read, path: readPath} of fieldReadsIn(op.value, [ ...path, o, "value" ])) checkOpFieldRead({
         ...ctx,
         read: read,
         path: readPath,
@@ -3486,35 +3551,55 @@ function opFieldReadMissMessage({read: read, where: where, hosts: hosts}) {
     return `${where} reads field "${read.field}", which is not declared at ${searched} — the read resolves to undefined at op time, so the write silently lands empty. Known: ${known.join(", ") || "(none)"}`;
 }
 
-function checkUpdateWhereOps(def, issues) {
+function checkFieldTargetOps(def, issues) {
     const workflow = def.fields ?? [];
     for (const site of opSites(def)) for (const [o, op] of (site.ops ?? []).entries()) {
-        if (op.type !== "field.updateWhere") continue;
-        const scopes = {
-            workflow: workflow,
-            stage: site.stage.fields ?? [],
-            activity: site.activity.fields ?? []
-        };
-        checkUpdateWhereTargetKind({
+        const path = [ ...site.path, o ], rule = TARGET_KIND_RULES[op.type];
+        rule !== void 0 && "target" in op && checkTargetKind({
             op: op,
-            path: [ ...site.path, o ],
+            path: [ ...path, "target" ],
             label: site.label,
-            scopes: scopes,
+            scopes: opTargetScopes(workflow, site),
+            rule: rule,
             issues: issues
-        }), checkUpdateWhereMergeKeys({
+        }), op.type === "field.updateWhere" && checkUpdateWhereMergeKeys({
             op: op,
-            path: [ ...site.path, o ],
+            path: path,
             label: site.label,
             issues: issues
         });
     }
 }
 
-function checkUpdateWhereTargetKind({op: op, path: path, label: label, scopes: scopes, issues: issues}) {
+const arithmeticTargetRule = {
+    accepts: target => target.type === "number",
+    issue: () => "arithmetic ops target `number` entries only"
+}, TARGET_KIND_RULES = {
+    "field.inc": arithmeticTargetRule,
+    "field.dec": arithmeticTargetRule,
+    "field.setIfMissing": {
+        accepts: target => !isAlwaysArrayFieldKind(target.type),
+        issue: () => "setIfMissing applies to nullable entries only; an empty array entry already holds []"
+    },
+    "field.updateWhere": {
+        accepts: target => target.type === "array",
+        issue: target => "updateWhere merges declared row sub-fields, so its target must be an `array` entry" + rowOpsHint(target.type)
+    }
+};
+
+function opTargetScopes(workflow, site) {
+    return {
+        workflow: workflow,
+        stage: site.stage.fields ?? [],
+        activity: site.activity.fields ?? []
+    };
+}
+
+function checkTargetKind({op: op, path: path, label: label, scopes: scopes, rule: rule, issues: issues}) {
     const target = scopes[op.target.scope]?.find(entry => entry.name === op.target.field);
-    target === void 0 || target.type === "array" || issues.push({
-        path: [ ...path, "target" ],
-        message: `${label} field.updateWhere targets ${op.target.scope}-scope "${op.target.field}" (${target.type}) — updateWhere merges declared row sub-fields, so its target must be an \`array\` entry${rowOpsHint(target.type)}`
+    target === void 0 || rule.accepts(target) || issues.push({
+        path: path,
+        message: `${label} ${op.type} targets ${op.target.scope}-scope "${op.target.field}" (${target.type}) — ${rule.issue(target)}`
     });
 }
 
@@ -3746,7 +3831,7 @@ function checkWorkflowInvariants(def) {
     }), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), 
     checkRequiredField(def, issues), checkStart(def, issues), checkPredicates(def, issues), 
     checkUnboundConditionVars(def, issues), checkConditionFieldReads(def, issues), checkFieldReadSeeds(def, issues), 
-    checkFieldReadOpValues(def, issues), checkUpdateWhereOps(def, issues), checkGuardFieldReads(def, issues), 
+    checkFieldReadOpValues(def, issues), checkFieldTargetOps(def, issues), checkGuardFieldReads(def, issues), 
     checkAssigneesEntries(def, issues), checkDueDateEntries(def, issues), checkSubjectEntries(def, issues), 
     checkLevelKindEffectOutputs(def, issues), checkActivityTerminalPaths(def, issues), 
     checkTerminalStageActivities(def, issues), checkTriggeredActionParams(def, issues), 
@@ -3787,6 +3872,8 @@ exports.CONDITION_VARS = CONDITION_VARS;
 
 exports.ContractViolationError = ContractViolationError;
 
+exports.DECISION_SEMANTICS = DECISION_SEMANTICS;
+
 exports.DEFAULT_TRANSITION_WHEN = DEFAULT_TRANSITION_WHEN;
 
 exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
@@ -3837,6 +3924,8 @@ exports.RESERVED_CONDITION_VARS = RESERVED_CONDITION_VARS;
 
 exports.RESOURCE_ALIAS_NAME_SOURCE = RESOURCE_ALIAS_NAME_SOURCE;
 
+exports.SIGNAL_SEMANTICS = SIGNAL_SEMANTICS;
+
 exports.START_FILTER_VARS = START_FILTER_VARS;
 
 exports.START_REQUIREMENT_VARS = START_REQUIREMENT_VARS;
@@ -3921,6 +4010,8 @@ exports.groq = groq;
 
 exports.groupMembershipNames = groupMembershipNames;
 
+exports.isAlwaysArrayFieldKind = isAlwaysArrayFieldKind;
+
 exports.isBareSeedId = isBareSeedId;
 
 exports.isCascadeFired = isCascadeFired;