@sanity/workflow-engine 0.31.0 → 0.33.0

package/dist/_chunks-cjs/invariants.cjs

@@ -40,6 +40,37 @@ function driverKind(actor) {
     return actor.kind === "person" || actor.kind === "agent" ? actor.kind : "service";
 }
 
+function isFilterScopedOut(entry) {
+    return entry.status === "skipped" && entry.startedAt === void 0;
+}
+
+function liveSubworkflows(host) {
+    return (host.subworkflows ?? []).filter(row => row.resolved === void 0);
+}
+
+function resolvedChildStatus(child) {
+    if (!(child.completedAt === void 0 || child.completedAt === null)) return child.abortedAt !== void 0 && child.abortedAt !== null ? "aborted" : "done";
+}
+
+function condemnedSubworkflows(host) {
+    return liveSubworkflows(host).filter(row => row.abortPending !== void 0);
+}
+
+function condemnSubworkflow(row, owed) {
+    row.abortPending !== void 0 || row.resolved !== void 0 || (row.abortPending = {
+        at: owed.at,
+        reason: owed.reason
+    });
+}
+
+function findOpenStageEntry(host) {
+    return host.stages.find(s => s.name === host.currentStage && s.exitedAt === void 0);
+}
+
+function findCurrentActivityEntry(host, activityName) {
+    return findOpenStageEntry(host)?.activities.find(a => a.name === activityName);
+}
+
 function errorMessage(err) {
     return (err instanceof Error ? err.message : String(err)).replace(/[^\P{Cc}\n\t]/gu, "");
 }
@@ -353,107 +384,191 @@ function tagScopeFilter() {
     return "tag == $tag";
 }
 
-const NonEmptyString$1 = v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("must not be empty"));
+const NonEmptyString$1 = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string"));
 
-function asPredicate(validate) {
-    return value => {
-        try {
-            return validate(value), !0;
-        } catch {
-            return !1;
-        }
-    };
+function isParseableInstant(value) {
+    return typeof value == "string" && !Number.isNaN(Date.parse(value));
 }
 
-const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts);
+const IsoTimestamp = v__namespace.pipe(v__namespace.string(), v__namespace.check(s => isParseableInstant(s), "must be an ISO-8601 datetime string"));
 
-function lakeSegment(label) {
-    return v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty(), v__namespace.check(isValidTag, `invalid ${label} — ${LAKE_ID_SEGMENT_GLOSS}`));
+function tolerantObject() {
+    return (entries, ..._exact) => v__namespace.looseObject(entries);
 }
 
-const WorkflowResourceSchema = v__namespace.variant("type", [ v__namespace.object({
-    type: v__namespace.literal("dataset"),
-    id: v__namespace.pipe(NonEmptyString$1, v__namespace.check(isValidDatasetId, 'invalid dataset resource id — expected "<projectId>.<dataset>"'))
-}), v__namespace.object({
-    type: v__namespace.literal("canvas"),
-    id: NonEmptyString$1
-}), v__namespace.object({
-    type: v__namespace.literal("media-library"),
-    id: NonEmptyString$1
-}), v__namespace.object({
-    type: v__namespace.literal("dashboard"),
-    id: NonEmptyString$1
-}) ]), ResourceBindingSchema = v__namespace.object({
-    name: v__namespace.pipe(NonEmptyString$1, v__namespace.check(isValidAliasName, "invalid resource handle name — lowercase letters, digits and dashes only, no leading dash")),
-    resource: WorkflowResourceSchema
-}), DefinitionSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.name == "string", "expected a workflow definition (an object with a string `name`)"), DeploymentSchema = v__namespace.object({
-    name: lakeSegment("name"),
-    expectedMinReaderModel: v__namespace.optional(v__namespace.custom(() => !0), void 0),
-    tag: lakeSegment("tag"),
-    workflowResource: WorkflowResourceSchema,
-    resourceAliases: v__namespace.optional(v__namespace.pipe(v__namespace.array(ResourceBindingSchema), v__namespace.check(bindings => duplicateHandleMessage(bindings) === void 0, issue => duplicateHandleMessage(issue.input) ?? "duplicate resource handle name"))),
-    definitions: v__namespace.pipe(v__namespace.array(DefinitionSchema), v__namespace.minLength(1, "a deployment needs at least one definition"))
-});
+function tolerantEntries() {
+    return (entries, ..._exact) => entries;
+}
 
