@sanity/workflow-engine 0.31.0 → 0.32.0

package/dist/_chunks-cjs/invariants.cjs

@@ -40,6 +40,37 @@ function driverKind(actor) {
     return actor.kind === "person" || actor.kind === "agent" ? actor.kind : "service";
 }
 
+function isFilterScopedOut(entry) {
+    return entry.status === "skipped" && entry.startedAt === void 0;
+}
+
+function liveSubworkflows(host) {
+    return (host.subworkflows ?? []).filter(row => row.resolved === void 0);
+}
+
+function resolvedChildStatus(child) {
+    if (!(child.completedAt === void 0 || child.completedAt === null)) return child.abortedAt !== void 0 && child.abortedAt !== null ? "aborted" : "done";
+}
+
+function condemnedSubworkflows(host) {
+    return liveSubworkflows(host).filter(row => row.abortPending !== void 0);
+}
+
+function condemnSubworkflow(row, owed) {
+    row.abortPending !== void 0 || row.resolved !== void 0 || (row.abortPending = {
+        at: owed.at,
+        reason: owed.reason
+    });
+}
+
+function findOpenStageEntry(host) {
+    return host.stages.find(s => s.name === host.currentStage && s.exitedAt === void 0);
+}
+
+function findCurrentActivityEntry(host, activityName) {
+    return findOpenStageEntry(host)?.activities.find(a => a.name === activityName);
+}
+
 function errorMessage(err) {
     return (err instanceof Error ? err.message : String(err)).replace(/[^\P{Cc}\n\t]/gu, "");
 }
@@ -499,8 +530,6 @@ function desugarWorkflow(authoring) {
     checkReservedRoleAliasKeys(authoring.roleAliases, issues);
     const roleAliases = normalizeRoleAliases(authoring.roleAliases), ctx = {
         issues: issues,
-        claimFields: /* @__PURE__ */ new Map,
-        claimedFields: /* @__PURE__ */ new Set,
         roleAliases: roleAliases
     }, workflowFields2 = desugarFieldEntries({
         entries: authoring.fields,
@@ -559,7 +588,7 @@ function desugarWorkflow(authoring) {
             } : {}
         };
     });
