@hyperscale0/udl 1.0.0-beta.1 → 1.0.0

package/dist/evolution.js

@@ -1,34 +1,62 @@
 import { UDL_LIMITS } from "./limits.js";
+import { deriveUdlActionEffects } from "./effects.js";
+import { udlClauseVocabulary } from "./schema.js";
 import { UdlError } from "./validation.js";
-/** Project an open .udl noun into the evolution engine's exact semantic shape. */
-export function snapshotUdlNoun(noun) {
-    const required = new Set(noun.required);
+import { issue } from "./diagnostics.js";
+/** Project an open .udl instrument into the evolution engine's exact semantic shape. */
+export function snapshotUdlInstrument(instrument) {
+    const required = new Set(instrument.required);
     return {
-        aggregateInvariants: (noun.aggregateInvariants ?? []).map(aggregateInvariantKey),
-        computedMoneyRefs: [...(noun.computedMoneyRefs ?? [])].sort(),
-        derivedAmounts: (noun.derivedAmounts ?? []).map((amount) => `${amount.field}=floor(${amount.sourceField}*${amount.rule.bps}/10000)`),
-        ...(noun.distinctParties ? { distinctParties: true } : {}),
-        fields: Object.fromEntries(Object.entries(noun.fields).map(([field, schema]) => [
+        actionOrder: [...instrument.actionOrder],
+        aggregateInvariants: (instrument.aggregateInvariants ?? []).map(aggregateInvariantKey),
+        callerParkedStates: instrument.callerParkedStates ?? {},
+        derivedAmounts: (instrument.derivedAmounts ?? []).map((amount) => `${amount.field}=floor(${amount.sourceField}*${amount.rule.bps}/10000)`),
+        dials: instrument.dials ?? [],
+        ...(instrument.distinctParties ? { distinctParties: true } : {}),
+        ...(instrument.feeRules
+            ? {
+                feeRules: instrument.feeRules.map((fee) => ({
+                    ...fee,
+                    rule: fee.rule.kind === "tiered"
+                        ? {
+                            ...fee.rule,
+                            tiers: fee.rule.tiers.map((tier) => ({
+                                ...tier,
+                                rule: { ...tier.rule },
+                            })),
+                        }
+                        : { ...fee.rule },
+                })),
+            }
+            : {}),
+        fields: Object.fromEntries(Object.entries(instrument.fields).map(([field, schema]) => [
             field,
             { required: required.has(field), schema },
         ])),
-        id: noun.id,
-        idPrefix: noun.idPrefix,
-        initial: noun.lifecycle.initial,
-        parties: compactStringRecord(noun.parties),
-        partitions: (noun.partitions ?? []).map((partition) => `${partition.totalField} = ${[...partition.pieceFields].sort().join(" + ")}`),
-        states: [...noun.lifecycle.states],
-        subjects: noun.subject ? [...noun.subject.kinds] : [],
-        transitions: Object.fromEntries(Object.entries(noun.lifecycle.transitions).map(([verb, transition]) => [
-            verb,
+        id: instrument.id,
+        idPrefix: instrument.idPrefix,
+        initial: instrument.lifecycle.initial,
+        nav: instrument.nav ?? [],
+        parties: compactStringRecord(instrument.parties),
+        partitions: (instrument.partitions ?? []).map((partition) => `${partition.totalField} = ${[...partition.pieceFields].sort().join(" + ")}`),
+        states: [...instrument.lifecycle.states],
+        subjects: instrument.subject ? [...instrument.subject.kinds] : [],
+        subjectExtensible: instrument.subject?.extensible ?? false,
+        surfaceVisibility: instrument.surfaceVisibility ?? null,
+        templateId: instrument.templateId ?? null,
+        transitions: Object.fromEntries(Object.entries(instrument.lifecycle.transitions).map(([action, transition]) => [
+            action,
             { from: [...transition.from], to: transition.to },
         ])),
-        unwind: noun.unwind ?? null,
-        updateFields: noun.update?.fields ?? [],
-        updateStates: noun.update?.states ?? [],
-        verbs: Object.fromEntries(Object.entries(noun.verbs).map(([verb, definition]) => [
-            verb,
-            snapshotUdlVerb(definition),
+        quotes: Object.fromEntries(Object.entries(instrument.actions)
+            .filter(([, action]) => action.quote)
+            .map(([name, action]) => [name, action.quote])),
+        updateFields: instrument.update?.fields ?? [],
+        updateExamples: instrument.update?.examples ?? null,
+        updateStates: instrument.update?.states ?? [],
+        actions: Object.fromEntries(instrument.actionOrder.map((action) => [
+            action,
+            snapshotUdlAction(instrument.actions[action]),
         ])),
     };
 }
@@ -41,6 +69,16 @@ export function snapshotUdlNoun(noun) {
  * clean `resource_limit` issue: parse first, then diff.
  */
 export function diffValidatedUdlEvolution(previous, next) {
+    return diffValidatedUdlEvolutionMessages(previous, next).map((message) => {
+        const instrumentId = /^([^:]+): /.exec(message)?.[1];
+        const instrumentIndex = previous.instruments.findIndex((instrument) => instrument.id === instrumentId);
+        const base = instrumentIndex < 0
+            ? "$.instruments"
+            : `$.instruments[${instrumentIndex}]`;
+        return evolutionIssue(message, base);
+    });
+}
+function diffValidatedUdlEvolutionMessages(previous, next) {
     const violations = [];
     if (previous.product !== next.product) {
         violations.push(`product id changed from ${previous.product} to ${next.product}`);
@@ -66,22 +104,22 @@ export function diffValidatedUdlEvolution(previous, next) {
         if (!previousSubjects.has(kind))
             semanticChange = true;
     }
-    const previousNouns = new Map(previous.nouns.map((noun) => [noun.id, snapshotUdlNoun(noun)]));
-    const nextNouns = new Map(next.nouns.map((noun) => [noun.id, snapshotUdlNoun(noun)]));
-    for (const [id, noun] of previousNouns) {
-        const current = nextNouns.get(id);
+    const previousInstruments = new Map(previous.instruments.map((instrument) => [instrument.id, snapshotUdlInstrument(instrument)]));
+    const nextInstruments = new Map(next.instruments.map((instrument) => [instrument.id, snapshotUdlInstrument(instrument)]));
+    for (const [id, instrument] of previousInstruments) {
+        const current = nextInstruments.get(id);
         if (!current) {
             semanticChange = true;
-            violations.push(`${id}: live noun was removed from the product`);
+            violations.push(`${id}: live instrument was removed from the product`);
             continue;
         }
-        if (stableStringify(noun) !== stableStringify(current)) {
+        if (stableStringify(instrument) !== stableStringify(current)) {
             semanticChange = true;
         }
-        violations.push(...diffNounEvolution(noun, current));
+        violations.push(...diffInstrumentEvolutionMessages(instrument, current));
     }
-    for (const id of nextNouns.keys()) {
-        if (!previousNouns.has(id))
+    for (const id of nextInstruments.keys()) {
+        if (!previousInstruments.has(id))
             semanticChange = true;
     }
     if (semanticChange && next.version <= previous.version) {
@@ -89,10 +127,13 @@ export function diffValidatedUdlEvolution(previous, next) {
     }
     return violations;
 }
-/** Diff one noun snapshot. An empty result means the change is additive. */
-export function diffNounEvolution(previous, next) {
+/** Diff one instrument snapshot. An empty result means the change is additive. */
+export function diffInstrumentEvolution(previous, next) {
+    return diffInstrumentEvolutionMessages(previous, next).map((message) => evolutionIssue(message, "$.instruments"));
+}
+function diffInstrumentEvolutionMessages(previous, next) {
     if (previous.id !== next.id) {
-        return [`noun id changed from ${previous.id} to ${next.id}`];
+        return [`instrument id changed from ${previous.id} to ${next.id}`];
     }
     const violations = [];
     if (previous.idPrefix !== next.idPrefix) {
@@ -102,47 +143,129 @@ export function diffNounEvolution(previous, next) {
         violations.push(`initial lifecycle state changed from ${previous.initial} to ${next.initial}`);
     }
     violations.push(...removedSetEntries(previous.states, next.states, (state) => `lifecycle state ${state} was removed or renamed`));
-    for (const [verb, transition] of Object.entries(previous.transitions)) {
-        const current = next.transitions[verb];
+    for (const [action, transition] of Object.entries(previous.transitions)) {
+        const current = next.transitions[action];
         if (!current) {
-            violations.push(`transition for verb ${verb} was removed or renamed`);
+            violations.push(`transition for action ${action} was removed or renamed`);
             continue;
         }
         if (transition.to !== current.to) {
-            violations.push(`transition for verb ${verb} changed its target state from ${transition.to} to ${current.to}`);
+            violations.push(`transition for action ${action} changed its target state from ${transition.to} to ${current.to}`);
         }
-        violations.push(...removedSetEntries(transition.from, current.from, (state) => `transition for verb ${verb} no longer fires from state ${state}`));
+        violations.push(...removedSetEntries(transition.from, current.from, (state) => `transition for action ${action} no longer fires from state ${state}`));
     }
     violations.push(...diffFields(previous.fields, next.fields));
     if (Boolean(previous.distinctParties) !== Boolean(next.distinctParties)) {
         violations.push("distinct-party admission changed after becoming live");
     }
-    violations.push(...diffVerbs(previous.verbs, next.verbs));
+    if (previous.actionOrder) {
+        const previousActions = new Set(previous.actionOrder);
+        const retainedActionOrder = (next.actionOrder ?? []).filter((action) => previousActions.has(action));
+        if (stableStringify(previous.actionOrder) !==
+            stableStringify(retainedActionOrder)) {
+            violations.push("instrument action order changed after becoming live");
+        }
+    }
+    violations.push(...diffActions(previous.actions, next.actions));
     violations.push(...diffParties(previous.parties, next.parties));
     violations.push(...diffAggregates(previous, next));
-    if (stableStringify(previous.computedMoneyRefs ?? []) !==
-        stableStringify(next.computedMoneyRefs ?? [])) {
-        violations.push("computed money refs changed; runtime-derived money surfaces are frozen once live");
+    if (stableStringify(Object.keys(previous.callerParkedStates ?? {}).sort()) !==
+        stableStringify(Object.keys(next.callerParkedStates ?? {}).sort())) {
+        violations.push("caller-parked state annotations changed");
+    }
+    if (stableStringify(previous.dials ?? []) !== stableStringify(next.dials ?? [])) {
+        violations.push("instrument dials changed after becoming live");
+    }
+    if ((previous.surfaceVisibility ?? null) !== (next.surfaceVisibility ?? null)) {
+        violations.push("instrument surface visibility changed after becoming live");
+    }
+    if ((previous.templateId ?? null) !== (next.templateId ?? null)) {
+        violations.push("instrument archetype template changed after becoming live");
+    }
+    if (previous.subjectExtensible && !next.subjectExtensible) {
+        violations.push("tenant-defined subject kinds are no longer accepted");
     }
     if (stableStringify(previous.derivedAmounts ?? []) !==
         stableStringify(next.derivedAmounts ?? [])) {
         violations.push("derived amount rules changed; derived money arithmetic is frozen once live");
     }
+    if (stableStringify(previous.feeRules ?? []) !==
+        stableStringify(next.feeRules ?? [])) {
+        violations.push("feeRules changed; fee calculation and settlement funding are frozen once live");
+    }
     violations.push(...removedSetEntries(previous.partitions, next.partitions, (law) => `partition law [${law}] was removed`), ...next.partitions
         .filter((law) => !previous.partitions.includes(law))
         .map((law) => `partition law [${law}] was added, which can reject existing callers`));
-    violations.push(...diffUnwind(previous.unwind, next.unwind));
+    violations.push(...diffQuotes(previous.quotes, next.quotes));
     violations.push(...removedSetEntries(previous.subjects, next.subjects, (kind) => `subject kind ${kind} was removed, rejecting linked instances`), ...removedSetEntries(previous.updateFields, next.updateFields, (field) => `update policy no longer permits field ${field}`), ...removedSetEntries(previous.updateStates, next.updateStates, (state) => `update policy no longer permits state ${state}`));
     return violations.map((violation) => `${next.id}: ${violation}`);
 }
-function snapshotUdlVerb(definition) {
+function evolutionIssue(message, instrumentBase) {
+    if (message.startsWith("product id changed"))
+        return issue("UDL7001", "$.product", message);
+    if (message.startsWith("product version moved backward"))
+        return issue("UDL7001", "$.version", message);
+    if (message.startsWith("product definition changed"))
+        return issue("UDL7002", "$.version", message);
+    if (message.startsWith("subject kind "))
+        return issue("UDL7001", "$.subjects", message);
+    const instrumentMatch = /^([^:]+): (.*)$/.exec(message);
+    const detail = instrumentMatch?.[2] ?? message;
+    const transitionAction = /^transition for action ([a-z][a-z0-9_]*)/.exec(detail)?.[1];
+    if (transitionAction)
+        return issue("UDL7001", `${instrumentBase}.lifecycle.transitions.${transitionAction}`, message);
+    const action = /^action ([a-z][a-z0-9_]*)/.exec(detail)?.[1];
+    if (action)
+        return issue("UDL7001", `${instrumentBase}.actions.${action}`, message);
+    if (detail.includes("instrument id"))
+        return issue("UDL7001", instrumentBase, message);
+    if (detail.includes("id prefix") ||
+        detail.includes("lifecycle") ||
+        detail.includes("transition") ||
+        detail.includes("initial") ||
+        detail.includes("live instrument was removed"))
+        return issue("UDL7001", `${instrumentBase}.lifecycle`, message);
+    if (detail.startsWith("field "))
+        return issue("UDL7001", `${instrumentBase}.fields`, message);
+    if (detail.includes("move") ||
+        detail.includes("payout") ||
+        detail.includes("fee") ||
+        detail.includes("quote") ||
+        detail.includes("derived amount") ||
+        detail.includes("partition") ||
+        detail.includes("distribution") ||
+        detail.includes("signed child sum") ||
+        detail.includes("earnable"))
+        return issue("UDL7001", `${instrumentBase}.actions`, message);
+    if (detail.includes("gate") ||
+        detail.includes("check prerequisite") ||
+        detail.includes("reconcile expectation") ||
+        detail.includes("drained-account") ||
+        detail.includes("exposure") ||
+        detail.includes("aggregate"))
+        return issue("UDL7001", `${instrumentBase}.actions`, message);
+    if (detail.startsWith("action ") ||
+        detail.includes("action order") ||
+        detail.includes("step count"))
+        return issue("UDL7001", `${instrumentBase}.actions`, message);
+    return issue("UDL7001", instrumentBase, message);
+}
+function snapshotUdlAction(definition) {
     return {
         captureInput: definition.captureInput ?? null,
+        commit: definition.commit ?? null,
         deadline: definition.deadline ?? null,
         decision: definition.decision ?? null,
+        principal: definition.principal ?? null,
+        remainder: definition.remainder ?? null,
+        requiresChecks: definition.requiresChecks ?? [],
+        sandboxFailurePoint: definition.sandboxFailurePoint ?? null,
+        updates: definition.updates ?? [],
         distribute: definition.distribute ?? null,
         due: definition.due ?? null,
         earnable: definition.earnable ?? false,
+        effects: definition.effects ??
+            deriveUdlActionEffects(definition, udlClauseVocabulary),
         eventName: definition.eventName ?? null,
         input: definition.input ? snapshotJsonSchemaFields(definition.input) : null,
         inputConstraints: definition.input
@@ -150,7 +273,7 @@ function snapshotUdlVerb(definition) {
             : null,
         payout: definition.payout ?? null,
         port: definition.port ?? null,
-        publicIntent: definition.publicIntent ?? null,
+        publicAction: definition.publicAction ?? null,
         setsAt: definition.setsAt ?? null,
         signedSum: definition.signedSum ?? null,
         moves: definition.moves.map((move) => ({
@@ -163,7 +286,7 @@ function snapshotUdlVerb(definition) {
         requiresDrainedAccount: definition.requiresDrainedAccount ?? null,
         requiresExposure: definition.requiresExposure ?? [],
         requiresRefs: definition.requiresRefs ?? [],
-        requiresSettlement: definition.requiresSettlement ?? null,
+        reconcile: definition.reconcile ?? null,
         steps: definition.steps.map((step) => ({
             bind: step.bind,
             capture: step.capture ?? {},
@@ -207,137 +330,160 @@ function diffFields(previous, next) {
     }
     return violations;
 }
-function diffVerbs(previous, next) {
+function diffActions(previous, next) {
     const violations = [];
-    for (const [verb, descriptor] of Object.entries(previous)) {
-        const current = next[verb];
+    for (const [action, descriptor] of Object.entries(previous)) {
+        const current = next[action];
         if (!current) {
-            violations.push(`verb ${verb} was removed or renamed`);
+            violations.push(`action ${action} was removed or renamed`);
             continue;
         }
         if (descriptor.moves.length !== current.moves.length) {
-            violations.push(`verb ${verb} changed its move count from ${descriptor.moves.length} to ${current.moves.length}; money movement is frozen once live`);
+            violations.push(`action ${action} changed its move count from ${descriptor.moves.length} to ${current.moves.length}; money movement is frozen once live`);
         }
         else {
             descriptor.moves.forEach((move, index) => {
                 const nextMove = current.moves[index];
                 if (stableStringify(move) !== stableStringify(nextMove)) {
-                    violations.push(`verb ${verb} changed move ${move.key} at index ${index}; money movement is frozen once live`);
+                    violations.push(`action ${action} changed move ${move.key} at index ${index}; money movement is frozen once live`);
                 }
             });
         }
         if (descriptor.steps.length !== current.steps.length) {
-            violations.push(`verb ${verb} changed its step count from ${descriptor.steps.length} to ${current.steps.length}; a live verb's steps are frozen`);
+            violations.push(`action ${action} changed its step count from ${descriptor.steps.length} to ${current.steps.length}; a live action's steps are frozen`);
         }
         else {
             descriptor.steps.forEach((step, index) => {
                 const nextStep = current.steps[index];
                 if (stableStringify(step) === stableStringify(nextStep))
                     return;
-                violations.push(`verb ${verb} changed step ${index} (${step.operation}); a live verb's steps are frozen`);
+                violations.push(`action ${action} changed step ${index} (${step.operation}); a live action's steps are frozen`);
             });
         }
-        violations.push(...diffInput(verb, descriptor.input ?? {}, current.input ?? {}));
-        // A verb gaining its first input is additive (per-field checks still catch
+        violations.push(...diffInput(action, descriptor.input ?? {}, current.input ?? {}));
+        // A action gaining its first input is additive (per-field checks still catch
         // added-as-required); once an input is live, its schema envelope is frozen.
         if (descriptor.input !== null &&
             stableStringify(descriptor.inputConstraints) !==
                 stableStringify(current.inputConstraints)) {
-            violations.push(`verb ${verb} changed its input schema beyond declared fields; a live verb input is frozen`);
+            violations.push(`action ${action} changed its input schema beyond declared fields; a live action input is frozen`);
         }
         if (stableStringify(descriptor.requiresRefs) !==
             stableStringify(current.requiresRefs)) {
-            violations.push(`verb ${verb} changed its cross-noun gates`);
+            violations.push(`action ${action} changed its cross-instrument gates`);
         }
         if (stableStringify(descriptor.requiresAggregate) !==
             stableStringify(current.requiresAggregate)) {
-            violations.push(`verb ${verb} changed its aggregate admission gates`);
+            violations.push(`action ${action} changed its aggregate admission gates`);
         }
         if (stableStringify(descriptor.requiresDrainedAccount) !==
             stableStringify(current.requiresDrainedAccount)) {
-            violations.push(`verb ${verb} changed its drained-account gate`);
+            violations.push(`action ${action} changed its drained-account gate`);
         }
         if (descriptor.requiresExposure !== undefined &&
             stableStringify(descriptor.requiresExposure) !==
                 stableStringify(current.requiresExposure)) {
-            violations.push(`verb ${verb} changed its exposure admission gates`);
+            violations.push(`action ${action} changed its exposure admission gates`);
         }
-        if (descriptor.requiresSettlement !== undefined &&
-            stableStringify(descriptor.requiresSettlement) !==
-                stableStringify(current.requiresSettlement)) {
-            violations.push(`verb ${verb} changed its settlement evidence gate`);
+        if (descriptor.reconcile !== undefined &&
+            stableStringify(descriptor.reconcile) !==
+                stableStringify(current.reconcile)) {
+            violations.push(`action ${action} changed its reconcile expectations`);
         }
         if (stableStringify(descriptor.payout ?? null) !==
             stableStringify(current.payout ?? null)) {
-            violations.push(`verb ${verb} changed its payout intent`);
+            violations.push(`action ${action} changed its payout intent`);
         }
         if (descriptor.earnable !== current.earnable) {
-            violations.push(`verb ${verb} changed its earnable flag`);
+            violations.push(`action ${action} changed its earnable flag`);
+        }
+        if (descriptor.effects !== undefined &&
+            stableStringify(descriptor.effects) !== stableStringify(current.effects)) {
+            violations.push(`action ${action} changed its derived effects`);
         }
         if (descriptor.eventName !== current.eventName) {
-            violations.push(`verb ${verb} changed its event name`);
+            violations.push(`action ${action} changed its event name`);
         }
         if (stableStringify(descriptor.due) !== stableStringify(current.due)) {
-            violations.push(`verb ${verb} changed its due condition`);
+            violations.push(`action ${action} changed its due condition`);
         }
         if (stableStringify(descriptor.deadline) !== stableStringify(current.deadline)) {
-            violations.push(`verb ${verb} changed its admission deadline`);
+            violations.push(`action ${action} changed its admission deadline`);
         }
         if (stableStringify(descriptor.decision) !== stableStringify(current.decision)) {
-            violations.push(`verb ${verb} changed its provider decision`);
+            violations.push(`action ${action} changed its provider decision`);
+        }
+        if ((descriptor.principal ?? null) !== (current.principal ?? null)) {
+            violations.push(`action ${action} changed its caller principal`);
+        }
+        if (stableStringify(descriptor.remainder ?? null) !==
+            stableStringify(current.remainder ?? null)) {
+            violations.push(`action ${action} changed its remainder rule`);
+        }
+        if (stableStringify(descriptor.requiresChecks ?? []) !==
+            stableStringify(current.requiresChecks ?? [])) {
+            violations.push(`action ${action} changed its check prerequisites`);
+        }
+        if ((descriptor.sandboxFailurePoint ?? null) !==
+            (current.sandboxFailurePoint ?? null)) {
+            violations.push(`action ${action} changed its sandbox failure point`);
+        }
+        if (stableStringify(descriptor.updates ?? []) !==
+            stableStringify(current.updates ?? [])) {
+            violations.push(`action ${action} changed its field updates`);
         }
         if (stableStringify(descriptor.distribute) !==
             stableStringify(current.distribute)) {
-            violations.push(`verb ${verb} changed its distribution rule; money distribution is frozen once live`);
+            violations.push(`action ${action} changed its distribution rule; money distribution is frozen once live`);
         }
         if (descriptor.captureInput !== undefined &&
             stableStringify(descriptor.captureInput) !==
                 stableStringify(current.captureInput)) {
-            violations.push(`verb ${verb} changed its captured receipt input`);
+            violations.push(`action ${action} changed its captured receipt input`);
         }
         if (stableStringify(descriptor.port) !== stableStringify(current.port)) {
-            violations.push(`verb ${verb} changed its decision port`);
+            violations.push(`action ${action} changed its decision port`);
         }
-        if (descriptor.publicIntent != null &&
-            descriptor.publicIntent !== current.publicIntent) {
-            violations.push(`verb ${verb} changed its public intent`);
+        if (descriptor.publicAction != null &&
+            descriptor.publicAction !== current.publicAction) {
+            violations.push(`action ${action} changed its public action`);
         }
         if (stableStringify(descriptor.setsAt) !== stableStringify(current.setsAt)) {
-            violations.push(`verb ${verb} changed its computed timestamp`);
+            violations.push(`action ${action} changed its computed timestamp`);
         }
         if (descriptor.signedSum !== undefined &&
             stableStringify(descriptor.signedSum) !==
                 stableStringify(current.signedSum)) {
-            violations.push(`verb ${verb} changed its signed child sum`);
+            violations.push(`action ${action} changed its signed child sum`);
         }
     }
-    for (const [verb, descriptor] of Object.entries(next)) {
-        if (previous[verb] || descriptor.payout == null)
+    for (const [action, descriptor] of Object.entries(next)) {
+        if (previous[action] || descriptor.payout == null)
             continue;
-        violations.push(`verb ${verb} added a payout intent; external money movement is frozen once live`);
+        violations.push(`action ${action} added a payout intent; external money movement is frozen once live`);
     }
     return violations;
 }
-function diffInput(verb, previous, next) {
+function diffInput(action, previous, next) {
     const violations = [];
     for (const [field, descriptor] of Object.entries(previous)) {
         const current = next[field];
         if (!current) {
-            // Compiled verb inputs are strict objects, so a removed field starts
-            // rejecting every caller that still sends it -- same law as noun fields.
-            violations.push(`verb ${verb} input field ${field} was removed or renamed`);
+            // Compiled action inputs are strict objects, so a removed field starts
+            // rejecting every caller that still sends it -- same law as instrument fields.
+            violations.push(`action ${action} input field ${field} was removed or renamed`);
             continue;
         }
         if (!descriptor.required && current.required) {
-            violations.push(`verb ${verb} input field ${field} became required, tightening the verb input`);
+            violations.push(`action ${action} input field ${field} became required, tightening the action input`);
         }
         if (stableStringify(descriptor.schema) !== stableStringify(current.schema)) {
-            violations.push(`verb ${verb} input field ${field} schema changed; a live verb input schema is frozen`);
+            violations.push(`action ${action} input field ${field} schema changed; a live action input schema is frozen`);
         }
     }
     for (const [field, descriptor] of Object.entries(next)) {
         if (!previous[field] && descriptor.required) {
-            violations.push(`verb ${verb} input field ${field} was added as required, tightening the verb input`);
+            violations.push(`action ${action} input field ${field} was added as required, tightening the action input`);
         }
     }
     return violations;
@@ -362,22 +508,22 @@ function diffAggregates(previous, next) {
             .map((key) => `aggregate invariant [${key}] was added, which can reject existing instances`),
     ];
 }
-function diffUnwind(previous, next) {
-    if (previous === null)
+function diffQuotes(previous, next) {
+    if (previous === null || previous === undefined)
         return [];
-    if (next === null)
-        return ["unwind policy was removed"];
+    if (next === null || next === undefined)
+        return ["quote policy was removed"];
     return stableStringify(previous) === stableStringify(next)
         ? []
         : [
-            "unwind policy changed; the penalty schedule and refund destination are frozen once live",
+            "quote policy changed; the charge schedule, the frozen fields, and the refund destination are frozen once live",
         ];
 }
 function aggregateInvariantKey(invariant) {
     const measure = "childField" in invariant
         ? invariant.childField
         : `count${invariant.window ? `[${invariant.window.field} per ${invariant.window.days}d]` : ""}`;
-    return `${invariant.childNounId}.${measure} within ${invariant.parentField} via ${invariant.childRefField} while ${[...invariant.childStatuses].sort().join(",")}`;
+    return `${invariant.childInstrumentId}.${measure} within ${invariant.parentField} via ${invariant.childRefField} while ${[...invariant.childStatuses].sort().join(",")}`;
 }
 function removedSetEntries(previous, next, message) {
     const current = new Set(next);
@@ -401,11 +547,7 @@ function recordValue(value) {
 function stableStringify(value, depth = 1) {
     if (depth > UDL_LIMITS.maxDepth) {
         throw new UdlError([
-            {
-                code: "resource_limit",
-                message: `UDL nesting exceeds ${UDL_LIMITS.maxDepth} levels`,
-                path: "$",
-            },
+            issue("UDL1004", "$", `UDL nesting exceeds ${UDL_LIMITS.maxDepth} levels`),
         ]);
     }
     if (value === null || typeof value !== "object") {