-function firstDuplicatePair(items, keyOf) {
-    const seen = /* @__PURE__ */ new Map;
-    for (const item of items) {
-        const key = keyOf(item), earlier = seen.get(key);
-        if (earlier !== void 0) return [ earlier, item ];
-        seen.set(key, item);
-    }
+function schemaTreeShape(schema) {
+    return walkSchemaShape(schema, /* @__PURE__ */ new Set);
 }
 
-function duplicateHandleMessage(bindings) {
-    const pair = firstDuplicatePair(bindings, binding => binding.name);
-    if (pair !== void 0) return `duplicate resource handle name "${pair[1].name}" — each binding name must be unique within a deployment`;
+function walkSchemaShape(node, path) {
+    if (typeof node != "object" || node === null) return "unknown";
+    if (path.has(node)) return "(circular)";
+    path.add(node);
+    try {
+        const schema = node;
+        return containerShape(schema, path) ?? leafShape(schema);
+    } finally {
+        path.delete(node);
+    }
 }
 
-function duplicateNameMessage(deployments) {
-    const pair = firstDuplicatePair(deployments, deployment => deployment.name);
-    if (pair !== void 0) return `duplicate deployment name "${pair[1].name}" — each deployment must use a unique name`;
+const objectWalker = (schema, path) => objectEntriesShape(schema.entries, path), unionWalker = (schema, path) => ({
+    union: schema.options.map(option => walkSchemaShape(option, path))
+}), unwrapWalker = (schema, path) => walkSchemaShape(schema.wrapped, path), CONTAINER_WALKERS = {
+    strict_object: objectWalker,
+    loose_object: objectWalker,
+    object: objectWalker,
+    array: (schema, path) => ({
+        array: walkSchemaShape(schema.item, path)
+    }),
+    record: (schema, path) => ({
+        record: walkSchemaShape(schema.value, path)
+    }),
+    union: unionWalker,
+    variant: unionWalker,
+    lazy: (schema, path) => walkSchemaShape(schema.getter(void 0), path),
+    exact_optional: unwrapWalker,
+    optional: unwrapWalker,
+    nullable: unwrapWalker
+};
+
+function containerShape(schema, path) {
+    return CONTAINER_WALKERS[String(schema.type)]?.(schema, path);
 }
 
-function partitionKey(deployment) {
-    return `${resourceGdr(deployment.workflowResource)} ${deployment.tag}`;
+function objectEntriesShape(entries, path) {
+    const out = {};
+    for (const [key, entry] of Object.entries(entries)) {
+        const optional = isOptionalEntry(entry), wrapped = optional ? entry.wrapped : entry;
+        out[optional ? `${key}?` : key] = walkSchemaShape(wrapped, path);
+    }
+    return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1));
 }
 
-function partitionCollisionMessage(deployments) {
-    const pair = firstDuplicatePair(deployments, partitionKey);
-    if (pair === void 0) return;
-    const [first, second] = pair;
-    return `deployments "${first.name}" and "${second.name}" share workflow resource + tag "${second.tag}" — both would write into the same partition; change one deployment’s tag or resource`;
+function isOptionalEntry(entry) {
+    if (typeof entry != "object" || entry === null) return !1;
+    const kind = entry.type;
+    return kind === "exact_optional" || kind === "optional";
 }
 
-const TelemetryLoggerSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.log == "function", "expected a telemetry logger (an object with a `log` function)"), WorkflowConfigSchema = v__namespace.object({
-    deployments: v__namespace.pipe(v__namespace.array(DeploymentSchema), v__namespace.minLength(1, "a config needs at least one deployment"), v__namespace.check(deployments => duplicateNameMessage(deployments) === void 0, issue => duplicateNameMessage(issue.input) ?? "duplicate deployment name"), v__namespace.check(deployments => partitionCollisionMessage(deployments) === void 0, issue => partitionCollisionMessage(issue.input) ?? "duplicate deployment partition")),
-    telemetry: v__namespace.optional(TelemetryLoggerSchema)
-});
+const LEAF_KINDS = /* @__PURE__ */ new Set([ "string", "number", "boolean", "null", "undefined", "unknown", "any" ]);
 
-function resourceAliasesToMap(resourceAliases) {
-    return Object.fromEntries((resourceAliases ?? []).map(binding => [ binding.name, binding.resource ]));
+function leafShape(schema) {
+    if (schema.type === "picklist") return schema.options.join(" | ");
+    if (schema.type === "literal") return `literal ${String(schema.literal)}`;
+    if (schema.type === "custom") return typeof schema.message == "string" ? `custom(${schema.message})` : "custom";
+    if (!LEAF_KINDS.has(String(schema.type))) throw new Error(`schemaTreeShape: unhandled schema kind "${String(schema.type)}" — extend the walker before regenerating the model ledger`);
+    return String(schema.type);
 }
 
-const FIELD_READ = /^\$fields\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
+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 isGuardReadExpr(expr) {
-    return expr === "$self" || expr === "$now" || FIELD_READ.test(expr) || EFFECTS_READ.test(expr);
+function issuesFromValibot(issues) {
+    return issues.map(issue => ({
+        path: issue.path ? issue.path.map(item => item.key) : [],
+        message: issue.message
+    }));
 }
 
-function printGuardRead(read) {
-    switch (read.type) {
-      case "self":
-        return "$self";
+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;
+}
 
-      case "now":
-        return "$now";
+class PersistedDocShapeError extends WorkflowError {
+    documentId;
+    documentType;
+    issues;
+    constructor(args) {
+        super("persisted-doc-shape", formatValidationError(`Persisted ${args.documentType} document "${args.documentId}"`, args.issues)), 
+        this.name = "PersistedDocShapeError", this.documentId = args.documentId, this.documentType = args.documentType, 
+        this.issues = args.issues;
+    }
+}
 
-      case "fieldRead":
-        return read.path === void 0 ? `$fields.${read.field}` : `$fields.${read.field}.${read.path}`;
+function parsePersistedDoc(args) {
+    const result = v__namespace.safeParse(args.schema, args.doc);
+    if (!result.success) throw new PersistedDocShapeError({
+        documentId: documentIdOf(args.doc),
+        documentType: args.docType,
+        issues: issuesFromValibot(result.issues)
+    });
+    return result.output;
+}
 
-      case "effectsRead":
-        return read.path === void 0 ? `$effects['${read.effect}']` : `$effects['${read.effect}'].${read.path}`;
+function documentIdOf(doc) {
+    if (typeof doc == "object" && doc !== null) {
+        const id = doc._id;
+        if (typeof id == "string") return id;
     }
+    return "(unknown id)";
+}
+
+const ACTOR_KINDS = [ "person", "agent", "system" ];
+
+function releaseDocId(releaseName) {
+    return `_.releases.${releaseName}`;
+}
+
+function releaseRef({res: res, releaseName: releaseName}) {
+    if (releaseName.length === 0) throw new ContractViolationError("releaseRef: releaseName must be a non-empty release name");
+    return {
+        id: gdrFromResource(res, releaseDocId(releaseName)),
+        type: "system.release",
+        releaseName: releaseName
+    };
+}
+
+function isAlwaysArrayFieldKind(kind) {
+    return kind === "doc.refs" || kind === "assignee" || kind === "assignees" || kind === "array";
+}
+
+function isSingleDocRefKind(kind) {
+    return kind === "doc.ref" || kind === "subject";
+}
+
+function refKindAcceptsTypes(kind) {
+    return isSingleDocRefKind(kind) || kind === "doc.refs";
+}
+
+function assignmentKindAcceptsRoles(kind) {
+    return kind === "assignee" || kind === "assignees";
+}
+
+function isSingleDocRefEntry(entry) {
+    return isSingleDocRefKind(entry._type);
+}
+
+function isAssignmentFieldEntry(entry) {
+    return assignmentKindAcceptsRoles(entry._type);
+}
+
+function isTodoListItem(row) {
+    if (typeof row != "object" || row === null) return !1;
+    const candidate = row, status = candidate.status;
+    return typeof candidate._key == "string" && typeof candidate.label == "string" && (status == null || typeof status == "string");
+}
+
+function declaredRowColumns(entry) {
+    if (("_type" in entry ? entry._type : entry.type) === "array") return new Set((("of" in entry ? entry.of : void 0) ?? []).map(shape => shape.name));
+}
+
+function isTodoListEntry(entry) {
+    const columns = declaredRowColumns(entry);
+    return columns !== void 0 && columns.has("label") && columns.has("status");
+}
+
+function isNotesEntry(entry) {
+    const columns = declaredRowColumns(entry);
+    return columns !== void 0 && columns.has("body") && columns.has("actor") && columns.has("at");
 }
 
 const UNIVERSAL_ROLE_ALIAS_KEY = "$all";
@@ -484,2183 +599,2157 @@ function actorFulfillsRole({actorRoles: actorRoles, required: 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 normalizeAssignmentMembers(value) {
+    return value === null ? [] : Array.isArray(value) ? value : [ value ];
 }
 
-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 assignmentMembers(entries) {
+    return entries.flatMap(entry => isAssignmentFieldEntry(entry) ? normalizeAssignmentMembers(entry.value) : []);
 }
 
-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,
-                semantics: stage.semantics,
-                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,
-                semantics: authoring.semantics,
-                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 assignmentState(members) {
+    return members.length === 0 ? "unrouted" : members.some(member => member.type === "user") ? "held" : "routed";
 }
 
-function desugarStart(start) {
-    if (start !== void 0) return {
-        kind: start.kind ?? "interactive",
-        ...start.filter !== void 0 ? {
-            filter: start.filter
-        } : {},
-        ...start.requirements !== void 0 ? {
-            requirements: start.requirements
-        } : {}
-    };
+function activeAssignmentMembers(members) {
+    const users = members.filter(member => member.type === "user");
+    return users.length > 0 ? users : members;
 }
 
-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.`
-    });
+function assignmentMatch(members, identity) {
+    const active = activeAssignmentMembers(members);
+    return active.some(member => member.type === "user" && member.id === identity.userId) ? "user" : active.some(member => member.type === "role" && identity.roles.includes(member.role)) ? "role" : void 0;
 }
 
-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 identityMatchesAssignment(members, identity) {
+    return assignmentMatch(members, identity) !== void 0;
 }
 
-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,
-            options: entry.options,
-            validation: entry.validation,
-            types: entry.types,
-            roles: entry.roles,
-            fields: entry.fields,
-            of: entry.of
-        })
+function assignmentStateCounts(assignments, identity) {
+    const counts = {
+        unrouted: 0,
+        routed: 0,
+        held: 0
     };
+    for (const members of assignments) {
+        const state = assignmentState(members);
+        state === "unrouted" ? counts.unrouted += 1 : identityMatchesAssignment(members, identity) && (counts[state] += 1);
+    }
+    return counts;
 }
 
-function 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 openActivityAssignments(instance) {
+    return (findOpenStageEntry(instance)?.activities ?? []).filter(activity => activity.status === "active").map(activity => assignmentMembers(activity.fields ?? []));
 }
 
-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 instanceAssignmentStateCounts(instance, identity) {
+    return assignmentStateCounts(openActivityAssignments(instance), identity);
 }
 
-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 actorMatchesAssignment(args) {
+    const actor = args.actor;
+    return actor === void 0 ? !1 : activeAssignmentMembers(args.members).some(member => member.type === "user" ? member.id === actor.id : actorFulfillsRole({
+        actorRoles: actor.roles,
+        required: member.role,
+        aliases: args.roleAliases
+    }));
 }
 
-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);
+const ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
+
+function classifyPrincipalId(id) {
+    if (id === ANONYMOUS_IDENTITY || id === SYSTEM_IDENTITY) return {
+        namespace: "sentinel"
+    };
+    if (id.startsWith("g")) return {
+        namespace: "global",
+        globalId: id
+    };
+    if (id.startsWith("p-")) return {
+        namespace: "robot",
+        globalId: id
+    };
+    const embeddedGlobal = E_PREFIXED_PROJECT_ID.exec(id)?.[1];
+    return embeddedGlobal !== void 0 ? embeddedGlobal.startsWith("g") ? {
+        namespace: "project",
+        globalId: embeddedGlobal
+    } : {
+        namespace: "unknown"
+    } : id.startsWith("p") ? {
+        namespace: "project"
+    } : {
+        namespace: "unknown"
     };
-    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);
+function directoryBridgeId(sanityUserId) {
+    if (typeof sanityUserId == "string") return classifyPrincipalId(sanityUserId).namespace === "global" ? sanityUserId : void 0;
+}
+
+function firstCarriedGlobalId(candidates) {
+    for (const candidate of candidates) {
+        if (candidate === void 0) continue;
+        const {globalId: globalId} = classifyPrincipalId(candidate);
+        if (globalId !== void 0) return globalId;
     }
-    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,
-            semantics: activity.semantics,
-            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", "subject", "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 reportEmptyActionRoles({action: action, path: path, 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"
-    });
-}
-
-function desugarActionOps(args) {
-    const {action: action, path: path, env: env, activityName: activityName, ctx: ctx} = args, 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
-    }), ops;
-}
-
-function desugarAction({action: action, path: path, env: env, activityName: activityName, ctx: ctx}) {
-    if ("type" in action) return desugarClaimAction({
-        action: action,
-        path: path,
-        env: env,
-        ctx: ctx
-    });
-    reportEmptyActionRoles({
-        action: action,
-        path: path,
-        ctx: ctx
-    });
-    const cascadeFired = isCascadeFired(action), filter = cascadeFired ? action.filter : andConditions([ rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = desugarActionOps({
-        action: action,
-        path: path,
-        env: env,
-        activityName: activityName,
-        ctx: ctx
-    });
-    return {
-        ...stripUndefined({
-            name: action.name,
-            semantics: action.semantics,
-            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 lakePrincipalId(args) {
+    return args.localPrincipalId ?? args.actor.id;
 }
 
-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
-    };
+function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
 }
 
-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;
+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;
     }
-    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);
-}
+const GdrUriSchema = v__namespace.custom(s => typeof s == "string" && isGdrUri(s), "must be a GDR URI"), GdrShape = tolerantObject()({
+    id: GdrUriSchema,
+    type: NonEmptyString$1
+}), ReleaseRefShape = v__namespace.pipe(tolerantObject()({
+    id: GdrUriSchema,
+    type: v__namespace.literal("system.release"),
+    releaseName: NonEmptyString$1
+}), v__namespace.check(ref => !isGdrUri(ref.id) || extractDocumentId(ref.id) === releaseDocId(ref.releaseName), "id must point at the `_.releases.<releaseName>` doc named by releaseName")), ActorShape = tolerantObject()({
+    kind: v__namespace.picklist(ACTOR_KINDS),
+    id: NonEmptyString$1,
+    roles: v__namespace.exactOptional(v__namespace.array(v__namespace.string())),
+    onBehalfOf: v__namespace.exactOptional(v__namespace.string())
+}), AssigneeShape = v__namespace.union([ tolerantObject()({
+    type: v__namespace.literal("user"),
+    id: NonEmptyString$1
+}), tolerantObject()({
+    type: v__namespace.literal("role"),
+    role: NonEmptyString$1
+}) ]), AssigneeListShape = v__namespace.pipe(v__namespace.union([ v__namespace.null(), AssigneeShape, v__namespace.array(AssigneeShape) ]), v__namespace.transform(normalizeAssignmentMembers)), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableProgress = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.number(), v__namespace.finite("progress must be a finite number"), v__namespace.minValue(0, "progress must be at least 0"), v__namespace.maxValue(100, "progress must be at most 100")) ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "dueDate", "datetime", "dueDatetime", "dateTime" ]);
 
-function fallbackRef(ref) {
-    return {
-        scope: ref.scope ?? "workflow",
-        field: ref.field
-    };
+function normalizedChoiceKind(kind) {
+    return kind === "dateTime" ? "datetime" : kind;
 }
 
-function rolesCondition(roles, aliases) {
-    if (!(!roles || roles.length === 0)) return groq`count($actor.roles[@ in ${expandRequiredRoles(roles, aliases)}]) > 0`;
+function checkChoiceList(args) {
+    const {entryType: entryType, options: options, validation: validation} = args;
+    if (options === void 0) return;
+    if (!CHOICE_KINDS.has(entryType)) return [ `\`options\` is not valid on "${entryType}" values` ];
+    const kind = normalizedChoiceKind(entryType), issues = options.list.flatMap((option, index) => issuesOf(checkValueAgainst({
+        entryType: kind,
+        value: option.value,
+        validation: validation
+    }, valueSchemas))?.map(issue => `at options.list.${index}.value: ${issue}`) ?? []), seen = /* @__PURE__ */ new Set;
+    for (const option of options.list) seen.has(option.value) && issues.push(`duplicate option value ${JSON.stringify(option.value)}`), 
+    seen.add(option.value);
+    return issues.length === 0 ? void 0 : issues;
 }
 
-function stripUndefined(obj) {
-    const out = {};
-    for (const [k, value] of Object.entries(obj)) value !== void 0 && (out[k] = value);
-    return out;
+function choiceValueIssues(options, value) {
+    if (!(options === void 0 || value === null || value === void 0)) return options.list.some(option => Object.is(option.value, value)) ? void 0 : [ `value ${JSON.stringify(value)} is not declared in \`options.list\`; expected one of ${options.list.map(option => JSON.stringify(option.value)).join(", ")}` ];
 }
 
-function isUnevaluable(result) {
-    return result == null;
-}
+const fieldValueSchemas = {
+    "doc.ref": v__namespace.union([ v__namespace.null(), GdrShape ]),
+    "doc.refs": v__namespace.array(GdrShape),
+    subject: v__namespace.union([ v__namespace.null(), GdrShape ]),
+    "release.ref": v__namespace.union([ v__namespace.null(), ReleaseRefShape ]),
+    string: NullableString,
+    text: NullableString,
+    number: NullableNumber,
+    progress: NullableProgress,
+    boolean: NullableBoolean,
+    date: NullableDate,
+    dueDate: NullableDate,
+    datetime: NullableDateTime,
+    dueDatetime: NullableDateTime,
+    url: NullableUrl,
+    actor: v__namespace.union([ v__namespace.null(), ActorShape ]),
+    assignee: AssigneeListShape,
+    assignees: v__namespace.array(AssigneeShape)
+}, WritePrincipalId = v__namespace.pipe(NonEmptyString$1, v__namespace.rawTransform(({dataset: dataset, addIssue: addIssue}) => {
+    const classified = classifyPrincipalId(dataset.value);
+    return classified.namespace === "global" || classified.namespace === "robot" ? dataset.value : classified.namespace === "project" && classified.globalId !== void 0 ? classified.globalId : (addIssue({
+        message: `principal id "${dataset.value}" is not an account-global user id. Workflow user ids are the global \`sanityUserId\` (or a robot token's id). Resolve project members through your surface's member hook, or /projects/<projectId>/users/<id> → sanityUserId.`
+    }), dataset.value);
+})), ActorWriteShape = tolerantObject()({
+    kind: v__namespace.picklist(ACTOR_KINDS),
+    id: WritePrincipalId,
+    roles: v__namespace.exactOptional(v__namespace.array(v__namespace.string())),
+    onBehalfOf: v__namespace.exactOptional(v__namespace.string())
+}), AssigneePrincipalId = v__namespace.pipe(WritePrincipalId, v__namespace.check(id => classifyPrincipalId(id).namespace !== "robot", "robot principals cannot be assignment members")), AssigneeWriteShape = v__namespace.union([ tolerantObject()({
+    type: v__namespace.literal("user"),
+    id: AssigneePrincipalId
+}), tolerantObject()({
+    type: v__namespace.literal("role"),
+    role: NonEmptyString$1
+}) ]), SingularAssigneeWriteShape = v__namespace.pipe(v__namespace.union([ AssigneeWriteShape, v__namespace.array(AssigneeWriteShape) ]), v__namespace.transform(normalizeAssignmentMembers), v__namespace.check(members => members.filter(member => member.type === "user").length <= 1, "must contain at most one user member")), valueSchemas = {
+    ...fieldValueSchemas,
+    actor: v__namespace.nullable(ActorWriteShape),
+    assignee: SingularAssigneeWriteShape,
+    assignees: v__namespace.array(AssigneeWriteShape),
+    query: v__namespace.any()
+};
 
-async function evaluateConditionOutcome(args) {
-    const {condition: condition, snapshot: snapshot, params: params} = args;
-    return groqConditionDescribe.evaluateConditionOutcome({
-        condition: condition,
-        params: params,
-        dataset: snapshot.docs
+function shapeValueSchema(args) {
+    const {shape: shape, leaf: leaf} = args;
+    if (shape.type === "object") return objectSchema({
+        fields: shape.fields ?? [],
+        leaf: leaf
     });
-}
-
-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 = groqConditionDescribe.conditionOutcome(result);
-        out[name] = outcome === "unevaluable" ? null : outcome === "satisfied";
-    }
-    return out;
-}
-
-async function runGroq({groq: groq2, params: params, snapshot: snapshot}) {
-    return groqConditionDescribe.runGroq({
-        groq: groq2,
-        params: params,
-        dataset: snapshot.docs
+    if (shape.type === "array") return v__namespace.array(objectSchema({
+        fields: shape.of ?? [],
+        leaf: leaf
+    }));
+    const schema = leaf[shape.type] ?? v__namespace.any();
+    return constrainedScalarSchema({
+        schema: schema,
+        entryType: shape.type,
+        ...shape
     });
 }
 
-function conditionSyntaxIssues(groq2, boundVars) {
-    const issues = [];
-    let tree;
-    try {
-        tree = groqJs.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 scalarMeasurement(entryType, value) {
+    if ((entryType === "number" || entryType === "progress") && typeof value == "number") return value;
+    if ((entryType === "string" || entryType === "text") && typeof value == "string") return value.length;
 }
 
-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 scalarBoundIssue(args) {
+    const {entryType: entryType, measured: measured, bound: bound, limit: limit} = args;
+    return bound === void 0 || limit === "min" && measured >= bound || limit === "max" && measured <= bound ? void 0 : `${entryType === "number" || entryType === "progress" ? "" : "length "}must be ${limit === "min" ? "greater than or equal to" : "less than or equal to"} ${bound}`;
 }
 
-function conditionFieldReadNames(groq2) {
-    return new Set(conditionFieldReads(groq2).map(read => read.name));
+function scalarValidationIssues(args) {
+    const {entryType: entryType, validation: validation, value: value} = args;
+    if (validation === void 0 || value === null || value === void 0) return;
+    const measured = scalarMeasurement(entryType, value);
+    if (measured === void 0) return;
+    const issues = [ scalarBoundIssue({
+        entryType: entryType,
+        measured: measured,
+        bound: validation.min,
+        limit: "min"
+    }), scalarBoundIssue({
+        entryType: entryType,
+        measured: measured,
+        bound: validation.max,
+        limit: "max"
+    }) ].filter(issue => issue !== void 0);
+    return issues.length === 0 ? void 0 : issues;
 }
 
-function conditionFieldReads(groq2) {
-    const reads = /* @__PURE__ */ new Map;
-    return collectFieldReads(tryParseGroq(groq2), reads), [ ...reads.values() ];
+function constrainedScalarSchema(args) {
+    const {schema: schema, entryType: entryType, options: options, validation: validation} = args;
+    return options === void 0 && validation === void 0 ? schema : v__namespace.pipe(schema, v__namespace.check(value => choiceValueIssues(options, value) === void 0 && scalarValidationIssues({
+        entryType: entryType,
+        validation: validation,
+        value: value
+    }) === void 0, issue => [ ...choiceValueIssues(options, issue.input) ?? [], ...scalarValidationIssues({
+        entryType: entryType,
+        validation: validation,
+        value: issue.input
+    }) ?? [] ].join("; ")));
 }
 
-function collectFieldReads(node, reads) {
-    if (Array.isArray(node)) {
-        for (const item of node) collectFieldReads(item, reads);
-        return;
-    }
-    if (typeof node != "object" || node === null) return;
-    const chain = fieldsAttributeChain(node);
-    if (chain !== void 0) {
-        const [name, ...tail] = chain, path = tail.length > 0 ? tail.join(".") : void 0;
-        reads.set(`${name}.${path ?? ""}`, {
-            name: name,
-            path: path
-        });
-        return;
-    }
-    for (const value of Object.values(node)) collectFieldReads(value, reads);
+function objectSchema(args) {
+    const {fields: fields, leaf: leaf} = args, entries = /* @__PURE__ */ Object.create(null);
+    for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema({
+        shape: f,
+        leaf: leaf
+    }));
+    return v__namespace.looseObject(entries);
 }
 
-function fieldsAttributeChain(node) {
-    const names = [];
-    let current = node;
-    for (;typeof current == "object" && current !== null; ) {
-        const typed = current;
-        if (typed.type !== "AccessAttribute" || typeof typed.name != "string") return;
-        names.unshift(typed.name);
-        const base = typed.base;
-        if (base?.type === "Parameter" && base.name === "fields") return names;
-        current = base;
-    }
+function wholeValueSchema(args) {
+    const {entryType: entryType, shape: shape, leaf: leaf} = args;
+    return entryType === "object" ? v__namespace.union([ v__namespace.null(), objectSchema({
+        fields: shape.fields ?? [],
+        leaf: leaf
+    }) ]) : entryType === "array" ? v__namespace.array(objectSchema({
+        fields: shape.of ?? [],
+        leaf: leaf
+    })) : leaf[entryType];
 }
 
-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 appendItemSchema(entryType, shape) {
+    if (entryType === "array") return objectSchema({
+        fields: shape.of ?? [],
+        leaf: valueSchemas
+    });
+    if (entryType === "doc.refs") return GdrShape;
+    if (entryType === "assignee" || entryType === "assignees") return AssigneeWriteShape;
 }
 
-function readsRootDocument(groq2) {
-    return nodeReadsRoot(tryParseGroq(groq2), 0);
+function rejectedRefTypes(args) {
+    const {entryType: entryType, types: types, value: value} = args;
+    if (types === void 0 || value === null || value === void 0) return [];
+    if (!refKindAcceptsTypes(entryType)) 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))) ];
 }
 
-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 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 tryParseGroq(groq2) {
-    try {
-        return groqJs.parse(groq2);
-    } catch {
-        return;
-    }
+function gdrTypeOf(item) {
+    if (typeof item != "object" || item === null) return;
+    const t = item.type;
+    return typeof t == "string" ? t : void 0;
 }
 
-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);
-    }
+function parseFieldValue(args) {
+    return checkValueAgainst(args, valueSchemas);
 }
 
-const ACTIVITY_STATUSES = [ "active", "done", "skipped", "failed" ], TERMINAL_ACTIVITY_STATUSES = [ "done", "skipped", "failed" ];
-
-function isTerminalActivityStatus(status) {
-    return TERMINAL_ACTIVITY_STATUSES.includes(status);
+function checkValueAgainst(args, leaf) {
+    const schema = wholeValueSchema({
+        entryType: args.entryType,
+        shape: args,
+        leaf: leaf
+    });
+    if (schema === void 0) return {
+        issues: [ `unknown field entry type ${args.entryType}` ]
+    };
+    const result = v__namespace.safeParse(schema, args.value);
+    if (!result.success) return {
+        issues: formatIssues(result.issues)
+    };
+    const postIssues = refTypeIssues({
+        entryType: args.entryType,
+        types: args.types,
+        value: args.value
+    }) ?? choiceValueIssues(args.options, args.value) ?? scalarValidationIssues({
+        entryType: args.entryType,
+        validation: args.validation,
+        value: args.value
+    }) ?? assignmentValueIssues(args, result.output);
+    return postIssues !== void 0 ? {
+        issues: postIssues
+    } : {
+        output: result.output
+    };
 }
 
-const SIGNAL_SEMANTICS = [ "signal.positive", "signal.caution", "signal.critical" ], DECISION_SEMANTICS = [ "decision.accept", "decision.decline" ], ACTION_SEMANTICS = [ ...DECISION_SEMANTICS, ...SIGNAL_SEMANTICS ], FIELD_SCOPES = [ "workflow", "stage", "activity" ], DOCUMENT_VALUE_PERMISSIONS = [ "create", "read", "update" ], MUTATION_GUARD_ACTIONS = [ "create", "update", "delete", "publish", "unpublish" ], ACTIVITY_KINDS = [ "user", "service", "script", "manual", "receive" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ];
-
-function releaseDocId(releaseName) {
-    return `_.releases.${releaseName}`;
+function assignmentIdentity(assignee) {
+    return assignee.type === "user" ? `user:${assignee.id}` : `role:${assignee.role}`;
 }
-
-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 assignmentCandidate(value) {
+    const parsed = v__namespace.safeParse(AssigneeShape, value);
+    return parsed.success ? parsed.output : void 0;
 }
 
-function isAlwaysArrayFieldKind(kind) {
-    return kind === "doc.refs" || kind === "assignees" || kind === "array";
+function assignmentValueIssues(args, value) {
+    const retained = previousAssignmentIdentities(args), issues = [];
+    return visitAssignmentEntries({
+        entryType: args.entryType,
+        value: value,
+        roles: args.roles,
+        fields: args.fields,
+        of: args.of,
+        path: "$"
+    }, ({assignee: assignee, roles: roles, path: path}) => {
+        consumeRetainedAssignment({
+            retained: retained,
+            path: path,
+            identity: assignmentIdentity(assignee)
+        }) || issues.push(...assignmentCandidateIssues({
+            roles: roles,
+            memberRoles: args.memberRoles,
+            roleAliases: args.roleAliases
+        }, assignee));
+    }), issues.length === 0 ? void 0 : issues;
 }
 
-function isSingleDocRefKind(kind) {
-    return kind === "doc.ref" || kind === "subject";
+function consumeRetainedAssignment(args) {
+    const identities = args.retained.get(args.path), remaining = identities?.get(args.identity) ?? 0;
+    return remaining === 0 || identities === void 0 ? !1 : (remaining === 1 ? identities.delete(args.identity) : identities.set(args.identity, remaining - 1), 
+    !0);
 }
 
-function refKindAcceptsTypes(kind) {
-    return isSingleDocRefKind(kind) || kind === "doc.refs";
+function previousAssignmentIdentities(args) {
+    const retained = /* @__PURE__ */ new Map;
+    if (args.previousValue === void 0) return retained;
+    const schema = wholeValueSchema({
+        entryType: args.entryType,
+        shape: args,
+        leaf: valueSchemas
+    });
+    if (schema === void 0) return retained;
+    const previous = v__namespace.safeParse(schema, args.previousValue);
+    return previous.success && visitAssignmentEntries({
+        entryType: args.entryType,
+        value: previous.output,
+        roles: args.roles,
+        fields: args.fields,
+        of: args.of,
+        path: "$"
+    }, ({assignee: assignee, path: path}) => {
+        const identities = retained.get(path) ?? /* @__PURE__ */ new Map, identity = assignmentIdentity(assignee);
+        identities.set(identity, (identities.get(identity) ?? 0) + 1), retained.set(path, identities);
+    }), retained;
 }
 
-function assignmentKindAcceptsRoles(kind) {
-    return kind === "assignee" || kind === "assignees";
+function visitAssignmentEntries(args, visit) {
+    if (assignmentKindAcceptsRoles(args.entryType)) {
+        visitAssignmentCandidates(args, visit);
+        return;
+    }
+    if (args.entryType === "object") {
+        visitAssignmentFields({
+            fields: args.fields,
+            value: args.value,
+            path: args.path
+        }, visit);
+        return;
+    }
+    if (!(args.entryType !== "array" || !Array.isArray(args.value))) for (const row of args.value) visitAssignmentFields({
+        fields: args.of,
+        value: row,
+        path: `${args.path}[]`
+    }, visit);
 }
 
-function isSingleDocRefEntry(entry) {
-    return isSingleDocRefKind(entry._type);
+function visitAssignmentCandidates(args, visit) {
+    if (args.roles === void 0) return;
+    const indexedValues = Array.isArray(args.value) ? args.value.map(value => ({
+        value: value,
+        path: args.path
+    })) : [ {
+        value: args.value,
+        path: args.path
+    } ];
+    for (const {value: value, path: path} of indexedValues) {
+        const assignee = assignmentCandidate(value);
+        assignee !== void 0 && visit({
+            assignee: assignee,
+            roles: args.roles,
+            path: path
+        });
+    }
 }
 
-function isAssignmentFieldEntry(entry) {
-    return assignmentKindAcceptsRoles(entry._type);
+function visitAssignmentFields(args, visit) {
+    if (!(args.fields === void 0 || !isRecord(args.value))) for (const field of args.fields) visitAssignmentShape({
+        shape: field,
+        value: args.value[field.name],
+        path: `${args.path}.${field.name}`
+    }, visit);
 }
 
-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 visitAssignmentShape(args, visit) {
+    visitAssignmentEntries({
+        entryType: args.shape.type,
+        value: args.value,
+        roles: args.shape.roles,
+        fields: args.shape.fields,
+        of: args.shape.of,
+        path: args.path
+    }, visit);
 }
 
-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 assignmentCandidateIssues(args, assignee) {
+    if (assignee.type === "role") return collectiveRoleIssues(args, assignee.role);
+    const held = args.memberRoles?.[assignee.id];
+    return held === void 0 ? args.memberRoles === void 0 ? [] : [ `user "${assignee.id}" has no available project membership for role eligibility` ] : args.roles.some(required => actorFulfillsRole({
+        actorRoles: held,
+        required: required,
+        aliases: args.roleAliases
+    })) ? [] : [ `user "${assignee.id}" does not fulfill any eligible role: ${formatEligibleRoles(args.roles)}` ];
 }
 
-function isTodoListEntry(entry) {
-    const columns = declaredRowColumns(entry);
-    return columns !== void 0 && columns.has("label") && columns.has("status");
+function collectiveRoleIssues(args, role) {
+    return args.roles.includes(role) ? [] : [ `collective role "${role}" is not eligible — this entry accepts ${formatEligibleRoles(args.roles)}` ];
 }
 
-function isNotesEntry(entry) {
-    const columns = declaredRowColumns(entry);
-    return columns !== void 0 && columns.has("body") && columns.has("actor") && columns.has("at");
+function formatEligibleRoles(roles) {
+    return roles.map(role => `"${role}"`).join(", ");
 }
 
-const 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 wrapper). Stage/activity scopes overlay lexically. What a read puts in your hand follows the declared kind: a singular `doc.ref` (or `subject`) DEREFERENCES into the hydrated document (lake `_id`/`_type` plus content fields — which may themselves be named `id`/`type`), while `doc.refs` elements and `release.ref` stay REFERENCES — `{id, type[, releaseName]}` with `id` a GDR URI — because identity reads (membership, counting, joins) must stay total without hydrating every target, and targets may live in resources the evaluation cannot fetch from. Conditions evaluate against the in-memory snapshot only, so a dereferencing plural kind would silently hole wherever hydration lagged."
-}, {
-    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: "attributes",
-    binding: "caller",
-    label: "your attributes",
-    description: "Advisory org-level User Attributes for the caller (Enterprise — same values as lake `user::attributes()`), keyed by attribute name with each active scalar or array value. `undefined` on expected HTTP absence; unexpected fetch failures throw; empty page binds `{}`. Bound wherever grants ride the evaluation (same sites as `$can`). Soft-gate paths fetch at most 100 attributes (no further pages) and warn when the envelope reports `hasMore: true` (partial bag still binds). Not a security boundary — the Content Lake remains the only enforcement point."
-}, {
-    name: "row",
-    binding: "spawn",
-    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). Deploy rejects a read at every other site (including `spawn.forEach` itself and `spawn.context`), where it is GROQ null."
-}, {
-    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",
-    label: "this engine tag",
-    description: "The engine's tag partition — scope `*[...]` instance scans with `tag == $tag`."
-}, {
-    name: "definition",
-    label: "this workflow definition",
-    description: "The `name` of the definition under evaluation (its own start block binds it)."
-}, {
-    name: "now",
-    label: "the current time",
-    description: "The ISO clock reading of the evaluating engine."
-} ], START_REQUIREMENT_VARS = [ ...START_FILTER_VARS, {
-    name: "fields",
-    label: "the start's input fields",
-    description: "The caller's input entries by name (`initialFields` — at `startInstance`, the values the start would seed; at a pre-flight, the values gathered so far, so a read of a not-yet-supplied entry is GROQ null). Document references bind as GDR envelopes — `$fields.<entry>.id` is the GDR URI, never a string authors assemble — a singular `doc.ref` or `subject` included (nothing hydrates at the gate or the pre-flight). Pathed reads are deploy-checked against these envelope shapes."
-} ], GUARD_PREDICATE_VARS = [ {
-    name: "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."
-} ], NonEmptyString = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string"));
+function issuesOf(check) {
+    return "issues" in check ? check.issues : void 0;
+}
+
+function validateFieldValue(args) {
+    const check = checkValueAgainst(args, valueSchemas);
+    if ("issues" in check) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: check.issues,
+        mode: "value"
+    });
+    return check.output;
+}
 
-function isParseableInstant(value) {
-    return typeof value == "string" && !Number.isNaN(Date.parse(value));
+const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]{0,127}", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
+
+function isBareDocumentId(id) {
+    return BARE_ID_RE.test(id) && !id.includes("..");
 }
 
-const IsoTimestamp = v__namespace.pipe(v__namespace.string(), v__namespace.check(s => isParseableInstant(s), "must be an ISO-8601 datetime string"));
+function isAuthoringRefId(id) {
+    if (id.startsWith("@")) {
+        const separator = id.indexOf(":");
+        return ALIAS_REF_RE.test(id) && isBareDocumentId(id.slice(separator + 1));
+    }
+    return id.includes(":") ? isGdrUri(id) : isBareDocumentId(id);
+}
 
-function tolerantObject() {
-    return (entries, ..._exact) => v__namespace.looseObject(entries);
+function isBareSeedId(id) {
+    return isBareDocumentId(id);
 }
 
-function tolerantEntries() {
-    return (entries, ..._exact) => entries;
+const AuthoringRefId = v__namespace.pipe(v__namespace.string(), v__namespace.check(isAuthoringRefId, "must be a bare document id, a GDR URI, or a portable `@<alias>:<id>` reference")), AuthoringGdrShape = v__namespace.looseObject({
+    id: AuthoringRefId,
+    type: NonEmptyString$1
+}), seedValueSchemas = {
+    ...valueSchemas,
+    "doc.ref": v__namespace.union([ v__namespace.null(), AuthoringGdrShape ]),
+    "doc.refs": v__namespace.array(AuthoringGdrShape),
+    subject: v__namespace.union([ v__namespace.null(), AuthoringGdrShape ]),
+    "release.ref": v__namespace.union([ v__namespace.null(), v__namespace.looseObject({
+        id: AuthoringRefId,
+        type: v__namespace.literal("system.release"),
+        releaseName: NonEmptyString$1
+    }) ])
+};
+
+function checkLiteralSeed(args) {
+    return args.value === null ? [ "a literal seed cannot be null — omit `initialValue` to start the field empty" ] : issuesOf(checkValueAgainst(args, seedValueSchemas));
 }
 
-function schemaTreeShape(schema) {
-    return walkSchemaShape(schema, /* @__PURE__ */ new Set);
+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__namespace.safeParse(schema, args.item);
+    if (!result.success) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: formatIssues(result.issues),
+        mode: "item"
+    });
+    const assignmentArgs = {
+        entryType: appendAssignmentEntryType(args.entryType),
+        value: result.output,
+        roles: args.roles,
+        fields: args.entryType === "array" ? args.of : void 0,
+        memberRoles: args.memberRoles,
+        roleAliases: args.roleAliases
+    }, assignmentIssues = assignmentValueIssues(assignmentArgs, result.output);
+    if (assignmentIssues !== void 0) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: assignmentIssues,
+        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"
+    });
+    return result.output;
 }
 
-function walkSchemaShape(node, path) {
-    if (typeof node != "object" || node === null) return "unknown";
-    if (path.has(node)) return "(circular)";
-    path.add(node);
-    try {
-        const schema = node;
-        return containerShape(schema, path) ?? leafShape(schema);
-    } finally {
-        path.delete(node);
-    }
+function appendAssignmentEntryType(entryType) {
+    return entryType === "assignee" || entryType === "assignees" ? "assignee" : entryType === "array" ? "object" : entryType;
 }
 
-const objectWalker = (schema, path) => objectEntriesShape(schema.entries, path), unionWalker = (schema, path) => ({
-    union: schema.options.map(option => walkSchemaShape(option, path))
-}), unwrapWalker = (schema, path) => walkSchemaShape(schema.wrapped, path), CONTAINER_WALKERS = {
-    strict_object: objectWalker,
-    loose_object: objectWalker,
-    object: objectWalker,
-    array: (schema, path) => ({
-        array: walkSchemaShape(schema.item, path)
-    }),
-    record: (schema, path) => ({
-        record: walkSchemaShape(schema.value, path)
-    }),
-    union: unionWalker,
-    variant: unionWalker,
-    lazy: (schema, path) => walkSchemaShape(schema.getter(void 0), path),
-    exact_optional: unwrapWalker,
-    optional: unwrapWalker,
-    nullable: unwrapWalker
-};
+function formatIssues(issues, formatMessage = issue => issue.message) {
+    const formatOne = (issue, prefix) => {
+        const keys = [ ...prefix, ...issue.path?.map(p => p.key) ?? [] ], sub = issue.issues?.filter(candidate => candidate.expected !== "null");
+        return sub !== void 0 && sub.length > 0 ? sub.flatMap(candidate => formatOne(candidate, keys)) : [ `${keys.length > 0 ? `at ${keys.join(".")}: ` : ""}${formatMessage(issue)}` ];
+    };
+    return issues.flatMap(issue => formatOne(issue, []));
+}
 
-function containerShape(schema, path) {
-    return CONTAINER_WALKERS[String(schema.type)]?.(schema, path);
+const ACTIVITY_STATUSES = groqConditionDescribe._exhaustiveOptions()([ "active", "done", "skipped", "failed" ]), TERMINAL_ACTIVITY_STATUSES = groqConditionDescribe._exhaustiveOptions()([ "done", "skipped", "failed" ]);
+
+function isTerminalActivityStatus(status) {
+    return TERMINAL_ACTIVITY_STATUSES.includes(status);
 }
 
-function objectEntriesShape(entries, path) {
-    const out = {};
-    for (const [key, entry] of Object.entries(entries)) {
-        const optional = isOptionalEntry(entry), wrapped = optional ? entry.wrapped : entry;
-        out[optional ? `${key}?` : key] = walkSchemaShape(wrapped, path);
+const SIGNAL_SEMANTICS = [ "signal.positive", "signal.caution", "signal.critical" ], DECISION_SEMANTICS = [ "decision.accept", "decision.decline" ], ACTION_SEMANTICS = [ ...DECISION_SEMANTICS, ...SIGNAL_SEMANTICS ], FIELD_SCOPES = groqConditionDescribe._exhaustiveOptions()([ "workflow", "stage", "activity" ]), DOCUMENT_VALUE_PERMISSIONS = [ "create", "manage", "read", "update" ], LAKE_MUTATION_GUARD_ACTIONS = groqConditionDescribe._exhaustiveOptions()([ "create", "update", "delete" ]), MUTATION_GUARD_ACTIONS = groqConditionDescribe._exhaustiveOptions()([ ...LAKE_MUTATION_GUARD_ACTIONS, "publish", "unpublish" ]), GUARD_ACTIONS_REQUIRED_MESSAGE = "a guard must match at least one action", MUTATION_GUARD_ID_SPACES = [ "authored", "edit", "published" ];
+
+function mutationGuardActionIdSpace(action) {
+    return action === "update" ? "edit" : action === "publish" || action === "unpublish" ? "published" : "authored";
+}
+
+function mutationGuardRequiresSplitEmission(actions) {
+    return new Set(actions.map(mutationGuardActionIdSpace)).size > 1;
+}
+
+const ACTIVITY_KINDS = [ "user", "service", "script", "manual", "receive" ], EXECUTOR_CLASSIFICATIONS = [ "autonomous", "interactive", "off-system", "hybrid" ], GROUP_KINDS = [ "core", "details" ], DRIVER_KINDS = [ "person", "agent", "service", "engine" ], NonEmpty = NonEmptyString$1, PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function groqIdentifier(referencedAs) {
+    return v__namespace.pipe(v__namespace.string(), v__namespace.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__namespace.picklist(options, invalidOptionMessage(options));
+}
+
+function invalidOptionMessage(options) {
+    return `Invalid option: expected one of ${options.map(option => `"${option}"`).join("|")}`;
+}
+
+function pinned() {
+    return (schema, ..._exact) => schema;
+}
+
+const LiteralSchema = v__namespace.strictObject({
+    type: v__namespace.literal("literal"),
+    value: v__namespace.unknown()
+}), FieldReadSchema = v__namespace.strictObject({
+    type: v__namespace.literal("fieldRead"),
+    scope: v__namespace.optional(v__namespace.union([ v__namespace.literal("workflow"), v__namespace.literal("stage") ])),
+    field: NonEmpty,
+    path: v__namespace.optional(v__namespace.string())
+}), FieldSourceSchema = v__namespace.variant("type", [ v__namespace.strictObject({
+    type: v__namespace.literal("input")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("query"),
+    query: NonEmpty
+}), LiteralSchema, FieldReadSchema ]), ValueExprSchema = v__namespace.lazy(() => v__namespace.variant("type", [ LiteralSchema, FieldReadSchema, v__namespace.strictObject({
+    type: v__namespace.literal("param"),
+    param: NonEmpty
+}), v__namespace.strictObject({
+    type: v__namespace.literal("actor")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("now")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("self")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("stage")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("object"),
+    fields: v__namespace.record(NonEmpty, ValueExprSchema)
+}) ])), StoredFieldRefSchema = v__namespace.strictObject({
+    scope: picklist(FIELD_SCOPES),
+    field: NonEmpty
+}), AuthoringFieldRefSchema = v__namespace.strictObject({
+    scope: v__namespace.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;
     }
-    return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1));
 }
 
-function isOptionalEntry(entry) {
-    if (typeof entry != "object" || entry === null) return !1;
-    const kind = entry.type;
-    return kind === "exact_optional" || kind === "optional";
+const UrlString = v__namespace.pipe(v__namespace.string(), v__namespace.url("must be a valid URL"), v__namespace.check(isHttpUrl, "must be an http(s) URL"));
+
+function manualTargetSchema(ref) {
+    return v__namespace.variant("type", [ v__namespace.strictObject({
+        type: v__namespace.literal("url"),
+        url: UrlString
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field"),
+        field: ref
+    }) ]);
 }
 
-const LEAF_KINDS = /* @__PURE__ */ new Set([ "string", "number", "boolean", "null", "undefined", "unknown", "any" ]);
+const StoredManualTargetSchema = pinned()(manualTargetSchema(StoredFieldRefSchema)), AuthoringManualTargetSchema = pinned()(manualTargetSchema(v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ]))), ConditionSchema = NonEmpty;
 
-function leafShape(schema) {
-    if (schema.type === "picklist") return schema.options.join(" | ");
-    if (schema.type === "literal") return `literal ${String(schema.literal)}`;
-    if (schema.type === "custom") return typeof schema.message == "string" ? `custom(${schema.message})` : "custom";
-    if (!LEAF_KINDS.has(String(schema.type))) throw new Error(`schemaTreeShape: unhandled schema kind "${String(schema.type)}" — extend the walker before regenerating the model ledger`);
-    return String(schema.type);
+function opSchemas(targetSchema) {
+    return [ v__namespace.strictObject({
+        type: v__namespace.literal("field.set"),
+        target: targetSchema,
+        value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.setIfMissing"),
+        target: targetSchema,
+        value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.unset"),
+        target: targetSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.append"),
+        target: targetSchema,
+        value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.inc"),
+        target: targetSchema,
+        value: v__namespace.optional(ValueExprSchema)
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.dec"),
+        target: targetSchema,
+        value: v__namespace.optional(ValueExprSchema)
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.updateWhere"),
+        target: targetSchema,
+        where: ConditionSchema,
+        value: ValueExprSchema
+    }), v__namespace.strictObject({
+        type: v__namespace.literal("field.removeWhere"),
+        target: targetSchema,
+        where: ConditionSchema
+    }) ];
 }
 
-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`)}`;
+const StoredFieldOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema) ])), StoredOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema), v__namespace.strictObject({
+    type: v__namespace.literal("status.set"),
+    activity: NonEmpty,
+    status: picklist(ACTIVITY_STATUSES)
+}) ])), AuditOpSchema = v__namespace.strictObject({
+    type: v__namespace.literal("audit"),
+    target: AuthoringFieldRefSchema,
+    value: ValueExprSchema,
+    stampFields: v__namespace.optional(v__namespace.strictObject({
+        actor: v__namespace.optional(NonEmpty),
+        at: v__namespace.optional(NonEmpty)
+    }))
+}), AuthoringOpSchema = pinned()(v__namespace.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), v__namespace.strictObject({
+    type: v__namespace.literal("status.set"),
+    activity: v__namespace.optional(NonEmpty),
+    status: picklist(ACTIVITY_STATUSES)
+}), AuditOpSchema ])), GroupName = v__namespace.pipe(v__namespace.string(), v__namespace.regex(GROQ_IDENTIFIER, "must be an identifier (letters, digits, underscore; not starting with a digit)")), GroupSchema = pinned()(v__namespace.strictObject({
+    name: GroupName,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string()),
+    kind: v__namespace.optional(picklist(GROUP_KINDS))
+})), GroupNameList = v__namespace.pipe(v__namespace.array(GroupName), v__namespace.minLength(1, "name at least one group, or omit `group`"), v__namespace.check(names => new Set(names).size === names.length, "a group is listed more than once — list each group once")), StoredGroupMembershipSchema = GroupNameList, AuthoringGroupMembershipSchema = v__namespace.union([ GroupName, GroupNameList ]);
+
+function groupMembershipNames(group) {
+    return group === void 0 ? [] : typeof group == "string" ? [ group ] : [ ...group ];
 }
 
-function issuesFromValibot(issues) {
-    return issues.map(issue => ({
-        path: issue.path ? issue.path.map(item => item.key) : [],
-        message: issue.message
-    }));
-}
+const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "progress", "boolean", "date", "dueDate", "datetime", "dueDatetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), AUTHORING_FIELD_SUGAR_KINDS = groqConditionDescribe._exhaustiveOptions()([ "todoList", "notes" ]), AUTHORING_FIELD_KINDS = [ ...FIELD_VALUE_KINDS, ...AUTHORING_FIELD_SUGAR_KINDS ], AuthoringRawFieldKindSchema = v__namespace.picklist(FIELD_VALUE_KINDS, issue => `${invalidOptionMessage(AUTHORING_FIELD_KINDS)} but received ${JSON.stringify(issue.input)}`), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
+    min: v__namespace.optional(FiniteNumber),
+    max: v__namespace.optional(FiniteNumber)
+}), v__namespace.check(validation => validation.min !== void 0 || validation.max !== void 0, "declare at least one bound, or omit `validation`"), v__namespace.check(validation => validation.min === void 0 || validation.max === void 0 || validation.min <= validation.max, "`min` must be less than or equal to `max`")), ChoiceOptionsSchema = v__namespace.strictObject({
+    list: v__namespace.pipe(v__namespace.array(v__namespace.strictObject({
+        title: NonEmpty,
+        value: v__namespace.union([ v__namespace.string(), v__namespace.number() ])
+    })), v__namespace.minLength(1, "declare at least one choice, or omit `options`"))
+});
 
-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 asShape(input) {
+    return typeof input == "object" && input !== null ? input : {};
 }
 
-class PersistedDocShapeError extends WorkflowError {
-    documentId;
-    documentType;
-    issues;
-    constructor(args) {
-        super("persisted-doc-shape", formatValidationError(`Persisted ${args.documentType} document "${args.documentId}"`, args.issues)), 
-        this.name = "PersistedDocShapeError", this.documentId = args.documentId, this.documentType = args.documentType, 
-        this.issues = args.issues;
-    }
+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 parsePersistedDoc(args) {
-    const result = v__namespace.safeParse(args.schema, args.doc);
-    if (!result.success) throw new PersistedDocShapeError({
-        documentId: documentIdOf(args.doc),
-        documentType: args.docType,
-        issues: issuesFromValibot(result.issues)
-    });
-    return result.output;
+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 documentIdOf(doc) {
-    if (typeof doc == "object" && doc !== null) {
-        const id = doc._id;
-        if (typeof id == "string") return id;
+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);
+        }
     }
-    return "(unknown id)";
-}
-
-const ACTOR_KINDS = [ "person", "agent", "system" ], ANONYMOUS_IDENTITY = "<anonymous>", SYSTEM_IDENTITY = "<system>", E_PREFIXED_PROJECT_ID = /^e-(.+)$/;
-
-function classifyPrincipalId(id) {
-    if (id === ANONYMOUS_IDENTITY || id === SYSTEM_IDENTITY) return {
-        namespace: "sentinel"
-    };
-    if (id.startsWith("g")) return {
-        namespace: "global",
-        globalId: id
-    };
-    if (id.startsWith("p-")) return {
-        namespace: "robot",
-        globalId: id
-    };
-    const embeddedGlobal = E_PREFIXED_PROJECT_ID.exec(id)?.[1];
-    return embeddedGlobal !== void 0 ? embeddedGlobal.startsWith("g") ? {
-        namespace: "project",
-        globalId: embeddedGlobal
-    } : {
-        namespace: "unknown"
-    } : id.startsWith("p") ? {
-        namespace: "project"
-    } : {
-        namespace: "unknown"
-    };
 }
 
-function directoryBridgeId(sanityUserId) {
-    if (typeof sanityUserId == "string") return classifyPrincipalId(sanityUserId).namespace === "global" ? sanityUserId : void 0;
+function compositeChecked(entries) {
+    return v__namespace.pipe(v__namespace.strictObject(entries), v__namespace.check(input => compositeShapeOk(input), issue => compositeShapeMessage(issue.input)), v__namespace.check(input => duplicateSubfieldName(input) === void 0, issue => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" — sub-field names must be unique within \`fields\` / \`of\``));
 }
 
-function firstCarriedGlobalId(candidates) {
-    for (const candidate of candidates) {
-        if (candidate === void 0) continue;
-        const {globalId: globalId} = classifyPrincipalId(candidate);
-        if (globalId !== void 0) return globalId;
-    }
-}
+const AssignmentRolesSchema = v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one eligible role, or omit `roles`")), FieldShapeSchema = v__namespace.lazy(() => v__namespace.pipe(compositeChecked({
+    type: FieldValueKindSchema,
+    name: FieldEntryName,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string()),
+    options: v__namespace.optional(ChoiceOptionsSchema),
+    validation: v__namespace.optional(ScalarValidationSchema),
+    roles: v__namespace.optional(AssignmentRolesSchema),
+    fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
+    of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+}), choiceOptionsCheck(), scalarValidationCheck(), assignmentRolesCheck())), StoredEditableSchema = pinned()(v__namespace.union([ v__namespace.literal(!0), NonEmpty ])), AuthoringEditableSchema = pinned()(v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]));
 