-    return checkUnclaimedClaimFields(ctx), {
+    return {
         definition: {
             ...stripUndefined({
                 name: authoring.name,
@@ -640,11 +669,6 @@ function desugarFieldEntries({entries: entries, path: path, ctx: ctx}) {
 }
 
 function desugarFieldEntry({entry: entry, path: path, ctx: ctx}) {
-    if (entry.type === "claim") return desugarClaimField({
-        entry: entry,
-        path: path,
-        ctx: ctx
-    });
     if (entry.type === "todoList" || entry.type === "notes") return desugarListField({
         entry: entry,
         path: path,
@@ -675,22 +699,6 @@ function desugarFieldEntry({entry: entry, path: path, ctx: ctx}) {
     };
 }
 
-function desugarClaimField({entry: entry, path: path, ctx: ctx}) {
-    const desugared = {
-        ...stripUndefined({
-            name: entry.name,
-            title: entry.title,
-            description: entry.description,
-            group: normalizeGroup(entry.group)
-        }),
-        type: "actor"
-    };
-    return ctx.claimFields.set(desugared, {
-        name: entry.name,
-        path: path
-    }), desugared;
-}
-
 function desugarListField({entry: entry, path: path, ctx: ctx}) {
     const editable = normalizeEditable({
         editable: entry.editable,
@@ -855,12 +863,6 @@ function desugarActionOps(args) {
 }
 
 function desugarAction({action: action, path: path, env: env, activityName: activityName, ctx: ctx}) {
-    if ("type" in action) return desugarClaimAction({
-        action: action,
-        path: path,
-        env: env,
-        ctx: ctx
-    });
     reportEmptyActionRoles({
         action: action,
         path: path,
@@ -897,67 +899,6 @@ function desugarAction({action: action, path: path, env: env, activityName: acti
     };
 }
 
-function desugarClaimAction({action: action, path: path, env: env, ctx: ctx}) {
-    const ref = typeof action.field == "string" ? {
-        field: action.field
-    } : action.field, resolved = resolveRef({
-        ref: ref,
-        env: env,
-        path: [ ...path, "field" ],
-        ctx: 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}" — a claim pair needs an actor-valued entry (a "claim" or "actor" field declaration)`
-        }), checkShadowedClaimTarget({
-            actionName: action.name,
-            field: ref.field,
-            resolved: resolved,
-            env: env,
-            path: [ ...path, "field" ],
-            ctx: ctx
-        }), entry && ctx.claimedFields.add(entry);
-    }
-    const noSteal = `!defined($fields.${ref.field})`, filter = 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,
-            group: normalizeGroup(action.group),
-            params: action.params,
-            effects: action.effects
-        }),
-        filter: filter,
-        ...ops.length > 0 ? {
-            ops: ops
-        } : {}
-    };
-}
-
-function checkShadowedClaimTarget({actionName: actionName, field: field, resolved: resolved, env: env, path: path, ctx: ctx}) {
-    const nearest = env.layers.find(l => l.entries.has(field));
-    nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
-        path: 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 — 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: name, path: path}] of ctx.claimFields) ctx.claimedFields.has(entry) || ctx.issues.push({
-        path: path,
-        message: `claim field "${name}" is never referenced by a claim action — you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw actor entry`
-    });
-}
-
 const DEFAULT_TRANSITION_WHEN = "$allActivitiesDone";
 
 function desugarTransition({transition: transition}) {
@@ -1257,13 +1198,23 @@ function walkAstNodes(node, visit) {
     }
 }
 
-const ACTIVITY_STATUSES = [ "active", "done", "skipped", "failed" ], TERMINAL_ACTIVITY_STATUSES = [ "done", "skipped", "failed" ];
+const ACTIVITY_STATUSES = groqConditionDescribe._exhaustiveOptions()([ "active", "done", "skipped", "failed" ]), TERMINAL_ACTIVITY_STATUSES = groqConditionDescribe._exhaustiveOptions()([ "done", "skipped", "failed" ]);
 
 function isTerminalActivityStatus(status) {
     return TERMINAL_ACTIVITY_STATUSES.includes(status);
 }
 
-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" ];
+const SIGNAL_SEMANTICS = [ "signal.positive", "signal.caution", "signal.critical" ], DECISION_SEMANTICS = [ "decision.accept", "decision.decline" ], ACTION_SEMANTICS = [ ...DECISION_SEMANTICS, ...SIGNAL_SEMANTICS ], FIELD_SCOPES = groqConditionDescribe._exhaustiveOptions()([ "workflow", "stage", "activity" ]), DOCUMENT_VALUE_PERMISSIONS = [ "create", "manage", "read", "update" ], LAKE_MUTATION_GUARD_ACTIONS = groqConditionDescribe._exhaustiveOptions()([ "create", "update", "delete" ]), MUTATION_GUARD_ACTIONS = groqConditionDescribe._exhaustiveOptions()([ ...LAKE_MUTATION_GUARD_ACTIONS, "publish", "unpublish" ]), GUARD_ACTIONS_REQUIRED_MESSAGE = "a guard must match at least one action", MUTATION_GUARD_ID_SPACES = [ "authored", "edit", "published" ];
+
+function mutationGuardActionIdSpace(action) {
+    return action === "update" ? "edit" : action === "publish" || action === "unpublish" ? "published" : "authored";
+}
+
+function mutationGuardRequiresSplitEmission(actions) {
+    return new Set(actions.map(mutationGuardActionIdSpace)).size > 1;
+}
+
+const 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}`;
@@ -1279,7 +1230,7 @@ function releaseRef({res: res, releaseName: releaseName}) {
 }
 
 function isAlwaysArrayFieldKind(kind) {
-    return kind === "doc.refs" || kind === "assignees" || kind === "array";
+    return kind === "doc.refs" || kind === "assignee" || kind === "assignees" || kind === "array";
 }
 
 function isSingleDocRefKind(kind) {
@@ -1434,6 +1385,9 @@ const CONDITION_VARS = [ {
     label: "the start's input fields",
     description: "The caller's input entries by name (`initialFields` — at `startInstance`, the values the start would seed; at a pre-flight, the values gathered so far, so a read of a not-yet-supplied entry is GROQ null). Document references bind as GDR envelopes — `$fields.<entry>.id` is the GDR URI, never a string authors assemble — a singular `doc.ref` or `subject` included (nothing hydrates at the gate or the pre-flight). Pathed reads are deploy-checked against these envelope shapes."
 } ], GUARD_PREDICATE_VARS = [ {
+    name: "document",
+    description: "The attempted mutation images, exposed as `document.before` and `document.after`."
+}, {
     name: "guard",
     description: "The guard document itself (its `metadata` carries deploy-time resolved values)."
 }, {
@@ -1567,7 +1521,65 @@ function documentIdOf(doc) {
     return "(unknown id)";
 }
 
-const ACTOR_KINDS = [ "person", "agent", "system" ], ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
+const ACTOR_KINDS = [ "person", "agent", "system" ];
+
+function normalizeAssignmentMembers(value) {
+    return value === null ? [] : Array.isArray(value) ? value : [ value ];
+}
+
+function assignmentMembers(entries) {
+    return entries.flatMap(entry => isAssignmentFieldEntry(entry) ? normalizeAssignmentMembers(entry.value) : []);
+}
+
+function assignmentState(members) {
+    return members.length === 0 ? "unrouted" : members.some(member => member.type === "user") ? "held" : "routed";
+}
+
+function activeAssignmentMembers(members) {
+    const users = members.filter(member => member.type === "user");
+    return users.length > 0 ? users : members;
+}
+
+function assignmentMatch(members, identity) {
+    const active = activeAssignmentMembers(members);
+    return active.some(member => member.type === "user" && member.id === identity.userId) ? "user" : active.some(member => member.type === "role" && identity.roles.includes(member.role)) ? "role" : void 0;
+}
+
+function identityMatchesAssignment(members, identity) {
+    return assignmentMatch(members, identity) !== void 0;
+}
+
+function assignmentStateCounts(assignments, identity) {
+    const counts = {
+        unrouted: 0,
+        routed: 0,
+        held: 0
+    };
+    for (const members of assignments) {
+        const state = assignmentState(members);
+        state === "unrouted" ? counts.unrouted += 1 : identityMatchesAssignment(members, identity) && (counts[state] += 1);
+    }
+    return counts;
+}
+
+function openActivityAssignments(instance) {
+    return (findOpenStageEntry(instance)?.activities ?? []).filter(activity => activity.status === "active").map(activity => assignmentMembers(activity.fields ?? []));
+}
+
+function instanceAssignmentStateCounts(instance, identity) {
+    return assignmentStateCounts(openActivityAssignments(instance), identity);
+}
+
+function actorMatchesAssignment(args) {
+    const actor = args.actor;
+    return actor === void 0 ? !1 : activeAssignmentMembers(args.members).some(member => member.type === "user" ? member.id === actor.id : actorFulfillsRole({
+        actorRoles: actor.roles,
+        required: member.role,
+        aliases: args.roleAliases
+    }));
+}
+
+const ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
 
 function classifyPrincipalId(id) {
     if (id === ANONYMOUS_IDENTITY || id === SYSTEM_IDENTITY) return {
@@ -1644,7 +1656,7 @@ const GdrUriSchema = v__namespace.custom(s => typeof s == "string" && isGdrUri(s
 }), tolerantObject()({
     type: v__namespace.literal("role"),
     role: NonEmptyString
-}) ]), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableProgress = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.number(), v__namespace.finite("progress must be a finite number"), v__namespace.minValue(0, "progress must be at least 0"), v__namespace.maxValue(100, "progress must be at most 100")) ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "dueDate", "datetime", "dueDatetime", "dateTime" ]);
+}) ]), AssigneeListShape = v__namespace.pipe(v__namespace.union([ v__namespace.null(), AssigneeShape, v__namespace.array(AssigneeShape) ]), v__namespace.transform(normalizeAssignmentMembers)), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableProgress = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.number(), v__namespace.finite("progress must be a finite number"), v__namespace.minValue(0, "progress must be at least 0"), v__namespace.maxValue(100, "progress must be at most 100")) ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "dueDate", "datetime", "dueDatetime", "dateTime" ]);
 
 function normalizedChoiceKind(kind) {
     return kind === "dateTime" ? "datetime" : kind;
@@ -1684,7 +1696,7 @@ const fieldValueSchemas = {
     dueDatetime: NullableDateTime,
     url: NullableUrl,
     actor: v__namespace.union([ v__namespace.null(), ActorShape ]),
-    assignee: v__namespace.union([ v__namespace.null(), AssigneeShape ]),
+    assignee: AssigneeListShape,
     assignees: v__namespace.array(AssigneeShape)
 }, WritePrincipalId = v__namespace.pipe(NonEmptyString, v__namespace.rawTransform(({dataset: dataset, addIssue: addIssue}) => {
     const classified = classifyPrincipalId(dataset.value);
@@ -1696,16 +1708,16 @@ const fieldValueSchemas = {
     id: WritePrincipalId,
     roles: v__namespace.exactOptional(v__namespace.array(v__namespace.string())),
     onBehalfOf: v__namespace.exactOptional(v__namespace.string())
-}), AssigneeWriteShape = v__namespace.union([ tolerantObject()({
+}), AssigneePrincipalId = v__namespace.pipe(WritePrincipalId, v__namespace.check(id => classifyPrincipalId(id).namespace !== "robot", "robot principals cannot be assignment members")), AssigneeWriteShape = v__namespace.union([ tolerantObject()({
     type: v__namespace.literal("user"),
-    id: WritePrincipalId
+    id: AssigneePrincipalId
 }), tolerantObject()({
     type: v__namespace.literal("role"),
     role: NonEmptyString
-}) ]), valueSchemas = {
+}) ]), SingularAssigneeWriteShape = v__namespace.pipe(v__namespace.union([ AssigneeWriteShape, v__namespace.array(AssigneeWriteShape) ]), v__namespace.transform(normalizeAssignmentMembers), v__namespace.check(members => members.filter(member => member.type === "user").length <= 1, "must contain at most one user member")), valueSchemas = {
     ...fieldValueSchemas,
     actor: v__namespace.nullable(ActorWriteShape),
-    assignee: v__namespace.nullable(AssigneeWriteShape),
+    assignee: SingularAssigneeWriteShape,
     assignees: v__namespace.array(AssigneeWriteShape),
     query: v__namespace.any()
 };
@@ -1796,7 +1808,7 @@ function appendItemSchema(entryType, shape) {
         leaf: valueSchemas
     });
     if (entryType === "doc.refs") return GdrShape;
-    if (entryType === "assignees") return AssigneeWriteShape;
+    if (entryType === "assignee" || entryType === "assignees") return AssigneeWriteShape;
 }
 
 function rejectedRefTypes(args) {
@@ -1893,7 +1905,7 @@ function consumeRetainedAssignment(args) {
 
 function previousAssignmentIdentities(args) {
     const retained = /* @__PURE__ */ new Map;
-    if (args.previousValue === void 0 || args.entryType === "assignee") return retained;
+    if (args.previousValue === void 0) return retained;
     const schema = wholeValueSchema({
         entryType: args.entryType,
         shape: args,
@@ -1936,7 +1948,7 @@ function visitAssignmentEntries(args, visit) {
 
 function visitAssignmentCandidates(args, visit) {
     if (args.roles === void 0) return;
-    const indexedValues = args.entryType === "assignees" && Array.isArray(args.value) ? args.value.map(value => ({
+    const indexedValues = Array.isArray(args.value) ? args.value.map(value => ({
         value: value,
         path: args.path
     })) : [ {
@@ -2005,14 +2017,22 @@ function validateFieldValue(args) {
     return check.output;
 }
 
-const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]*", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
+const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]{0,127}", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
+
+function isBareDocumentId(id) {
+    return BARE_ID_RE.test(id) && !id.includes("..");
+}
 
 function isAuthoringRefId(id) {
-    return id.startsWith("@") ? ALIAS_REF_RE.test(id) : id.includes(":") ? isGdrUri(id) : BARE_ID_RE.test(id);
+    if (id.startsWith("@")) {
+        const separator = id.indexOf(":");
+        return ALIAS_REF_RE.test(id) && isBareDocumentId(id.slice(separator + 1));
+    }
+    return id.includes(":") ? isGdrUri(id) : isBareDocumentId(id);
 }
 
 function isBareSeedId(id) {
-    return BARE_ID_RE.test(id);
+    return isBareDocumentId(id);
 }
 
 const AuthoringRefId = v__namespace.pipe(v__namespace.string(), v__namespace.check(isAuthoringRefId, "must be a bare document id, a GDR URI, or a portable `@<alias>:<id>` reference")), AuthoringGdrShape = v__namespace.looseObject({
@@ -2078,7 +2098,7 @@ function validateFieldAppendItem(args) {
 }
 
 function appendAssignmentEntryType(entryType) {
-    return entryType === "assignees" ? "assignee" : entryType === "array" ? "object" : entryType;
+    return entryType === "assignee" || entryType === "assignees" ? "assignee" : entryType === "array" ? "object" : entryType;
 }
 
 function formatIssues(issues, formatMessage = issue => issue.message) {
@@ -2103,10 +2123,6 @@ function invalidOptionMessage(options) {
     return `Invalid option: expected one of ${options.map(option => `"${option}"`).join("|")}`;
 }
 
-function exhaustiveOptions() {
-    return options => options;
-}
-
 function pinned() {
     return (schema, ..._exact) => schema;
 }
@@ -2166,7 +2182,7 @@ function manualTargetSchema(ref) {
     }) ]);
 }
 
-const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ])), ConditionSchema = NonEmpty;
+const StoredManualTargetSchema = pinned()(manualTargetSchema(StoredFieldRefSchema)), AuthoringManualTargetSchema = pinned()(manualTargetSchema(v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ]))), ConditionSchema = NonEmpty;
 
 function opSchemas(targetSchema) {
     return [ v__namespace.strictObject({
@@ -2204,11 +2220,11 @@ function opSchemas(targetSchema) {
     }) ];
 }
 
-const StoredFieldOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema) ]), StoredOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema), v__namespace.strictObject({
+const StoredFieldOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema) ])), StoredOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema), v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
     activity: NonEmpty,
     status: picklist(ACTIVITY_STATUSES)
-}) ]), AuditOpSchema = v__namespace.strictObject({
+}) ])), AuditOpSchema = v__namespace.strictObject({
     type: v__namespace.literal("audit"),
     target: AuthoringFieldRefSchema,
     value: ValueExprSchema,
@@ -2216,11 +2232,11 @@ const StoredFieldOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFi
         actor: v__namespace.optional(NonEmpty),
         at: v__namespace.optional(NonEmpty)
     }))
-}), AuthoringOpSchema = v__namespace.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), v__namespace.strictObject({
+}), AuthoringOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
     activity: v__namespace.optional(NonEmpty),
     status: picklist(ACTIVITY_STATUSES)
-}), AuditOpSchema ]), GroupName = v__namespace.pipe(v__namespace.string(), v__namespace.regex(GROQ_IDENTIFIER, "must be an identifier (letters, digits, underscore; not starting with a digit)")), GroupSchema = pinned()(v__namespace.strictObject({
+}), AuditOpSchema ])), GroupName = v__namespace.pipe(v__namespace.string(), v__namespace.regex(GROQ_IDENTIFIER, "must be an identifier (letters, digits, underscore; not starting with a digit)")), GroupSchema = pinned()(v__namespace.strictObject({
     name: GroupName,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
@@ -2231,7 +2247,7 @@ function groupMembershipNames(group) {
     return group === void 0 ? [] : typeof group == "string" ? [ group ] : [ ...group ];
 }
 
-const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "progress", "boolean", "date", "dueDate", "datetime", "dueDatetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), AUTHORING_FIELD_SUGAR_KINDS = exhaustiveOptions()([ "claim", "todoList", "notes" ]), AUTHORING_FIELD_KINDS = [ ...FIELD_VALUE_KINDS, ...AUTHORING_FIELD_SUGAR_KINDS ], AuthoringRawFieldKindSchema = v__namespace.picklist(FIELD_VALUE_KINDS, issue => `${invalidOptionMessage(AUTHORING_FIELD_KINDS)} but received ${JSON.stringify(issue.input)}`), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
+const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "progress", "boolean", "date", "dueDate", "datetime", "dueDatetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), AUTHORING_FIELD_SUGAR_KINDS = groqConditionDescribe._exhaustiveOptions()([ "todoList", "notes" ]), AUTHORING_FIELD_KINDS = [ ...FIELD_VALUE_KINDS, ...AUTHORING_FIELD_SUGAR_KINDS ], AuthoringRawFieldKindSchema = v__namespace.picklist(FIELD_VALUE_KINDS, issue => `${invalidOptionMessage(AUTHORING_FIELD_KINDS)} but received ${JSON.stringify(issue.input)}`), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
     min: v__namespace.optional(FiniteNumber),
     max: v__namespace.optional(FiniteNumber)
 }), v__namespace.check(validation => validation.min !== void 0 || validation.max !== void 0, "declare at least one bound, or omit `validation`"), v__namespace.check(validation => validation.min === void 0 || validation.max === void 0 || validation.min <= validation.max, "`min` must be less than or equal to `max`")), ChoiceOptionsSchema = v__namespace.strictObject({
@@ -2283,7 +2299,7 @@ const AssignmentRolesSchema = v__namespace.pipe(v__namespace.array(NonEmpty), v_
     roles: v__namespace.optional(AssignmentRolesSchema),
     fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
     of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
-}), choiceOptionsCheck(), scalarValidationCheck(), assignmentRolesCheck())), StoredEditableSchema = v__namespace.union([ v__namespace.literal(!0), NonEmpty ]), AuthoringEditableSchema = v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]);
+}), choiceOptionsCheck(), scalarValidationCheck(), assignmentRolesCheck())), StoredEditableSchema = pinned()(v__namespace.union([ v__namespace.literal(!0), NonEmpty ])), AuthoringEditableSchema = pinned()(v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]));
 
 function fieldBase(editable, group) {
     return {
@@ -2373,13 +2389,7 @@ const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryF
     editable: AuthoringEditableSchema,
     group: AuthoringGroupMembershipSchema,
     kind: AuthoringRawFieldKindSchema
-})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
-    type: v__namespace.literal("claim"),
-    name: FieldEntryName,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    group: v__namespace.optional(AuthoringGroupMembershipSchema)
-}));
+})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck()));
 
 function listSugarFields(type) {
     return {
@@ -2390,7 +2400,7 @@ function listSugarFields(type) {
 
 const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v__namespace.lazy(input => {
     const type = asShape(input).type;
-    return type === "claim" ? ClaimFieldSchema : type === "todoList" ? TodoListFieldSchema : type === "notes" ? NotesFieldSchema : RawAuthoringFieldEntrySchema;
+    return type === "todoList" ? TodoListFieldSchema : type === "notes" ? NotesFieldSchema : RawAuthoringFieldEntrySchema;
 })), EffectSchema = v__namespace.strictObject({
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
@@ -2455,18 +2465,7 @@ const StoredActionSchema = pinned()(v__namespace.strictObject({
     ...actionFields(AuthoringOpSchema, AuthoringGroupMembershipSchema),
     roles: v__namespace.optional(v__namespace.array(NonEmpty)),
     status: v__namespace.optional(TerminalActivityStatus)
-})), ClaimActionSchema = pinned()(v__namespace.strictObject({
-    type: v__namespace.literal("claim"),
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    group: v__namespace.optional(AuthoringGroupMembershipSchema),
-    field: v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ]),
-    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-    filter: v__namespace.optional(ConditionSchema),
-    params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
-    effects: v__namespace.optional(v__namespace.array(EffectSchema))
-})), AuthoringActionSchema = pinned()(v__namespace.lazy(input => typeof input == "object" && input !== null && "type" in input ? ClaimActionSchema : RawAuthoringActionSchema)), requirementBase = {
+})), AuthoringActionSchema = pinned()(RawAuthoringActionSchema), requirementBase = {
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string())
@@ -2517,7 +2516,7 @@ function transitionFields(when) {
     };
 }
 
-const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = v__namespace.variant("type", [ v__namespace.strictObject({
+const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardActionsSchema = v__namespace.array(GuardActionSchema), NonEmptyGuardActionsSchema = v__namespace.pipe(GuardActionsSchema, v__namespace.minLength(1, GUARD_ACTIONS_REQUIRED_MESSAGE)), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = pinned()(v__namespace.variant("type", [ v__namespace.strictObject({
     type: v__namespace.literal("self")
 }), v__namespace.strictObject({
     type: v__namespace.literal("now")
@@ -2529,29 +2528,29 @@ const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFiel
     type: v__namespace.literal("effectsRead"),
     effect: v__namespace.pipe(NonEmpty, v__namespace.check(name => !name.includes("'"), "an effect name cannot contain `'`")),
     path: v__namespace.optional(GuardReadPath)
-}) ]);
+}) ]));
 
