@hyperscale0/udl 1.0.0-beta.1 → 1.0.0

package/dist/finance.js

@@ -14,90 +14,91 @@ function withoutPiece(amounts, amount) {
     return amounts.filter((_, position) => position !== index);
 }
 /**
- * One financial typestate owner for canonical UDL and static noun contracts.
+ * One financial typestate owner for canonical UDL and static instrument contracts.
  * It proves a tracked escrow account holds an exact set of funded amounts,
  * models held transfers through reserve/post/void, consumes every direct
- * debit piece by piece, and makes the unwind refund's sole remainder an
+ * debit piece by piece, and makes the quoted refund's sole remainder an
  * exactly-once penalty payout.
  */
-export function analyzeNounFinance(noun, options = {}) {
+export function analyzeInstrumentFinance(instrument, options = {}) {
     const issues = [];
     const seenIssues = new Set();
-    const add = (path, message) => {
+    const add = (path, message, code = "UDL4001") => {
         const key = `${path.join(".")}\0${message}`;
         if (seenIssues.has(key))
             return;
         seenIssues.add(key);
-        issues.push({ message, path });
+        issues.push({ code, message, path });
     };
-    const admissionProblem = financeAdmissionProblem(noun);
+    const admissionProblem = financeAdmissionProblem(instrument);
     if (admissionProblem) {
-        add(["lifecycle"], admissionProblem);
+        add(["lifecycle"], admissionProblem, "UDL1004");
         return issues;
     }
-    const trackedAccounts = workspaceEscrowAccounts(noun);
-    const confirmTransfer = noun.unwind
-        ? noun.verbs[noun.unwind.confirm]?.moves?.filter((move) => move.operation === "internal_transfer.create")[0]
-        : undefined;
-    const refundSource = canonicalAccount(noun, confirmTransfer?.bind.sourceAccountId);
-    if (refundSource)
-        trackedAccounts.add(refundSource);
+    const trackedAccounts = productEscrowAccounts(instrument);
+    const quotes = quoteFacts(instrument, options);
+    const refundSources = new Map();
+    for (const quote of quotes) {
+        const commitTransfer = instrument.actions[quote.commit]?.moves?.filter((move) => move.operation === "internal_transfer.create")[0];
+        const source = canonicalAccount(instrument, commitTransfer?.bind.sourceAccountId);
+        if (!source)
+            continue;
+        refundSources.set(quote.commit, source);
+        trackedAccounts.add(source);
+    }
+    const refundSourceAccounts = new Set(refundSources.values());
     if (trackedAccounts.size === 0)
         return [];
     if (trackedAccounts.size > UDL_LIMITS.financeAccounts) {
-        add(["verbs"], `financial analysis exceeds ${UDL_LIMITS.financeAccounts} tracked accounts`);
+        add(["actions"], `financial analysis exceeds ${UDL_LIMITS.financeAccounts} tracked accounts`, "UDL1004");
         return issues;
     }
-    const reservations = reservationsByKey(noun);
-    const declaresPenaltyPayout = Object.values(noun.verbs).some((verb) => (verb.moves ?? []).some((move) => Object.values(move.bind).some((binding) => binding.from === "instance" && binding.path === "refs.unwindPenalty")));
-    const penaltyCanBeNonzero = options.penaltyMayBeNonzero === true ||
-        declaresPenaltyPayout ||
-        noun.unwind?.penalty.some((tier) => tier.bps > 0) === true;
-    if (noun.unwind) {
-        validatePenaltyPayout(noun, refundSource, penaltyCanBeNonzero, add);
+    const reservations = reservationsByKey(instrument);
+    for (const quote of quotes) {
+        validateChargePayout(instrument, quote, refundSources.get(quote.commit), add);
     }
     let pathVariants = 0;
     let work = 0;
     for (const account of trackedAccounts) {
-        const effects = effectsByVerb(noun, account, reservations, penaltyCanBeNonzero);
+        const effects = effectsByAction(instrument, account, reservations, quotes);
         const createEffects = effects.get("create") ?? [];
         work += 1 + createEffects.length;
         if (work > UDL_LIMITS.financeWork) {
-            add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financeWork} deterministic work units`);
+            add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financeWork} deterministic work units`, "UDL1004");
             return issues;
         }
-        const initial = applyEffects(noun, account, "create", { balance: EMPTY, holds: {} }, createEffects, reservations, account === refundSource, add);
+        const initial = applyEffects(account, "create", { balance: EMPTY, holds: {} }, createEffects, reservations, refundSourceAccounts.has(account), add);
         const states = new Map([
-            [noun.lifecycle.initial, new Map([[stateKey(initial), initial]])],
+            [instrument.lifecycle.initial, new Map([[stateKey(initial), initial]])],
         ]);
         pathVariants += 1;
-        const pending = [noun.lifecycle.initial];
+        const pending = [instrument.lifecycle.initial];
         while (pending.length > 0) {
             const from = pending.shift();
             const sourceStates = states.get(from);
             if (!sourceStates)
                 continue;
-            for (const [verb, transition] of Object.entries(noun.lifecycle.transitions)) {
+            for (const [action, transition] of Object.entries(instrument.lifecycle.transitions)) {
                 if (!transition.from.includes(from))
                     continue;
                 const targetStates = states.get(transition.to) ?? new Map();
                 states.set(transition.to, targetStates);
                 let grew = false;
                 for (const sourceState of sourceStates.values()) {
-                    const transitionEffects = effects.get(verb) ?? [];
+                    const transitionEffects = effects.get(action) ?? [];
                     work += 1 + transitionEffects.length;
                     if (work > UDL_LIMITS.financeWork) {
-                        add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financeWork} deterministic work units`);
+                        add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financeWork} deterministic work units`, "UDL1004");
                         return issues;
                     }
-                    const targetState = applyEffects(noun, account, verb, sourceState, transitionEffects, reservations, account === refundSource, add);
+                    const targetState = applyEffects(account, action, sourceState, transitionEffects, reservations, refundSourceAccounts.has(account), add);
                     const key = stateKey(targetState);
                     if (targetStates.has(key))
                         continue;
                     targetStates.set(key, targetState);
                     pathVariants += 1;
                     if (pathVariants > UDL_LIMITS.financePathVariants) {
-                        add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financePathVariants} distinct path variants`);
+                        add(["lifecycle"], `financial analysis exceeds ${UDL_LIMITS.financePathVariants} distinct path variants`, "UDL1004");
                         return issues;
                     }
                     grew = true;
@@ -106,7 +107,7 @@ export function analyzeNounFinance(noun, options = {}) {
                     pending.push(transition.to);
             }
         }
-        const nonterminalStates = new Set(Object.values(noun.lifecycle.transitions).flatMap((transition) => transition.from));
+        const nonterminalStates = new Set(Object.values(instrument.lifecycle.transitions).flatMap((transition) => transition.from));
         for (const [state, variants] of states) {
             if (nonterminalStates.has(state))
                 continue;
@@ -115,54 +116,54 @@ export function analyzeNounFinance(noun, options = {}) {
                     Object.keys(variant.holds).length === 0) {
                     continue;
                 }
-                add(["lifecycle", "states", noun.lifecycle.states.indexOf(state)], `terminal state ${state} can strand value in ${formatAccount(account)}`);
+                add(["lifecycle", "states", instrument.lifecycle.states.indexOf(state)], `terminal state ${state} can strand value in ${formatAccount(account)}`);
             }
         }
     }
     return issues;
 }
-export function financeAdmissionProblem(noun) {
-    if (noun.lifecycle.states.length > UDL_LIMITS.financeStates) {
+export function financeAdmissionProblem(instrument) {
+    if (instrument.lifecycle.states.length > UDL_LIMITS.financeStates) {
         return `financial analysis exceeds ${UDL_LIMITS.financeStates} lifecycle states`;
     }
     let transitionCount = 0;
     let transitionEdges = 0;
-    for (const name in noun.lifecycle.transitions) {
-        if (!Object.hasOwn(noun.lifecycle.transitions, name))
+    for (const name in instrument.lifecycle.transitions) {
+        if (!Object.hasOwn(instrument.lifecycle.transitions, name))
             continue;
         transitionCount += 1;
         if (transitionCount > UDL_LIMITS.financeTransitions) {
             return `financial analysis exceeds ${UDL_LIMITS.financeTransitions} lifecycle transitions`;
         }
-        transitionEdges += noun.lifecycle.transitions[name]?.from.length ?? 0;
+        transitionEdges += instrument.lifecycle.transitions[name]?.from.length ?? 0;
         if (transitionEdges > UDL_LIMITS.financeTransitionEdges) {
             return `financial analysis exceeds ${UDL_LIMITS.financeTransitionEdges} lifecycle transition edges`;
         }
     }
-    let verbCount = 0;
+    let actionCount = 0;
     let effectCount = 0;
-    for (const name in noun.verbs) {
-        if (!Object.hasOwn(noun.verbs, name))
+    for (const name in instrument.actions) {
+        if (!Object.hasOwn(instrument.actions, name))
             continue;
-        verbCount += 1;
-        if (verbCount > UDL_LIMITS.financeVerbs) {
-            return `financial analysis exceeds ${UDL_LIMITS.financeVerbs} verbs`;
+        actionCount += 1;
+        if (actionCount > UDL_LIMITS.financeActions) {
+            return `financial analysis exceeds ${UDL_LIMITS.financeActions} actions`;
         }
-        const verb = noun.verbs[name];
-        effectCount += (verb?.steps.length ?? 0) + (verb?.moves?.length ?? 0);
+        const action = instrument.actions[name];
+        effectCount += (action?.steps.length ?? 0) + (action?.moves?.length ?? 0);
         if (effectCount > UDL_LIMITS.financeEffects) {
             return `financial analysis exceeds ${UDL_LIMITS.financeEffects} kernel effects`;
         }
     }
     return undefined;
 }
-function workspaceEscrowAccounts(noun) {
+function productEscrowAccounts(instrument) {
     const accounts = new Set();
-    for (const verb of Object.values(noun.verbs)) {
-        for (const step of verb.steps) {
+    for (const action of Object.values(instrument.actions)) {
+        for (const step of action.steps) {
             if (step.operation !== "account.escrow.provision" ||
                 step.bind.role?.from !== "const" ||
-                step.bind.role.value !== "workspace_escrow") {
+                step.bind.role.value !== "product_escrow") {
                 continue;
             }
             for (const [key, result] of Object.entries(step.capture ?? {})) {
@@ -171,27 +172,29 @@ function workspaceEscrowAccounts(noun) {
             }
         }
     }
-    // `workspace_escrow` also backs open-ended balance products such as wallets.
+    // `product_escrow` also backs open-ended balance products such as wallets.
     // Only instance-bound amounts claim static conservation; caller-sized flows
-    // remain runtime balance checks. Unwind sources are added separately above.
-    return new Set([...accounts].filter((account) => Object.values(noun.verbs).some((verb) => (verb.moves ?? []).some((step) => {
+    // remain runtime balance checks. Commit sources are added separately above.
+    return new Set([...accounts].filter((account) => Object.values(instrument.actions).some((action) => (action.moves ?? []).some((step) => {
         if ((step.operation !== "internal_transfer.create" &&
             step.operation !== "internal_transfer.reserve") ||
             step.bind.amount?.from !== "instance") {
             return false;
         }
-        return (canonicalAccount(noun, step.bind.sourceAccountId) === account ||
-            canonicalAccount(noun, step.bind.destinationAccountId) === account);
+        return (canonicalAccount(instrument, step.bind.sourceAccountId) ===
+            account ||
+            canonicalAccount(instrument, step.bind.destinationAccountId) ===
+                account);
     }))));
 }
-function reservationsByKey(noun) {
+function reservationsByKey(instrument) {
     const reservations = new Map();
-    for (const verb of Object.values(noun.verbs)) {
-        for (const step of verb.moves ?? []) {
+    for (const action of Object.values(instrument.actions)) {
+        for (const step of action.moves ?? []) {
             if (step.operation !== "internal_transfer.reserve")
                 continue;
-            const source = canonicalAccount(noun, step.bind.sourceAccountId);
-            const destination = canonicalAccount(noun, step.bind.destinationAccountId);
+            const source = canonicalAccount(instrument, step.bind.sourceAccountId);
+            const destination = canonicalAccount(instrument, step.bind.destinationAccountId);
             const amount = amountIdentity(step.bind.amount);
             for (const [key, result] of Object.entries(step.capture ?? {})) {
                 if (result === "transferId") {
@@ -206,43 +209,60 @@ function reservationsByKey(noun) {
     }
     return reservations;
 }
-function effectsByVerb(noun, account, reservations, penaltyCanBeNonzero) {
-    return new Map(Object.entries(noun.verbs).map(([verbName, verb]) => [
-        verbName,
-        (verb.moves ?? []).flatMap((step, stepIndex) => {
-            const path = ["verbs", verbName, "moves", stepIndex, "bind"];
+function effectsByAction(instrument, account, reservations, quotes) {
+    const quoteByCommit = new Map(quotes.map((quote) => [quote.commit, quote]));
+    const chargePaths = new Map(quotes.map((quote) => [`refs.${quote.chargeRef}`, quote]));
+    return new Map(Object.entries(instrument.actions).map(([actionName, action]) => [
+        actionName,
+        (action.moves ?? []).flatMap((step, stepIndex) => {
+            const path = [
+                "actions",
+                actionName,
+                "moves",
+                stepIndex,
+                "bind",
+            ];
             if (step.operation === "internal_transfer.create") {
                 const effects = [];
                 const amount = amountIdentity(step.bind.amount);
-                if (canonicalAccount(noun, step.bind.destinationAccountId) === account) {
+                if (canonicalAccount(instrument, step.bind.destinationAccountId) ===
+                    account) {
                     effects.push({ amount, kind: "credit", path });
                 }
-                const source = canonicalAccount(noun, step.bind.sourceAccountId);
+                const source = canonicalAccount(instrument, step.bind.sourceAccountId);
                 if (source && accountsMayAlias(source, account)) {
-                    const kind = verbName === noun.unwind?.confirm &&
-                        step.bind.amount?.from === "instance" &&
-                        step.bind.amount.path === "refs.unwindRefund"
+                    const committed = quoteByCommit.get(actionName);
+                    const amountPath = step.bind.amount?.from === "instance"
+                        ? step.bind.amount.path
+                        : undefined;
+                    const refunded = committed && amountPath === `refs.${committed.netRef}`
+                        ? committed
+                        : undefined;
+                    const charged = amountPath
+                        ? chargePaths.get(amountPath)
+                        : undefined;
+                    const kind = refunded
                         ? "refund"
-                        : step.bind.amount?.from === "instance" &&
-                            step.bind.amount.path === "refs.unwindPenalty"
+                        : charged
                             ? "penalty_debit"
-                            : step.bind.amount?.from === "instance"
+                            : amountPath !== undefined
                                 ? "debit"
                                 : "dynamic_debit";
                     effects.push({
-                        amount: kind === "refund" && !penaltyCanBeNonzero
+                        amount: refunded && !refunded.chargeCanBeNonzero
                             ? "refund_without_penalty"
                             : amount,
                         kind,
                         path,
+                        ...(refunded ? { refundable: refunded.baseField } : {}),
                     });
                 }
                 return effects;
             }
             if (step.operation === "internal_transfer.reserve") {
-                const reservation = transferRefKey(step) ?? `${verbName}:${stepIndex}`;
+                const reservation = transferRefKey(step) ?? `${actionName}:${stepIndex}`;
                 const effects = [];
-                const source = canonicalAccount(noun, step.bind.sourceAccountId);
+                const source = canonicalAccount(instrument, step.bind.sourceAccountId);
                 if (source && accountsMayAlias(source, account)) {
                     effects.push({
                         amount: amountIdentity(step.bind.amount),
@@ -251,7 +271,8 @@ function effectsByVerb(noun, account, reservations, penaltyCanBeNonzero) {
                         reservation,
                     });
                 }
-                if (canonicalAccount(noun, step.bind.destinationAccountId) === account) {
+                if (canonicalAccount(instrument, step.bind.destinationAccountId) ===
+                    account) {
                     effects.push({
                         amount: amountIdentity(step.bind.amount),
                         kind: "incoming_reserve",
@@ -285,16 +306,16 @@ function effectsByVerb(noun, account, reservations, penaltyCanBeNonzero) {
         }),
     ]));
 }
-function applyEffects(noun, account, verb, input, effects, reservations, exactBalance, add) {
+function applyEffects(account, action, input, effects, reservations, exactBalance, add) {
     let balance = input.balance;
     const holds = { ...input.holds };
     const accountLabel = formatAccount(account);
     for (const effect of effects) {
-        const fail = (message) => add([...effect.path, "sourceAccountId"], `verb ${verb} ${message}`);
+        const fail = (message) => add([...effect.path, "sourceAccountId"], `action ${action} ${message}`);
         if (effect.kind === "credit") {
             if (exactBalance &&
                 (balance.kind !== "empty" || Object.keys(holds).length > 0)) {
-                add([...effect.path, "destinationAccountId"], `verb ${verb} funds ${accountLabel} while earlier value may remain; unwind funding must establish exactly one refundable balance`);
+                add([...effect.path, "destinationAccountId"], `action ${action} funds ${accountLabel} while earlier value may remain; quoted funding must establish exactly one refundable balance`);
                 balance = UNKNOWN;
                 continue;
             }
@@ -340,14 +361,14 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
                         balance = held;
                     }
                     else {
-                        add([...effect.path, "transferId"], `verb ${verb} restores a held ${accountLabel} balance on top of existing value`);
+                        add([...effect.path, "transferId"], `action ${action} restores a held ${accountLabel} balance on top of existing value`);
                         balance = UNKNOWN;
                     }
                 }
             }
             if (effect.kind === "post" && reservation?.destination === account) {
                 if (balance.kind !== "empty" || Object.keys(holds).length > 0) {
-                    add([...effect.path, "transferId"], `verb ${verb} posts funding into ${accountLabel} while earlier value may remain`);
+                    add([...effect.path, "transferId"], `action ${action} posts funding into ${accountLabel} while earlier value may remain`);
                     balance = UNKNOWN;
                 }
                 else {
@@ -357,7 +378,7 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
             continue;
         }
         if (effect.kind === "refund") {
-            const refundable = `fields.${noun.unwind?.refundableField ?? ""}`;
+            const refundable = `fields.${effect.refundable ?? ""}`;
             if (balance.kind !== "funded" ||
                 balance.amounts.length !== 1 ||
                 balance.amounts[0] !== refundable) {
@@ -374,7 +395,7 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
         }
         if (effect.kind === "penalty_debit") {
             if (balance.kind !== "penalty") {
-                fail(`cannot pay refs.unwindPenalty from ${accountLabel} before the refund leaves that exact remainder`);
+                fail(`cannot pay the quoted charge from ${accountLabel} before the refund leaves that exact remainder`);
             }
             balance = EMPTY;
             continue;
@@ -384,7 +405,7 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
                 fail(`can debit unfunded ${accountLabel}`);
             }
             else if (balance.kind === "penalty") {
-                fail(`can debit ${accountLabel} after its refund left only refs.unwindPenalty`);
+                fail(`can debit ${accountLabel} after its refund left only the quoted charge`);
             }
             balance = balance.kind === "empty" ? EMPTY : { kind: "unknown" };
             continue;
@@ -397,7 +418,7 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
             fail(`can debit unfunded ${accountLabel}`);
         }
         else if (balance.kind === "penalty") {
-            fail(`can debit ${accountLabel} after its refund left only refs.unwindPenalty`);
+            fail(`can debit ${accountLabel} after its refund left only the quoted charge`);
         }
         else if (balance.kind === "funded" || exactBalance) {
             fail(`cannot prove ${effect.amount} is the exact available balance of ${accountLabel}`);
@@ -406,46 +427,81 @@ function applyEffects(noun, account, verb, input, effects, reservations, exactBa
     }
     return { balance, holds };
 }
-function validatePenaltyPayout(noun, refundSource, required, add) {
-    const uses = Object.entries(noun.verbs).flatMap(([verbName, verb]) => (verb.moves ?? []).flatMap((step, stepIndex) => Object.entries(step.bind).flatMap(([target, binding]) => binding.from === "instance" && binding.path === "refs.unwindPenalty"
-        ? [{ binding, step, stepIndex, target, verb, verbName }]
+/**
+ * Flattens every quote-commit pair the instrument declares. A quoting action
+ * with no committing action, or a commit naming a non-quoting action, is a
+ * validator failure rather than a typestate one, so it is simply skipped here.
+ */
+function quoteFacts(instrument, options) {
+    const facts = [];
+    for (const [quoting, action] of Object.entries(instrument.actions)) {
+        const quote = action.quote;
+        if (!quote)
+            continue;
+        const commit = Object.entries(instrument.actions).find(([, candidate]) => candidate.commit === quoting)?.[0];
+        if (commit === undefined)
+            continue;
+        const chargePath = `refs.${quote.chargeRef}`;
+        const declaresChargePayout = Object.values(instrument.actions).some((candidate) => (candidate.moves ?? []).some((move) => Object.values(move.bind).some((binding) => binding.from === "instance" && binding.path === chargePath)));
+        facts.push({
+            baseField: quote.baseField,
+            chargeCanBeNonzero: options.penaltyMayBeNonzero === true ||
+                declaresChargePayout ||
+                quote.charges.some((tier) => tier.bps > 0),
+            chargeRef: quote.chargeRef,
+            commit,
+            netRef: quote.netRef,
+            quoting,
+        });
+    }
+    return facts;
+}
+/**
+ * The quoted charge is the exact remainder the commit leaves behind, so it may
+ * fund one transfer, out of the same account the refund left, in its own
+ * one-way action directly after the commit.
+ */
+function validateChargePayout(instrument, quote, refundSource, add) {
+    const chargePath = `refs.${quote.chargeRef}`;
+    const uses = Object.entries(instrument.actions).flatMap(([actionName, action]) => (action.moves ?? []).flatMap((step, stepIndex) => Object.entries(step.bind).flatMap(([target, binding]) => binding.from === "instance" && binding.path === chargePath
+        ? [{ binding, step, stepIndex, target, action, actionName }]
         : [])));
-    if (required && uses.length !== 1) {
-        add(["verbs"], `refs.unwindPenalty is consumed ${uses.length} times; a nonzero penalty schedule requires exactly one payout`);
+    if (quote.chargeCanBeNonzero && uses.length !== 1) {
+        add(["actions"], `${chargePath} is consumed ${uses.length} times; a nonzero charge schedule requires exactly one payout`);
     }
     if (uses.length === 0)
         return;
     if (uses.length !== 1) {
-        if (!required) {
-            add(["verbs"], `refs.unwindPenalty is consumed ${uses.length} times; it may fund at most one payout`);
+        if (!quote.chargeCanBeNonzero) {
+            add(["actions"], `${chargePath} is consumed ${uses.length} times; it may fund at most one payout`);
         }
         return;
     }
     const use = uses[0];
-    const payoutTransition = noun.lifecycle.transitions[use.verbName];
-    const confirmTarget = noun.lifecycle.transitions[noun.unwind.confirm]?.to;
-    const source = canonicalAccount(noun, use.step.bind.sourceAccountId);
-    const destination = canonicalAccount(noun, use.step.bind.destinationAccountId);
-    const directAfterConfirm = confirmTarget !== undefined &&
+    const payoutTransition = instrument.lifecycle.transitions[use.actionName];
+    const commitTarget = instrument.lifecycle.transitions[quote.commit]?.to;
+    const source = canonicalAccount(instrument, use.step.bind.sourceAccountId);
+    const destination = canonicalAccount(instrument, use.step.bind.destinationAccountId);
+    const directAfterCommit = commitTarget !== undefined &&
         payoutTransition?.from.length === 1 &&
-        payoutTransition.from[0] === confirmTarget;
+        payoutTransition.from[0] === commitTarget;
     const oneWay = payoutTransition !== undefined &&
-        payoutTransition.to !== confirmTarget &&
-        !stateCanReach(noun, payoutTransition.to, confirmTarget);
+        payoutTransition.to !== commitTarget &&
+        !stateCanReach(instrument, payoutTransition.to, commitTarget);
     const valid = use.target === "amount" &&
         use.step.operation === "internal_transfer.create" &&
-        (use.verb.moves?.length ?? 0) === 1 &&
-        directAfterConfirm &&
+        (use.action.moves?.length ?? 0) === 1 &&
+        directAfterCommit &&
         oneWay &&
         source !== undefined &&
         source === refundSource &&
         destination !== undefined &&
         !accountsMayAlias(source, destination);
     if (!valid) {
-        add(["verbs", use.verbName, "moves", use.stepIndex, "bind", use.target], `refs.unwindPenalty must be the amount of one internal transfer from the unwind refund source to a different account, in its own one-way verb directly after ${noun.unwind.confirm}`);
+        add(["actions", use.actionName, "moves", use.stepIndex, "bind", use.target], `${chargePath} must be the amount of one internal transfer from the quoted refund source to a different account, in its own one-way action directly after ${quote.commit}`);
     }
 }
-function canonicalAccount(noun, binding) {
+function canonicalAccount(instrument, binding) {
     if (binding?.from !== "instance")
         return undefined;
     const [root, key, extra] = binding.path.split(".");
@@ -456,7 +512,7 @@ function canonicalAccount(noun, binding) {
     if (root === "refs")
         return `ref:${key}`;
     if (root === "party") {
-        const field = noun.parties?.[key];
+        const field = instrument.parties?.[key];
         return field ? `field:${field}` : undefined;
     }
     return undefined;
@@ -480,7 +536,7 @@ function boundTransferRefKey(step) {
         ? binding.path.slice("refs.".length)
         : undefined;
 }
-function stateCanReach(noun, start, target) {
+function stateCanReach(instrument, start, target) {
     if (!target)
         return false;
     const seen = new Set([start]);
@@ -489,7 +545,7 @@ function stateCanReach(noun, start, target) {
         const state = pending.shift();
         if (state === target)
             return true;
-        for (const transition of Object.values(noun.lifecycle.transitions)) {
+        for (const transition of Object.values(instrument.lifecycle.transitions)) {
             if (!transition.from.includes(state) || seen.has(transition.to))
                 continue;
             seen.add(transition.to);