-function lakePrincipalId(args) {
-    return args.localPrincipalId ?? args.actor.id;
+function fieldBase(editable, group) {
+    return {
+        name: FieldEntryName,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        group: v__namespace.optional(group),
+        required: v__namespace.optional(v__namespace.boolean()),
+        initialValue: v__namespace.optional(FieldSourceSchema),
+        editable: v__namespace.optional(editable)
+    };
 }
 
-function isRecord(value) {
-    return typeof value == "object" && value !== null && !Array.isArray(value);
+function fieldEntryFields({editable: editable, group: group, kind: kind = FieldKindSchema}) {
+    return {
+        type: kind,
+        ...fieldBase(editable, group),
+        options: v__namespace.optional(ChoiceOptionsSchema),
+        validation: v__namespace.optional(ScalarValidationSchema),
+        types: v__namespace.optional(v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one accepted type, or omit `types` to accept any"))),
+        roles: v__namespace.optional(AssignmentRolesSchema),
+        fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
+        of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+    };
 }
 
-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;
-    }
+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,
+        options: entry.options,
+        validation: entry.validation,
+        roles: entry.roles
+    });
 }
 
-const GdrUriSchema = v__namespace.custom(s => typeof s == "string" && isGdrUri(s), "must be a GDR URI"), GdrShape = tolerantObject()({
-    id: GdrUriSchema,
-    type: NonEmptyString
-}), ReleaseRefShape = v__namespace.pipe(tolerantObject()({
-    id: GdrUriSchema,
-    type: v__namespace.literal("system.release"),
-    releaseName: NonEmptyString
-}), v__namespace.check(ref => !isGdrUri(ref.id) || extractDocumentId(ref.id) === releaseDocId(ref.releaseName), "id must point at the `_.releases.<releaseName>` doc named by releaseName")), ActorShape = tolerantObject()({
-    kind: v__namespace.picklist(ACTOR_KINDS),
-    id: NonEmptyString,
-    roles: v__namespace.exactOptional(v__namespace.array(v__namespace.string())),
-    onBehalfOf: v__namespace.exactOptional(v__namespace.string())
-}), AssigneeShape = v__namespace.union([ tolerantObject()({
-    type: v__namespace.literal("user"),
-    id: NonEmptyString
-}), tolerantObject()({
-    type: v__namespace.literal("role"),
-    role: NonEmptyString
-}) ]), NullableString = v__namespace.union([ v__namespace.null(), v__namespace.string() ]), NullableNumber = v__namespace.union([ v__namespace.null(), v__namespace.number() ]), NullableBoolean = v__namespace.union([ v__namespace.null(), v__namespace.boolean() ]), NullableProgress = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.number(), v__namespace.finite("progress must be a finite number"), v__namespace.minValue(0, "progress must be at least 0"), v__namespace.maxValue(100, "progress must be at most 100")) ]), NullableDateTime = v__namespace.union([ v__namespace.null(), IsoTimestamp ]), NullableDate = v__namespace.union([ v__namespace.null(), v__namespace.pipe(v__namespace.string(), v__namespace.regex(/^\d{4}-\d{2}-\d{2}$/, "must be a `YYYY-MM-DD` date")) ]), NullableUrl = NullableString, CHOICE_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "url", "date", "dueDate", "datetime", "dueDatetime", "dateTime" ]);
-
-function normalizedChoiceKind(kind) {
-    return kind === "dateTime" ? "datetime" : kind;
+function literalSeedCheck() {
+    return v__namespace.check(entry => literalSeedIssues(entry) === void 0, issue => `initialValue literal does not fit the declared kind: ${(literalSeedIssues(issue.input) ?? []).join("; ")}`);
 }
 
-function checkChoiceList(args) {
-    const {entryType: entryType, options: options, validation: validation} = args;
-    if (options === void 0) return;
-    if (!CHOICE_KINDS.has(entryType)) return [ `\`options\` is not valid on "${entryType}" values` ];
-    const kind = normalizedChoiceKind(entryType), issues = options.list.flatMap((option, index) => issuesOf(checkValueAgainst({
-        entryType: kind,
-        value: option.value,
-        validation: validation
-    }, valueSchemas))?.map(issue => `at options.list.${index}.value: ${issue}`) ?? []), seen = /* @__PURE__ */ new Set;
-    for (const option of options.list) seen.has(option.value) && issues.push(`duplicate option value ${JSON.stringify(option.value)}`), 
-    seen.add(option.value);
-    return issues.length === 0 ? void 0 : issues;
+function refTypesCheck() {
+    return v__namespace.check(entry => entry.types === void 0 || refKindAcceptsTypes(entry.type), issue => `\`types\` is only valid on \`doc.ref\` / \`doc.refs\` / \`subject\` entries, not "${issue.input.type}"`);
 }
 
-function choiceValueIssues(options, value) {
-    if (!(options === void 0 || value === null || value === void 0)) return options.list.some(option => Object.is(option.value, value)) ? void 0 : [ `value ${JSON.stringify(value)} is not declared in \`options.list\`; expected one of ${options.list.map(option => JSON.stringify(option.value)).join(", ")}` ];
+function assignmentRolesCheck() {
+    return v__namespace.check(entry => entry.roles === void 0 || assignmentKindAcceptsRoles(entry.type), issue => `\`roles\` is only valid on \`assignee\` / \`assignees\` entries, not "${issue.input.type}"`);
 }
 
-const fieldValueSchemas = {
-    "doc.ref": v__namespace.union([ v__namespace.null(), GdrShape ]),
-    "doc.refs": v__namespace.array(GdrShape),
-    subject: v__namespace.union([ v__namespace.null(), GdrShape ]),
-    "release.ref": v__namespace.union([ v__namespace.null(), ReleaseRefShape ]),
-    string: NullableString,
-    text: NullableString,
-    number: NullableNumber,
-    progress: NullableProgress,
-    boolean: NullableBoolean,
-    date: NullableDate,
-    dueDate: NullableDate,
-    datetime: NullableDateTime,
-    dueDatetime: NullableDateTime,
-    url: NullableUrl,
-    actor: v__namespace.union([ v__namespace.null(), ActorShape ]),
-    assignee: v__namespace.union([ v__namespace.null(), AssigneeShape ]),
-    assignees: v__namespace.array(AssigneeShape)
-}, WritePrincipalId = v__namespace.pipe(NonEmptyString, v__namespace.rawTransform(({dataset: dataset, addIssue: addIssue}) => {
-    const classified = classifyPrincipalId(dataset.value);
-    return classified.namespace === "global" || classified.namespace === "robot" ? dataset.value : classified.namespace === "project" && classified.globalId !== void 0 ? classified.globalId : (addIssue({
-        message: `principal id "${dataset.value}" is not an account-global user id. Workflow user ids are the global \`sanityUserId\` (or a robot token's id). Resolve project members through your surface's member hook, or /projects/<projectId>/users/<id> → sanityUserId.`
-    }), dataset.value);
-})), ActorWriteShape = tolerantObject()({
-    kind: v__namespace.picklist(ACTOR_KINDS),
-    id: WritePrincipalId,
-    roles: v__namespace.exactOptional(v__namespace.array(v__namespace.string())),
-    onBehalfOf: v__namespace.exactOptional(v__namespace.string())
-}), AssigneeWriteShape = v__namespace.union([ tolerantObject()({
-    type: v__namespace.literal("user"),
-    id: WritePrincipalId
-}), tolerantObject()({
-    type: v__namespace.literal("role"),
-    role: NonEmptyString
-}) ]), valueSchemas = {
-    ...fieldValueSchemas,
-    actor: v__namespace.nullable(ActorWriteShape),
-    assignee: v__namespace.nullable(AssigneeWriteShape),
-    assignees: v__namespace.array(AssigneeWriteShape),
-    query: v__namespace.any()
-};
-
-function shapeValueSchema(args) {
-    const {shape: shape, leaf: leaf} = args;
-    if (shape.type === "object") return objectSchema({
-        fields: shape.fields ?? [],
-        leaf: leaf
-    });
-    if (shape.type === "array") return v__namespace.array(objectSchema({
-        fields: shape.of ?? [],
-        leaf: leaf
-    }));
-    const schema = leaf[shape.type] ?? v__namespace.any();
-    return constrainedScalarSchema({
-        schema: schema,
-        entryType: shape.type,
-        ...shape
-    });
+function choiceOptionsCheck() {
+    return v__namespace.check(entry => checkChoiceList({
+        entryType: entry.type,
+        options: entry.options,
+        validation: entry.validation
+    }) === void 0, issue => (checkChoiceList({
+        entryType: issue.input.type,
+        options: issue.input.options,
+        validation: issue.input.validation
+    }) ?? []).join("; "));
 }
 
-function scalarMeasurement(entryType, value) {
-    if ((entryType === "number" || entryType === "progress") && typeof value == "number") return value;
-    if ((entryType === "string" || entryType === "text") && typeof value == "string") return value.length;
-}
+const SCALAR_VALIDATION_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "progress" ]);
 
-function scalarBoundIssue(args) {
-    const {entryType: entryType, measured: measured, bound: bound, limit: limit} = args;
-    return bound === void 0 || limit === "min" && measured >= bound || limit === "max" && measured <= bound ? void 0 : `${entryType === "number" || entryType === "progress" ? "" : "length "}must be ${limit === "min" ? "greater than or equal to" : "less than or equal to"} ${bound}`;
+function scalarValidationCheck() {
+    return v__namespace.check(entry => scalarValidationDeclarationIssues(entry) === void 0, issue => (scalarValidationDeclarationIssues(issue.input) ?? []).join("; "));
 }
 
-function scalarValidationIssues(args) {
-    const {entryType: entryType, validation: validation, value: value} = args;
-    if (validation === void 0 || value === null || value === void 0) return;
-    const measured = scalarMeasurement(entryType, value);
-    if (measured === void 0) return;
-    const issues = [ scalarBoundIssue({
-        entryType: entryType,
-        measured: measured,
-        bound: validation.min,
-        limit: "min"
-    }), scalarBoundIssue({
-        entryType: entryType,
-        measured: measured,
-        bound: validation.max,
-        limit: "max"
-    }) ].filter(issue => issue !== void 0);
+function scalarValidationDeclarationIssues(entry) {
+    const {type: type, validation: validation} = entry;
+    if (validation === void 0) return;
+    if (!SCALAR_VALIDATION_KINDS.has(type)) return [ `\`validation\` is only valid on \`string\` / \`text\` / \`number\` / \`progress\` values, not "${type}"` ];
+    if (type === "progress") {
+        const issues2 = Object.entries(validation).flatMap(([bound, value]) => typeof value == "number" && value >= 0 && value <= 100 ? [] : [ `\`validation.${bound}\` must stay within the progress kind's 0–100 contract` ]);
+        return issues2.length === 0 ? void 0 : issues2;
+    }
+    if (type === "number") return;
+    const issues = Object.entries(validation).flatMap(([bound, value]) => Number.isInteger(value) && value >= 0 ? [] : [ `\`validation.${bound}\` must be a non-negative integer for ${type} length` ]);
     return issues.length === 0 ? void 0 : issues;
 }
 
-function constrainedScalarSchema(args) {
-    const {schema: schema, entryType: entryType, options: options, validation: validation} = args;
-    return options === void 0 && validation === void 0 ? schema : v__namespace.pipe(schema, v__namespace.check(value => choiceValueIssues(options, value) === void 0 && scalarValidationIssues({
-        entryType: entryType,
-        validation: validation,
-        value: value
-    }) === void 0, issue => [ ...choiceValueIssues(options, issue.input) ?? [], ...scalarValidationIssues({
-        entryType: entryType,
-        validation: validation,
-        value: issue.input
-    }) ?? [] ].join("; ")));
+const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
+    editable: StoredEditableSchema,
+    group: StoredGroupMembershipSchema
+})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
+    editable: AuthoringEditableSchema,
+    group: AuthoringGroupMembershipSchema,
+    kind: AuthoringRawFieldKindSchema
+})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck()));
+
+function listSugarFields(type) {
+    return {
+        type: v__namespace.literal(type),
+        ...fieldBase(AuthoringEditableSchema, AuthoringGroupMembershipSchema)
+    };
 }
 