-function guardMatchFields(read) {
+function guardMatchFields(read, actions) {
     return {
         types: v__namespace.optional(v__namespace.array(NonEmpty)),
         idRefs: v__namespace.optional(v__namespace.array(read)),
         idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
-        actions: v__namespace.pipe(v__namespace.array(GuardActionSchema), v__namespace.minLength(1, "a guard must match at least one action"))
+        actions: actions
     };
 }
 
-function guardFields(read) {
+function guardFields(read, actions) {
     return {
         name: NonEmpty,
         title: v__namespace.optional(v__namespace.string()),
         description: v__namespace.optional(v__namespace.string()),
-        match: v__namespace.strictObject(guardMatchFields(read)),
+        match: v__namespace.strictObject(guardMatchFields(read, actions)),
         predicate: v__namespace.optional(v__namespace.string()),
         metadata: v__namespace.optional(v__namespace.record(NonEmpty, read))
     };
 }
 
-const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty)), AuthoringGuardSchema = v__namespace.strictObject(guardFields(GuardReadSchema));
+const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty, GuardActionsSchema)), AuthoringGuardSchema = v__namespace.strictObject(guardFields(GuardReadSchema, NonEmptyGuardActionsSchema));
 
 function stageFields({field: field, activity: activity, transition: transition, guard: guard, editable: editable}) {
     return {
@@ -2580,7 +2579,7 @@ const StoredStageSchema = pinned()(v__namespace.strictObject(stageFields({
     transition: AuthoringTransitionSchema,
     guard: AuthoringGuardSchema,
     editable: AuthoringEditableSchema
-}))), RoleAliasesSchema = v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))), WORKFLOW_LIFECYCLES = [ "standalone", "child" ], START_KINDS = [ "interactive", "autonomous" ];
+}))), RoleAliasesSchema = pinned()(v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role")))), WORKFLOW_LIFECYCLES = groqConditionDescribe._exhaustiveOptions()([ "standalone", "child" ]), START_KINDS = groqConditionDescribe._exhaustiveOptions()([ "interactive", "autonomous" ]);
 
 function startFields(kind) {
     return {
@@ -4097,6 +4096,8 @@ exports.FieldValueShapeError = FieldValueShapeError;
 
 exports.GROUP_KINDS = GROUP_KINDS;
 
+exports.GUARD_ACTIONS_REQUIRED_MESSAGE = GUARD_ACTIONS_REQUIRED_MESSAGE;
+
 exports.GUARD_PREDICATE_VARS = GUARD_PREDICATE_VARS;
 
 exports.GdrShape = GdrShape;
@@ -4107,8 +4108,12 @@ exports.InstanceNotFoundError = InstanceNotFoundError;
 
 exports.IsoTimestamp = IsoTimestamp;
 
+exports.LAKE_MUTATION_GUARD_ACTIONS = LAKE_MUTATION_GUARD_ACTIONS;
+
 exports.MUTATION_GUARD_ACTIONS = MUTATION_GUARD_ACTIONS;
 
+exports.MUTATION_GUARD_ID_SPACES = MUTATION_GUARD_ID_SPACES;
+
 exports.NonEmptyString = NonEmptyString;
 
 exports.PersistedDocShapeError = PersistedDocShapeError;
@@ -4129,6 +4134,8 @@ exports.SpawnContractsInvalidError = SpawnContractsInvalidError;
 
 exports.StoredFieldOpSchema = StoredFieldOpSchema;
 
+exports.UNIVERSAL_ROLE_ALIAS_KEY = UNIVERSAL_ROLE_ALIAS_KEY;
+
 exports.VersionSpecificDatasetGdrError = VersionSpecificDatasetGdrError;
 
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
@@ -4137,12 +4144,24 @@ exports.WorkflowConfigSchema = WorkflowConfigSchema;
 
 exports.WorkflowError = WorkflowError;
 
+exports.activeAssignmentMembers = activeAssignmentMembers;
+
 exports.actorFulfillsRole = actorFulfillsRole;
 
+exports.actorMatchesAssignment = actorMatchesAssignment;
+
 exports.andConditions = andConditions;
 
 exports.assignmentKindAcceptsRoles = assignmentKindAcceptsRoles;
 
+exports.assignmentMatch = assignmentMatch;
+
+exports.assignmentMembers = assignmentMembers;
+
+exports.assignmentState = assignmentState;
+
+exports.assignmentStateCounts = assignmentStateCounts;
+
 exports.checkWorkflowInvariants = checkWorkflowInvariants;
 
 exports.choiceValueIssues = choiceValueIssues;
@@ -4151,6 +4170,10 @@ exports.classifyPrincipalId = classifyPrincipalId;
 
 exports.clientConfigFromResource = clientConfigFromResource;
 
+exports.condemnSubworkflow = condemnSubworkflow;
+
+exports.condemnedSubworkflows = condemnedSubworkflows;
+
 exports.conditionEffectReads = conditionEffectReads;
 
 exports.conditionFieldReadNames = conditionFieldReadNames;
@@ -4185,6 +4208,10 @@ exports.extractDocumentId = extractDocumentId;
 
 exports.fieldValueSchemas = fieldValueSchemas;
 
+exports.findCurrentActivityEntry = findCurrentActivityEntry;
+
+exports.findOpenStageEntry = findOpenStageEntry;
+
 exports.firstCarriedGlobalId = firstCarriedGlobalId;
 
 exports.formatIssuePath = formatIssuePath;
@@ -4205,14 +4232,22 @@ exports.groq = groq;
 
 exports.groupMembershipNames = groupMembershipNames;
 
+exports.identityMatchesAssignment = identityMatchesAssignment;
+
+exports.instanceAssignmentStateCounts = instanceAssignmentStateCounts;
+
 exports.isAlwaysArrayFieldKind = isAlwaysArrayFieldKind;
 
 exports.isAssignmentFieldEntry = isAssignmentFieldEntry;
 
+exports.isBareDocumentId = isBareDocumentId;
+
 exports.isBareSeedId = isBareSeedId;
 
 exports.isCascadeFired = isCascadeFired;
 
+exports.isFilterScopedOut = isFilterScopedOut;
+
 exports.isGdr = isGdr;
 
 exports.isGdrUri = isGdrUri;
@@ -4247,6 +4282,16 @@ exports.labelFor = labelFor;
 
 exports.lakePrincipalId = lakePrincipalId;
 
+exports.liveSubworkflows = liveSubworkflows;
+
+exports.mutationGuardActionIdSpace = mutationGuardActionIdSpace;
+
+exports.mutationGuardRequiresSplitEmission = mutationGuardRequiresSplitEmission;
+
+exports.normalizeAssignmentMembers = normalizeAssignmentMembers;
+
+exports.openActivityAssignments = openActivityAssignments;
+
 exports.parseFieldValue = parseFieldValue;
 
 exports.parseGdr = parseGdr;
@@ -4279,6 +4324,8 @@ exports.releaseDocId = releaseDocId;
 
 exports.releaseRef = releaseRef;
 
+exports.resolvedChildStatus = resolvedChildStatus;
+
 exports.resourceAliasesToMap = resourceAliasesToMap;
 
 exports.resourceFromGdrUri = resourceFromGdrUri;