@sanity/workflow-engine 0.14.0 → 0.16.0

package/dist/_chunks-es/invariants.js

@@ -0,0 +1,2976 @@
+import * as v from "valibot";
+
+import { conditionOutcome, runGroq as runGroq$1, evaluateConditionOutcome as evaluateConditionOutcome$1 } from "@sanity/groq-condition-describe";
+
+import { parse } from "groq-js";
+
+function isCascadeFired(action) {
+    return action.when !== void 0;
+}
+
+function deriveActivityKind(activity) {
+    if (activity.target !== void 0) return "manual";
+    const actions = activity.actions ?? [];
+    return actions.some(a => !isCascadeFired(a)) ? "user" : actions.some(a => (a.effects ?? []).length > 0 || a.spawn !== void 0) ? "service" : actions.length > 0 ? "receive" : "script";
+}
+
+function deriveExecutorClassification(activity) {
+    if (activity.target !== void 0) return "off-system";
+    const actions = activity.actions ?? [], cascadeFired = actions.filter(isCascadeFired).length;
+    return cascadeFired === actions.length ? "autonomous" : cascadeFired === 0 ? "interactive" : "hybrid";
+}
+
+function driverKind(actor) {
+    return actor.kind === "person" || actor.kind === "agent" ? actor.kind : "service";
+}
+
+function errorMessage(err) {
+    return (err instanceof Error ? err.message : String(err)).replace(/[^\P{Cc}\n\t]/gu, "");
+}
+
+function rethrowWithContext(err, context) {
+    throw new Error(`${context}: ${errorMessage(err)}`, {
+        cause: err
+    });
+}
+
+function andConditions(parts) {
+    const present = parts.filter(p => p !== void 0);
+    if (present.length !== 0) return present.length === 1 ? present[0] : present.map(p => `(${p})`).join(" && ");
+}
+
+const KNOWN_SCHEMES = /* @__PURE__ */ new Set([ "dataset", "canvas", "media-library", "dashboard" ]), KNOWN_SCHEMES_TEXT = [ ...KNOWN_SCHEMES ].join(", ");
+
+function parseGdr(uri) {
+    const colon = uri.indexOf(":");
+    if (colon < 0) throw new Error(`Invalid GDR "${uri}": must be a URI of form "<scheme>:<...id-parts>". Known schemes: ${KNOWN_SCHEMES_TEXT}.`);
+    const scheme = uri.slice(0, colon), rest = uri.slice(colon + 1);
+    if (!KNOWN_SCHEMES.has(scheme)) throw new Error(`Invalid GDR "${uri}": unknown scheme "${scheme}". Known: ${KNOWN_SCHEMES_TEXT}.`);
+    const parts = rest.split(":");
+    if (parts.some(part => part.length === 0)) throw new Error(`Invalid GDR "${uri}": id parts must be non-empty (no leading, trailing, or doubled ":").`);
+    if (scheme === "dataset") {
+        if (parts.length !== 3) throw new Error(`Invalid GDR "${uri}": dataset scheme requires <projectId>:<dataset>:<documentId> (3 parts after scheme); got ${parts.length}.`);
+        return {
+            scheme: "dataset",
+            projectId: parts[0],
+            dataset: parts[1],
+            documentId: parts[2]
+        };
+    }
+    if (parts.length !== 2) throw new Error(`Invalid GDR "${uri}": ${scheme} scheme requires <resourceId>:<documentId> (2 parts after scheme); got ${parts.length}.`);
+    return {
+        scheme: scheme,
+        resourceId: parts[0],
+        documentId: parts[1]
+    };
+}
+
+function tryParseGdr(uri) {
+    try {
+        return parseGdr(uri);
+    } catch {
+        return;
+    }
+}
+
+function gdrUri(parts) {
+    return parts.scheme === "dataset" ? `dataset:${parts.projectId}:${parts.dataset}:${parts.documentId}` : `${parts.scheme}:${parts.resourceId}:${parts.documentId}`;
+}
+
+function extractDocumentId(gdrUriString) {
+    return parseGdr(gdrUriString).documentId;
+}
+
+const RESOURCE_ALIAS_NAME_SOURCE = "[a-z0-9][a-z0-9-]*", RESOURCE_ALIAS_NAME_RE = new RegExp(`^${RESOURCE_ALIAS_NAME_SOURCE}$`);
+
+function validateResourceAliasName(name) {
+    if (!RESOURCE_ALIAS_NAME_RE.test(name)) throw new Error(`Invalid resource alias name "${name}": expected lowercase letters, digits, and dashes (no leading dash).`);
+}
+
+function toPhysicalGdr(id, home) {
+    return isGdrUri(id) ? id : gdrFromResource(home, id);
+}
+
+function refDataset({projectId: projectId, dataset: dataset, documentId: documentId, type: type}) {
+    return {
+        id: gdrUri({
+            scheme: "dataset",
+            projectId: projectId,
+            dataset: dataset,
+            documentId: documentId
+        }),
+        type: type
+    };
+}
+
+function refCanvas({resourceId: resourceId, documentId: documentId, type: type}) {
+    return {
+        id: gdrUri({
+            scheme: "canvas",
+            resourceId: resourceId,
+            documentId: documentId
+        }),
+        type: type
+    };
+}
+
+function refMediaLibrary({resourceId: resourceId, documentId: documentId, type: type}) {
+    return {
+        id: gdrUri({
+            scheme: "media-library",
+            resourceId: resourceId,
+            documentId: documentId
+        }),
+        type: type
+    };
+}
+
+function refDashboard({resourceId: resourceId, documentId: documentId, type: type}) {
+    return {
+        id: gdrUri({
+            scheme: "dashboard",
+            resourceId: resourceId,
+            documentId: documentId
+        }),
+        type: type
+    };
+}
+
+function datasetResourceParts(id) {
+    const dot = id.indexOf(".");
+    if (dot <= 0 || dot === id.length - 1) throw new Error(`Invalid dataset resource id "${id}": expected "<projectId>.<dataset>".`);
+    return {
+        projectId: id.slice(0, dot),
+        dataset: id.slice(dot + 1)
+    };
+}
+
+function clientConfigFromResource(res) {
+    return res.type === "dataset" ? datasetResourceParts(res.id) : {
+        resource: res
+    };
+}
+
+function gdrFromResource(res, documentId) {
+    if (res.type === "dataset") {
+        const {projectId: projectId, dataset: dataset} = datasetResourceParts(res.id);
+        return gdrUri({
+            scheme: "dataset",
+            projectId: projectId,
+            dataset: dataset,
+            documentId: documentId
+        });
+    }
+    return gdrUri({
+        scheme: res.type,
+        resourceId: res.id,
+        documentId: documentId
+    });
+}
+
+function resourceGdr(res) {
+    return `${res.type}:${res.id}`;
+}
+
+function parseResourceGdr(uri) {
+    const expected = 'expected "<type>:<id>" with no document part, e.g. "dataset:<projectId>.<dataset>" or "media-library:<resourceId>"', parts = uri.split(":");
+    if (parts.length !== 2 || parts.some(part => part.length === 0)) throw new Error(`Invalid resource GDR "${uri}": ${expected}.`);
+    const [type, id] = parts;
+    if (!KNOWN_SCHEMES.has(type)) throw new Error(`Invalid resource GDR "${uri}": unknown resource type "${type}". Known: ${KNOWN_SCHEMES_TEXT}.`);
+    return type === "dataset" && datasetResourceParts(id), {
+        type: type,
+        id: id
+    };
+}
+
+function gdrResourcePrefix(res) {
+    const full = gdrFromResource(res, "x");
+    return full.slice(0, full.length - 1);
+}
+
+function resourceFromParsed(parsed) {
+    return parsed.scheme === "dataset" ? {
+        type: "dataset",
+        id: `${parsed.projectId}.${parsed.dataset}`
+    } : {
+        type: parsed.scheme,
+        id: parsed.resourceId ?? ""
+    };
+}
+
+function resourceFromGdrUri(uri) {
+    const parsed = tryParseGdr(uri);
+    return parsed === void 0 ? void 0 : resourceFromParsed(parsed);
+}
+
+function sameResource(a, b) {
+    return a.type === b.type && a.id === b.id;
+}
+
+function selfGdr(doc) {
+    return gdrFromResource(doc.workflowResource, doc._id);
+}
+
+function definitionDocId({tag: tag, definition: definition, version: version}) {
+    return `${tag}.${definition}.v${version}`;
+}
+
+function isGdrUri(value) {
+    return typeof value == "string" && tryParseGdr(value) !== void 0;
+}
+
+function toBareId(id) {
+    return isGdrUri(id) ? extractDocumentId(id) : id;
+}
+
+function gdrRef({res: res, documentId: documentId, type: type}) {
+    return {
+        id: gdrFromResource(res, documentId),
+        type: type
+    };
+}
+
+function isGdr(value) {
+    return typeof value == "object" && value !== null && typeof value.id == "string" && typeof value.type == "string";
+}
+
+class WorkflowError extends Error {
+    kind;
+    constructor(kind, message, options) {
+        super(message, options), this.kind = kind;
+    }
+}
+
+class ContractViolationError extends WorkflowError {
+    constructor(message) {
+        super("contract-violation", message), this.name = "ContractViolationError";
+    }
+}
+
+class InstanceNotFoundError extends WorkflowError {
+    instanceId;
+    constructor(args) {
+        super("instance-not-found", `Workflow instance ${args.instanceId} not found${args.detail ? ` (${args.detail})` : ""}`), 
+        this.name = "InstanceNotFoundError", this.instanceId = args.instanceId;
+    }
+}
+
+class DefinitionNotFoundError extends WorkflowError {
+    definition;
+    version;
+    constructor(args) {
+        super("definition-not-found", args.version !== void 0 ? `Workflow definition ${args.definition} v${args.version} not deployed` : `Workflow definition ${args.definition} has no deployed versions`), 
+        this.name = "DefinitionNotFoundError", this.definition = args.definition, args.version !== void 0 && (this.version = args.version);
+    }
+}
+
+class DefinitionInUseError extends WorkflowError {
+    definition;
+    blockedBy;
+    constructor(args) {
+        super("definition-in-use", definitionInUseMessage(args.definition, args.blockedBy)), 
+        this.name = "DefinitionInUseError", this.definition = args.definition, this.blockedBy = args.blockedBy;
+    }
+}
+
+function definitionInUseMessage(definition, blockedBy) {
+    if (blockedBy.reason === "non-terminal-instances") {
+        const head = blockedBy.instanceIds.slice(0, 3).join(", "), preview = blockedBy.instanceIds.length > 3 ? `${head}, …` : head;
+        return `Cannot delete ${definition}: ${blockedBy.instanceIds.length} non-terminal instance(s) exist (${preview}). Pass cascade to abort them first — instances are aborted in place, never deleted.`;
+    }
+    const names = blockedBy.referrers.map(r => `${r.definition} v${r.version}`).join(", ");
+    return `Cannot delete ${definition}: still spawn-referenced by deployed definition(s) ${names}. Delete or redeploy the referrer(s) first.`;
+}
+
+class EffectNotFoundError extends WorkflowError {
+    instanceId;
+    effectKey;
+    settled;
+    constructor(args) {
+        super("effect-not-found", effectNotFoundMessage(args)), this.name = "EffectNotFoundError", 
+        this.instanceId = args.instanceId, this.effectKey = args.effectKey, args.settled !== void 0 && (this.settled = args.settled);
+    }
+}
+
+function effectNotFoundMessage(args) {
+    const base = `Pending effect "${args.effectKey}" not found on instance ${args.instanceId}`;
+    if (args.settled === void 0) return base;
+    const cause = args.settled.detail !== void 0 ? ` (${args.settled.detail})` : "";
+    return args.settled.status === "cancelled" ? `${base} — it was cancelled at ${args.settled.ranAt}${cause}` : `${base} — it already settled "${args.settled.status}" at ${args.settled.ranAt}${cause}`;
+}
+
+const TAG_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+function validateTag(tag) {
+    if (!TAG_RE.test(tag)) throw new ContractViolationError(`tag: invalid tag "${tag}" — must match ${TAG_RE.source} (ASCII lowercase + digits + dashes, no leading dash, no dots)`);
+}
+
+function tagScopeFilter() {
+    return "tag == $tag";
+}
+
+const NonEmptyString = v.pipe(v.string(), v.nonEmpty("must not be empty"));
+
+function asPredicate(validate) {
+    return value => {
+        try {
+            return validate(value), !0;
+        } catch {
+            return !1;
+        }
+    };
+}
+
+const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts), WorkflowResourceSchema = v.variant("type", [ v.object({
+    type: v.literal("dataset"),
+    id: v.pipe(NonEmptyString, v.check(isValidDatasetId, 'invalid dataset resource id — expected "<projectId>.<dataset>"'))
+}), v.object({
+    type: v.literal("canvas"),
+    id: NonEmptyString
+}), v.object({
+    type: v.literal("media-library"),
+    id: NonEmptyString
+}), v.object({
+    type: v.literal("dashboard"),
+    id: NonEmptyString
+}) ]), ResourceBindingSchema = v.object({
+    name: v.pipe(NonEmptyString, v.check(isValidAliasName, "invalid resource handle name — lowercase letters, digits and dashes only, no leading dash")),
+    resource: WorkflowResourceSchema
+}), DefinitionSchema = v.custom(input => typeof input == "object" && input !== null && typeof input.name == "string", "expected a workflow definition (an object with a string `name`)"), DeploymentSchema = v.object({
+    name: NonEmptyString,
+    tag: v.pipe(v.string(), v.nonEmpty(), v.check(isValidTag, "invalid tag — lowercase letters, digits and dashes only, no leading dash, no dots")),
+    workflowResource: WorkflowResourceSchema,
+    resourceAliases: v.optional(v.pipe(v.array(ResourceBindingSchema), v.check(bindings => new Set(bindings.map(binding => binding.name)).size === bindings.length, "duplicate resource handle name — each binding name must be unique within a deployment"))),
+    definitions: v.pipe(v.array(DefinitionSchema), v.minLength(1, "a deployment needs at least one definition"))
+}), TelemetryLoggerSchema = v.custom(input => typeof input == "object" && input !== null && typeof input.log == "function", "expected a telemetry logger (an object with a `log` function)"), WorkflowConfigSchema = v.object({
+    deployments: v.pipe(v.array(DeploymentSchema), v.minLength(1, "a config needs at least one deployment"), v.check(deployments => new Set(deployments.map(deployment => deployment.tag)).size === deployments.length, "duplicate deployment tag — each deployment must use a unique tag")),
+    telemetry: v.optional(TelemetryLoggerSchema)
+});
+
+function resourceAliasesToMap(resourceAliases) {
+    return Object.fromEntries((resourceAliases ?? []).map(binding => [ binding.name, binding.resource ]));
+}
+
+const FIELD_READ = /^\$fields\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
+
+function isGuardReadExpr(expr) {
+    return expr === "$self" || expr === "$now" || FIELD_READ.test(expr) || EFFECTS_READ.test(expr);
+}
+
+function printGuardRead(read) {
+    switch (read.type) {
+      case "self":
+        return "$self";
+
+      case "now":
+        return "$now";
+
+      case "fieldRead":
+        return read.path === void 0 ? `$fields.${read.field}` : `$fields.${read.field}.${read.path}`;
+
+      case "effectsRead":
+        return read.path === void 0 ? `$effects['${read.effect}']` : `$effects['${read.effect}'].${read.path}`;
+    }
+}
+
+const UNIVERSAL_ROLE_ALIAS_KEY = "$all";
+
+function normalizeRoleAliases(aliases) {
+    if (aliases === void 0 || !("*" in aliases)) return aliases;
+    const {["*"]: universal, ...perRole} = aliases;
+    return {
+        ...perRole,
+        [UNIVERSAL_ROLE_ALIAS_KEY]: universal
+    };
+}
+
+function expandRequiredRoles(required, aliases) {
+    if (aliases === void 0) return [ ...required ];
+    const out = /* @__PURE__ */ new Set;
+    for (const role of required) {
+        out.add(role);
+        for (const fulfiller of aliases[role] ?? []) out.add(fulfiller);
+    }
+    for (const fulfiller of aliases[UNIVERSAL_ROLE_ALIAS_KEY] ?? []) out.add(fulfiller);
+    return [ ...out ];
+}
+
+function actorFulfillsRole({actorRoles: actorRoles, required: required, aliases: aliases}) {
+    if (actorRoles === void 0 || actorRoles.length === 0) return !1;
+    const accepted = new Set(expandRequiredRoles([ required ], aliases));
+    return actorRoles.some(role => accepted.has(role));
+}
+
+function groq(strings, ...values) {
+    return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
+}
+
+function serializeGroqValue(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) throw new Error(`groq tag cannot serialize ${typeof value} — interpolate JSON-representable values only`);
+    return serialized;
+}
+
+function desugarWorkflow(authoring) {
+    const issues = [];
+    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,
+        path: [ "fields" ],
+        ctx: ctx
+    }), workflowLayer = layerOf(workflowFields2), stages = authoring.stages.map((stage, i) => {
+        const path = [ "stages", i ], stageFields2 = desugarFieldEntries({
+            entries: stage.fields,
+            path: [ ...path, "fields" ],
+            ctx: ctx
+        }), stageEnv = {
+            layers: [ {
+                scope: "stage",
+                entries: layerOf(stageFields2)
+            }, {
+                scope: "workflow",
+                entries: workflowLayer
+            } ]
+        }, activities = (stage.activities ?? []).map((activity, j) => desugarActivity({
+            activity: activity,
+            path: [ ...path, "activities", j ],
+            stageEnv: stageEnv,
+            ctx: ctx
+        })), transitions = (stage.transitions ?? []).map(transition => desugarTransition({
+            transition: transition
+        })), editable = desugarStageEditable({
+            overrides: stage.editable,
+            inScope: editableFieldNames({
+                workflowFields: workflowFields2,
+                stageFields: stageFields2,
+                activities: activities
+            }),
+            path: [ ...path, "editable" ],
+            ctx: ctx
+        });
+        return {
+            ...stripUndefined({
+                name: stage.name,
+                title: stage.title,
+                description: stage.description,
+                groups: stage.groups,
+                guards: stage.guards?.map(desugarGuard)
+            }),
+            ...stageFields2 ? {
+                fields: stageFields2
+            } : {},
+            ...activities.length > 0 ? {
+                activities: activities
+            } : {},
+            ...transitions.length > 0 ? {
+                transitions: transitions
+            } : {},
+            ...editable ? {
+                editable: editable
+            } : {}
+        };
+    });
+    return checkUnclaimedClaimFields(ctx), {
+        definition: {
+            ...stripUndefined({
+                name: authoring.name,
+                title: authoring.title,
+                description: authoring.description,
+                groups: authoring.groups,
+                lifecycle: authoring.lifecycle,
+                start: desugarStart(authoring.start),
+                initialStage: authoring.initialStage,
+                predicates: authoring.predicates,
+                roleAliases: roleAliases
+            }),
+            ...workflowFields2 ? {
+                fields: workflowFields2
+            } : {},
+            stages: stages
+        },
+        issues: ctx.issues
+    };
+}
+
+function desugarStart(start) {
+    if (start !== void 0) return {
+        kind: start.kind ?? "interactive",
+        ...start.filter !== void 0 ? {
+            filter: start.filter
+        } : {}
+    };
+}
+
+function checkReservedRoleAliasKeys(aliases, issues) {
+    for (const key of Object.keys(aliases ?? {})) key.startsWith("$") && issues.push({
+        path: [ "roleAliases", key ],
+        message: `role alias key "${key}" uses the reserved "$" prefix — that namespace is the engine's stored spelling for the universal fulfiller. Use "*" to mean "fulfills any gate", or rename the role.`
+    });
+}
+
+const TODOLIST_OF = [ {
+    type: "string",
+    name: "label",
+    title: "Label"
+}, {
+    type: "string",
+    name: "status",
+    title: "Status"
+}, {
+    type: "assignee",
+    name: "assignee",
+    title: "Assignee"
+}, {
+    type: "date",
+    name: "dueDate",
+    title: "Due date"
+} ], NOTES_OF = [ {
+    type: "text",
+    name: "body",
+    title: "Body"
+}, {
+    type: "actor",
+    name: "actor",
+    title: "Actor"
+}, {
+    type: "datetime",
+    name: "at",
+    title: "At"
+} ];
+
+function desugarFieldEntries({entries: entries, path: path, ctx: ctx}) {
+    return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => desugarFieldEntry({
+        entry: entry,
+        path: [ ...path, i ],
+        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,
+        ctx: ctx
+    });
+    const editable = normalizeEditable({
+        editable: entry.editable,
+        path: [ ...path, "editable" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            type: entry.type,
+            name: entry.name,
+            title: entry.title,
+            description: entry.description,
+            group: normalizeGroup(entry.group),
+            required: entry.required,
+            initialValue: entry.initialValue,
+            editable: editable,
+            types: entry.types,
+            fields: entry.fields,
+            of: entry.of
+        })
+    };
+}
+
+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,
+        path: [ ...path, "editable" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            name: entry.name,
+            title: entry.title,
+            description: entry.description,
+            group: normalizeGroup(entry.group),
+            required: entry.required,
+            initialValue: entry.initialValue,
+            editable: editable
+        }),
+        type: "array",
+        of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
+    };
+}
+
+function normalizeEditable({editable: editable, path: path, ctx: 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: path,
+                message: "editable: [] names no roles — use `true` to open the field to anyone in its scope, or list at least one role"
+            });
+            return;
+        }
+        return condition;
+    }
+    return editable;
+}
+
+function editableFieldNames({workflowFields: workflowFields2, stageFields: stageFields2, activities: activities}) {
+    const names = /* @__PURE__ */ new Set, collect = entries => {
+        for (const entry of entries ?? []) entry.editable !== void 0 && names.add(entry.name);
+    };
+    collect(workflowFields2), collect(stageFields2);
+    for (const activity of activities) collect(activity.fields);
+    return names;
+}
+
+function desugarStageEditable({overrides: overrides, inScope: inScope, path: path, ctx: ctx}) {
+    if (overrides === void 0) return;
+    const out = {};
+    for (const [name, value] of Object.entries(overrides)) {
+        if (!inScope.has(name)) {
+            ctx.issues.push({
+                path: [ ...path, name ],
+                message: `stage editable override "${name}" does not narrow an editable field in scope — name a workflow/stage/activity field of this stage that declares \`editable\``
+            });
+            continue;
+        }
+        const normalized = normalizeEditable({
+            editable: value,
+            path: [ ...path, name ],
+            ctx: ctx
+        });
+        normalized !== void 0 && (out[name] = normalized);
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+}
+
+function layerOf(entries) {
+    return new Map((entries ?? []).map(entry => [ entry.name, entry ]));
+}
+
+function normalizeGroup(group) {
+    return group === void 0 || Array.isArray(group) ? group : [ group ];
+}
+
+function desugarActivity({activity: activity, path: path, stageEnv: stageEnv, ctx: ctx}) {
+    const activityFields2 = desugarFieldEntries({
+        entries: activity.fields,
+        path: [ ...path, "fields" ],
+        ctx: ctx
+    }), env = {
+        layers: [ {
+            scope: "activity",
+            entries: layerOf(activityFields2)
+        }, ...stageEnv.layers ]
+    }, actions = (activity.actions ?? []).map((action, a) => desugarAction({
+        action: action,
+        path: [ ...path, "actions", a ],
+        env: env,
+        activityName: activity.name,
+        ctx: ctx
+    })), target = desugarTarget({
+        target: activity.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            name: activity.name,
+            title: activity.title,
+            description: activity.description,
+            groups: activity.groups,
+            group: normalizeGroup(activity.group),
+            filter: activity.filter,
+            requirements: activity.requirements
+        }),
+        ...target ? {
+            target: target
+        } : {},
+        ...activityFields2 ? {
+            fields: activityFields2
+        } : {},
+        ...actions.length > 0 ? {
+            actions: actions
+        } : {}
+    };
+}
+
+const TARGET_DOC_KINDS = [ "doc.ref", "doc.refs", "release.ref" ];
+
+function desugarTarget({target: target, env: env, path: path, ctx: ctx}) {
+    if (target === void 0 || target.type === "url") return target;
+    const ref = typeof target.field == "string" ? {
+        field: target.field
+    } : target.field, field = resolveRef({
+        ref: ref,
+        env: env,
+        path: [ ...path, "field" ],
+        ctx: 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}" — a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
+    }), {
+        type: "field",
+        field: field
+    };
+}
+
+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
+    });
+    action.roles !== void 0 && action.roles.length === 0 && ctx.issues.push({
+        path: [ ...path, "roles" ],
+        message: "roles: [] names no roles — omit it to allow any identity, or list at least one role"
+    });
+    const cascadeFired = isCascadeFired(action), filter = cascadeFired ? action.filter : andConditions([ rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = desugarOps({
+        ops: action.ops,
+        path: [ ...path, "ops" ],
+        env: env,
+        firingActivity: activityName,
+        ctx: ctx
+    }) ?? [];
+    return action.status !== void 0 && ops.push({
+        type: "status.set",
+        activity: activityName,
+        status: action.status
+    }), {
+        ...stripUndefined({
+            name: action.name,
+            title: action.title,
+            description: action.description,
+            group: normalizeGroup(action.group),
+            when: action.when,
+            params: action.params,
+            effects: action.effects,
+            spawn: action.spawn
+        }),
+        ...cascadeFired && action.roles !== void 0 && action.roles.length > 0 ? {
+            roles: action.roles
+        } : {},
+        ...filter ? {
+            filter: filter
+        } : {},
+        ...ops.length > 0 ? {
+            ops: ops
+        } : {}
+    };
+}
+
+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}) {
+    return {
+        ...stripUndefined({
+            name: transition.name,
+            title: transition.title,
+            description: transition.description,
+            to: transition.to
+        }),
+        when: transition.when ?? DEFAULT_TRANSITION_WHEN
+    };
+}
+
+function desugarGuard(guard) {
+    const {match: match, metadata: metadata, ...rest} = guard, {idRefs: idRefs, ...matchRest} = match;
+    return {
+        ...rest,
+        match: {
+            ...matchRest,
+            ...idRefs !== void 0 ? {
+                idRefs: idRefs.map(printGuardRead)
+            } : {}
+        },
+        ...metadata !== void 0 ? {
+            metadata: Object.fromEntries(Object.entries(metadata).map(([key, read]) => [ key, printGuardRead(read) ]))
+        } : {}
+    };
+}
+
+function desugarOps({ops: ops, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
+    if (ops) return ops.map((op, i) => desugarOp({
+        op: op,
+        path: [ ...path, i ],
+        env: env,
+        firingActivity: firingActivity,
+        ctx: ctx
+    }));
+}
+
+function desugarOp({op: op, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
+    if (op.type === "status.set") return {
+        type: "status.set",
+        activity: op.activity ?? firingActivity,
+        status: op.status
+    };
+    if (op.type === "audit") return desugarAuditOp({
+        op: op,
+        path: path,
+        env: env,
+        ctx: ctx
+    });
+    const target = resolveRef({
+        ref: op.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    }) ?? fallbackRef(op.target);
+    return {
+        ...op,
+        target: target
+    };
+}
+
+const AUDIT_STAMPS = {
+    actor: {
+        type: "actor"
+    },
+    at: {
+        type: "now"
+    }
+};
+
+function desugarAuditOp({op: op, path: path, env: env, ctx: ctx}) {
+    const target = resolveRef({
+        ref: op.target,
+        env: env,
+        path: [ ...path, "target" ],
+        ctx: ctx
+    }) ?? fallbackRef(op.target);
+    if (op.value.type !== "object") return ctx.issues.push({
+        path: [ ...path, "value" ],
+        message: `audit value must be an object source carrying the domain fields (got "${op.value.type}")`
+    }), {
+        type: "field.append",
+        target: target,
+        value: op.value
+    };
+    const actorField = op.stampFields?.actor ?? "actor", atField = op.stampFields?.at ?? "at", fields = {
+        ...op.value.fields
+    };
+    for (const [stamp, source] of [ [ actorField, AUDIT_STAMPS.actor ], [ atField, AUDIT_STAMPS.at ] ]) {
+        if (stamp in fields) {
+            ctx.issues.push({
+                path: [ ...path, "value", "fields", stamp ],
+                message: `audit stamp field "${stamp}" collides with an authored domain field — rename yours or remap the stamp via stampFields`
+            });
+            continue;
+        }
+        fields[stamp] = source;
+    }
+    return {
+        type: "field.append",
+        target: target,
+        value: {
+            type: "object",
+            fields: fields
+        }
+    };
+}
+
+function resolveRef({ref: ref, env: env, path: path, ctx: ctx}) {
+    const layers = ref.scope === void 0 ? env.layers : env.layers.filter(l => l.scope === ref.scope);
+    for (const layer of layers) if (layer.entries.has(ref.field)) return {
+        scope: layer.scope,
+        field: ref.field
+    };
+    const reachable = env.layers.flatMap(l => [ ...l.entries.keys() ].map(n => `${l.scope}:${n}`));
+    ctx.issues.push({
+        path: path,
+        message: `field reference "${ref.field}"${ref.scope ? ` (scope "${ref.scope}")` : ""} does not resolve to a declared entry. Reachable: ${reachable.join(", ") || "(none)"}`
+    });
+}
+
+function entryAt(env, ref) {
+    return env.layers.find(l => l.scope === ref.scope)?.entries.get(ref.field);
+}
+
+function fallbackRef(ref) {
+    return {
+        scope: ref.scope ?? "workflow",
+        field: ref.field
+    };
+}
+
+function rolesCondition(roles, aliases) {
+    if (!(!roles || roles.length === 0)) return groq`count($actor.roles[@ in ${expandRequiredRoles(roles, aliases)}]) > 0`;
+}
+
+function stripUndefined(obj) {
+    const out = {};
+    for (const [k, value] of Object.entries(obj)) value !== void 0 && (out[k] = value);
+    return out;
+}
+
+function isUnevaluable(result) {
+    return result == null;
+}
+
+async function evaluateConditionOutcome(args) {
+    const {condition: condition, snapshot: snapshot, params: params} = args;
+    return evaluateConditionOutcome$1({
+        condition: condition,
+        params: params,
+        dataset: snapshot.docs
+    });
+}
+
+async function evaluateCondition(args) {
+    return await evaluateConditionOutcome(args) === "satisfied";
+}
+
+async function evaluatePredicates(args) {
+    const out = {};
+    for (const [name, groq2] of Object.entries(args.predicates ?? {})) {
+        const result = await runGroq({
+            groq: groq2,
+            params: args.params,
+            snapshot: args.snapshot
+        }), outcome = conditionOutcome(result);
+        out[name] = outcome === "unevaluable" ? null : outcome === "satisfied";
+    }
+    return out;
+}
+
+async function runGroq({groq: groq2, params: params, snapshot: snapshot}) {
+    return runGroq$1({
+        groq: groq2,
+        params: params,
+        dataset: snapshot.docs
+    });
+}
+
+function conditionSyntaxIssues(groq2, boundVars) {
+    const issues = [];
+    let tree;
+    try {
+        tree = parse(groq2);
+    } catch (err) {
+        issues.push(errorMessage(err));
+    }
+    if (/\*\s*\[\s*_type\b/.test(groq2) && issues.push("condition scans by `_type` — that's a discovery query, not a predicate. Conditions evaluate against the in-memory snapshot (instance + ancestors + field-declared docs). To bring extra docs in scope, declare a `doc.ref` (or `doc.refs`) field entry on the workflow or this stage. For lake scans like \"all articles in this release\", use a spawn action's `forEach` instead."), 
+    boundVars !== void 0 && tree !== void 0) for (const name of conditionParameterNames(groq2)) boundVars.includes(name) || issues.push(`reads $${name}, which this scope does not bind — an unbound variable evaluates to GROQ null, so the condition silently never matches. Bound here: ` + boundVars.map(n => `$${n}`).join(", "));
+    return issues;
+}
+
+function conditionParameterNames(groq2) {
+    const read = /* @__PURE__ */ new Set;
+    return walkAstNodes(tryParseGroq(groq2), node => {
+        node.type === "Parameter" && typeof node.name == "string" && read.add(node.name);
+    }), read;
+}
+
+function conditionFieldReadNames(groq2) {
+    const read = /* @__PURE__ */ new Set;
+    return walkAstNodes(tryParseGroq(groq2), node => {
+        if (node.type !== "AccessAttribute" || typeof node.name != "string") return;
+        const base = node.base;
+        base?.type === "Parameter" && base.name === "fields" && read.add(node.name);
+    }), read;
+}
+
+function conditionEffectReads(groq2) {
+    const reads = [];
+    return walkAstNodes(tryParseGroq(groq2), node => {
+        if (node.type !== "AccessAttribute" || typeof node.name != "string") return;
+        const base = node.base;
+        base?.type !== "AccessAttribute" || typeof base.name != "string" || base.base?.type === "Parameter" && base.base.name === "effects" && reads.push({
+            effect: base.name,
+            key: node.name
+        });
+    }), reads;
+}
+
+function readsRootDocument(groq2) {
+    return nodeReadsRoot(tryParseGroq(groq2), 0);
+}
+
+const SCOPED_CHILD = {
+    Filter: "expr",
+    Projection: "expr",
+    Map: "expr",
+    FlatMap: "expr",
+    PipeFuncCall: "args"
+};
+
+function nodeReadsRoot(node, depth) {
+    if (Array.isArray(node)) return node.some(item => nodeReadsRoot(item, depth));
+    if (typeof node != "object" || node === null) return !1;
+    const typed = node;
+    if (depth === 0 && typed.type === "This" || depth === 0 && typed.type === "AccessAttribute" && typed.base === void 0) return !0;
+    if (typed.type === "Parent") {
+        const climb = typeof typed.n == "number" ? typed.n : 1;
+        return depth - climb <= 0;
+    }
+    const scopedChild = typeof typed.type == "string" ? SCOPED_CHILD[typed.type] : void 0;
+    return scopedChild !== void 0 ? Object.entries(node).some(([key, value]) => nodeReadsRoot(value, key === scopedChild ? depth + 1 : depth)) : Object.values(node).some(value => nodeReadsRoot(value, depth));
+}
+
+function tryParseGroq(groq2) {
+    try {
+        return parse(groq2);
+    } catch {
+        return;
+    }
+}
+
+function walkAstNodes(node, visit) {
+    if (Array.isArray(node)) {
+        for (const item of node) walkAstNodes(item, visit);
+        return;
+    }
+    if (!(typeof node != "object" || node === null)) {
+        visit(node);
+        for (const value of Object.values(node)) walkAstNodes(value, visit);
+    }
+}
+
+const ACTIVITY_STATUSES = [ "active", "done", "skipped", "failed" ], TERMINAL_ACTIVITY_STATUSES = [ "done", "skipped", "failed" ];
+
+function isTerminalActivityStatus(status) {
+    return TERMINAL_ACTIVITY_STATUSES.includes(status);
+}
+
+const FIELD_SCOPES = [ "workflow", "stage", "activity" ], DOCUMENT_VALUE_PERMISSIONS = [ "create", "read", "update" ], MUTATION_GUARD_ACTIONS = [ "create", "update", "delete", "publish", "unpublish" ], ACTIVITY_KINDS = [ "user", "service", "script", "manual", "receive" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ], CONDITION_VARS = [ {
+    name: "self",
+    binding: "always",
+    label: "this workflow instance",
+    description: "GDR URI of the instance document itself — `*[_id == $self][0]` reads the instance in the snapshot."
+}, {
+    name: "fields",
+    binding: "always",
+    label: "the workflow's fields",
+    description: "Declared field entries rendered by name (`$fields.<name>` is the value, no envelope). Stage/activity scopes overlay lexically; `doc.ref` values render the hydrated document when the snapshot holds it."
+}, {
+    name: "parent",
+    binding: "always",
+    label: "the parent workflow",
+    description: "The parent instance's GDR URI, `null` on a root instance."
+}, {
+    name: "ancestors",
+    binding: "always",
+    label: "the workflow's ancestors",
+    description: "GDR URIs of the ancestor chain, root first."
+}, {
+    name: "stage",
+    binding: "always",
+    label: "the current stage",
+    description: "The current stage's name."
+}, {
+    name: "now",
+    binding: "always",
+    label: "the current time",
+    description: "The ISO clock reading shared by every condition in one evaluation pass, so they agree on the time."
+}, {
+    name: "context",
+    binding: "always",
+    label: "start-time context",
+    description: "The instance's `context` bag: values seeded at `startInstance` plus a parent's `spawn.context` handoff, by entry name. Written only at start — never mutated afterwards."
+}, {
+    name: "effects",
+    binding: "always",
+    label: "automation outputs",
+    description: "Completed effects' outputs, namespaced by effect name (`$effects['<effect>'].<output>`) — each effect's latest completed run wins. Handler fuel — transition triggers should read instance/lake state (or $effectStatus) instead."
+}, {
+    name: "effectStatus",
+    binding: "always",
+    label: "automation status",
+    description: "Effect name → `'done'` | `'failed'` of the latest completed run queued during the current stage entry; absent until the effect drains for this entry. Re-entry-safe: runs queued under a prior entry never count, so `$effectStatus['<effect>'] == 'done'` (or `defined($effectStatus['<effect>'])` for settled-either-way) waits for the fresh run."
+}, {
+    name: "activities",
+    binding: "always",
+    label: "this stage's activities",
+    description: "The current stage's activity rows, statuses included."
+}, {
+    name: "allActivitiesDone",
+    binding: "always",
+    label: "all activities in this stage are finished",
+    description: "Every current-stage activity is `done` or `skipped` — the default transition gate."
+}, {
+    name: "anyActivityFailed",
+    binding: "always",
+    label: "an activity in this stage has failed",
+    description: "Some current-stage activity is `failed`."
+}, {
+    name: "actor",
+    binding: "caller",
+    label: "you",
+    description: "The acting identity (id + roles); `undefined` when no caller rides the evaluation. Never holds a value in the cascade gates (deploy-rejected there)."
+}, {
+    name: "assigned",
+    binding: "caller",
+    label: "you are assigned to this activity",
+    description: "Whether the caller matches the activity's assignees-kind field entry (by user id, or by a role under the definition's `roleAliases`); `false` outside an activity context. Constant `false` in the cascade gates (deploy-rejected there)."
+}, {
+    name: "can",
+    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: "row",
+    binding: "spawn",
+    label: "the spawned row",
+    description: "One `spawn.forEach` result row, bound while its `with` map evaluates — and the row under test while a where-op `where` evaluates (per row)."
+}, {
+    name: "params",
+    binding: "caller",
+    label: "the action's arguments",
+    description: "The firing action's args — they hold values only while a fireAction-fired action's effect bindings and where-op `where`s evaluate (spawn sites don't bind it at all, and a cascade-fired action has no caller to supply args). Deploy rejects a read in the cascade gates, in a cascade-fired action's payload, and in the caller-bound projection (action filters, requirements, editable predicates): args exist only once the caller fires the action, after those sites have evaluated."
+}, {
+    name: "subworkflows",
+    binding: "always",
+    label: "the spawned subworkflows",
+    description: "Every row of the instance's subworkflow registry, faceted by `activity`/`action`/`definition`/`rowKey`/`status` (`'active'|'done'|'aborted'`) with `current` marking the open stage entry's cohort and `stage` the child's current stage. Usable anywhere — transition `when`s, requirements, any stage's gates; the settled gate is `count($subworkflows[activity == <name> && current && status == 'active']) == 0`."
+} ], RESERVED_CONDITION_VARS = CONDITION_VARS.map(v2 => v2.name), FILTER_SCOPE_VARS = CONDITION_VARS.filter(v2 => v2.binding === "always").map(v2 => v2.name), CALLER_BOUND_VARS = CONDITION_VARS.filter(v2 => v2.binding === "caller").map(v2 => v2.name), START_FILTER_VARS = [ {
+    name: "tag",
+    description: "The engine's tag partition — scope `*[...]` instance scans with `tag == $tag`."
+}, {
+    name: "definition",
+    description: "The `name` of the definition under evaluation (its own start.filter binds it)."
+}, {
+    name: "now",
+    description: "The ISO clock reading of the evaluating engine."
+}, {
+    name: "fields",
+    description: "The candidate initialFields by entry name, when the read surface has them (the Studio start control: yes; a per-doc picker: no). Document references bind as GDR envelopes — `$fields.<entry>.id` is the GDR URI, never a string authors assemble."
+} ], GUARD_PREDICATE_VARS = [ {
+    name: "guard",
+    description: "The guard document itself (its `metadata` carries deploy-time resolved values)."
+}, {
+    name: "mutation",
+    description: "The attempted mutation — `mutation.action` is the write kind being gated."
+} ], 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 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");
+}
+
+class FieldValueShapeError extends WorkflowError {
+    entryType;
+    entryName;
+    issues;
+    constructor(args) {
+        const issueText = args.issues.join("; ");
+        super("field-value-shape", `Field entry ${args.mode} shape invalid for "${args.entryName}" (${args.entryType}): ${issueText}`), 
+        this.name = "FieldValueShapeError", this.entryType = args.entryType, this.entryName = args.entryName, 
+        this.issues = args.issues;
+    }
+}
+
+const GdrShape = v.looseObject({
+    id: v.pipe(v.string(), v.check(s => isGdrUri(s), "must be a GDR URI")),
+    type: v.pipe(v.string(), v.minLength(1))
+}), ReleaseRefShape = v.pipe(v.looseObject({
+    id: v.pipe(v.string(), v.check(s => isGdrUri(s), "must be a GDR URI")),
+    type: v.literal("system.release"),
+    releaseName: v.pipe(v.string(), v.minLength(1))
+}), v.check(ref => !isGdrUri(ref.id) || extractDocumentId(ref.id) === releaseDocId(ref.releaseName), "id must point at the `_.releases.<releaseName>` doc named by releaseName")), ActorShape = v.looseObject({
+    kind: v.picklist(ACTOR_KINDS),
+    id: v.pipe(v.string(), v.minLength(1)),
+    roles: v.optional(v.array(v.string())),
+    onBehalfOf: v.optional(v.string())
+}), AssigneeShape = v.union([ v.looseObject({
+    type: v.literal("user"),
+    id: v.pipe(v.string(), v.minLength(1))
+}), v.looseObject({
+    type: v.literal("role"),
+    role: v.pipe(v.string(), v.minLength(1))
+}) ]), NullableString = v.union([ v.null(), v.string() ]), NullableNumber = v.union([ v.null(), v.number() ]), NullableBoolean = v.union([ v.null(), v.boolean() ]), NullableDateTime = v.union([ v.null(), v.pipe(v.string(), v.check(s => !Number.isNaN(Date.parse(s)), "must be an ISO-8601 datetime string")) ]), NullableDate = v.union([ v.null(), v.pipe(v.string(), v.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, valueSchemas = {
+    "doc.ref": v.union([ v.null(), GdrShape ]),
+    "doc.refs": v.array(GdrShape),
+    "release.ref": v.union([ v.null(), ReleaseRefShape ]),
+    query: v.any(),
+    string: NullableString,
+    text: NullableString,
+    number: NullableNumber,
+    boolean: NullableBoolean,
+    date: NullableDate,
+    datetime: NullableDateTime,
+    url: NullableUrl,
+    actor: v.union([ v.null(), ActorShape ]),
+    assignee: v.union([ v.null(), AssigneeShape ]),
+    assignees: v.array(AssigneeShape)
+};
+
+function shapeValueSchema(shape, leaf) {
+    return shape.type === "object" ? objectSchema(shape.fields ?? [], leaf) : shape.type === "array" ? v.array(objectSchema(shape.of ?? [], leaf)) : leaf[shape.type] ?? v.any();
+}
+
+function objectSchema(fields, leaf) {
+    const entries = /* @__PURE__ */ Object.create(null);
+    for (const f of fields) entries[f.name] = v.optional(shapeValueSchema(f, leaf));
+    return v.looseObject(entries);
+}
+
+function wholeValueSchema(args) {
+    const {entryType: entryType, shape: shape, leaf: leaf} = args;
+    return entryType === "object" ? v.union([ v.null(), objectSchema(shape.fields ?? [], leaf) ]) : entryType === "array" ? v.array(objectSchema(shape.of ?? [], leaf)) : leaf[entryType];
+}
+
+function appendItemSchema(entryType, shape) {
+    if (entryType === "array") return objectSchema(shape.of ?? [], valueSchemas);
+    if (entryType === "doc.refs") return GdrShape;
+    if (entryType === "assignees") return AssigneeShape;
+}
+
+function rejectedRefTypes(args) {
+    const {entryType: entryType, types: types, value: value} = args;
+    if (types === void 0 || value === null || value === void 0) return [];
+    if (entryType !== "doc.ref" && entryType !== "doc.refs") return [];
+    let items = [ value ];
+    return entryType === "doc.refs" && (items = Array.isArray(value) ? value : []), 
+    [ ...new Set(items.map(gdrTypeOf).filter(t => t !== void 0 && !types.includes(t))) ];
+}
+
+function refTypeIssues(args) {
+    const rejected = rejectedRefTypes(args);
+    if (rejected.length === 0) return;
+    const accepts = (args.types ?? []).map(t => `"${t}"`).join(", ");
+    return rejected.map(t => `document type "${t}" is not accepted — this entry accepts ${accepts} (a GDR's \`type\` names the target document's schema type)`);
+}
+
+function gdrTypeOf(item) {
+    if (typeof item != "object" || item === null) return;
+    const t = item.type;
+    return typeof t == "string" ? t : void 0;
+}
+
+function checkFieldValue(args) {
+    return checkValueAgainst(args, valueSchemas);
+}
+
+function checkValueAgainst(args, leaf) {
+    const schema = wholeValueSchema({
+        entryType: args.entryType,
+        shape: args,
+        leaf: leaf
+    });
+    if (schema === void 0) return [ `unknown field entry type ${args.entryType}` ];
+    const result = v.safeParse(schema, args.value);
+    return result.success ? refTypeIssues({
+        entryType: args.entryType,
+        types: args.types,
+        value: args.value
+    }) : formatIssues(result.issues);
+}
+
+function validateFieldValue(args) {
+    const issues = checkFieldValue(args);
+    if (issues !== void 0) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: issues,
+        mode: "value"
+    });
+}
+
+const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]*", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
+
+function isAuthoringRefId(id) {
+    return id.startsWith("@") ? ALIAS_REF_RE.test(id) : id.includes(":") ? isGdrUri(id) : BARE_ID_RE.test(id);
+}
+
+function isBareSeedId(id) {
+    return BARE_ID_RE.test(id);
+}
+
+const AuthoringRefId = v.pipe(v.string(), v.check(isAuthoringRefId, "must be a bare document id, a GDR URI, or a portable `@<alias>:<id>` reference")), AuthoringGdrShape = v.looseObject({
+    id: AuthoringRefId,
+    type: v.pipe(v.string(), v.minLength(1))
+}), seedValueSchemas = {
+    ...valueSchemas,
+    "doc.ref": v.union([ v.null(), AuthoringGdrShape ]),
+    "doc.refs": v.array(AuthoringGdrShape),
+    "release.ref": v.union([ v.null(), v.looseObject({
+        id: AuthoringRefId,
+        type: v.literal("system.release"),
+        releaseName: v.pipe(v.string(), v.minLength(1))
+    }) ])
+};
+
+function checkLiteralSeed(args) {
+    return args.value === null ? [ "a literal seed cannot be null — omit `initialValue` to start the field empty" ] : checkValueAgainst(args, seedValueSchemas);
+}
+
+function validateFieldAppendItem(args) {
+    const schema = appendItemSchema(args.entryType, args);
+    if (schema === void 0) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: [ `field entry type ${args.entryType} does not support append` ],
+        mode: "item"
+    });
+    const result = v.safeParse(schema, args.item);
+    if (!result.success) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: formatIssues(result.issues),
+        mode: "item"
+    });
+    const typeIssues = refTypeIssues({
+        entryType: args.entryType,
+        types: args.types,
+        value: [ args.item ]
+    });
+    if (typeIssues !== void 0) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: typeIssues,
+        mode: "item"
+    });
+}
+
+function formatIssues(issues) {
+    return issues.map(i => {
+        const keys = i.path?.map(p => p.key) ?? [];
+        return `${keys.length > 0 ? `at ${keys.join(".")}: ` : ""}${i.message}`;
+    });
+}
+
+const NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function groqIdentifier(referencedAs) {
+    return v.pipe(v.string(), v.regex(GROQ_IDENTIFIER, `must be a GROQ-safe identifier (letters, digits, underscore; not starting with a digit) because it is referenced as ${referencedAs} in GROQ conditions`));
+}
+
+function picklist(options) {
+    return v.picklist(options, `Invalid option: expected one of ${options.map(o => `"${o}"`).join("|")}`);
+}
+
+function pinned() {
+    return (schema, ..._exact) => schema;
+}
+
+const LiteralSchema = v.strictObject({
+    type: v.literal("literal"),
+    value: v.unknown()
+}), FieldReadSchema = v.strictObject({
+    type: v.literal("fieldRead"),
+    scope: v.optional(v.union([ v.literal("workflow"), v.literal("stage") ])),
+    field: NonEmpty,
+    path: v.optional(v.string())
+}), FieldSourceSchema = v.union([ v.strictObject({
+    type: v.literal("input")
+}), v.strictObject({
+    type: v.literal("query"),
+    query: NonEmpty
+}), LiteralSchema, FieldReadSchema ]), ValueExprSchema = v.lazy(() => v.union([ LiteralSchema, FieldReadSchema, v.strictObject({
+    type: v.literal("param"),
+    param: NonEmpty
+}), v.strictObject({
+    type: v.literal("actor")
+}), v.strictObject({
+    type: v.literal("now")
+}), v.strictObject({
+    type: v.literal("self")
+}), v.strictObject({
+    type: v.literal("stage")
+}), v.strictObject({
+    type: v.literal("object"),
+    fields: v.record(NonEmpty, ValueExprSchema)
+}) ])), StoredFieldRefSchema = v.strictObject({
+    scope: picklist(FIELD_SCOPES),
+    field: NonEmpty
+}), AuthoringFieldRefSchema = v.strictObject({
+    scope: v.optional(picklist(FIELD_SCOPES)),
+    field: NonEmpty
+}), HREF_SCHEMES = [ "http:", "https:" ];
+
+function isHttpUrl(value) {
+    try {
+        return HREF_SCHEMES.includes(new URL(value).protocol);
+    } catch {
+        return !1;
+    }
+}
+
+const UrlString = v.pipe(v.string(), v.url("must be a valid URL"), v.check(isHttpUrl, "must be an http(s) URL"));
+
+function manualTargetSchema(ref) {
+    return v.variant("type", [ v.strictObject({
+        type: v.literal("url"),
+        url: UrlString
+    }), v.strictObject({
+        type: v.literal("field"),
+        field: ref
+    }) ]);
+}
+
+const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v.union([ NonEmpty, AuthoringFieldRefSchema ])), ConditionSchema = NonEmpty;
+
+function opSchemas(targetSchema) {
+    return [ v.strictObject({
+        type: v.literal("field.set"),
+        target: targetSchema,
+        value: ValueExprSchema
+    }), v.strictObject({
+        type: v.literal("field.unset"),
+        target: targetSchema
+    }), v.strictObject({
+        type: v.literal("field.append"),
+        target: targetSchema,
+        value: ValueExprSchema
+    }), v.strictObject({
+        type: v.literal("field.updateWhere"),
+        target: targetSchema,
+        where: ConditionSchema,
+        value: ValueExprSchema
+    }), v.strictObject({
+        type: v.literal("field.removeWhere"),
+        target: targetSchema,
+        where: ConditionSchema
+    }) ];
+}
+
+const StoredFieldOpSchema = v.variant("type", [ ...opSchemas(StoredFieldRefSchema) ]), StoredOpSchema = v.variant("type", [ ...opSchemas(StoredFieldRefSchema), v.strictObject({
+    type: v.literal("status.set"),
+    activity: NonEmpty,
+    status: picklist(ACTIVITY_STATUSES)
+}) ]), AuditOpSchema = v.strictObject({
+    type: v.literal("audit"),
+    target: AuthoringFieldRefSchema,
+    value: ValueExprSchema,
+    stampFields: v.optional(v.strictObject({
+        actor: v.optional(NonEmpty),
+        at: v.optional(NonEmpty)
+    }))
+}), AuthoringOpSchema = v.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), v.strictObject({
+    type: v.literal("status.set"),
+    activity: v.optional(NonEmpty),
+    status: picklist(ACTIVITY_STATUSES)
+}), AuditOpSchema ]), GroupName = v.pipe(v.string(), v.regex(GROQ_IDENTIFIER, "must be an identifier (letters, digits, underscore; not starting with a digit)")), GroupSchema = pinned()(v.strictObject({
+    name: GroupName,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    kind: v.optional(picklist(GROUP_KINDS))
+})), GroupNameList = v.pipe(v.array(GroupName), v.minLength(1, "name at least one group, or omit `group`"), v.check(names => new Set(names).size === names.length, "a group is listed more than once — list each group once")), StoredGroupMembershipSchema = GroupNameList, AuthoringGroupMembershipSchema = v.union([ GroupName, GroupNameList ]);
+
+function groupMembershipNames(group) {
+    return group === void 0 ? [] : typeof group == "string" ? [ group ] : [ ...group ];
+}
+
+const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "release.ref", "string", "text", "number", "boolean", "date", "datetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), FieldEntryName = groqIdentifier("`$fields.<name>`");
+
+function asShape(input) {
+    return typeof input == "object" && input !== null ? input : {};
+}
+
+function compositeShapeOk(input) {
+    const shape = asShape(input);
+    return shape.type === "object" ? Array.isArray(shape.fields) && shape.fields.length > 0 && shape.of === void 0 : shape.type === "array" ? Array.isArray(shape.of) && shape.of.length > 0 && shape.fields === void 0 : shape.fields === void 0 && shape.of === void 0;
+}
+
+function compositeShapeMessage(input) {
+    const shape = asShape(input);
+    return shape.type === "object" ? shape.of !== void 0 ? "an `object` kind declares its sub-fields with `fields`, not `of`" : "an `object` kind needs a non-empty `fields` list of sub-field shapes" : shape.type === "array" ? shape.fields !== void 0 ? "an `array` kind declares its item shape with `of`, not `fields`" : "an `array` kind needs a non-empty `of` list of sub-field shapes" : `\`fields\` / \`of\` are only valid on the \`object\` / \`array\` kinds, not "${String(shape.type)}"`;
+}
+
+function duplicateSubfieldName(input) {
+    const shape = asShape(input);
+    let list = [];
+    Array.isArray(shape.fields) ? list = shape.fields : Array.isArray(shape.of) && (list = shape.of);
+    const seen = /* @__PURE__ */ new Set;
+    for (const item of list) {
+        const name = asShape(item).name;
+        if (typeof name == "string") {
+            if (seen.has(name)) return name;
+            seen.add(name);
+        }
+    }
+}
+
+function compositeChecked(entries) {
+    return v.pipe(v.strictObject(entries), v.check(input => compositeShapeOk(input), issue => compositeShapeMessage(issue.input)), v.check(input => duplicateSubfieldName(input) === void 0, issue => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" — sub-field names must be unique within \`fields\` / \`of\``));
+}
+
+const FieldShapeSchema = v.lazy(() => compositeChecked({
+    type: FieldValueKindSchema,
+    name: FieldEntryName,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    fields: v.optional(v.array(FieldShapeSchema)),
+    of: v.optional(v.array(FieldShapeSchema))
+})), StoredEditableSchema = v.union([ v.literal(!0), NonEmpty ]), AuthoringEditableSchema = v.union([ v.literal(!0), v.array(NonEmpty), NonEmpty ]);
+
+function fieldBase(editable, group) {
+    return {
+        name: FieldEntryName,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        group: v.optional(group),
+        required: v.optional(v.boolean()),
+        initialValue: v.optional(FieldSourceSchema),
+        editable: v.optional(editable)
+    };
+}
+
+function fieldEntryFields(editable, group) {
+    return {
+        type: FieldKindSchema,
+        ...fieldBase(editable, group),
+        types: v.optional(v.pipe(v.array(NonEmpty), v.minLength(1, "declare at least one accepted type, or omit `types` to accept any"))),
+        fields: v.optional(v.array(FieldShapeSchema)),
+        of: v.optional(v.array(FieldShapeSchema))
+    };
+}
+
+function literalSeedIssues(entry) {
+    if (entry.initialValue?.type === "literal") return checkLiteralSeed({
+        entryType: entry.type,
+        value: entry.initialValue.value,
+        types: entry.types,
+        fields: entry.fields,
+        of: entry.of
+    });
+}
+
+function literalSeedCheck() {
+    return v.check(entry => literalSeedIssues(entry) === void 0, issue => `initialValue literal does not fit the declared kind: ${(literalSeedIssues(issue.input) ?? []).join("; ")}`);
+}
+
+function refTypesCheck() {
+    return v.check(entry => entry.types === void 0 || entry.type === "doc.ref" || entry.type === "doc.refs", issue => `\`types\` is only valid on \`doc.ref\` / \`doc.refs\` entries, not "${issue.input.type}"`);
+}
+
+const FieldEntrySchema = pinned()(v.pipe(compositeChecked(fieldEntryFields(StoredEditableSchema, StoredGroupMembershipSchema)), refTypesCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v.pipe(compositeChecked(fieldEntryFields(AuthoringEditableSchema, AuthoringGroupMembershipSchema)), refTypesCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v.strictObject({
+    type: v.literal("claim"),
+    name: FieldEntryName,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    group: v.optional(AuthoringGroupMembershipSchema)
+}));
+
+function listSugarFields(type) {
+    return {
+        type: v.literal(type),
+        ...fieldBase(AuthoringEditableSchema, AuthoringGroupMembershipSchema)
+    };
+}
+
+const TodoListFieldSchema = pinned()(v.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v.union([ RawAuthoringFieldEntrySchema, ClaimFieldSchema, TodoListFieldSchema, NotesFieldSchema ])), EffectSchema = v.strictObject({
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    bindings: v.optional(v.record(v.string(), ConditionSchema)),
+    input: v.optional(v.record(v.string(), v.unknown())),
+    outputs: v.optional(v.array(FieldShapeSchema))
+}), DefinitionRefSchema = v.strictObject({
+    name: NonEmpty,
+    version: v.optional(v.union([ PositiveInt, v.literal("latest") ]))
+}), SubworkflowsSchema = v.strictObject({
+    forEach: NonEmpty,
+    definition: DefinitionRefSchema,
+    with: v.optional(v.record(NonEmpty, ConditionSchema)),
+    context: v.optional(v.record(NonEmpty, ConditionSchema)),
+    onExit: v.optional(picklist([ "detach", "abort" ]))
+}), ActionParamSchema = v.strictObject({
+    type: picklist([ "string", "number", "boolean", "url", "dateTime", "actor", "doc.ref", "doc.refs", "json" ]),
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    required: v.optional(v.boolean())
+});
+
+function actionFields(op, group) {
+    return {
+        name: NonEmpty,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        group: v.optional(group),
+        when: v.optional(ConditionSchema),
+        filter: v.optional(ConditionSchema),
+        params: v.optional(v.array(ActionParamSchema)),
+        ops: v.optional(v.array(op)),
+        effects: v.optional(v.array(EffectSchema)),
+        spawn: v.optional(SubworkflowsSchema)
+    };
+}
+
+const StoredActionSchema = pinned()(v.strictObject({
+    ...actionFields(StoredOpSchema, StoredGroupMembershipSchema),
+    roles: v.optional(v.array(NonEmpty))
+})), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(v.strictObject({
+    ...actionFields(AuthoringOpSchema, AuthoringGroupMembershipSchema),
+    roles: v.optional(v.array(NonEmpty)),
+    status: v.optional(TerminalActivityStatus)
+})), ClaimActionSchema = pinned()(v.strictObject({
+    type: v.literal("claim"),
+    name: NonEmpty,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    group: v.optional(AuthoringGroupMembershipSchema),
+    field: v.union([ NonEmpty, AuthoringFieldRefSchema ]),
+    roles: v.optional(v.array(NonEmpty)),
+    filter: v.optional(ConditionSchema),
+    params: v.optional(v.array(ActionParamSchema)),
+    effects: v.optional(v.array(EffectSchema))
+})), AuthoringActionSchema = pinned()(v.lazy(input => typeof input == "object" && input !== null && "type" in input ? ClaimActionSchema : RawAuthoringActionSchema));
+
+function activityFields({field: field, action: action, target: target, group: group}) {
+    return {
+        name: NonEmpty,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        groups: v.optional(v.array(GroupSchema)),
+        group: v.optional(group),
+        target: v.optional(target),
+        filter: v.optional(ConditionSchema),
+        requirements: v.optional(v.record(NonEmpty, ConditionSchema)),
+        actions: v.optional(v.array(action)),
+        fields: v.optional(v.array(field))
+    };
+}
+
+const StoredActivitySchema = pinned()(v.strictObject(activityFields({
+    field: FieldEntrySchema,
+    action: StoredActionSchema,
+    target: StoredManualTargetSchema,
+    group: StoredGroupMembershipSchema
+}))), AuthoringActivitySchema = pinned()(v.strictObject(activityFields({
+    field: AuthoringFieldEntrySchema,
+    action: AuthoringActionSchema,
+    target: AuthoringManualTargetSchema,
+    group: AuthoringGroupMembershipSchema
+})));
+
+function transitionFields(when) {
+    return {
+        name: NonEmpty,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        to: NonEmpty,
+        when: when
+    };
+}
+
+const StoredTransitionSchema = pinned()(v.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v.strictObject(transitionFields(v.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v.pipe(NonEmpty, v.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = v.variant("type", [ v.strictObject({
+    type: v.literal("self")
+}), v.strictObject({
+    type: v.literal("now")
+}), v.strictObject({
+    type: v.literal("fieldRead"),
+    field: FieldEntryName,
+    path: v.optional(GuardReadPath)
+}), v.strictObject({
+    type: v.literal("effectsRead"),
+    effect: v.pipe(NonEmpty, v.check(name => !name.includes("'"), "an effect name cannot contain `'`")),
+    path: v.optional(GuardReadPath)
+}) ]);
+
+function guardMatchFields(read) {
+    return {
+        types: v.optional(v.array(NonEmpty)),
+        idRefs: v.optional(v.array(read)),
+        idPatterns: v.optional(v.array(NonEmpty)),
+        actions: v.pipe(v.array(GuardActionSchema), v.minLength(1, "a guard must match at least one action"))
+    };
+}
+
+function guardFields(read) {
+    return {
+        name: NonEmpty,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        match: v.strictObject(guardMatchFields(read)),
+        predicate: v.optional(v.string()),
+        metadata: v.optional(v.record(NonEmpty, read))
+    };
+}
+
+const GuardSchema = v.strictObject(guardFields(NonEmpty)), AuthoringGuardSchema = v.strictObject(guardFields(GuardReadSchema));
+
+function stageFields({field: field, activity: activity, transition: transition, guard: guard, editable: editable}) {
+    return {
+        name: NonEmpty,
+        title: v.optional(v.string()),
+        description: v.optional(v.string()),
+        groups: v.optional(v.array(GroupSchema)),
+        activities: v.optional(v.array(activity)),
+        transitions: v.optional(v.array(transition)),
+        guards: v.optional(v.array(guard)),
+        fields: v.optional(v.array(field)),
+        editable: v.optional(v.record(FieldEntryName, editable))
+    };
+}
+
+const StoredStageSchema = pinned()(v.strictObject(stageFields({
+    field: FieldEntrySchema,
+    activity: StoredActivitySchema,
+    transition: StoredTransitionSchema,
+    guard: GuardSchema,
+    editable: StoredEditableSchema
+}))), AuthoringStageSchema = pinned()(v.strictObject(stageFields({
+    field: AuthoringFieldEntrySchema,
+    activity: AuthoringActivitySchema,
+    transition: AuthoringTransitionSchema,
+    guard: AuthoringGuardSchema,
+    editable: AuthoringEditableSchema
+}))), RoleAliasesSchema = v.record(NonEmpty, v.pipe(v.array(NonEmpty), v.minLength(1, "a role alias must list at least one fulfilling role"))), WORKFLOW_LIFECYCLES = [ "standalone", "child" ], START_KINDS = [ "interactive", "autonomous" ];
+
+function startFields(kind) {
+    return {
+        kind: kind,
+        filter: v.optional(ConditionSchema)
+    };
+}
+
+const StoredStartSchema = pinned()(v.strictObject(startFields(picklist(START_KINDS)))), AuthoringStartSchema = pinned()(v.strictObject(startFields(v.optional(picklist(START_KINDS)))));
+
+function workflowFields({field: field, stage: stage, start: start}) {
+    return {
+        name: NonEmpty,
+        title: NonEmpty,
+        description: v.optional(v.string()),
+        groups: v.optional(v.array(GroupSchema)),
+        lifecycle: v.optional(picklist(WORKFLOW_LIFECYCLES)),
+        start: v.optional(start),
+        initialStage: NonEmpty,
+        fields: v.optional(v.array(field)),
+        stages: v.pipe(v.array(stage), v.minLength(1, "must declare at least one stage")),
+        predicates: v.optional(v.record(groqIdentifier("`$<name>`"), ConditionSchema)),
+        roleAliases: v.optional(RoleAliasesSchema)
+    };
+}
+
+const WorkflowDefinitionSchema = pinned()(v.strictObject(workflowFields({
+    field: FieldEntrySchema,
+    stage: StoredStageSchema,
+    start: StoredStartSchema
+})));
+
+function parseStoredDefinition(input, label) {
+    return parseOrThrow({
+        schema: WorkflowDefinitionSchema,
+        input: input,
+        label: label
+    });
+}
+
+const AuthoringWorkflowSchema = pinned()(v.strictObject(workflowFields({
+    field: AuthoringFieldEntrySchema,
+    stage: AuthoringStageSchema,
+    start: AuthoringStartSchema
+}))), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
+
+function isStartableDefinition(definition) {
+    return definition.lifecycle !== "child";
+}
+
+function startKindOf(definition) {
+    return definition.start?.kind ?? "interactive";
+}
+
+function isSubjectEntry(entry) {
+    return entry.required === !0 && (entry.type === "doc.ref" || entry.type === "doc.refs");
+}
+
+function isInputSourced(entry) {
+    return entry.initialValue?.type === "input";
+}
+
+function formatValidationError(label, issues) {
+    const lines = issues.map(issue => `  - ${issue.path.length === 0 ? "(root)" : formatIssuePath(issue.path)}: ${issue.message}`);
+    return `${label} failed validation (${issues.length} issue${issues.length === 1 ? "" : "s"}):\n${lines.join(`\n`)}`;
+}
+
+function issuesFromValibot(issues) {
+    return issues.map(issue => ({
+        path: issue.path ? issue.path.map(item => item.key) : [],
+        message: issue.message
+    }));
+}
+
+function formatIssuePath(path) {
+    let out = "";
+    for (const seg of path) typeof seg == "number" ? out += `[${seg}]` : out += out.length === 0 ? String(seg) : `.${String(seg)}`;
+    return out;
+}
+
+function parseOrThrow({schema: schema, input: input, label: label}) {
+    const result = v.safeParse(schema, input);
+    if (!result.success) throw new Error(formatValidationError(label, issuesFromValibot(result.issues)));
+    return result.output;
+}
+
+function labelFor(fn, value) {
+    if (value && typeof value == "object" && "name" in value) {
+        const raw = value.name;
+        if (typeof raw == "string") return `${fn}("${raw}")`;
+    }
+    return fn;
+}
+
+function knownList(ids) {
+    const quoted = [ ...ids ].map(s => `"${s}"`);
+    return quoted.length > 0 ? quoted.join(", ") : "(none)";
+}
+
+function checkDuplicates({names: names, what: what, issues: issues}) {
+    const seen = /* @__PURE__ */ new Set;
+    for (const {name: name, path: path} of names) seen.has(name) && issues.push({
+        path: path,
+        message: `duplicate ${what} "${name}" (already declared earlier)`
+    }), seen.add(name);
+    return seen;
+}
+
+function checkStages(def, issues) {
+    const stageNames = checkDuplicates({
+        names: def.stages.map((stage, i) => ({
+            name: stage.name,
+            path: [ "stages", i, "name" ]
+        })),
+        what: "stage name",
+        issues: issues
+    });
+    for (const [i, stage] of def.stages.entries()) {
+        const activityNames = checkDuplicates({
+            names: (stage.activities ?? []).map((activity, j) => ({
+                name: activity.name,
+                path: [ "stages", i, "activities", j, "name" ]
+            })),
+            what: `activity name in stage "${stage.name}"`,
+            issues: issues
+        });
+        checkDuplicates({
+            names: (stage.transitions ?? []).map((t, k) => ({
+                name: t.name,
+                path: [ "stages", i, "transitions", k, "name" ]
+            })),
+            what: `transition name in stage "${stage.name}"`,
+            issues: issues
+        }), checkActivities({
+            def: def,
+            i: i,
+            activityNames: activityNames,
+            issues: issues
+        });
+    }
+    return stageNames;
+}
+
+function checkActivities({def: def, i: i, activityNames: activityNames, issues: issues}) {
+    const stage = def.stages[i];
+    for (const [j, activity] of (stage.activities ?? []).entries()) {
+        const path = [ "stages", i, "activities", j ];
+        checkDuplicates({
+            names: (activity.actions ?? []).map((action, a) => ({
+                name: action.name,
+                path: [ ...path, "actions", a, "name" ]
+            })),
+            what: `action name in activity "${activity.name}"`,
+            issues: issues
+        }), checkStatusSetTargets({
+            activity: activity,
+            activityNames: activityNames,
+            path: path,
+            issues: issues
+        });
+    }
+}
+
+function checkStatusSetTargets({activity: activity, activityNames: activityNames, path: path, issues: issues}) {
+    for (const [a, action] of (activity.actions ?? []).entries()) checkStatusSetOps({
+        ops: action.ops,
+        activityNames: activityNames,
+        path: [ ...path, "actions", a, "ops" ],
+        issues: issues
+    });
+}
+
+function checkStatusSetOps({ops: ops, activityNames: activityNames, path: path, issues: 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: def, stageNames: stageNames, issues: 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: def, stageNames: stageNames, issues: issues}) {
+    for (const [i, stage] of def.stages.entries()) for (const [k, t] of (stage.transitions ?? []).entries()) stageNames.has(t.to) || issues.push({
+        path: [ "stages", i, "transitions", k, "to" ],
+        message: `transition target "${t.to}" is not a declared stage. Known stages: ${knownList(stageNames)}`
+    });
+}
+
+function checkStageReachability({def: def, stageNames: stageNames, issues: issues}) {
+    if (!stageNames.has(def.initialStage)) return;
+    const stagesByName = /* @__PURE__ */ new Map;
+    for (const stage of def.stages) stagesByName.has(stage.name) || stagesByName.set(stage.name, stage);
+    const reached = /* @__PURE__ */ new Set([ def.initialStage ]), frontier = [ def.initialStage ];
+    for (;frontier.length > 0; ) {
+        const stage = stagesByName.get(frontier.pop());
+        for (const t of stage?.transitions ?? []) reached.has(t.to) || !stageNames.has(t.to) || (reached.add(t.to), 
+        frontier.push(t.to));
+    }
+    for (const [i, stage] of def.stages.entries()) reached.has(stage.name) || issues.push({
+        path: [ "stages", i, "name" ],
+        message: `stage "${stage.name}" is unreachable — no transition path leads from initialStage "${def.initialStage}" to it, so no instance can ever enter it. Add a transition targeting it, or remove the stage`
+    });
+}
+
+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({
+        effects: action.effects,
+        path: [ "stages", i, "activities", j, "actions", a, "effects" ],
+        sites: sites
+    });
+    return sites;
+}
+
+function checkEffectNames(def, issues) {
+    checkDuplicates({
+        names: effectNameSites(def),
+        what: "effect name (registry key — unique per definition)",
+        issues: issues
+    });
+}
+
+function collectEffects({effects: effects, path: path, sites: sites}) {
+    for (const [e, effect] of (effects ?? []).entries()) sites.push({
+        name: effect.name,
+        path: [ ...path, e, "name" ]
+    });
+}
+
+function checkGuardNames(def, issues) {
+    const sites = def.stages.flatMap((stage, i) => (stage.guards ?? []).map((guard, g) => ({
+        name: guard.name,
+        path: [ "stages", i, "guards", g, "name" ]
+    })));
+    checkDuplicates({
+        names: sites,
+        what: "guard name (the guard lake _id derives from it — unique per definition)",
+        issues: issues
+    });
+}
+
+function fieldScopes(def) {
+    const scopes = [ {
+        entries: def.fields,
+        scope: "workflow",
+        path: [ "fields" ],
+        label: "workflow fields"
+    } ];
+    for (const [i, stage] of def.stages.entries()) {
+        scopes.push({
+            entries: stage.fields,
+            scope: "stage",
+            path: [ "stages", i, "fields" ],
+            label: `stage "${stage.name}" fields`
+        });
+        for (const [j, activity] of (stage.activities ?? []).entries()) scopes.push({
+            entries: activity.fields,
+            scope: "activity",
+            path: [ "stages", i, "activities", j, "fields" ],
+            label: `activity "${activity.name}" fields`
+        });
+    }
+    return scopes;
+}
+
+function checkRequiredField(def, issues) {
+    for (const {entries: entries, scope: scope, path: path, label: label} of fieldScopes(def)) for (const [n, entry] of (entries ?? []).entries()) if (entry.required === !0) {
+        if (scope !== "workflow") issues.push({
+            path: [ ...path, n, "required" ],
+            message: `${label} entry "${entry.name}" is \`required\`, but \`required\` applies only to workflow-scope \`input\` entries — only those are caller-supplied at start/spawn`
+        }); else if (entry.initialValue?.type !== "input") {
+            const seed = entry.initialValue?.type ?? "working memory (no initialValue)";
+            issues.push({
+                path: [ ...path, n, "required" ],
+                message: `field entry "${entry.name}" has initialValue "${seed}" — \`required\` applies only to \`input\`-sourced entries (the caller fills them at start/spawn)`
+            });
+        }
+    }
+}
+
+function checkFieldEntryNames(def, issues) {
+    for (const {entries: entries, path: path, label: label} of fieldScopes(def)) checkDuplicates({
+        names: (entries ?? []).map((entry, n) => ({
+            name: entry.name,
+            path: [ ...path, n, "name" ]
+        })),
+        what: `field entry name in ${label}`,
+        issues: issues
+    });
+}
+
+function checkPredicates(def, issues) {
+    const reserved = new Set(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} — pick another name`
+    });
+    for (const [name, groq2] of Object.entries(def.predicates ?? {})) checkPredicateBody({
+        name: name,
+        groq: groq2,
+        names: names,
+        issues: issues
+    });
+}
+
+function checkPredicateBody({name: name, groq: groq2, names: names, issues: issues}) {
+    const reads = conditionParameterNames(groq2);
+    for (const caller of CALLER_BOUND_VARS) reads.has(caller) && issues.push({
+        path: [ "predicates", name ],
+        message: `predicate "${name}" reads $${caller} — predicates are instance-level (pre-evaluated once, without a caller); compose caller gates at the condition site instead`
+    });
+    for (const other of names) other === name || !reads.has(other) || issues.push({
+        path: [ "predicates", name ],
+        message: `predicate "${name}" references predicate $${other} — predicates may read built-in vars only (no cross-references; compose at the condition site instead)`
+    });
+}
+
+function entryNames(entries) {
+    return new Set((entries ?? []).map(entry => entry.name));
+}
+
+function checkUnboundCallerVars(def, issues) {
+    for (const site of conditionSites(def)) {
+        const reads = conditionParameterNames(site.groq);
+        for (const name of unboundCallerVars(site.policy)) reads.has(name) && issues.push({
+            path: site.path,
+            message: callerVarMessage(site, name)
+        });
+    }
+}
+
+function unboundCallerVars(policy) {
+    return policy === "cascade" ? CALLER_BOUND_VARS : policy === "caller-bound" ? [ "params" ] : policy === "triggered-payload" ? [ "can", "params" ] : [ "can" ];
+}
+
+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`;
+}
+
+function conditionSites(def) {
+    const sites = [], workflowLayer = {
+        scope: "workflow",
+        names: entryNames(def.fields)
+    };
+    collectEditableSites({
+        entries: def.fields,
+        path: [ "fields" ],
+        labelPrefix: "workflow",
+        fields: "context-dependent",
+        sites: sites
+    });
+    for (const [i, stage] of def.stages.entries()) collectStageConditionSites({
+        stage: stage,
+        i: i,
+        workflowLayer: workflowLayer,
+        sites: sites
+    });
+    return sites;
+}
+
+function collectStageConditionSites({stage: stage, i: i, workflowLayer: workflowLayer, sites: sites}) {
+    const stageLayer = {
+        scope: "stage",
+        names: entryNames(stage.fields)
+    }, stageFields2 = [ stageLayer, workflowLayer ], editableWindow = [ stageLayer, workflowLayer, ...(stage.activities ?? []).map(activity => ({
+        scope: "activity",
+        names: entryNames(activity.fields)
+    })) ];
+    for (const [k, t] of (stage.transitions ?? []).entries()) sites.push({
+        groq: t.when,
+        path: [ "stages", i, "transitions", k, "when" ],
+        label: `transition "${t.name}" when`,
+        policy: "cascade",
+        fields: stageFields2
+    });
+    collectEditableSites({
+        entries: stage.fields,
+        path: [ "stages", i, "fields" ],
+        labelPrefix: `stage "${stage.name}"`,
+        fields: editableWindow,
+        sites: sites
+    });
+    for (const [name, editable] of Object.entries(stage.editable ?? {})) typeof editable == "string" && sites.push({
+        groq: editable,
+        path: [ "stages", i, "editable", name ],
+        label: `stage "${stage.name}" editable override "${name}"`,
+        policy: "caller-bound",
+        fields: editableWindow
+    });
+    for (const [j, activity] of (stage.activities ?? []).entries()) collectActivityConditionSites({
+        activity: activity,
+        path: [ "stages", i, "activities", j ],
+        stageFields: stageFields2,
+        sites: sites
+    });
+}
+
+function collectEditableSites({entries: entries, path: path, labelPrefix: labelPrefix, fields: fields, sites: sites}) {
+    for (const [n, entry] of (entries ?? []).entries()) typeof entry.editable == "string" && sites.push({
+        groq: entry.editable,
+        path: [ ...path, n, "editable" ],
+        label: `${labelPrefix} field "${entry.name}" editable`,
+        policy: "caller-bound",
+        fields: fields
+    });
+}
+
+function collectOpWhereSites({ops: ops, path: path, label: label, policy: policy, fields: fields, sites: 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`,
+        ...policy !== void 0 ? {
+            policy: policy
+        } : {},
+        fields: fields
+    });
+}
+
+function collectActivityConditionSites({activity: activity, path: path, stageFields: stageFields2, sites: sites}) {
+    const fields = [ {
+        scope: "activity",
+        names: entryNames(activity.fields)
+    }, ...stageFields2 ];
+    activity.filter !== void 0 && sites.push({
+        groq: activity.filter,
+        path: [ ...path, "filter" ],
+        label: `activity "${activity.name}".filter`,
+        policy: "cascade",
+        fields: fields
+    });
+    for (const [name, groq2] of Object.entries(activity.requirements ?? {})) sites.push({
+        groq: groq2,
+        path: [ ...path, "requirements", name ],
+        label: `activity "${activity.name}" requirement "${name}"`,
+        policy: "caller-bound",
+        fields: fields
+    });
+    collectEditableSites({
+        entries: activity.fields,
+        path: [ ...path, "fields" ],
+        labelPrefix: `activity "${activity.name}"`,
+        fields: fields,
+        sites: sites
+    }), collectActionConditionSites({
+        activity: activity,
+        path: path,
+        fields: fields,
+        sites: sites
+    });
+}
+
+function collectActionConditionSites({activity: activity, path: path, fields: fields, sites: sites}) {
+    for (const [a, action] of (activity.actions ?? []).entries()) {
+        const actionPath = [ ...path, "actions", a ], cascadeFired = action.when !== void 0;
+        action.when !== void 0 && sites.push({
+            groq: action.when,
+            path: [ ...actionPath, "when" ],
+            label: `action "${action.name}" when`,
+            policy: "cascade",
+            fields: fields
+        }), action.filter !== void 0 && sites.push({
+            groq: action.filter,
+            path: [ ...actionPath, "filter" ],
+            label: `action "${action.name}" filter`,
+            policy: cascadeFired ? "cascade" : "caller-bound",
+            fields: fields
+        });
+        const payloadPolicy = cascadeFired ? "triggered-payload" : void 0;
+        collectBindingSites({
+            effects: action.effects,
+            path: [ ...actionPath, "effects" ],
+            label: `action "${action.name}"`,
+            policy: payloadPolicy,
+            fields: fields,
+            sites: sites
+        }), collectOpWhereSites({
+            ops: action.ops,
+            path: [ ...actionPath, "ops" ],
+            label: `action "${action.name}"`,
+            policy: payloadPolicy,
+            fields: fields,
+            sites: sites
+        }), collectSpawnSites({
+            action: action,
+            path: actionPath,
+            fields: fields,
+            sites: sites
+        });
+    }
+}
+
+function collectSpawnSites({action: action, path: path, fields: fields, sites: sites}) {
+    const spawn = action.spawn;
+    if (spawn === void 0) return;
+    const spawnPath = [ ...path, "spawn" ];
+    sites.push({
+        groq: spawn.forEach,
+        path: [ ...spawnPath, "forEach" ],
+        label: `action "${action.name}".spawn.forEach`,
+        policy: "cascade",
+        fields: fields
+    });
+    for (const [group, record] of [ [ "with", spawn.with ], [ "context", spawn.context ] ]) for (const [key, groq2] of Object.entries(record ?? {})) sites.push({
+        groq: groq2,
+        path: [ ...spawnPath, group, key ],
+        label: `action "${action.name}".spawn.${group} "${key}"`,
+        policy: "triggered-payload",
+        fields: fields
+    });
+}
+
+function collectBindingSites({effects: effects, path: path, label: label, policy: policy, fields: fields, sites: sites}) {
+    for (const [e, effect] of (effects ?? []).entries()) for (const [key, groq2] of Object.entries(effect.bindings ?? {})) sites.push({
+        groq: groq2,
+        path: [ ...path, e, "bindings", key ],
+        label: `${label} effect "${effect.name}" binding "${key}"`,
+        ...policy !== void 0 ? {
+            policy: policy
+        } : {},
+        fields: fields
+    });
+}
+
+function checkAssigneesEntries(def, issues) {
+    for (const {entries: entries, path: path} of fieldScopes(def)) (entries ?? []).filter(e => e.type === "assignees").length <= 1 || issues.push({
+        path: path,
+        message: "at most one assignees-kind field entry per scope — the inbox reads it by kind"
+    });
+}
+
+function checkActivityTerminalPaths(def, issues) {
+    for (const [i, stage] of def.stages.entries()) {
+        const resolvable = terminallyResolvableActivities(stage);
+        for (const [j, activity] of (stage.activities ?? []).entries()) resolvable.has(activity.name) || issues.push({
+            path: [ "stages", i, "activities", j ],
+            message: `activity "${activity.name}" has no path to a terminal status — no action in stage "${stage.name}" resolves it (\`status: 'done'\` on one of its actions, a \`{when: <condition>, status: 'done'}\` trigger, or a sibling's \`status.set\`), so it can never finish and the stage's \`$allActivitiesDone\` gate would wedge`
+        });
+    }
+}
+
+function terminallyResolvableActivities(stage) {
+    const terminalSets = (stage.activities ?? []).flatMap(activity => activity.actions ?? []).flatMap(action => action.ops ?? []).filter(op => op.type === "status.set").filter(op => TERMINAL_ACTIVITY_STATUSES.includes(op.status));
+    return new Set(terminalSets.map(op => op.activity));
+}
+
+function checkTerminalStageActivities(def, issues) {
+    for (const [i, stage] of def.stages.entries()) (stage.transitions ?? []).length > 0 || (stage.activities ?? []).length === 0 || issues.push({
+        path: [ "stages", i, "activities" ],
+        message: `stage "${stage.name}" is terminal (no transitions) but declares activities — entering a terminal stage completes the instance, so they can never run. Move the work to a \`when\` action in the source stage (it commits in the hop that moves here), or give the stage a transition out`
+    });
+}
+
+function storedRolesIssue(action) {
+    if (action.roles !== void 0) {
+        if (action.roles.length === 0) return `action "${action.name}" stores \`roles: []\`, which names no roles — the runtime reads an empty pin as "anyone may execute", the opposite of a pin. Omit \`roles\` to allow any identity, or list at least one role`;
+        if (action.when === void 0) return `action "${action.name}" stores \`roles\` but is fireAction-fired (no \`when\`) — the stored pin is only read on cascade fires. Author \`roles\` normally (it desugars into the action's \`filter\`), or add \`when\` to make it a trigger`;
+    }
+}
+
+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()) {
+        const message = storedRolesIssue(action);
+        message !== void 0 && issues.push({
+            path: [ "stages", i, "activities", j, "actions", a, "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" ],
+        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`
+    });
+}
+
+function checkStart(def, issues) {
+    if (def.start !== void 0 && (def.lifecycle === "child" && issues.push({
+        path: [ "start" ],
+        message: "a spawn-only (lifecycle 'child') definition declares `start` — children are instantiated by a parent's `spawn`, never started standalone, so the block would never apply. Remove `start`, or drop `lifecycle: 'child'`"
+    }), checkStartFilterReads(def, issues), def.start.kind === "autonomous")) for (const [n, entry] of (def.fields ?? []).entries()) entry.required !== !0 || isSubjectEntry(entry) || issues.push({
+        path: [ "fields", n, "required" ],
+        message: `start.kind 'autonomous' means runs are initiated by a system reacting to a document, so every required input must be derivable from that triggering document — required entry "${entry.name}" (kind "${entry.type}") is not a document reference. Make it optional, seed it another way (query/literal), or declare it doc.ref / doc.refs`
+    });
+}
+
+function checkStartFilterReads(def, issues) {
+    const filter = def.start?.filter;
+    if (filter === void 0) return;
+    const bindable = new Set((def.fields ?? []).filter(isInputSourced).map(entry => entry.name)), declared = new Set((def.fields ?? []).map(entry => entry.name));
+    for (const name of conditionFieldReadNames(filter)) bindable.has(name) || issues.push({
+        path: [ "start", "filter" ],
+        message: declared.has(name) ? `start.filter reads $fields.${name}, but "${name}" is not an \`input\`-sourced entry — $fields binds only the caller's input entries (query/literal/fieldRead entries resolve at materialisation, after any read-side evaluation), so the read is GROQ null and the filter silently never passes. Bindable (input) fields: ${knownList(bindable)}` : `start.filter reads $fields.${name}, but no workflow-scope field entry named "${name}" is declared — $fields binds only the caller's input entries, so the read is GROQ null and the filter silently never passes. Bindable (input) fields: ${knownList(bindable)}`
+    });
+    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 required subject entry (a required doc.ref / doc.refs input) — a read surface would never have a document to bind as root, so the filter could never pass. Declare a required subject entry, or gate on $fields / the dataset instead"
+    });
+}
+
+function checkGroups(def, issues) {
+    const workflowGroups = checkGroupDeclarations({
+        groups: def.groups,
+        path: [ "groups" ],
+        what: "group name",
+        issues: issues
+    });
+    checkFieldMemberships({
+        entries: def.fields,
+        reachable: [ workflowGroups ],
+        path: [ "fields" ],
+        label: "workflow fields",
+        issues: issues
+    });
+    for (const [i, stage] of def.stages.entries()) checkStageGroups({
+        stage: stage,
+        i: i,
+        workflowGroups: workflowGroups,
+        issues: issues
+    });
+}
+
+function checkGroupDeclarations({groups: groups, path: path, what: what, issues: issues}) {
+    return checkDuplicates({
+        names: (groups ?? []).map((group, n) => ({
+            name: group.name,
+            path: [ ...path, n, "name" ]
+        })),
+        what: what,
+        issues: issues
+    });
+}
+
+function checkStageGroups({stage: stage, i: i, workflowGroups: workflowGroups, issues: issues}) {
+    const path = [ "stages", i ], enclosing = [ checkGroupDeclarations({
+        groups: stage.groups,
+        path: [ ...path, "groups" ],
+        what: `group name in stage "${stage.name}"`,
+        issues: issues
+    }), workflowGroups ];
+    checkFieldMemberships({
+        entries: stage.fields,
+        reachable: enclosing,
+        path: [ ...path, "fields" ],
+        label: `stage "${stage.name}" fields`,
+        issues: issues
+    });
+    for (const [j, activity] of (stage.activities ?? []).entries()) checkActivityGroups({
+        activity: activity,
+        path: [ ...path, "activities", j ],
+        enclosing: enclosing,
+        issues: issues
+    });
+}
+
+function checkActivityGroups({activity: activity, path: path, enclosing: enclosing, issues: issues}) {
+    checkGroupMembership({
+        group: activity.group,
+        reachable: enclosing,
+        path: [ ...path, "group" ],
+        label: `activity "${activity.name}"`,
+        issues: issues
+    });
+    const inner = [ checkGroupDeclarations({
+        groups: activity.groups,
+        path: [ ...path, "groups" ],
+        what: `group name in activity "${activity.name}"`,
+        issues: issues
+    }), ...enclosing ];
+    checkFieldMemberships({
+        entries: activity.fields,
+        reachable: inner,
+        path: [ ...path, "fields" ],
+        label: `activity "${activity.name}" fields`,
+        issues: issues
+    });
+    for (const [a, action] of (activity.actions ?? []).entries()) checkGroupMembership({
+        group: action.group,
+        reachable: inner,
+        path: [ ...path, "actions", a, "group" ],
+        label: `action "${action.name}"`,
+        issues: issues
+    });
+}
+
+function checkFieldMemberships({entries: entries, reachable: reachable, path: path, label: label, issues: issues}) {
+    for (const [n, entry] of (entries ?? []).entries()) checkGroupMembership({
+        group: entry.group,
+        reachable: reachable,
+        path: [ ...path, n, "group" ],
+        label: `${label} entry "${entry.name}"`,
+        issues: issues
+    });
+}
+
+function checkGroupMembership({group: group, reachable: reachable, path: path, label: label, issues: issues}) {
+    for (const name of groupMembershipNames(group)) {
+        if (reachable.some(names => names.has(name))) continue;
+        const declared = new Set(reachable.flatMap(names => [ ...names ]));
+        issues.push({
+            path: path,
+            message: `${label} names group "${name}", which is not declared on its enclosing chain. Declared: ${knownList(declared)}`
+        });
+    }
+}
+
+function checkConditionFieldReads(def, issues) {
+    const everywhere = allDeclaredFieldNames(def);
+    for (const site of conditionSites(def)) for (const name of conditionFieldReadNames(site.groq)) fieldVisibleAtSite({
+        site: site,
+        name: name,
+        everywhere: everywhere
+    }) || issues.push({
+        path: site.path,
+        message: undeclaredFieldReadMessage(site, name)
+    });
+    for (const [name, groq2] of Object.entries(def.predicates ?? {})) for (const read of conditionFieldReadNames(groq2)) everywhere.has(read) || issues.push({
+        path: [ "predicates", name ],
+        message: noFieldAnywhereMessage(`predicate "${name}"`, read)
+    });
+}
+
+function allDeclaredFieldNames(def) {
+    const names = /* @__PURE__ */ new Set;
+    for (const {entries: entries} of fieldScopes(def)) for (const entry of entries ?? []) names.add(entry.name);
+    return names;
+}
+
+function fieldVisibleAtSite({site: site, name: name, everywhere: everywhere}) {
+    return site.fields === "context-dependent" ? everywhere.has(name) : site.fields.some(layer => layer.names.has(name));
+}
+
+function noFieldAnywhereMessage(label, name) {
+    return `${label} reads $fields.${name}, but no field entry named "${name}" is declared anywhere in the definition — the read evaluates to GROQ null, so the condition silently fails closed`;
+}
+
+function undeclaredFieldReadMessage(site, name) {
+    if (site.fields === "context-dependent") return noFieldAnywhereMessage(site.label, name);
+    const visible = site.fields.flatMap(layer => [ ...layer.names ].map(n => `${layer.scope}:${n}`));
+    return `${site.label} reads $fields.${name}, but no field entry named "${name}" is lexically visible here — the read evaluates to GROQ null, so the condition silently fails closed. Visible: ${visible.join(", ") || "(none)"}`;
+}
+
+function checkFieldReadSeeds(def, issues) {
+    const workflowEntries = def.fields ?? [];
+    for (const {entries: entries, scope: scope, path: path, label: label} of fieldScopes(def)) for (const [n, entry] of (entries ?? []).entries()) {
+        const read = entry.initialValue;
+        read?.type === "fieldRead" && checkSeedRead({
+            read: read,
+            where: `${label} entry "${entry.name}"`,
+            entryName: entry.name,
+            scope: scope,
+            siblings: entries ?? [],
+            index: n,
+            workflowEntries: workflowEntries,
+            path: [ ...path, n, "initialValue" ],
+            issues: issues
+        });
+    }
+}
+
+function checkSeedRead(args) {
+    const {read: read, where: where, path: path, issues: issues} = args, misspelled = seedScopeSpellingIssue(args);
+    if (misspelled !== void 0) {
+        issues.push({
+            path: path,
+            message: `${where} ${misspelled}`
+        });
+        return;
+    }
+    const target = read.scope === "workflow" ? seedWorkflowTarget(args) : seedEarlierSiblingTarget(args);
+    target !== void 0 && pushFieldReadPathIssue({
+        where: where,
+        read: read,
+        target: target,
+        path: path,
+        issues: issues
+    });
+}
+
+function seedScopeSpellingIssue({read: read, scope: scope}) {
+    if (read.scope === "workflow" && scope === "workflow") return 'seeds from a fieldRead with scope "workflow", but workflow-scope seeds resolve against earlier same-scope siblings only (no workflow layer exists yet at start/spawn) — omit `scope`';
+    if (read.scope === "stage") {
+        if (scope === "workflow") return 'seeds from a fieldRead with scope "stage", but a workflow-scope entry has no stage in scope — omit `scope` to read an earlier workflow-scope sibling';
+        if (scope === "activity") return 'seeds from a fieldRead with scope "stage", but a seed resolves non-workflow reads against the scope being seeded, so an activity-scope entry cannot read stage fields — omit `scope` to read an earlier activity-scope sibling, or use scope "workflow"';
+    }
+}
+
+function seedWorkflowTarget({read: read, where: where, workflowEntries: workflowEntries, path: path, issues: issues}) {
+    const target = workflowEntries.find(entry => entry.name === read.field);
+    if (target !== void 0) return target;
+    issues.push({
+        path: path,
+        message: `${where} seeds from workflow-scope field "${read.field}", which is not declared — the read would resolve to the default value. Known workflow fields: ${knownList(workflowEntries.map(entry => entry.name))}`
+    });
+}
+
+function seedEarlierSiblingTarget(args) {
+    const {read: read, where: where, entryName: entryName, scope: scope, siblings: siblings, index: index, workflowEntries: workflowEntries, path: path, issues: issues} = args, targetIndex = siblings.findIndex(entry => entry.name === read.field);
+    if (targetIndex !== -1 && targetIndex < index) return siblings[targetIndex];
+    if (targetIndex === index) {
+        issues.push({
+            path: path,
+            message: `${where} seeds from itself — a fieldRead cannot read the entry it seeds`
+        });
+        return;
+    }
+    if (targetIndex > index) {
+        issues.push({
+            path: path,
+            message: `${where} seeds from "${read.field}", which is declared later in the same scope — entries resolve in declaration order, so the read would see its default. Move "${read.field}" before "${entryName}"`
+        });
+        return;
+    }
+    const workflowHint = scope !== "workflow" && workflowEntries.some(entry => entry.name === read.field) ? ' — a workflow-scope entry of that name exists; add `scope: "workflow"` to read it (an omitted scope reads same-scope siblings only)' : "";
+    issues.push({
+        path: path,
+        message: `${where} seeds from "${read.field}", which is not an earlier ${scope}-scope sibling — the read would resolve to the default value${workflowHint}. Earlier siblings: ${knownList(siblings.slice(0, index).map(entry => entry.name))}`
+    });
+}
+
+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({
+        ops: action.ops,
+        path: [ "stages", i, "activities", j, "actions", a, "ops" ],
+        label: `action "${action.name}"`,
+        stage: stage,
+        activity: activity
+    });
+    return sites;
+}
+
+function checkFieldReadOpValues(def, issues) {
+    const workflowEntries = def.fields ?? [];
+    for (const site of opSites(def)) checkOpsFieldReads({
+        workflowEntries: workflowEntries,
+        stageEntries: site.stage.fields ?? [],
+        issues: issues,
+        ops: site.ops,
+        path: site.path,
+        label: site.label,
+        activityNames: entryNames(site.activity.fields)
+    });
+}
+
+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({
+        ...ctx,
+        read: read,
+        path: readPath,
+        where: `${label} ${op.type} value`
+    });
+}
+
+function fieldReadsIn(value, path) {
+    return value.type === "fieldRead" ? [ {
+        read: value,
+        path: path
+    } ] : value.type !== "object" ? [] : Object.entries(value.fields).flatMap(([key, sub]) => fieldReadsIn(sub, [ ...path, "fields", key ]));
+}
+
+function checkOpFieldRead({read: read, where: where, path: path, workflowEntries: workflowEntries, stageEntries: stageEntries, activityNames: activityNames, issues: issues}) {
+    const hosts = [ {
+        scope: "stage",
+        entries: stageEntries
+    }, {
+        scope: "workflow",
+        entries: workflowEntries
+    } ].filter(host => read.scope === void 0 || host.scope === read.scope), target = hosts.flatMap(host => host.entries).find(entry => entry.name === read.field);
+    if (target === void 0) {
+        issues.push({
+            path: path,
+            message: opFieldReadMissMessage({
+                read: read,
+                where: where,
+                hosts: hosts,
+                activityNames: activityNames
+            })
+        });
+        return;
+    }
+    pushFieldReadPathIssue({
+        where: where,
+        read: read,
+        target: target,
+        path: path,
+        issues: issues
+    });
+}
+
+function opFieldReadMissMessage({read: read, where: where, hosts: hosts, activityNames: activityNames}) {
+    const searched = read.scope === void 0 ? "stage or workflow scope" : `${read.scope} scope`, activityHint = activityNames?.has(read.field) ? ` "${read.field}" is an activity-scope field, and op-time field reads resolve against stage and workflow scopes only — declare it at stage scope to read it from an op.` : "", known = hosts.flatMap(host => host.entries.map(entry => `${host.scope}:${entry.name}`));
+    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.${activityHint} Known: ${known.join(", ") || "(none)"}`;
+}
+
+function checkUpdateWhereOps(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({
+            op: op,
+            path: [ ...site.path, o ],
+            label: site.label,
+            scopes: scopes,
+            issues: issues
+        }), checkUpdateWhereMergeKeys({
+            op: op,
+            path: [ ...site.path, o ],
+            label: site.label,
+            issues: issues
+        });
+    }
+}
+
+function checkUpdateWhereTargetKind({op: op, path: path, label: label, scopes: scopes, 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)}`
+    });
+}
+
+function rowOpsHint(type) {
+    return type === "doc.refs" || type === "assignees" ? `; to add or drop ${type} rows use field.append / field.removeWhere` : "";
+}
+
+function checkUpdateWhereMergeKeys({op: op, path: path, label: label, issues: issues}) {
+    if (op.value.type === "object") for (const key of Object.keys(op.value.fields)) key !== "_key" && key !== "_type" || issues.push({
+        path: [ ...path, "value", "fields", key ],
+        message: `${label} field.updateWhere merge writes the reserved row key "${key}" — row identity and bookkeeping are engine-stamped, and a merge would restamp every matched row with the same literal`
+    });
+}
+
+function checkGuardFieldReads(def, issues) {
+    const reads = {
+        workflowEntries: def.fields ?? [],
+        effectNames: new Set(effectNameSites(def).map(site => site.name)),
+        issues: issues
+    };
+    for (const [i, stage] of def.stages.entries()) for (const [g, guard] of (stage.guards ?? []).entries()) {
+        const where = `stage "${stage.name}" guard "${guard.name}"`, guardPath = [ "stages", i, "guards", g ];
+        for (const [k, expr] of (guard.match.idRefs ?? []).entries()) checkGuardRead({
+            ...reads,
+            expr: expr,
+            where: `${where} match.idRefs`,
+            path: [ ...guardPath, "match", "idRefs", k ]
+        });
+        for (const [key, expr] of Object.entries(guard.metadata ?? {})) checkGuardRead({
+            ...reads,
+            expr: expr,
+            where: `${where} metadata "${key}"`,
+            path: [ ...guardPath, "metadata", key ]
+        });
+    }
+}
+
+function checkGuardRead(args) {
+    const fieldRead = FIELD_READ.exec(args.expr);
+    if (fieldRead !== null) {
+        checkGuardFieldRead({
+            ...args,
+            name: fieldRead[1],
+            valuePath: fieldRead[2]
+        });
+        return;
+    }
+    const effectName = EFFECTS_READ.exec(args.expr)?.[1];
+    effectName === void 0 || args.effectNames.has(effectName) || args.issues.push({
+        path: args.path,
+        message: `${args.where} reads "${args.expr}", but no effect named "${effectName}" is declared — the read resolves to undefined and the guard deploys with a hole. Known effects: ${knownList(args.effectNames)}`
+    });
+}
+
+function checkGuardFieldRead({name: name, valuePath: valuePath, where: where, path: path, workflowEntries: workflowEntries, issues: issues}) {
+    const target = workflowEntries.find(entry => entry.name === name);
+    if (target === void 0) {
+        issues.push({
+            path: path,
+            message: `${where} reads "$fields.${name}", but "${name}" is not a workflow-scope field entry — guard reads resolve against workflow-scope fields only. Known workflow fields: ${knownList(workflowEntries.map(entry => entry.name))}`
+        });
+        return;
+    }
+    pushFieldReadPathIssue({
+        where: where,
+        read: {
+            field: name,
+            path: valuePath
+        },
+        target: target,
+        path: path,
+        issues: issues
+    });
+}
+
+function pushFieldReadPathIssue({where: where, read: read, target: target, path: path, issues: issues}) {
+    if (read.path === void 0) return;
+    const pathIssue = fieldValuePathIssue({
+        target: target,
+        path: read.path
+    });
+    pathIssue !== void 0 && issues.push({
+        path: path,
+        message: `${where} reads "${read.field}" with path "${read.path}", which does not fit the declared shape of "${target.name ?? read.field}" (${target.type}) — ${pathIssue}`
+    });
+}
+
+const SCALAR = {
+    kind: "scalar"
+}, DOC_CONTENT = {
+    kind: "opaque"
+}, GDR_VALUE = {
+    kind: "record",
+    keys: {
+        id: SCALAR,
+        type: SCALAR
+    }
+}, RELEASE_VALUE = {
+    kind: "record",
+    keys: {
+        id: SCALAR,
+        type: SCALAR,
+        releaseName: SCALAR
+    }
+}, ACTOR_VALUE = {
+    kind: "record",
+    keys: {
+        kind: SCALAR,
+        id: SCALAR,
+        roles: {
+            kind: "list",
+            item: SCALAR
+        },
+        onBehalfOf: SCALAR
+    }
+}, ASSIGNEE_VALUE = {
+    kind: "record",
+    keys: {
+        type: SCALAR,
+        id: SCALAR,
+        role: SCALAR
+    }
+}, VALUE_NODES = {
+    "doc.ref": () => DOC_CONTENT,
+    "doc.refs": () => ({
+        kind: "list",
+        item: GDR_VALUE
+    }),
+    "release.ref": () => RELEASE_VALUE,
+    string: () => SCALAR,
+    text: () => SCALAR,
+    number: () => SCALAR,
+    boolean: () => SCALAR,
+    date: () => SCALAR,
+    datetime: () => SCALAR,
+    url: () => SCALAR,
+    actor: () => ACTOR_VALUE,
+    assignee: () => ASSIGNEE_VALUE,
+    assignees: () => ({
+        kind: "list",
+        item: ASSIGNEE_VALUE
+    }),
+    object: shape => ({
+        kind: "object",
+        fields: shape.fields ?? []
+    }),
+    array: shape => ({
+        kind: "rows",
+        of: shape.of ?? []
+    })
+};
+
+function valueNodeFor(shape) {
+    return Object.hasOwn(VALUE_NODES, shape.type) ? VALUE_NODES[shape.type](shape) : void 0;
+}
+
+const INDEX_SEGMENT = /^\d+$/;
+
+function stepIntoValueNode(node, segment) {
+    switch (node.kind) {
+      case "scalar":
+        return "the value is a scalar with no sub-paths";
+
+      case "object":
+        {
+            const sub = node.fields.find(f => f.name === segment), next = sub === void 0 ? void 0 : valueNodeFor(sub);
+            return next !== void 0 ? next : `an object value has sub-fields ${knownList(node.fields.map(f => f.name))} — "${segment}" is not one`;
+        }
+
+      case "rows":
+        return INDEX_SEGMENT.test(segment) ? {
+            kind: "object",
+            fields: node.of
+        } : `an array value is addressed by numeric row index first (e.g. "0.<subField>") — "${segment}" is not an index`;
+
+      case "list":
+        return INDEX_SEGMENT.test(segment) ? node.item : `an array value is addressed by numeric item index (e.g. "0") — "${segment}" is not an index`;
+
+      case "record":
+        return Object.hasOwn(node.keys, segment) ? node.keys[segment] : `the value carries ${knownList(Object.keys(node.keys))} — "${segment}" is not one of them`;
+
+      case "opaque":
+        return node;
+    }
+}
+
+function fieldValuePathIssue({target: target, path: path}) {
+    let node = valueNodeFor(target);
+    if (node === void 0) return `"${String(target.type)}" is not a known field kind`;
+    for (const segment of path.split(".")) {
+        const next = stepIntoValueNode(node, segment);
+        if (typeof next == "string") return `at segment "${segment}": ${next}`;
+        node = next;
+    }
+}
+
+function checkWorkflowInvariants(def) {
+    const issues = [], stageNames = checkStages(def, issues);
+    return checkInitialStage({
+        def: def,
+        stageNames: stageNames,
+        issues: issues
+    }), checkTransitionTargets({
+        def: def,
+        stageNames: stageNames,
+        issues: issues
+    }), checkStageReachability({
+        def: def,
+        stageNames: stageNames,
+        issues: issues
+    }), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), 
+    checkRequiredField(def, issues), checkStart(def, issues), checkPredicates(def, issues), 
+    checkUnboundCallerVars(def, issues), checkConditionFieldReads(def, issues), checkFieldReadSeeds(def, issues), 
+    checkFieldReadOpValues(def, issues), checkUpdateWhereOps(def, issues), checkGuardFieldReads(def, issues), 
+    checkAssigneesEntries(def, issues), checkActivityTerminalPaths(def, issues), checkTerminalStageActivities(def, issues), 
+    checkTriggeredActionParams(def, issues), checkStoredRolesPlacement(def, issues), 
+    checkGroups(def, issues), issues;
+}
+
+export { ACTIVITY_KINDS, ACTOR_KINDS, AuthoringActionSchema, AuthoringActivitySchema, AuthoringFieldEntrySchema, AuthoringGuardSchema, AuthoringOpSchema, AuthoringStageSchema, AuthoringTransitionSchema, AuthoringWorkflowSchema, CALLER_BOUND_VARS, CONDITION_VARS, ContractViolationError, DEFAULT_TRANSITION_WHEN, DOCUMENT_VALUE_PERMISSIONS, DRIVER_KINDS, DefinitionInUseError, DefinitionNotFoundError, EFFECTS_READ, EXECUTOR_CLASSIFICATIONS, EffectNotFoundError, EffectSchema, FIELD_READ, FILTER_SCOPE_VARS, FieldValueShapeError, GROUP_KINDS, GUARD_PREDICATE_VARS, GroupSchema, InstanceNotFoundError, RESERVED_CONDITION_VARS, RESOURCE_ALIAS_NAME_SOURCE, START_FILTER_VARS, StoredFieldOpSchema, WORKFLOW_DEFINITION_TYPE, WorkflowConfigSchema, WorkflowError, actorFulfillsRole, andConditions, checkFieldValue, checkWorkflowInvariants, clientConfigFromResource, conditionEffectReads, conditionFieldReadNames, conditionParameterNames, conditionSyntaxIssues, datasetResourceParts, definitionDocId, deriveActivityKind, deriveExecutorClassification, desugarWorkflow, driverKind, errorMessage, evaluateCondition, evaluateConditionOutcome, evaluatePredicates, extractDocumentId, formatIssuePath, formatIssues, formatValidationError, gdrFromResource, gdrRef, gdrResourcePrefix, gdrUri, groq, groupMembershipNames, isBareSeedId, isCascadeFired, isGdr, isGdrUri, isGuardReadExpr, isInputSourced, isNotesEntry, isStartableDefinition, isSubjectEntry, isTerminalActivityStatus, isTodoListEntry, isTodoListItem, isUnevaluable, labelFor, parseGdr, parseOrThrow, parseResourceGdr, parseStoredDefinition, readsRootDocument, refCanvas, refDashboard, refDataset, refMediaLibrary, refTypeIssues, rejectedRefTypes, releaseDocId, releaseRef, resourceAliasesToMap, resourceFromGdrUri, resourceFromParsed, resourceGdr, rethrowWithContext, runGroq, sameResource, selfGdr, startKindOf, tagScopeFilter, toBareId, toPhysicalGdr, tryParseGdr, validateFieldAppendItem, validateFieldValue, validateResourceAliasName, validateTag };