-function objectSchema(args) {
-    const {fields: fields, leaf: leaf} = args, entries = /* @__PURE__ */ Object.create(null);
-    for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema({
-        shape: f,
-        leaf: leaf
-    }));
-    return v__namespace.looseObject(entries);
+const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v__namespace.lazy(input => {
+    const type = asShape(input).type;
+    return type === "todoList" ? TodoListFieldSchema : type === "notes" ? NotesFieldSchema : RawAuthoringFieldEntrySchema;
+})), RUNTIME_KINDS = groqConditionDescribe._exhaustiveOptions()([ "function", "durableFunction", "selfHosted" ]), RuntimeBlockSchema = pinned()(v__namespace.strictObject({
+    kind: picklist(RUNTIME_KINDS)
+})), EffectRuntimeBlockSchema = pinned()(v__namespace.variant("kind", [ v__namespace.strictObject({
+    kind: v__namespace.literal("function"),
+    timeout: v__namespace.optional(PositiveInt),
+    memory: v__namespace.optional(PositiveInt)
+}), v__namespace.strictObject({
+    kind: v__namespace.literal("durableFunction")
+}), v__namespace.strictObject({
+    kind: v__namespace.literal("selfHosted")
+}) ], invalidOptionMessage(RUNTIME_KINDS))), EFFECT_RETRY_KINDS = groqConditionDescribe._exhaustiveOptions()([ "engine" ]), EffectRetryBackoffSchema = pinned()(v__namespace.strictObject({
+    kind: picklist([ "fixed", "exponential" ]),
+    delayMs: PositiveInt
+}));
+
+function effectRetryFields(kind) {
+    return {
+        kind: kind,
+        attempts: PositiveInt,
+        backoff: v__namespace.optional(EffectRetryBackoffSchema),
+        expiryMs: v__namespace.optional(PositiveInt)
+    };
 }
 
-function wholeValueSchema(args) {
-    const {entryType: entryType, shape: shape, leaf: leaf} = args;
-    return entryType === "object" ? v__namespace.union([ v__namespace.null(), objectSchema({
-        fields: shape.fields ?? [],
-        leaf: leaf
-    }) ]) : entryType === "array" ? v__namespace.array(objectSchema({
-        fields: shape.of ?? [],
-        leaf: leaf
-    })) : leaf[entryType];
+const StoredEffectRetrySchema = pinned()(v__namespace.strictObject(effectRetryFields(picklist(EFFECT_RETRY_KINDS)))), AuthoringEffectRetrySchema = pinned()(v__namespace.strictObject(effectRetryFields(v__namespace.optional(picklist(EFFECT_RETRY_KINDS)))));
+
+function effectFields(retry) {
+    return {
+        name: NonEmpty,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        bindings: v__namespace.optional(v__namespace.record(v__namespace.string(), ConditionSchema)),
+        input: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown())),
+        outputs: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
+        retry: v__namespace.optional(retry)
+    };
 }
 
-function appendItemSchema(entryType, shape) {
-    if (entryType === "array") return objectSchema({
-        fields: shape.of ?? [],
-        leaf: valueSchemas
-    });
-    if (entryType === "doc.refs") return GdrShape;
-    if (entryType === "assignees") return AssigneeWriteShape;
+const EffectSchema = pinned()(v__namespace.strictObject(effectFields(StoredEffectRetrySchema))), AuthoringEffectSchema = pinned()(v__namespace.strictObject({
+    ...effectFields(AuthoringEffectRetrySchema),
+    runtime: v__namespace.optional(EffectRuntimeBlockSchema)
+})), DefinitionRefSchema = v__namespace.strictObject({
+    name: NonEmpty,
+    version: v__namespace.optional(v__namespace.union([ PositiveInt, v__namespace.literal("latest") ]))
+}), SubworkflowsSchema = v__namespace.strictObject({
+    forEach: NonEmpty,
+    definition: DefinitionRefSchema,
+    with: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
+    context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
+    onExit: v__namespace.optional(picklist([ "detach", "abort" ]))
+}), ActionParamSchema = v__namespace.pipe(v__namespace.strictObject({
+    type: picklist([ "string", "number", "boolean", "url", "dateTime", "actor", "doc.ref", "doc.refs", "json" ]),
+    name: NonEmpty,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string()),
+    required: v__namespace.optional(v__namespace.boolean()),
+    options: v__namespace.optional(ChoiceOptionsSchema),
+    validation: v__namespace.optional(ScalarValidationSchema)
+}), choiceOptionsCheck(), scalarValidationCheck()), CUSTOM_SEMANTIC_HINT = "`custom.<camelCaseMeaning>`", CustomSemanticSchema = v__namespace.custom(input => typeof input == "string" && /^custom\.[a-z][a-zA-Z0-9]*$/.test(input)), SemanticSchema = v__namespace.union([ picklist(SIGNAL_SEMANTICS), CustomSemanticSchema ], `expected ${SIGNAL_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`), ActionSemanticSchema = v__namespace.union([ picklist(ACTION_SEMANTICS), CustomSemanticSchema ], `expected ${ACTION_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`);
+
+function semanticNamespace(semantic) {
+    return semantic.startsWith("custom.") ? semantic : semantic.split(".", 1)[0] ?? semantic;
 }
 
-function rejectedRefTypes(args) {
-    const {entryType: entryType, types: types, value: value} = args;
-    if (types === void 0 || value === null || value === void 0) return [];
-    if (!refKindAcceptsTypes(entryType)) 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 hasUniqueSemanticNamespaces(semantics) {
+    const namespaces = semantics.map(semanticNamespace);
+    return new Set(namespaces).size === namespaces.length;
 }
 
-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 semanticsFieldSchema(semantic) {
+    return v__namespace.optional(v__namespace.pipe(v__namespace.array(semantic), v__namespace.minLength(1, "declare at least one semantic, or omit `semantics`"), v__namespace.check(hasUniqueSemanticNamespaces, "declare at most one semantic from each namespace")));
 }
 
-function gdrTypeOf(item) {
-    if (typeof item != "object" || item === null) return;
-    const t = item.type;
-    return typeof t == "string" ? t : void 0;
+const SemanticsFieldSchema = semanticsFieldSchema(SemanticSchema), ActionSemanticsFieldSchema = semanticsFieldSchema(ActionSemanticSchema);
+
+function actionFields(schemas) {
+    const {op: op, group: group, effect: effect} = schemas;
+    return {
+        name: NonEmpty,
+        semantics: ActionSemanticsFieldSchema,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        group: v__namespace.optional(group),
+        when: v__namespace.optional(ConditionSchema),
+        filter: v__namespace.optional(ConditionSchema),
+        params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
+        ops: v__namespace.optional(v__namespace.array(op)),
+        effects: v__namespace.optional(v__namespace.array(effect)),
+        spawn: v__namespace.optional(SubworkflowsSchema)
+    };
 }
 
-function parseFieldValue(args) {
-    return checkValueAgainst(args, valueSchemas);
+const StoredActionSchema = pinned()(v__namespace.strictObject({
+    ...actionFields({
+        op: StoredOpSchema,
+        group: StoredGroupMembershipSchema,
+        effect: EffectSchema
+    }),
+    roles: v__namespace.optional(v__namespace.array(NonEmpty))
+})), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(v__namespace.strictObject({
+    ...actionFields({
+        op: AuthoringOpSchema,
+        group: AuthoringGroupMembershipSchema,
+        effect: AuthoringEffectSchema
+    }),
+    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
+    status: v__namespace.optional(TerminalActivityStatus)
+})), AuthoringActionSchema = pinned()(RawAuthoringActionSchema), requirementBase = {
+    name: NonEmpty,
+    title: v__namespace.optional(v__namespace.string()),
+    description: v__namespace.optional(v__namespace.string())
+}, GroqRequirementSchemaRaw = v__namespace.strictObject({
+    ...requirementBase,
+    type: v__namespace.literal("groq"),
+    query: ConditionSchema
+}), SingleSubjectRequirementSchemaRaw = v__namespace.strictObject({
+    ...requirementBase,
+    type: v__namespace.literal("singleSubject")
+}), GroqRequirementSchema = pinned()(GroqRequirementSchemaRaw), StartRequirementSchema = pinned()(v__namespace.variant("type", [ GroqRequirementSchemaRaw, SingleSubjectRequirementSchemaRaw ]));
+
+function activityFields({field: field, action: action, target: target, group: group}) {
+    return {
+        name: NonEmpty,
+        semantics: SemanticsFieldSchema,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
+        group: v__namespace.optional(group),
+        target: v__namespace.optional(target),
+        filter: v__namespace.optional(ConditionSchema),
+        requirements: v__namespace.optional(v__namespace.array(GroqRequirementSchema)),
+        actions: v__namespace.optional(v__namespace.array(action)),
+        fields: v__namespace.optional(v__namespace.array(field))
+    };
 }
 
-function checkValueAgainst(args, leaf) {
-    const schema = wholeValueSchema({
-        entryType: args.entryType,
-        shape: args,
-        leaf: leaf
-    });
-    if (schema === void 0) return {
-        issues: [ `unknown field entry type ${args.entryType}` ]
+const StoredActivitySchema = pinned()(v__namespace.strictObject(activityFields({
+    field: FieldEntrySchema,
+    action: StoredActionSchema,
+    target: StoredManualTargetSchema,
+    group: StoredGroupMembershipSchema
+}))), AuthoringActivitySchema = pinned()(v__namespace.strictObject(activityFields({
+    field: AuthoringFieldEntrySchema,
+    action: AuthoringActionSchema,
+    target: AuthoringManualTargetSchema,
+    group: AuthoringGroupMembershipSchema
+})));
+
+function transitionFields(when) {
+    return {
+        name: NonEmpty,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        to: NonEmpty,
+        when: when
     };
-    const result = v__namespace.safeParse(schema, args.value);
-    if (!result.success) return {
-        issues: formatIssues(result.issues)
+}
+
+const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardActionsSchema = v__namespace.array(GuardActionSchema), NonEmptyGuardActionsSchema = v__namespace.pipe(GuardActionsSchema, v__namespace.minLength(1, GUARD_ACTIONS_REQUIRED_MESSAGE)), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = pinned()(v__namespace.variant("type", [ v__namespace.strictObject({
+    type: v__namespace.literal("self")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("now")
+}), v__namespace.strictObject({
+    type: v__namespace.literal("fieldRead"),
+    field: FieldEntryName,
+    path: v__namespace.optional(GuardReadPath)
+}), v__namespace.strictObject({
+    type: v__namespace.literal("effectsRead"),
+    effect: v__namespace.pipe(NonEmpty, v__namespace.check(name => !name.includes("'"), "an effect name cannot contain `'`")),
+    path: v__namespace.optional(GuardReadPath)
+}) ]));
+
+function guardMatchFields(read, actions) {
+    return {
+        types: v__namespace.optional(v__namespace.array(NonEmpty)),
+        idRefs: v__namespace.optional(v__namespace.array(read)),
+        idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
+        actions: actions
     };
-    const postIssues = refTypeIssues({
-        entryType: args.entryType,
-        types: args.types,
-        value: args.value
-    }) ?? choiceValueIssues(args.options, args.value) ?? scalarValidationIssues({
-        entryType: args.entryType,
-        validation: args.validation,
-        value: args.value
-    }) ?? assignmentValueIssues(args, result.output);
-    return postIssues !== void 0 ? {
-        issues: postIssues
-    } : {
-        output: result.output
+}
+
+function guardFields(read, actions) {
+    return {
+        name: NonEmpty,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        match: v__namespace.strictObject(guardMatchFields(read, actions)),
+        predicate: v__namespace.optional(v__namespace.string()),
+        metadata: v__namespace.optional(v__namespace.record(NonEmpty, read))
     };
 }
 
-function assignmentIdentity(assignee) {
-    return assignee.type === "user" ? `user:${assignee.id}` : `role:${assignee.role}`;
-}
+const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty, GuardActionsSchema)), AuthoringGuardSchema = v__namespace.strictObject(guardFields(GuardReadSchema, NonEmptyGuardActionsSchema));
 
-function assignmentCandidate(value) {
-    const parsed = v__namespace.safeParse(AssigneeShape, value);
-    return parsed.success ? parsed.output : void 0;
+function stageFields({field: field, activity: activity, transition: transition, guard: guard, editable: editable}) {
+    return {
+        name: NonEmpty,
+        semantics: SemanticsFieldSchema,
+        title: v__namespace.optional(v__namespace.string()),
+        description: v__namespace.optional(v__namespace.string()),
+        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
+        activities: v__namespace.optional(v__namespace.array(activity)),
+        transitions: v__namespace.optional(v__namespace.array(transition)),
+        guards: v__namespace.optional(v__namespace.array(guard)),
+        fields: v__namespace.optional(v__namespace.array(field)),
+        editable: v__namespace.optional(v__namespace.record(FieldEntryName, editable))
+    };
 }
 
-function assignmentValueIssues(args, value) {
-    const retained = previousAssignmentIdentities(args), issues = [];
-    return visitAssignmentEntries({
-        entryType: args.entryType,
-        value: value,
-        roles: args.roles,
-        fields: args.fields,
-        of: args.of,
-        path: "$"
-    }, ({assignee: assignee, roles: roles, path: path}) => {
-        consumeRetainedAssignment({
-            retained: retained,
-            path: path,
-            identity: assignmentIdentity(assignee)
-        }) || issues.push(...assignmentCandidateIssues({
-            roles: roles,
-            memberRoles: args.memberRoles,
-            roleAliases: args.roleAliases
-        }, assignee));
-    }), issues.length === 0 ? void 0 : issues;
+const StoredStageSchema = pinned()(v__namespace.strictObject(stageFields({
+    field: FieldEntrySchema,
+    activity: StoredActivitySchema,
+    transition: StoredTransitionSchema,
+    guard: GuardSchema,
+    editable: StoredEditableSchema
+}))), AuthoringStageSchema = pinned()(v__namespace.strictObject(stageFields({
+    field: AuthoringFieldEntrySchema,
+    activity: AuthoringActivitySchema,
+    transition: AuthoringTransitionSchema,
+    guard: AuthoringGuardSchema,
+    editable: AuthoringEditableSchema
+}))), RoleAliasesSchema = pinned()(v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role")))), WORKFLOW_LIFECYCLES = groqConditionDescribe._exhaustiveOptions()([ "standalone", "child" ]), START_KINDS = groqConditionDescribe._exhaustiveOptions()([ "interactive", "autonomous" ]);
+
+function startFields(kind) {
+    return {
+        kind: kind,
+        filter: v__namespace.optional(ConditionSchema),
+        requirements: v__namespace.optional(v__namespace.array(StartRequirementSchema))
+    };
 }
 
-function consumeRetainedAssignment(args) {
-    const identities = args.retained.get(args.path), remaining = identities?.get(args.identity) ?? 0;
-    return remaining === 0 || identities === void 0 ? !1 : (remaining === 1 ? identities.delete(args.identity) : identities.set(args.identity, remaining - 1), 
-    !0);
+const StoredStartSchema = pinned()(v__namespace.strictObject(startFields(picklist(START_KINDS)))), AuthoringStartSchema = pinned()(v__namespace.strictObject(startFields(v__namespace.optional(picklist(START_KINDS)))));
+
+function workflowFields({field: field, stage: stage, start: start}) {
+    return {
+        name: NonEmpty,
+        semantics: SemanticsFieldSchema,
+        title: NonEmpty,
+        description: v__namespace.optional(v__namespace.string()),
+        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
+        lifecycle: v__namespace.optional(picklist(WORKFLOW_LIFECYCLES)),
+        start: v__namespace.optional(start),
+        initialStage: NonEmpty,
+        fields: v__namespace.optional(v__namespace.array(field)),
+        stages: v__namespace.pipe(v__namespace.array(stage), v__namespace.minLength(1, "must declare at least one stage")),
+        predicates: v__namespace.optional(v__namespace.record(groqIdentifier("`$<name>`"), ConditionSchema)),
+        roleAliases: v__namespace.optional(RoleAliasesSchema)
+    };
 }
 
-function previousAssignmentIdentities(args) {
-    const retained = /* @__PURE__ */ new Map;
-    if (args.previousValue === void 0 || args.entryType === "assignee") return retained;
-    const schema = wholeValueSchema({
-        entryType: args.entryType,
-        shape: args,
-        leaf: valueSchemas
+const WorkflowDefinitionSchema = pinned()(v__namespace.strictObject(workflowFields({
+    field: FieldEntrySchema,
+    stage: StoredStageSchema,
+    start: StoredStartSchema
+})));
+
+function parseStoredDefinition(input, label) {
+    return parseOrThrow({
+        schema: WorkflowDefinitionSchema,
+        input: input,
+        label: label
     });
-    if (schema === void 0) return retained;
-    const previous = v__namespace.safeParse(schema, args.previousValue);
-    return previous.success && visitAssignmentEntries({
-        entryType: args.entryType,
-        value: previous.output,
-        roles: args.roles,
-        fields: args.fields,
-        of: args.of,
-        path: "$"
-    }, ({assignee: assignee, path: path}) => {
-        const identities = retained.get(path) ?? /* @__PURE__ */ new Map, identity = assignmentIdentity(assignee);
-        identities.set(identity, (identities.get(identity) ?? 0) + 1), retained.set(path, identities);
-    }), retained;
 }
 
-function visitAssignmentEntries(args, visit) {
-    if (assignmentKindAcceptsRoles(args.entryType)) {
-        visitAssignmentCandidates(args, visit);
-        return;
-    }
-    if (args.entryType === "object") {
-        visitAssignmentFields({
-            fields: args.fields,
-            value: args.value,
-            path: args.path
-        }, visit);
-        return;
-    }
-    if (!(args.entryType !== "array" || !Array.isArray(args.value))) for (const row of args.value) visitAssignmentFields({
-        fields: args.of,
-        value: row,
-        path: `${args.path}[]`
-    }, visit);
-}
+const AuthoringWorkflowSchema = pinned()(v__namespace.strictObject({
+    ...workflowFields({
+        field: AuthoringFieldEntrySchema,
+        stage: AuthoringStageSchema,
+        start: AuthoringStartSchema
+    }),
+    runtime: v__namespace.optional(RuntimeBlockSchema)
+})), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
 
-function visitAssignmentCandidates(args, visit) {
-    if (args.roles === void 0) return;
-    const indexedValues = args.entryType === "assignees" && Array.isArray(args.value) ? args.value.map(value => ({
-        value: value,
-        path: args.path
-    })) : [ {
-        value: args.value,
-        path: args.path
-    } ];
-    for (const {value: value, path: path} of indexedValues) {
-        const assignee = assignmentCandidate(value);
-        assignee !== void 0 && visit({
-            assignee: assignee,
-            roles: args.roles,
-            path: path
-        });
-    }
+function isStartableDefinition(definition) {
+    return definition.lifecycle !== "child";
 }
 
-function visitAssignmentFields(args, visit) {
-    if (!(args.fields === void 0 || !isRecord(args.value))) for (const field of args.fields) visitAssignmentShape({
-        shape: field,
-        value: args.value[field.name],
-        path: `${args.path}.${field.name}`
-    }, visit);
+function startKindOf(definition) {
+    return definition.start?.kind ?? "interactive";
 }
 
-function visitAssignmentShape(args, visit) {
-    visitAssignmentEntries({
-        entryType: args.shape.type,
-        value: args.value,
-        roles: args.shape.roles,
-        fields: args.shape.fields,
-        of: args.shape.of,
-        path: args.path
-    }, visit);
+function isSubjectEntry(entry) {
+    return entry.type === "subject";
 }
 
-function assignmentCandidateIssues(args, assignee) {
-    if (assignee.type === "role") return collectiveRoleIssues(args, assignee.role);
-    const held = args.memberRoles?.[assignee.id];
-    return held === void 0 ? args.memberRoles === void 0 ? [] : [ `user "${assignee.id}" has no available project membership for role eligibility` ] : args.roles.some(required => actorFulfillsRole({
-        actorRoles: held,
-        required: required,
-        aliases: args.roleAliases
-    })) ? [] : [ `user "${assignee.id}" does not fulfill any eligible role: ${formatEligibleRoles(args.roles)}` ];
+function isDueDateEntry(entry) {
+    return entry.type === "dueDate" || entry.type === "dueDatetime";
 }
 
-function collectiveRoleIssues(args, role) {
-    return args.roles.includes(role) ? [] : [ `collective role "${role}" is not eligible — this entry accepts ${formatEligibleRoles(args.roles)}` ];
+function isInputSourced(entry) {
+    return entry.initialValue?.type === "input";
 }
 
-function formatEligibleRoles(roles) {
-    return roles.map(role => `"${role}"`).join(", ");
+function parseOrThrow({schema: schema, input: input, label: label}) {
+    const result = v__namespace.safeParse(schema, input);
+    if (!result.success) throw new Error(formatValidationError(label, issuesFromValibot(result.issues)));
+    return result.output;
 }
 
-function issuesOf(check) {
-    return "issues" in check ? check.issues : void 0;
+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 validateFieldValue(args) {
-    const check = checkValueAgainst(args, valueSchemas);
-    if ("issues" in check) throw new FieldValueShapeError({
-        entryType: args.entryType,
-        entryName: args.entryName,
-        issues: check.issues,
-        mode: "value"
-    });
-    return check.output;
+const NonEmptyString = v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("must not be empty"));
+
+function asPredicate(validate) {
+    return value => {
+        try {
+            return validate(value), !0;
+        } catch {
+            return !1;
+        }
+    };
 }
 
-const BARE_ID_SOURCE = "[A-Za-z0-9_][A-Za-z0-9._-]*", BARE_ID_RE = new RegExp(`^${BARE_ID_SOURCE}$`), ALIAS_REF_RE = new RegExp(`^@${RESOURCE_ALIAS_NAME_SOURCE}:${BARE_ID_SOURCE}$`);
+const isValidTag = asPredicate(validateTag), isValidAliasName = asPredicate(validateResourceAliasName), isValidDatasetId = asPredicate(datasetResourceParts);
 
-function isAuthoringRefId(id) {
-    return id.startsWith("@") ? ALIAS_REF_RE.test(id) : id.includes(":") ? isGdrUri(id) : BARE_ID_RE.test(id);
+function lakeSegment(label) {
+    return v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty(), v__namespace.check(isValidTag, `invalid ${label} — ${LAKE_ID_SEGMENT_GLOSS}`));
 }
 
-function isBareSeedId(id) {
-    return BARE_ID_RE.test(id);
-}
+const WorkflowResourceSchema = v__namespace.variant("type", [ v__namespace.object({
+    type: v__namespace.literal("dataset"),
+    id: v__namespace.pipe(NonEmptyString, v__namespace.check(isValidDatasetId, 'invalid dataset resource id — expected "<projectId>.<dataset>"'))
+}), v__namespace.object({
+    type: v__namespace.literal("canvas"),
+    id: NonEmptyString
+}), v__namespace.object({
+    type: v__namespace.literal("media-library"),
+    id: NonEmptyString
+}), v__namespace.object({
+    type: v__namespace.literal("dashboard"),
+    id: NonEmptyString
+}) ]), ResourceBindingSchema = v__namespace.object({
+    name: v__namespace.pipe(NonEmptyString, v__namespace.check(isValidAliasName, "invalid resource handle name — lowercase letters, digits and dashes only, no leading dash")),
+    resource: WorkflowResourceSchema
+}), DefinitionSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.name == "string", "expected a workflow definition (an object with a string `name`)"), DeploymentSchema = v__namespace.object({
+    name: lakeSegment("name"),
+    expectedMinReaderModel: v__namespace.optional(v__namespace.custom(() => !0), void 0),
+    tag: lakeSegment("tag"),
+    workflowResource: WorkflowResourceSchema,
+    resourceAliases: v__namespace.optional(v__namespace.pipe(v__namespace.array(ResourceBindingSchema), v__namespace.check(bindings => duplicateHandleMessage(bindings) === void 0, issue => duplicateHandleMessage(issue.input) ?? "duplicate resource handle name"))),
+    definitions: v__namespace.pipe(v__namespace.array(DefinitionSchema), v__namespace.minLength(1, "a deployment needs at least one definition")),
+    runtime: v__namespace.optional(RuntimeBlockSchema)
+});
 
-const AuthoringRefId = v__namespace.pipe(v__namespace.string(), v__namespace.check(isAuthoringRefId, "must be a bare document id, a GDR URI, or a portable `@<alias>:<id>` reference")), AuthoringGdrShape = v__namespace.looseObject({
-    id: AuthoringRefId,
-    type: NonEmptyString
-}), seedValueSchemas = {
-    ...valueSchemas,
-    "doc.ref": v__namespace.union([ v__namespace.null(), AuthoringGdrShape ]),
-    "doc.refs": v__namespace.array(AuthoringGdrShape),
-    subject: v__namespace.union([ v__namespace.null(), AuthoringGdrShape ]),
-    "release.ref": v__namespace.union([ v__namespace.null(), v__namespace.looseObject({
-        id: AuthoringRefId,
-        type: v__namespace.literal("system.release"),
-        releaseName: NonEmptyString
-    }) ])
-};
+function firstDuplicatePair(items, keyOf) {
+    const seen = /* @__PURE__ */ new Map;
+    for (const item of items) {
+        const key = keyOf(item), earlier = seen.get(key);
+        if (earlier !== void 0) return [ earlier, item ];
+        seen.set(key, item);
+    }
+}
 
-function checkLiteralSeed(args) {
-    return args.value === null ? [ "a literal seed cannot be null — omit `initialValue` to start the field empty" ] : issuesOf(checkValueAgainst(args, seedValueSchemas));
+function duplicateHandleMessage(bindings) {
+    const pair = firstDuplicatePair(bindings, binding => binding.name);
+    if (pair !== void 0) return `duplicate resource handle name "${pair[1].name}" — each binding name must be unique within a deployment`;
 }
 
-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__namespace.safeParse(schema, args.item);
-    if (!result.success) throw new FieldValueShapeError({
-        entryType: args.entryType,
-        entryName: args.entryName,
-        issues: formatIssues(result.issues),
-        mode: "item"
-    });
-    const assignmentArgs = {
-        entryType: appendAssignmentEntryType(args.entryType),
-        value: result.output,
-        roles: args.roles,
-        fields: args.entryType === "array" ? args.of : void 0,
-        memberRoles: args.memberRoles,
-        roleAliases: args.roleAliases
-    }, assignmentIssues = assignmentValueIssues(assignmentArgs, result.output);
-    if (assignmentIssues !== void 0) throw new FieldValueShapeError({
-        entryType: args.entryType,
-        entryName: args.entryName,
-        issues: assignmentIssues,
-        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"
-    });
-    return result.output;
+function duplicateNameMessage(deployments) {
+    const pair = firstDuplicatePair(deployments, deployment => deployment.name);
+    if (pair !== void 0) return `duplicate deployment name "${pair[1].name}" — each deployment must use a unique name`;
 }
 
-function appendAssignmentEntryType(entryType) {
-    return entryType === "assignees" ? "assignee" : entryType === "array" ? "object" : entryType;
+function partitionKey(deployment) {
+    return `${resourceGdr(deployment.workflowResource)} ${deployment.tag}`;
 }
 
-function formatIssues(issues, formatMessage = issue => issue.message) {
-    const formatOne = (issue, prefix) => {
-        const keys = [ ...prefix, ...issue.path?.map(p => p.key) ?? [] ], sub = issue.issues?.filter(candidate => candidate.expected !== "null");
-        return sub !== void 0 && sub.length > 0 ? sub.flatMap(candidate => formatOne(candidate, keys)) : [ `${keys.length > 0 ? `at ${keys.join(".")}: ` : ""}${formatMessage(issue)}` ];
-    };
-    return issues.flatMap(issue => formatOne(issue, []));
+function partitionCollisionMessage(deployments) {
+    const pair = firstDuplicatePair(deployments, partitionKey);
+    if (pair === void 0) return;
+    const [first, second] = pair;
+    return `deployments "${first.name}" and "${second.name}" share workflow resource + tag "${second.tag}" — both would write into the same partition; change one deployment’s tag or resource`;
 }
 
-const NonEmpty = NonEmptyString, PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const TelemetryLoggerSchema = v__namespace.custom(input => typeof input == "object" && input !== null && typeof input.log == "function", "expected a telemetry logger (an object with a `log` function)"), WorkflowConfigSchema = v__namespace.object({
+    deployments: v__namespace.pipe(v__namespace.array(DeploymentSchema), v__namespace.minLength(1, "a config needs at least one deployment"), v__namespace.check(deployments => duplicateNameMessage(deployments) === void 0, issue => duplicateNameMessage(issue.input) ?? "duplicate deployment name"), v__namespace.check(deployments => partitionCollisionMessage(deployments) === void 0, issue => partitionCollisionMessage(issue.input) ?? "duplicate deployment partition")),
+    telemetry: v__namespace.optional(TelemetryLoggerSchema)
+});
 
-function groqIdentifier(referencedAs) {
-    return v__namespace.pipe(v__namespace.string(), v__namespace.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 resourceAliasesToMap(resourceAliases) {
+    return Object.fromEntries((resourceAliases ?? []).map(binding => [ binding.name, binding.resource ]));
 }
 
-function picklist(options) {
-    return v__namespace.picklist(options, invalidOptionMessage(options));
-}
+const FIELD_READ = /^\$fields\.(\w+)(?:\.(.+))?$/, EFFECTS_READ = /^\$effects\['([^']+)'\](?:\.(.+))?$/;
 
-function invalidOptionMessage(options) {
-    return `Invalid option: expected one of ${options.map(option => `"${option}"`).join("|")}`;
+function isGuardReadExpr(expr) {
+    return expr === "$self" || expr === "$now" || FIELD_READ.test(expr) || EFFECTS_READ.test(expr);
 }
 
-function exhaustiveOptions() {
-    return options => options;
+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}`;
+    }
 }
 
-function pinned() {
-    return (schema, ..._exact) => schema;
+function groq(strings, ...values) {
+    return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
 }
 
-const LiteralSchema = v__namespace.strictObject({
-    type: v__namespace.literal("literal"),
-    value: v__namespace.unknown()
-}), FieldReadSchema = v__namespace.strictObject({
-    type: v__namespace.literal("fieldRead"),
-    scope: v__namespace.optional(v__namespace.union([ v__namespace.literal("workflow"), v__namespace.literal("stage") ])),
-    field: NonEmpty,
-    path: v__namespace.optional(v__namespace.string())
-}), FieldSourceSchema = v__namespace.variant("type", [ v__namespace.strictObject({
-    type: v__namespace.literal("input")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("query"),
-    query: NonEmpty
-}), LiteralSchema, FieldReadSchema ]), ValueExprSchema = v__namespace.lazy(() => v__namespace.variant("type", [ LiteralSchema, FieldReadSchema, v__namespace.strictObject({
-    type: v__namespace.literal("param"),
-    param: NonEmpty
-}), v__namespace.strictObject({
-    type: v__namespace.literal("actor")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("now")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("self")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("stage")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("object"),
-    fields: v__namespace.record(NonEmpty, ValueExprSchema)
-}) ])), StoredFieldRefSchema = v__namespace.strictObject({
-    scope: picklist(FIELD_SCOPES),
-    field: NonEmpty
-}), AuthoringFieldRefSchema = v__namespace.strictObject({
-    scope: v__namespace.optional(picklist(FIELD_SCOPES)),
-    field: NonEmpty
-}), HREF_SCHEMES = [ "http:", "https:" ];
+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 isHttpUrl(value) {
-    try {
-        return HREF_SCHEMES.includes(new URL(value).protocol);
-    } catch {
-        return !1;
-    }
+function desugarWorkflow(authoring) {
+    const issues = [];
+    checkReservedRoleAliasKeys(authoring.roleAliases, issues);
+    const roleAliases = normalizeRoleAliases(authoring.roleAliases), ctx = {
+        issues: issues,
+        roleAliases: roleAliases,
+        effectRuntime: /* @__PURE__ */ new Map
+    }, 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,
+                semantics: stage.semantics,
+                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 {
+        definition: {
+            ...stripUndefined({
+                name: authoring.name,
+                semantics: authoring.semantics,
+                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
+        },
+        runtime: collectRuntime({
+            authoring: authoring,
+            ctx: ctx
+        }),
+        issues: ctx.issues
+    };
 }
 
-const UrlString = v__namespace.pipe(v__namespace.string(), v__namespace.url("must be a valid URL"), v__namespace.check(isHttpUrl, "must be an http(s) URL"));
+function collectRuntime(args) {
+    const {kind: kind} = args.authoring.runtime ?? {}, effects = Object.fromEntries(args.ctx.effectRuntime), declared = {
+        ...kind === void 0 ? {} : {
+            kind: kind
+        },
+        ...Object.keys(effects).length === 0 ? {} : {
+            effects: effects
+        }
+    };
+    return Object.keys(declared).length === 0 ? void 0 : declared;
+}
+
+function desugarEffect(args) {
+    const {runtime: runtime, ...effect} = args.effect;
+    runtime !== void 0 && args.ctx.effectRuntime.set(effect.name, runtime);
+    const {retry: retry} = effect;
+    return retry === void 0 ? effect : {
+        ...effect,
+        retry: {
+            ...retry,
+            kind: retry.kind ?? "engine"
+        }
+    };
+}
 
-function manualTargetSchema(ref) {
-    return v__namespace.variant("type", [ v__namespace.strictObject({
-        type: v__namespace.literal("url"),
-        url: UrlString
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field"),
-        field: ref
-    }) ]);
+function desugarStart(start) {
+    if (start !== void 0) return {
+        kind: start.kind ?? "interactive",
+        ...start.filter !== void 0 ? {
+            filter: start.filter
+        } : {},
+        ...start.requirements !== void 0 ? {
+            requirements: start.requirements
+        } : {}
+    };
 }
 
-const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ])), ConditionSchema = NonEmpty;
-
-function opSchemas(targetSchema) {
-    return [ v__namespace.strictObject({
-        type: v__namespace.literal("field.set"),
-        target: targetSchema,
-        value: ValueExprSchema
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.setIfMissing"),
-        target: targetSchema,
-        value: ValueExprSchema
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.unset"),
-        target: targetSchema
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.append"),
-        target: targetSchema,
-        value: ValueExprSchema
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.inc"),
-        target: targetSchema,
-        value: v__namespace.optional(ValueExprSchema)
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.dec"),
-        target: targetSchema,
-        value: v__namespace.optional(ValueExprSchema)
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.updateWhere"),
-        target: targetSchema,
-        where: ConditionSchema,
-        value: ValueExprSchema
-    }), v__namespace.strictObject({
-        type: v__namespace.literal("field.removeWhere"),
-        target: targetSchema,
-        where: ConditionSchema
-    }) ];
+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 StoredFieldOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema) ]), StoredOpSchema = v__namespace.variant("type", [ ...opSchemas(StoredFieldRefSchema), v__namespace.strictObject({
-    type: v__namespace.literal("status.set"),
-    activity: NonEmpty,
-    status: picklist(ACTIVITY_STATUSES)
-}) ]), AuditOpSchema = v__namespace.strictObject({
-    type: v__namespace.literal("audit"),
-    target: AuthoringFieldRefSchema,
-    value: ValueExprSchema,
-    stampFields: v__namespace.optional(v__namespace.strictObject({
-        actor: v__namespace.optional(NonEmpty),
-        at: v__namespace.optional(NonEmpty)
-    }))
-}), AuthoringOpSchema = v__namespace.variant("type", [ ...opSchemas(AuthoringFieldRefSchema), v__namespace.strictObject({
-    type: v__namespace.literal("status.set"),
-    activity: v__namespace.optional(NonEmpty),
-    status: picklist(ACTIVITY_STATUSES)
-}), AuditOpSchema ]), GroupName = v__namespace.pipe(v__namespace.string(), v__namespace.regex(GROQ_IDENTIFIER, "must be an identifier (letters, digits, underscore; not starting with a digit)")), GroupSchema = pinned()(v__namespace.strictObject({
-    name: GroupName,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    kind: v__namespace.optional(picklist(GROUP_KINDS))
-})), GroupNameList = v__namespace.pipe(v__namespace.array(GroupName), v__namespace.minLength(1, "name at least one group, or omit `group`"), v__namespace.check(names => new Set(names).size === names.length, "a group is listed more than once — list each group once")), StoredGroupMembershipSchema = GroupNameList, AuthoringGroupMembershipSchema = v__namespace.union([ GroupName, GroupNameList ]);
+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 groupMembershipNames(group) {
-    return group === void 0 ? [] : typeof group == "string" ? [ group ] : [ ...group ];
+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
+    }));
 }
 
-const FIELD_VALUE_KINDS = [ "doc.ref", "doc.refs", "subject", "release.ref", "string", "text", "number", "progress", "boolean", "date", "dueDate", "datetime", "dueDatetime", "url", "actor", "assignee", "assignees", "object", "array" ], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), AUTHORING_FIELD_SUGAR_KINDS = exhaustiveOptions()([ "claim", "todoList", "notes" ]), AUTHORING_FIELD_KINDS = [ ...FIELD_VALUE_KINDS, ...AUTHORING_FIELD_SUGAR_KINDS ], AuthoringRawFieldKindSchema = v__namespace.picklist(FIELD_VALUE_KINDS, issue => `${invalidOptionMessage(AUTHORING_FIELD_KINDS)} but received ${JSON.stringify(issue.input)}`), FieldEntryName = groqIdentifier("`$fields.<name>`"), FiniteNumber = v__namespace.pipe(v__namespace.number(), v__namespace.finite("must be finite")), ScalarValidationSchema = v__namespace.pipe(v__namespace.strictObject({
-    min: v__namespace.optional(FiniteNumber),
-    max: v__namespace.optional(FiniteNumber)
-}), v__namespace.check(validation => validation.min !== void 0 || validation.max !== void 0, "declare at least one bound, or omit `validation`"), v__namespace.check(validation => validation.min === void 0 || validation.max === void 0 || validation.min <= validation.max, "`min` must be less than or equal to `max`")), ChoiceOptionsSchema = v__namespace.strictObject({
-    list: v__namespace.pipe(v__namespace.array(v__namespace.strictObject({
-        title: NonEmpty,
-        value: v__namespace.union([ v__namespace.string(), v__namespace.number() ])
-    })), v__namespace.minLength(1, "declare at least one choice, or omit `options`"))
-});
+function desugarFieldEntry({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,
+            options: entry.options,
+            validation: entry.validation,
+            types: entry.types,
+            roles: entry.roles,
+            fields: entry.fields,
+            of: entry.of
+        })
+    };
+}
 
-function asShape(input) {
-    return typeof input == "object" && input !== null ? input : {};
+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 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 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 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 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 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 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 compositeChecked(entries) {
-    return v__namespace.pipe(v__namespace.strictObject(entries), v__namespace.check(input => compositeShapeOk(input), issue => compositeShapeMessage(issue.input)), v__namespace.check(input => duplicateSubfieldName(input) === void 0, issue => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" — sub-field names must be unique within \`fields\` / \`of\``));
+function layerOf(entries) {
+    return new Map((entries ?? []).map(entry => [ entry.name, entry ]));
 }
 
-const AssignmentRolesSchema = v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one eligible role, or omit `roles`")), FieldShapeSchema = v__namespace.lazy(() => v__namespace.pipe(compositeChecked({
-    type: FieldValueKindSchema,
-    name: FieldEntryName,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    options: v__namespace.optional(ChoiceOptionsSchema),
-    validation: v__namespace.optional(ScalarValidationSchema),
-    roles: v__namespace.optional(AssignmentRolesSchema),
-    fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
-    of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
-}), choiceOptionsCheck(), scalarValidationCheck(), assignmentRolesCheck())), StoredEditableSchema = v__namespace.union([ v__namespace.literal(!0), NonEmpty ]), AuthoringEditableSchema = v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]);
+function normalizeGroup(group) {
+    return group === void 0 || Array.isArray(group) ? group : [ group ];
+}
 
-function fieldBase(editable, group) {
-    return {
-        name: FieldEntryName,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        group: v__namespace.optional(group),
-        required: v__namespace.optional(v__namespace.boolean()),
-        initialValue: v__namespace.optional(FieldSourceSchema),
-        editable: v__namespace.optional(editable)
+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,
+            semantics: activity.semantics,
+            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
+        } : {}
     };
 }
 
-function fieldEntryFields({editable: editable, group: group, kind: kind = FieldKindSchema}) {
-    return {
-        type: kind,
-        ...fieldBase(editable, group),
-        options: v__namespace.optional(ChoiceOptionsSchema),
-        validation: v__namespace.optional(ScalarValidationSchema),
-        types: v__namespace.optional(v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one accepted type, or omit `types` to accept any"))),
-        roles: v__namespace.optional(AssignmentRolesSchema),
-        fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
-        of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
+const TARGET_DOC_KINDS = [ "doc.ref", "doc.refs", "subject", "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 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,
-        options: entry.options,
-        validation: entry.validation,
-        roles: entry.roles
+function reportEmptyActionRoles({action: action, path: path, 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"
     });
 }
 
-function literalSeedCheck() {
-    return v__namespace.check(entry => literalSeedIssues(entry) === void 0, issue => `initialValue literal does not fit the declared kind: ${(literalSeedIssues(issue.input) ?? []).join("; ")}`);
+function desugarActionOps(args) {
+    const {action: action, path: path, env: env, activityName: activityName, ctx: ctx} = args, 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
+    }), ops;
 }
 
-function refTypesCheck() {
-    return v__namespace.check(entry => entry.types === void 0 || refKindAcceptsTypes(entry.type), issue => `\`types\` is only valid on \`doc.ref\` / \`doc.refs\` / \`subject\` entries, not "${issue.input.type}"`);
+function desugarAction({action: action, path: path, env: env, activityName: activityName, ctx: ctx}) {
+    reportEmptyActionRoles({
+        action: action,
+        path: path,
+        ctx: ctx
+    });
+    const cascadeFired = isCascadeFired(action), filter = cascadeFired ? action.filter : andConditions([ rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = desugarActionOps({
+        action: action,
+        path: path,
+        env: env,
+        activityName: activityName,
+        ctx: ctx
+    });
+    return {
+        ...stripUndefined({
+            name: action.name,
+            semantics: action.semantics,
+            title: action.title,
+            description: action.description,
+            group: normalizeGroup(action.group),
+            when: action.when,
+            params: action.params,
+            effects: action.effects?.map(effect => desugarEffect({
+                effect: effect,
+                ctx: ctx
+            })),
+            spawn: action.spawn
+        }),
+        ...cascadeFired && action.roles !== void 0 && action.roles.length > 0 ? {
+            roles: action.roles
+        } : {},
+        ...filter ? {
+            filter: filter
+        } : {},
+        ...ops.length > 0 ? {
+            ops: ops
+        } : {}
+    };
 }
 
-function assignmentRolesCheck() {
-    return v__namespace.check(entry => entry.roles === void 0 || assignmentKindAcceptsRoles(entry.type), issue => `\`roles\` is only valid on \`assignee\` / \`assignees\` entries, not "${issue.input.type}"`);
-}
+const DEFAULT_TRANSITION_WHEN = "$allActivitiesDone";
 
-function choiceOptionsCheck() {
-    return v__namespace.check(entry => checkChoiceList({
-        entryType: entry.type,
-        options: entry.options,
-        validation: entry.validation
-    }) === void 0, issue => (checkChoiceList({
-        entryType: issue.input.type,
-        options: issue.input.options,
-        validation: issue.input.validation
-    }) ?? []).join("; "));
+function desugarTransition({transition: transition}) {
+    return {
+        ...stripUndefined({
+            name: transition.name,
+            title: transition.title,
+            description: transition.description,
+            to: transition.to
+        }),
+        when: transition.when ?? DEFAULT_TRANSITION_WHEN
+    };
 }
 
-const SCALAR_VALIDATION_KINDS = /* @__PURE__ */ new Set([ "string", "text", "number", "progress" ]);
-
-function scalarValidationCheck() {
-    return v__namespace.check(entry => scalarValidationDeclarationIssues(entry) === void 0, issue => (scalarValidationDeclarationIssues(issue.input) ?? []).join("; "));
+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 scalarValidationDeclarationIssues(entry) {
-    const {type: type, validation: validation} = entry;
-    if (validation === void 0) return;
-    if (!SCALAR_VALIDATION_KINDS.has(type)) return [ `\`validation\` is only valid on \`string\` / \`text\` / \`number\` / \`progress\` values, not "${type}"` ];
-    if (type === "progress") {
-        const issues2 = Object.entries(validation).flatMap(([bound, value]) => typeof value == "number" && value >= 0 && value <= 100 ? [] : [ `\`validation.${bound}\` must stay within the progress kind's 0–100 contract` ]);
-        return issues2.length === 0 ? void 0 : issues2;
-    }
-    if (type === "number") return;
-    const issues = Object.entries(validation).flatMap(([bound, value]) => Number.isInteger(value) && value >= 0 ? [] : [ `\`validation.${bound}\` must be a non-negative integer for ${type} length` ]);
-    return issues.length === 0 ? void 0 : issues;
+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
+    }));
 }
 
-const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
-    editable: StoredEditableSchema,
-    group: StoredGroupMembershipSchema
-})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
-    editable: AuthoringEditableSchema,
-    group: AuthoringGroupMembershipSchema,
-    kind: AuthoringRawFieldKindSchema
-})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
-    type: v__namespace.literal("claim"),
-    name: FieldEntryName,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    group: v__namespace.optional(AuthoringGroupMembershipSchema)
-}));
-
-function listSugarFields(type) {
+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 {
-        type: v__namespace.literal(type),
-        ...fieldBase(AuthoringEditableSchema, AuthoringGroupMembershipSchema)
+        ...op,
+        target: target
     };
 }
 
-const TodoListFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("todoList"))), NotesFieldSchema = pinned()(v__namespace.strictObject(listSugarFields("notes"))), AuthoringFieldEntrySchema = pinned()(v__namespace.lazy(input => {
-    const type = asShape(input).type;
-    return type === "claim" ? ClaimFieldSchema : type === "todoList" ? TodoListFieldSchema : type === "notes" ? NotesFieldSchema : RawAuthoringFieldEntrySchema;
-})), EffectSchema = v__namespace.strictObject({
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    bindings: v__namespace.optional(v__namespace.record(v__namespace.string(), ConditionSchema)),
-    input: v__namespace.optional(v__namespace.record(v__namespace.string(), v__namespace.unknown())),
-    outputs: v__namespace.optional(v__namespace.array(FieldShapeSchema))
-}), DefinitionRefSchema = v__namespace.strictObject({
-    name: NonEmpty,
-    version: v__namespace.optional(v__namespace.union([ PositiveInt, v__namespace.literal("latest") ]))
-}), SubworkflowsSchema = v__namespace.strictObject({
-    forEach: NonEmpty,
-    definition: DefinitionRefSchema,
-    with: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
-    context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
-    onExit: v__namespace.optional(picklist([ "detach", "abort" ]))
-}), ActionParamSchema = v__namespace.pipe(v__namespace.strictObject({
-    type: picklist([ "string", "number", "boolean", "url", "dateTime", "actor", "doc.ref", "doc.refs", "json" ]),
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    required: v__namespace.optional(v__namespace.boolean()),
-    options: v__namespace.optional(ChoiceOptionsSchema),
-    validation: v__namespace.optional(ScalarValidationSchema)
-}), choiceOptionsCheck(), scalarValidationCheck()), CUSTOM_SEMANTIC_HINT = "`custom.<camelCaseMeaning>`", CustomSemanticSchema = v__namespace.custom(input => typeof input == "string" && /^custom\.[a-z][a-zA-Z0-9]*$/.test(input)), SemanticSchema = v__namespace.union([ picklist(SIGNAL_SEMANTICS), CustomSemanticSchema ], `expected ${SIGNAL_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`), ActionSemanticSchema = v__namespace.union([ picklist(ACTION_SEMANTICS), CustomSemanticSchema ], `expected ${ACTION_SEMANTICS.join(", ")}, or ${CUSTOM_SEMANTIC_HINT}`);
+const AUDIT_STAMPS = {
+    actor: {
+        type: "actor"
+    },
+    at: {
+        type: "now"
+    }
+};
 
-function semanticNamespace(semantic) {
-    return semantic.startsWith("custom.") ? semantic : semantic.split(".", 1)[0] ?? semantic;
+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 hasUniqueSemanticNamespaces(semantics) {
-    const namespaces = semantics.map(semanticNamespace);
-    return new Set(namespaces).size === namespaces.length;
+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 semanticsFieldSchema(semantic) {
-    return v__namespace.optional(v__namespace.pipe(v__namespace.array(semantic), v__namespace.minLength(1, "declare at least one semantic, or omit `semantics`"), v__namespace.check(hasUniqueSemanticNamespaces, "declare at most one semantic from each namespace")));
+function entryAt(env, ref) {
+    return env.layers.find(l => l.scope === ref.scope)?.entries.get(ref.field);
 }
 
-const SemanticsFieldSchema = semanticsFieldSchema(SemanticSchema), ActionSemanticsFieldSchema = semanticsFieldSchema(ActionSemanticSchema);
-
-function actionFields(op, group) {
+function fallbackRef(ref) {
     return {
-        name: NonEmpty,
-        semantics: ActionSemanticsFieldSchema,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        group: v__namespace.optional(group),
-        when: v__namespace.optional(ConditionSchema),
-        filter: v__namespace.optional(ConditionSchema),
-        params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
-        ops: v__namespace.optional(v__namespace.array(op)),
-        effects: v__namespace.optional(v__namespace.array(EffectSchema)),
-        spawn: v__namespace.optional(SubworkflowsSchema)
+        scope: ref.scope ?? "workflow",
+        field: ref.field
     };
 }
 
-const StoredActionSchema = pinned()(v__namespace.strictObject({
-    ...actionFields(StoredOpSchema, StoredGroupMembershipSchema),
-    roles: v__namespace.optional(v__namespace.array(NonEmpty))
-})), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = pinned()(v__namespace.strictObject({
-    ...actionFields(AuthoringOpSchema, AuthoringGroupMembershipSchema),
-    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-    status: v__namespace.optional(TerminalActivityStatus)
-})), ClaimActionSchema = pinned()(v__namespace.strictObject({
-    type: v__namespace.literal("claim"),
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string()),
-    group: v__namespace.optional(AuthoringGroupMembershipSchema),
-    field: v__namespace.union([ NonEmpty, AuthoringFieldRefSchema ]),
-    roles: v__namespace.optional(v__namespace.array(NonEmpty)),
-    filter: v__namespace.optional(ConditionSchema),
-    params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
-    effects: v__namespace.optional(v__namespace.array(EffectSchema))
-})), AuthoringActionSchema = pinned()(v__namespace.lazy(input => typeof input == "object" && input !== null && "type" in input ? ClaimActionSchema : RawAuthoringActionSchema)), requirementBase = {
-    name: NonEmpty,
-    title: v__namespace.optional(v__namespace.string()),
-    description: v__namespace.optional(v__namespace.string())
-}, GroqRequirementSchemaRaw = v__namespace.strictObject({
-    ...requirementBase,
-    type: v__namespace.literal("groq"),
-    query: ConditionSchema
-}), SingleSubjectRequirementSchemaRaw = v__namespace.strictObject({
-    ...requirementBase,
-    type: v__namespace.literal("singleSubject")
-}), GroqRequirementSchema = pinned()(GroqRequirementSchemaRaw), StartRequirementSchema = pinned()(v__namespace.variant("type", [ GroqRequirementSchemaRaw, SingleSubjectRequirementSchemaRaw ]));
-
-function activityFields({field: field, action: action, target: target, group: group}) {
-    return {
-        name: NonEmpty,
-        semantics: SemanticsFieldSchema,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
-        group: v__namespace.optional(group),
-        target: v__namespace.optional(target),
-        filter: v__namespace.optional(ConditionSchema),
-        requirements: v__namespace.optional(v__namespace.array(GroqRequirementSchema)),
-        actions: v__namespace.optional(v__namespace.array(action)),
-        fields: v__namespace.optional(v__namespace.array(field))
-    };
+function rolesCondition(roles, aliases) {
+    if (!(!roles || roles.length === 0)) return groq`count($actor.roles[@ in ${expandRequiredRoles(roles, aliases)}]) > 0`;
 }
 
-const StoredActivitySchema = pinned()(v__namespace.strictObject(activityFields({
-    field: FieldEntrySchema,
-    action: StoredActionSchema,
-    target: StoredManualTargetSchema,
-    group: StoredGroupMembershipSchema
-}))), AuthoringActivitySchema = pinned()(v__namespace.strictObject(activityFields({
-    field: AuthoringFieldEntrySchema,
-    action: AuthoringActionSchema,
-    target: AuthoringManualTargetSchema,
-    group: AuthoringGroupMembershipSchema
-})));
+function stripUndefined(obj) {
+    const out = {};
+    for (const [k, value] of Object.entries(obj)) value !== void 0 && (out[k] = value);
+    return out;
+}
 
-function transitionFields(when) {
-    return {
-        name: NonEmpty,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        to: NonEmpty,
-        when: when
-    };
+function isUnevaluable(result) {
+    return result == null;
 }
 
-const StoredTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(ConditionSchema))), AuthoringTransitionSchema = pinned()(v__namespace.strictObject(transitionFields(v__namespace.optional(ConditionSchema)))), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardReadPath = v__namespace.pipe(NonEmpty, v__namespace.check(path => !/[\r\n\u2028\u2029]/.test(path), "a guard read path cannot contain a line break")), GuardReadSchema = v__namespace.variant("type", [ v__namespace.strictObject({
-    type: v__namespace.literal("self")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("now")
-}), v__namespace.strictObject({
-    type: v__namespace.literal("fieldRead"),
-    field: FieldEntryName,
-    path: v__namespace.optional(GuardReadPath)
-}), v__namespace.strictObject({
-    type: v__namespace.literal("effectsRead"),
-    effect: v__namespace.pipe(NonEmpty, v__namespace.check(name => !name.includes("'"), "an effect name cannot contain `'`")),
-    path: v__namespace.optional(GuardReadPath)
-}) ]);
+async function evaluateConditionOutcome(args) {
+    const {condition: condition, snapshot: snapshot, params: params} = args;
+    return groqConditionDescribe.evaluateConditionOutcome({
+        condition: condition,
+        params: params,
+        dataset: snapshot.docs
+    });
+}
 
-function guardMatchFields(read) {
-    return {
-        types: v__namespace.optional(v__namespace.array(NonEmpty)),
-        idRefs: v__namespace.optional(v__namespace.array(read)),
-        idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
-        actions: v__namespace.pipe(v__namespace.array(GuardActionSchema), v__namespace.minLength(1, "a guard must match at least one action"))
-    };
+async function evaluateCondition(args) {
+    return await evaluateConditionOutcome(args) === "satisfied";
 }
 
-function guardFields(read) {
-    return {
-        name: NonEmpty,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        match: v__namespace.strictObject(guardMatchFields(read)),
-        predicate: v__namespace.optional(v__namespace.string()),
-        metadata: v__namespace.optional(v__namespace.record(NonEmpty, read))
-    };
+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 = groqConditionDescribe.conditionOutcome(result);
+        out[name] = outcome === "unevaluable" ? null : outcome === "satisfied";
+    }
+    return out;
 }
 
-const GuardSchema = v__namespace.strictObject(guardFields(NonEmpty)), AuthoringGuardSchema = v__namespace.strictObject(guardFields(GuardReadSchema));
+async function runGroq({groq: groq2, params: params, snapshot: snapshot}) {
+    return groqConditionDescribe.runGroq({
+        groq: groq2,
+        params: params,
+        dataset: snapshot.docs
+    });
+}
 
-function stageFields({field: field, activity: activity, transition: transition, guard: guard, editable: editable}) {
-    return {
-        name: NonEmpty,
-        semantics: SemanticsFieldSchema,
-        title: v__namespace.optional(v__namespace.string()),
-        description: v__namespace.optional(v__namespace.string()),
-        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
-        activities: v__namespace.optional(v__namespace.array(activity)),
-        transitions: v__namespace.optional(v__namespace.array(transition)),
-        guards: v__namespace.optional(v__namespace.array(guard)),
-        fields: v__namespace.optional(v__namespace.array(field)),
-        editable: v__namespace.optional(v__namespace.record(FieldEntryName, editable))
-    };
+function conditionSyntaxIssues(groq2, boundVars) {
+    const issues = [];
+    let tree;
+    try {
+        tree = groqJs.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;
 }
 
-const StoredStageSchema = pinned()(v__namespace.strictObject(stageFields({
-    field: FieldEntrySchema,
-    activity: StoredActivitySchema,
-    transition: StoredTransitionSchema,
-    guard: GuardSchema,
-    editable: StoredEditableSchema
-}))), AuthoringStageSchema = pinned()(v__namespace.strictObject(stageFields({
-    field: AuthoringFieldEntrySchema,
-    activity: AuthoringActivitySchema,
-    transition: AuthoringTransitionSchema,
-    guard: AuthoringGuardSchema,
-    editable: AuthoringEditableSchema
-}))), RoleAliasesSchema = v__namespace.record(NonEmpty, v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))), WORKFLOW_LIFECYCLES = [ "standalone", "child" ], START_KINDS = [ "interactive", "autonomous" ];
+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 startFields(kind) {
-    return {
-        kind: kind,
-        filter: v__namespace.optional(ConditionSchema),
-        requirements: v__namespace.optional(v__namespace.array(StartRequirementSchema))
-    };
+function conditionFieldReadNames(groq2) {
+    return new Set(conditionFieldReads(groq2).map(read => read.name));
 }
 
-const StoredStartSchema = pinned()(v__namespace.strictObject(startFields(picklist(START_KINDS)))), AuthoringStartSchema = pinned()(v__namespace.strictObject(startFields(v__namespace.optional(picklist(START_KINDS)))));
+function conditionFieldReads(groq2) {
+    const reads = /* @__PURE__ */ new Map;
+    return collectFieldReads(tryParseGroq(groq2), reads), [ ...reads.values() ];
+}
 
-function workflowFields({field: field, stage: stage, start: start}) {
-    return {
-        name: NonEmpty,
-        semantics: SemanticsFieldSchema,
-        title: NonEmpty,
-        description: v__namespace.optional(v__namespace.string()),
-        groups: v__namespace.optional(v__namespace.array(GroupSchema)),
-        lifecycle: v__namespace.optional(picklist(WORKFLOW_LIFECYCLES)),
-        start: v__namespace.optional(start),
-        initialStage: NonEmpty,
-        fields: v__namespace.optional(v__namespace.array(field)),
-        stages: v__namespace.pipe(v__namespace.array(stage), v__namespace.minLength(1, "must declare at least one stage")),
-        predicates: v__namespace.optional(v__namespace.record(groqIdentifier("`$<name>`"), ConditionSchema)),
-        roleAliases: v__namespace.optional(RoleAliasesSchema)
-    };
+function collectFieldReads(node, reads) {
+    if (Array.isArray(node)) {
+        for (const item of node) collectFieldReads(item, reads);
+        return;
+    }
+    if (typeof node != "object" || node === null) return;
+    const chain = fieldsAttributeChain(node);
+    if (chain !== void 0) {
+        const [name, ...tail] = chain, path = tail.length > 0 ? tail.join(".") : void 0;
+        reads.set(`${name}.${path ?? ""}`, {
+            name: name,
+            path: path
+        });
+        return;
+    }
+    for (const value of Object.values(node)) collectFieldReads(value, reads);
 }
 
-const WorkflowDefinitionSchema = pinned()(v__namespace.strictObject(workflowFields({
-    field: FieldEntrySchema,
-    stage: StoredStageSchema,
-    start: StoredStartSchema
-})));
-
-function parseStoredDefinition(input, label) {
-    return parseOrThrow({
-        schema: WorkflowDefinitionSchema,
-        input: input,
-        label: label
-    });
+function fieldsAttributeChain(node) {
+    const names = [];
+    let current = node;
+    for (;typeof current == "object" && current !== null; ) {
+        const typed = current;
+        if (typed.type !== "AccessAttribute" || typeof typed.name != "string") return;
+        names.unshift(typed.name);
+        const base = typed.base;
+        if (base?.type === "Parameter" && base.name === "fields") return names;
+        current = base;
+    }
 }
 
-const AuthoringWorkflowSchema = pinned()(v__namespace.strictObject(workflowFields({
-    field: AuthoringFieldEntrySchema,
-    stage: AuthoringStageSchema,
-    start: AuthoringStartSchema
-}))), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
-
-function isStartableDefinition(definition) {
-    return definition.lifecycle !== "child";
+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 startKindOf(definition) {
-    return definition.start?.kind ?? "interactive";
+function readsRootDocument(groq2) {
+    return nodeReadsRoot(tryParseGroq(groq2), 0);
 }
 
-function isSubjectEntry(entry) {
-    return entry.type === "subject";
+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 isDueDateEntry(entry) {
-    return entry.type === "dueDate" || entry.type === "dueDatetime";
+function tryParseGroq(groq2) {
+    try {
+        return groqJs.parse(groq2);
+    } catch {
+        return;
+    }
 }
 
-function isInputSourced(entry) {
-    return entry.initialValue?.type === "input";
+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);
+    }
 }
 
-function parseOrThrow({schema: schema, input: input, label: label}) {
-    const result = v__namespace.safeParse(schema, input);
-    if (!result.success) throw new Error(formatValidationError(label, issuesFromValibot(result.issues)));
-    return result.output;
+const 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 wrapper). Stage/activity scopes overlay lexically. What a read puts in your hand follows the declared kind: a singular `doc.ref` (or `subject`) DEREFERENCES into the hydrated document (lake `_id`/`_type` plus content fields — which may themselves be named `id`/`type`), while `doc.refs` elements and `release.ref` stay REFERENCES — `{id, type[, releaseName]}` with `id` a GDR URI — because identity reads (membership, counting, joins) must stay total without hydrating every target, and targets may live in resources the evaluation cannot fetch from. Conditions evaluate against the in-memory snapshot only, so a dereferencing plural kind would silently hole wherever hydration lagged."
+}, {
+    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: "attributes",
+    binding: "caller",
+    label: "your attributes",
+    description: "Advisory org-level User Attributes for the caller (Enterprise — same values as lake `user::attributes()`), keyed by attribute name with each active scalar or array value. `undefined` on expected HTTP absence; unexpected fetch failures throw; empty page binds `{}`. Bound wherever grants ride the evaluation (same sites as `$can`). Soft-gate paths fetch at most 100 attributes (no further pages) and warn when the envelope reports `hasMore: true` (partial bag still binds). Not a security boundary — the Content Lake remains the only enforcement point."
+}, {
+    name: "row",
+    binding: "spawn",
+    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). Deploy rejects a read at every other site (including `spawn.forEach` itself and `spawn.context`), where it is GROQ null."
+}, {
+    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",
+    label: "this engine tag",
+    description: "The engine's tag partition — scope `*[...]` instance scans with `tag == $tag`."
+}, {
+    name: "definition",
+    label: "this workflow definition",
+    description: "The `name` of the definition under evaluation (its own start block binds it)."
+}, {
+    name: "now",
+    label: "the current time",
+    description: "The ISO clock reading of the evaluating engine."
+} ], START_REQUIREMENT_VARS = [ ...START_FILTER_VARS, {
+    name: "fields",
+    label: "the start's input fields",
+    description: "The caller's input entries by name (`initialFields` — at `startInstance`, the values the start would seed; at a pre-flight, the values gathered so far, so a read of a not-yet-supplied entry is GROQ null). Document references bind as GDR envelopes — `$fields.<entry>.id` is the GDR URI, never a string authors assemble — a singular `doc.ref` or `subject` included (nothing hydrates at the gate or the pre-flight). Pathed reads are deploy-checked against these envelope shapes."
+} ], GUARD_PREDICATE_VARS = [ {
+    name: "document",
+    description: "The attempted mutation images, exposed as `document.before` and `document.after`."
+}, {
+    name: "guard",
+    description: "The guard document itself (its `metadata` carries deploy-time resolved values)."
+}, {
+    name: "mutation",
+    description: "The attempted mutation — `mutation.action` is the write kind being gated."
+} ];
+
+function effectBackoffMs(retry, endedAttempts) {
+    const {backoff: backoff} = retry;
+    return backoff === void 0 || endedAttempts < 1 ? 0 : backoff.kind === "fixed" ? backoff.delayMs : backoff.delayMs * 2 ** (endedAttempts - 1);
 }
 
-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 totalEffectBackoffMs(retry) {
+    const waits = retry.attempts - 1;
+    return retry.backoff === void 0 || waits < 1 ? 0 : retry.backoff.kind === "fixed" ? retry.backoff.delayMs * waits : retry.backoff.delayMs * (2 ** waits - 1);
 }
 
 function knownList(ids) {
@@ -3251,6 +3340,40 @@ function pushOutputIssues(args) {
     }
 }
 
+function checkEffectRetry(def, issues) {
+    for (const {action: action, path: path} of actionSites(def)) for (const [e, effect] of (action.effects ?? []).entries()) effect.retry !== void 0 && pushRetryIssue({
+        retry: effect.retry,
+        name: effect.name,
+        path: [ ...path, "effects", e, "retry" ],
+        issues: issues
+    });
+}
+
+function pushRetryIssue(args) {
+    const {retry: retry, name: name, path: path, issues: issues} = args;
+    if (retry.expiryMs !== void 0 && retry.expiryMs > MAX_RETRY_SPAN_MS) {
+        issues.push({
+            path: [ ...path, "expiryMs" ],
+            message: `effect "${name}" declares a ${retry.expiryMs}ms \`expiryMs\`, past the ${MAX_RETRY_SPAN_MS}ms ceiling — a policy runs inside one \`drainEffects\` invocation, and no host offers a single execution longer than a year. Lower \`expiryMs\``
+        });
+        return;
+    }
+    const wait = totalEffectBackoffMs(retry);
+    if (wait > MAX_RETRY_SPAN_MS) {
+        issues.push({
+            path: [ ...path, "attempts" ],
+            message: `effect "${name}" accumulates ${spanned(wait)} of backoff before attempt ${retry.attempts}, past the ${MAX_RETRY_SPAN_MS}ms ceiling — a policy runs inside one \`drainEffects\` invocation, and no host offers a single execution longer than a year. Lower \`attempts\` or \`backoff.delayMs\``
+        });
+        return;
+    }
+    retry.expiryMs === void 0 || wait < retry.expiryMs || issues.push({
+        path: [ ...path, "expiryMs" ],
+        message: `effect "${name}" waits ${wait}ms of backoff before attempt ${retry.attempts}, which its ${retry.expiryMs}ms \`expiryMs\` closes first — the effect fails before the declared attempts run. Raise \`expiryMs\`, or lower \`attempts\`/\`backoff.delayMs\``
+    });
+}
+
+const spanned = ms => Number.isFinite(ms) ? `${ms}ms` : "more milliseconds than a number can count", MAX_RETRY_SPAN_MS = 316224e5;
+
 function checkSubjectEntries(def, issues) {
     for (const {entries: entries, scope: scope, path: path, label: label} of fieldScopes(def)) {
         const subjects = (entries ?? []).flatMap((entry, n) => isSubjectEntry(entry) ? [ {
@@ -4026,7 +4149,7 @@ function checkWorkflowInvariants(def) {
     checkUnboundConditionVars(def, issues), checkConditionFieldReads(def, issues), checkFieldReadSeeds(def, issues), 
     checkFieldReadOpValues(def, issues), checkFieldTargetOps(def, issues), checkGuardFieldReads(def, issues), 
     checkAssigneesEntries(def, issues), checkDueDateEntries(def, issues), checkSubjectEntries(def, issues), 
-    checkLevelKindEffectOutputs(def, issues), checkActivityTerminalPaths(def, issues), 
+    checkLevelKindEffectOutputs(def, issues), checkEffectRetry(def, issues), checkActivityTerminalPaths(def, issues), 
     checkTerminalStageActivities(def, issues), checkTriggeredActionParams(def, issues), 
     checkStoredRolesPlacement(def, issues), checkGroups(def, issues), issues;
 }
@@ -4047,6 +4170,8 @@ exports.AuthoringActionSchema = AuthoringActionSchema;
 
 exports.AuthoringActivitySchema = AuthoringActivitySchema;
 
+exports.AuthoringEffectSchema = AuthoringEffectSchema;
+
 exports.AuthoringFieldEntrySchema = AuthoringFieldEntrySchema;
 
 exports.AuthoringGuardSchema = AuthoringGuardSchema;
@@ -4083,8 +4208,6 @@ exports.EXECUTOR_CLASSIFICATIONS = EXECUTOR_CLASSIFICATIONS;
 
 exports.EffectNotFoundError = EffectNotFoundError;
 
-exports.EffectSchema = EffectSchema;
-
 exports.FIELD_READ = FIELD_READ;
 
 exports.FIELD_SCOPES = FIELD_SCOPES;
@@ -4097,6 +4220,8 @@ exports.FieldValueShapeError = FieldValueShapeError;
 
 exports.GROUP_KINDS = GROUP_KINDS;
 
+exports.GUARD_ACTIONS_REQUIRED_MESSAGE = GUARD_ACTIONS_REQUIRED_MESSAGE;
+
 exports.GUARD_PREDICATE_VARS = GUARD_PREDICATE_VARS;
 
 exports.GdrShape = GdrShape;
@@ -4107,9 +4232,13 @@ exports.InstanceNotFoundError = InstanceNotFoundError;
 
 exports.IsoTimestamp = IsoTimestamp;
 
+exports.LAKE_MUTATION_GUARD_ACTIONS = LAKE_MUTATION_GUARD_ACTIONS;
+
 exports.MUTATION_GUARD_ACTIONS = MUTATION_GUARD_ACTIONS;
 
-exports.NonEmptyString = NonEmptyString;
+exports.MUTATION_GUARD_ID_SPACES = MUTATION_GUARD_ID_SPACES;
+
+exports.NonEmptyString = NonEmptyString$1;
 
 exports.PersistedDocShapeError = PersistedDocShapeError;
 
@@ -4129,6 +4258,8 @@ exports.SpawnContractsInvalidError = SpawnContractsInvalidError;
 
 exports.StoredFieldOpSchema = StoredFieldOpSchema;
 
+exports.UNIVERSAL_ROLE_ALIAS_KEY = UNIVERSAL_ROLE_ALIAS_KEY;
+
 exports.VersionSpecificDatasetGdrError = VersionSpecificDatasetGdrError;
 
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
@@ -4137,12 +4268,24 @@ exports.WorkflowConfigSchema = WorkflowConfigSchema;
 
 exports.WorkflowError = WorkflowError;
 
+exports.activeAssignmentMembers = activeAssignmentMembers;
+
 exports.actorFulfillsRole = actorFulfillsRole;
 
+exports.actorMatchesAssignment = actorMatchesAssignment;
+
 exports.andConditions = andConditions;
 
 exports.assignmentKindAcceptsRoles = assignmentKindAcceptsRoles;
 
+exports.assignmentMatch = assignmentMatch;
+
+exports.assignmentMembers = assignmentMembers;
+
+exports.assignmentState = assignmentState;
+
+exports.assignmentStateCounts = assignmentStateCounts;
+
 exports.checkWorkflowInvariants = checkWorkflowInvariants;
 
 exports.choiceValueIssues = choiceValueIssues;
@@ -4151,6 +4294,10 @@ exports.classifyPrincipalId = classifyPrincipalId;
 
 exports.clientConfigFromResource = clientConfigFromResource;
 
+exports.condemnSubworkflow = condemnSubworkflow;
+
+exports.condemnedSubworkflows = condemnedSubworkflows;
+
 exports.conditionEffectReads = conditionEffectReads;
 
 exports.conditionFieldReadNames = conditionFieldReadNames;
@@ -4173,6 +4320,8 @@ exports.directoryBridgeId = directoryBridgeId;
 
 exports.driverKind = driverKind;
 
+exports.effectBackoffMs = effectBackoffMs;
+
 exports.errorMessage = errorMessage;
 
 exports.evaluateCondition = evaluateCondition;
@@ -4185,6 +4334,10 @@ exports.extractDocumentId = extractDocumentId;
 
 exports.fieldValueSchemas = fieldValueSchemas;
 
+exports.findCurrentActivityEntry = findCurrentActivityEntry;
+
+exports.findOpenStageEntry = findOpenStageEntry;
+
 exports.firstCarriedGlobalId = firstCarriedGlobalId;
 
 exports.formatIssuePath = formatIssuePath;
@@ -4205,14 +4358,22 @@ exports.groq = groq;
 
 exports.groupMembershipNames = groupMembershipNames;
 
+exports.identityMatchesAssignment = identityMatchesAssignment;
+
+exports.instanceAssignmentStateCounts = instanceAssignmentStateCounts;
+
 exports.isAlwaysArrayFieldKind = isAlwaysArrayFieldKind;
 
 exports.isAssignmentFieldEntry = isAssignmentFieldEntry;
 
+exports.isBareDocumentId = isBareDocumentId;
+
 exports.isBareSeedId = isBareSeedId;
 
 exports.isCascadeFired = isCascadeFired;
 
+exports.isFilterScopedOut = isFilterScopedOut;
+
 exports.isGdr = isGdr;
 
 exports.isGdrUri = isGdrUri;
@@ -4247,6 +4408,16 @@ exports.labelFor = labelFor;
 
 exports.lakePrincipalId = lakePrincipalId;
 
+exports.liveSubworkflows = liveSubworkflows;
+
+exports.mutationGuardActionIdSpace = mutationGuardActionIdSpace;
+
+exports.mutationGuardRequiresSplitEmission = mutationGuardRequiresSplitEmission;
+
+exports.normalizeAssignmentMembers = normalizeAssignmentMembers;
+
+exports.openActivityAssignments = openActivityAssignments;
+
 exports.parseFieldValue = parseFieldValue;
 
 exports.parseGdr = parseGdr;
@@ -4279,6 +4450,8 @@ exports.releaseDocId = releaseDocId;
 
 exports.releaseRef = releaseRef;
 
+exports.resolvedChildStatus = resolvedChildStatus;
+
 exports.resourceAliasesToMap = resourceAliasesToMap;
 
 exports.resourceFromGdrUri = resourceFromGdrUri;