@hyperscale0/hsx 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/src/check.js

@@ -5,70 +5,9 @@
  * exactly when nothing error-severity was found. Warnings are the compiler's
  * lint voice and never block.
  */
+import { ARCHETYPE_DEFINITIONS, SETTLEMENT_ARCHETYPES, } from "./archetypes.js";
 import { ASSET_KINDS, PARTY_KINDS, } from "./model.js";
-/** Every archetype the settlement stdlib ships; all of them lower today. */
-export const SETTLEMENT_ARCHETYPES = [
-    "advance",
-    "deposit",
-    "held_payment",
-    "instant_transfer",
-    "metered",
-    "pooled_split",
-    "premium_forward",
-    "scheduled",
-    "swap",
-];
-/** Each archetype's parameter surface: the entries its body understands. */
-const ARCHETYPE_SURFACES = {
-    advance: {
-        keys: [
-            "against",
-            "amount",
-            "count",
-            "every",
-            "fee",
-            "first_due",
-            "funder",
-            "to",
-        ],
-        // The repayment source is one of two shapes (a schedule, or a carve out of
-        // a hold's release), so the advance case below states that requirement
-        // itself rather than listing either shape's keys here.
-        required: ["funder", "to", "amount"],
-    },
-    deposit: {
-        keys: ["amount", "claim", "holder", "payer", "return"],
-        required: ["payer", "holder", "amount", "claim", "return"],
-    },
-    held_payment: {
-        keys: ["amount", "fees", "on_cancel", "payer", "payee", "release"],
-        required: ["payer", "payee", "amount", "release"],
-    },
-    instant_transfer: {
-        keys: ["amount", "fees", "payer", "payee"],
-        required: ["payer", "payee", "amount"],
-    },
-    metered: {
-        keys: ["close_by", "payer", "payee", "rates"],
-        required: ["payer", "payee", "rates", "close_by"],
-    },
-    pooled_split: {
-        keys: ["amount", "payer", "payout_due", "split"],
-        required: ["payer", "amount", "split", "payout_due"],
-    },
-    premium_forward: {
-        keys: ["amount", "bind", "carrier", "commission", "on_cancel", "payer"],
-        required: ["payer", "carrier", "amount", "bind"],
-    },
-    scheduled: {
-        keys: ["amount", "count", "every", "first_due", "payer", "payee"],
-        required: ["payer", "payee", "amount", "count", "every", "first_due"],
-    },
-    swap: {
-        keys: ["amounts", "between", "dispute", "fees", "release"],
-        required: ["between", "amounts", "release"],
-    },
-};
+export { SETTLEMENT_ARCHETYPES } from "./archetypes.js";
 /** The three terms that together declare a finite schedule. */
 const SCHEDULE_KEYS = ["count", "every", "first_due"];
 const SNAKE_CASE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
@@ -83,6 +22,7 @@ export function checkProgram(program) {
     const warning = (span, message) => {
         diagnostics.push({ message, severity: "warning", span });
     };
+    const derivedAmounts = [];
     // --- Header ---------------------------------------------------------------
     const headers = program.decls.filter((decl) => decl.kind === "program");
     const header = headers[0];
@@ -245,6 +185,7 @@ export function checkProgram(program) {
         /^piece\d+Amount$/,
         /^installment\d+Amount$/,
         /^repayment\d+Amount$/,
+        /^carve(?:Hold|Recourse\d+)Id$/,
         /ShareAmount$/,
         /AccountId$/,
     ];
@@ -320,31 +261,31 @@ export function checkProgram(program) {
             port: value.name.name,
         };
     };
-    const parseDisputeEntry = (entry, owner) => {
+    const parseDisputeEntry = (entry, owner, label = "dispute") => {
         if (!entry)
             return undefined;
         noQualifiers(entry, owner);
         const value = entry.value;
         if (value.kind !== "port_ref") {
-            error(value.span, `${owner} needs one whole-trade dispute decision, like: dispute: port resolve_dispute within P14D`);
+            error(value.span, `${owner} needs one ${label} decision through a fixed windowed port`);
             return undefined;
         }
         if (!portNames.has(value.name.name)) {
-            error(value.name.span, `${owner} disputes through port ${value.name.name}, but no port with that name is declared`);
+            error(value.name.span, `${owner} routes ${label} through port ${value.name.name}, but no port with that name is declared`);
             return undefined;
         }
         if (!value.within) {
-            error(value.span, `${owner} dispute needs a fixed window, like: dispute: port ${value.name.name} within P14D`);
+            error(value.span, `${owner} ${label} needs a fixed window, like: ${entry.key.name}: port ${value.name.name} within P14D`);
             return undefined;
         }
         const raw = value.within.name;
         const match = /^P([1-9]\d{0,3})([DW])$/.exec(raw);
-        if (raw !== "P0D" && !match) {
-            error(value.within.span, `dispute on ${owner} uses a fixed duration in days or weeks, like P14D; calendar months cannot define an exact money deadline`);
+        if (!match) {
+            error(value.within.span, `${label} on ${owner} uses a fixed duration in days or weeks, like P14D; calendar months cannot define an exact money deadline`);
             return undefined;
         }
-        const magnitude = match ? Number(match[1]) : 0;
-        const days = match?.[2] === "W" ? magnitude * 7 : magnitude;
+        const magnitude = Number(match[1]);
+        const days = match[2] === "W" ? magnitude * 7 : magnitude;
         referencedPorts.add(value.name.name);
         return {
             origin: value.span,
@@ -532,7 +473,59 @@ export function checkProgram(program) {
         error(entry.value.span, `${entry.key.name} on ${owner} names a camelCase date field, like: ${entry.key.name}: dueDate`);
         return undefined;
     };
-    const parseSchedule = (entries, owner, origin) => {
+    const parseFieldName = (entry, owner) => {
+        if (!entry)
+            return undefined;
+        noQualifiers(entry, owner);
+        if (entry.value.kind === "ident" && CAMEL_CASE.test(entry.value.name)) {
+            return reservedFieldName(entry.value.name, entry.value.span, owner)
+                ? undefined
+                : entry.value.name;
+        }
+        error(entry.value.span, `${entry.key.name} on ${owner} names a camelCase lineage field, like: ${entry.key.name}: captureReference`);
+        return undefined;
+    };
+    const requireIdentPolicy = (entry, owner, expected, refusal) => {
+        if (!entry)
+            return false;
+        noQualifiers(entry, owner);
+        if (entry.value.kind === "ident" && entry.value.name === expected) {
+            return true;
+        }
+        error(entry.value.span, `${entry.key.name} on ${owner} is ${expected}; ${refusal}`);
+        return false;
+    };
+    const parseLiteralCount = (entry, owner, label, minimum, maximum) => {
+        if (!entry)
+            return undefined;
+        noQualifiers(entry, owner);
+        const parsed = entry.value.kind === "number" ? Number(entry.value.raw) : Number.NaN;
+        if (Number.isInteger(parsed) && parsed >= minimum && parsed <= maximum) {
+            return parsed;
+        }
+        error(entry.value.span, `${label} on ${owner} is a literal integer from ${minimum} through ${maximum}`);
+        return undefined;
+    };
+    const parsePartyList = (entry, owner, label, minimum, maximum) => {
+        if (!entry)
+            return undefined;
+        noQualifiers(entry, owner);
+        if (entry.value.kind !== "list" ||
+            entry.value.items.length < minimum ||
+            entry.value.items.length > maximum) {
+            error(entry.value.span, `${label} on ${owner} lists ${minimum} through ${maximum} declared parties`);
+            return undefined;
+        }
+        const names = entry.value.items
+            .map((item) => partyRef(item, `${owner} ${label}`))
+            .filter((name) => name !== undefined);
+        if (new Set(names).size !== names.length) {
+            error(entry.value.span, `${label} on ${owner} must not repeat a party`);
+            return undefined;
+        }
+        return names.length === entry.value.items.length ? names : undefined;
+    };
+    const parseSchedule = (entries, owner, origin, maxCount = 12) => {
         const countEntry = entries.get("count");
         const everyEntry = entries.get("every");
         let count;
@@ -540,11 +533,11 @@ export function checkProgram(program) {
             noQualifiers(countEntry, owner);
             const value = countEntry.value;
             const parsed = value.kind === "number" ? Number(value.raw) : Number.NaN;
-            if (Number.isInteger(parsed) && parsed >= 2 && parsed <= 12) {
+            if (Number.isInteger(parsed) && parsed >= 2 && parsed <= maxCount) {
                 count = parsed;
             }
             else {
-                error(value.span, `count on ${owner} is a literal number of anchors between 2 and 12; the schedule stays finite by construction`);
+                error(value.span, `count on ${owner} is a literal number of anchors between 2 and ${maxCount}; the schedule stays finite by construction`);
             }
         }
         let every;
@@ -573,6 +566,42 @@ export function checkProgram(program) {
             return undefined;
         return { count, every, firstDueField, origin };
     };
+    const parseSettlementReference = (entry, owner) => {
+        noQualifiers(entry, owner);
+        const value = entry.value;
+        if (value.kind !== "settlement_ref") {
+            error(value.span, `${owner} draws against a held payment's release, like: against: retention.release`);
+            return undefined;
+        }
+        const target = value.owner.name;
+        const targetDecl = settlementDecls.find((decl) => decl.name.name === target);
+        if (!targetDecl) {
+            const other = declared.get(target);
+            error(value.owner.span, other
+                ? `${owner} references ${target}, which is a ${other.kind}; settlement exits belong to settlements`
+                : `${owner} references ${target}, but no settlement with that name is declared`);
+            return undefined;
+        }
+        const targetArchetype = targetDecl.archetype.name;
+        if (!SETTLEMENT_ARCHETYPES.includes(targetArchetype)) {
+            return undefined;
+        }
+        const exits = ARCHETYPE_DEFINITIONS[targetArchetype]
+            .referenceableExits;
+        if (!exits.includes(value.member.name)) {
+            const offered = exits.length > 0
+                ? `it exposes ${exits.join(", ")}`
+                : "it exposes no referenceable exits";
+            error(value.member.span, `${owner} references ${target}.${value.member.name}, but ${targetArchetype} does not expose that exit; ${offered}`);
+            return undefined;
+        }
+        return {
+            exit: value.member.name,
+            origin: value.span,
+            settlement: target,
+            targetArchetype: targetArchetype,
+        };
+    };
     /**
      * An advance draws its repayment from exactly one source: its own finite
      * schedule, or a carve out of the release of a hold the advanced party is
@@ -598,17 +627,8 @@ export function checkProgram(program) {
             const schedule = parseSchedule(entries, owner, origin);
             return schedule ? { kind: "schedule", schedule } : undefined;
         }
-        noQualifiers(againstEntry, owner);
-        const value = againstEntry.value;
-        if (value.kind !== "settlement_ref") {
-            error(value.span, `${owner} draws against a held payment's release, like: against: retention.release`);
-            return undefined;
-        }
-        if (value.member.name !== "release") {
-            error(value.member.span, `an advance carves a hold's release; there is no exit named ${value.member.name} on ${value.owner.name} to draw against`);
-            return undefined;
-        }
-        return { kind: "carve", origin: value.span, settlement: value.owner.name };
+        const reference = parseSettlementReference(againstEntry, owner);
+        return reference ? { kind: "carve", ...reference } : undefined;
     };
     // --- Settlements: one checker per archetype ---------------------------------
     for (const decl of settlementDecls) {
@@ -620,8 +640,8 @@ export function checkProgram(program) {
             continue;
         }
         const owner = `settlement ${decl.name.name}`;
-        const surface = ARCHETYPE_SURFACES[archetype];
-        const entries = entriesOf(decl.body, surface.keys, owner);
+        const surface = ARCHETYPE_DEFINITIONS[archetype];
+        const entries = entriesOf(decl.body, [...surface.keys, "derived_amount"], owner);
         for (const required of surface.required) {
             if (!entries.has(required)) {
                 error(decl.span, `${owner} is missing ${required}`);
@@ -641,7 +661,429 @@ export function checkProgram(program) {
             }
             return true;
         };
+        const derived = entries.get("derived_amount");
+        if (derived) {
+            noQualifiers(derived, owner);
+            if (derived.value.kind !== "block") {
+                error(derived.value.span, "derived_amount is a block with field, source, rule, and bearer");
+            }
+            else {
+                const terms = entriesOf(derived.value, ["field", "source", "rule", "bearer"], `${owner} derived_amount`);
+                for (const key of ["field", "source", "rule", "bearer"]) {
+                    if (!terms.has(key))
+                        error(derived.span, `${owner} derived_amount is missing ${key}`);
+                }
+                const fieldValue = terms.get("field")?.value;
+                const baseValue = terms.get("source")?.value;
+                const ruleValue = terms.get("rule")?.value;
+                const bearerValue = terms.get("bearer")?.value;
+                const field = fieldValue?.kind === "ident" ? fieldValue.name : undefined;
+                const baseField = baseValue?.kind === "ident" ? baseValue.name : undefined;
+                const bearer = bearerValue
+                    ? partyRef(bearerValue, `${owner} derived amount bearer`)
+                    : undefined;
+                if (fieldValue && fieldValue.kind !== "ident")
+                    error(fieldValue.span, "derived amount field must be a camelCase identifier");
+                if (baseValue && baseValue.kind !== "ident")
+                    error(baseValue.span, "derived amount source must name one stored money field");
+                if (ruleValue && ruleValue.kind !== "percent") {
+                    error(ruleValue.span, "derived_amount proves percentage-of rules only; fixed and tiered rules are refused");
+                }
+                if (ruleValue?.kind === "percent" &&
+                    (ruleValue.bps <= 0 || ruleValue.bps >= TOTAL_BPS)) {
+                    error(ruleValue.span, "derived amount percentage must be above 0% and below 100%");
+                }
+                if (field && !CAMEL_CASE.test(field))
+                    error(fieldValue.span, `derived amount field ${field} must be camelCase`);
+                if (baseField && !CAMEL_CASE.test(baseField))
+                    error(baseValue.span, `derived amount source ${baseField} must be camelCase`);
+                if (field && baseField && field === baseField)
+                    error(derived.span, "derived amount field must differ from its source field");
+                if (field &&
+                    baseField &&
+                    bearer &&
+                    ruleValue?.kind === "percent" &&
+                    ruleValue.bps > 0 &&
+                    ruleValue.bps < TOTAL_BPS) {
+                    derivedAmounts.push({
+                        baseField,
+                        bearer,
+                        bps: ruleValue.bps,
+                        field,
+                        origin: derived.span,
+                        settlement: decl.name.name,
+                    });
+                }
+            }
+        }
         switch (archetype) {
+            case "captured_payment": {
+                const payer = party("payer", "payer");
+                const payee = party("payee", "payee");
+                const sound = distinct(payer, payee, `pays ${payer} from ${payer}; payer and payee must differ`);
+                const amount = parseAmount(entries.get("amount"), owner);
+                const reserveUntilField = parseDateField(entries.get("reserve_until"), owner);
+                const correction = parsePortEntry(entries.get("correction"), owner, "payee correction");
+                const externalReversal = parseDisputeEntry(entries.get("external_reversal"), owner, "external reversal");
+                const captureInSlices = requireIdentPolicy(entries.get("capture_mode"), owner, "partial_then_full", "capture calls must leave a remainder and settle posts the final remainder");
+                const fullCorrection = requireIdentPolicy(entries.get("correction_mode"), owner, "full_only", "repeated partial corrections are not representable yet, so the checker refuses them");
+                const noNegativePosition = requireIdentPolicy(entries.get("negative_position"), owner, "reject", "a correction or reversal must fail when the payee cannot fund it");
+                const timeoutRejects = requireIdentPolicy(entries.get("timeout"), owner, "reject", "a timeout records no money movement; only a confirmed decision may reverse funds");
+                if (entries.has("fees")) {
+                    error(entries.get("fees").span, `${owner} does not price fees inside captured_payment; compose a separate fee settlement so capture and correction amounts stay exact`);
+                }
+                if (amount && reserveUntilField === amount.name) {
+                    error(entries.get("reserve_until")?.span ?? decl.span, `${owner} uses ${amount.name} as both the reserved amount and reserve_until date field; they need distinct names`);
+                    break;
+                }
+                if (payer &&
+                    payee &&
+                    amount &&
+                    reserveUntilField &&
+                    correction &&
+                    externalReversal &&
+                    captureInSlices &&
+                    fullCorrection &&
+                    noNegativePosition &&
+                    timeoutRejects &&
+                    sound) {
+                    settlements.push({
+                        amount,
+                        archetype: "captured_payment",
+                        correction,
+                        externalReversal,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        payee,
+                        payer,
+                        reserveUntilField,
+                    });
+                }
+                break;
+            }
+            case "settlement_batch": {
+                const settlementAccount = party("settlement_account", "settlement account");
+                const payoutDestination = party("payout_destination", "payout destination");
+                const sound = distinct(settlementAccount, payoutDestination, `routes payout from ${settlementAccount} back to itself; settlement account and payout destination must differ`);
+                const sourceCaptureReferenceField = parseFieldName(entries.get("source_capture_refs"), owner);
+                const feeReferenceField = parseFieldName(entries.get("fee_entries"), owner);
+                const externalReversalReferenceField = parseFieldName(entries.get("external_reversal_offsets"), owner);
+                const closeTriggerField = parseDateField(entries.get("close_trigger"), owner);
+                const payoutAcknowledgement = parsePortEntry(entries.get("payout_acknowledgement"), owner, "payout acknowledgement");
+                const payoutBeneficiaryReferenceField = parseFieldName(entries.get("payout_beneficiary_ref"), owner);
+                const rejectsNegative = requireIdentPolicy(entries.get("negative_position"), owner, "reject", "offsets beyond gross capture entries must stop calculation and post no payout");
+                const lineageFields = [
+                    sourceCaptureReferenceField,
+                    feeReferenceField,
+                    externalReversalReferenceField,
+                    closeTriggerField,
+                    payoutBeneficiaryReferenceField,
+                ].filter((field) => field !== undefined);
+                if (new Set(lineageFields).size !== lineageFields.length) {
+                    error(decl.span, `${owner} needs distinct source_capture_refs, fee_entries, external_reversal_offsets, close_trigger, and payout_beneficiary_ref field names`);
+                    break;
+                }
+                if (settlementAccount &&
+                    payoutDestination &&
+                    sourceCaptureReferenceField &&
+                    feeReferenceField &&
+                    externalReversalReferenceField &&
+                    closeTriggerField &&
+                    payoutAcknowledgement &&
+                    payoutBeneficiaryReferenceField &&
+                    rejectsNegative &&
+                    sound) {
+                    settlements.push({
+                        archetype: "settlement_batch",
+                        closeTriggerField,
+                        externalReversalReferenceField,
+                        feeReferenceField,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        payoutDestination,
+                        payoutAcknowledgement,
+                        payoutBeneficiaryReferenceField,
+                        settlementAccount,
+                        sourceCaptureReferenceField,
+                    });
+                }
+                break;
+            }
+            case "funding_round": {
+                const contributor = party("contributor", "contributor");
+                const beneficiary = party("beneficiary", "beneficiary");
+                const target = parseAmount(entries.get("target"), owner);
+                const commitment = parseAmount(entries.get("commitment"), owner);
+                const maxContributors = parseLiteralCount(entries.get("max_contributors"), owner, "max_contributors", 2, 10_000);
+                const closeByField = parseDateField(entries.get("close_by"), owner);
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("close_policy"), owner, "threshold", "close must follow the locked committed sum at the stored close date"),
+                    requireIdentPolicy(entries.get("overfund_policy"), owner, "reject", "a commitment past the remaining target headroom must refuse"),
+                    requireIdentPolicy(entries.get("cancel_policy"), owner, "before_close", "a commitment may cancel only while its parent remains open"),
+                    requireIdentPolicy(entries.get("fail_policy"), owner, "whole_commitment_refund", "failure refunds each stored commitment whole"),
+                ].every(Boolean);
+                const sound = distinct(contributor, beneficiary, `uses ${contributor} as both contributor and beneficiary; the roles must differ`);
+                if (target && commitment && target.currency !== commitment.currency) {
+                    error(commitment.origin, `${owner} mixes ${target.currency} and ${commitment.currency}; target and commitment need one currency`);
+                }
+                if (target && commitment && target.name === commitment.name) {
+                    error(commitment.origin, `${owner} uses ${target.name} for both target and commitment; the parent and child amounts need distinct fields`);
+                }
+                if (contributor &&
+                    beneficiary &&
+                    target &&
+                    commitment &&
+                    target.currency === commitment.currency &&
+                    target.name !== commitment.name &&
+                    maxContributors &&
+                    closeByField &&
+                    policiesSound &&
+                    sound) {
+                    settlements.push({
+                        archetype: "funding_round",
+                        beneficiary,
+                        cancelPolicy: "before_close",
+                        closeByField,
+                        closePolicy: "threshold",
+                        commitment,
+                        contributor,
+                        failPolicy: "whole_commitment_refund",
+                        maxContributors,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        overfundPolicy: "reject",
+                        target,
+                    });
+                }
+                break;
+            }
+            case "weighted_distribution": {
+                const source = party("source", "source");
+                const recipient = party("recipient", "recipient template");
+                const amount = parseAmount(entries.get("amount"), owner);
+                const weight = parseAmount(entries.get("weight"), owner);
+                const maxRecipients = parseLiteralCount(entries.get("max_recipients"), owner, "max_recipients", 2, 10_000);
+                const recordAtField = parseDateField(entries.get("record_at"), owner);
+                const snapshot = parsePortEntry(entries.get("snapshot"), owner, "entitlement snapshot");
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("rounding_policy"), owner, "largest_remainder", "floor shares use a deterministic largest-remainder allocation with noun id as the tie-break"),
+                    requireIdentPolicy(entries.get("withholding_policy"), owner, "refuse", "withholding needs its own proved retained-amount mechanism"),
+                    requireIdentPolicy(entries.get("correction_policy"), owner, "new_distribution", "post-payout correction is a new linked distribution, never a rewrite or caller amount"),
+                ].every(Boolean);
+                const sound = distinct(source, recipient, `uses ${source} as both source and recipient; the roles must differ`);
+                if (amount && weight && amount.currency !== weight.currency) {
+                    error(weight.origin, `${owner} mixes ${amount.currency} and ${weight.currency}; pool and stored weights need one denomination`);
+                }
+                if (amount && weight && amount.name === weight.name) {
+                    error(weight.origin, `${owner} uses ${amount.name} for both pool and weight; the fields must differ`);
+                }
+                if (source &&
+                    recipient &&
+                    amount &&
+                    weight &&
+                    amount.currency === weight.currency &&
+                    amount.name !== weight.name &&
+                    maxRecipients &&
+                    recordAtField &&
+                    snapshot &&
+                    policiesSound &&
+                    sound) {
+                    settlements.push({
+                        amount,
+                        archetype: "weighted_distribution",
+                        correctionPolicy: "new_distribution",
+                        maxRecipients,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        recipient,
+                        recordAtField,
+                        roundingPolicy: "largest_remainder",
+                        snapshot,
+                        source,
+                        weight,
+                        withholdingPolicy: "refuse",
+                    });
+                }
+                break;
+            }
+            case "credit_facility": {
+                const lender = party("lender", "lender");
+                const borrower = party("borrower", "borrower");
+                const drawDestination = party("draw_destination", "draw destination");
+                const limit = parseAmount(entries.get("limit"), owner);
+                const expiresAtField = parseDateField(entries.get("expires_at"), owner);
+                const obligationEntry = entries.get("obligation");
+                const obligation = obligationEntry
+                    ? parseSettlementReference(obligationEntry, owner)
+                    : undefined;
+                const availabilityEntry = entries.get("availability_policy");
+                let availabilityPolicy;
+                if (availabilityEntry?.value.kind === "ident" &&
+                    (availabilityEntry.value.name === "revolving" ||
+                        availabilityEntry.value.name === "non_revolving")) {
+                    availabilityPolicy = availabilityEntry.value.name;
+                }
+                else if (availabilityEntry) {
+                    error(availabilityEntry.value.span, `availability_policy on ${owner} is revolving or non_revolving; the factpack does not justify an implicit choice`);
+                }
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("expiry_policy"), owner, "freeze_draws", "expiry stops new draws without closing linked debt"),
+                    requireIdentPolicy(entries.get("close_policy"), owner, "no_open_draws", "the facility closes only after every linked obligation resolves"),
+                ].every(Boolean);
+                const rolesSound = [
+                    distinct(lender, borrower, `uses ${lender} as both lender and borrower; the roles must differ`),
+                    distinct(lender, drawDestination, `draws back to its lender ${lender}; draw_destination must differ`),
+                ].every(Boolean);
+                if (lender &&
+                    borrower &&
+                    drawDestination &&
+                    limit &&
+                    expiresAtField &&
+                    obligation &&
+                    availabilityPolicy &&
+                    policiesSound &&
+                    rolesSound) {
+                    settlements.push({
+                        archetype: "credit_facility",
+                        availabilityPolicy,
+                        borrower,
+                        closePolicy: "no_open_draws",
+                        drawDestination,
+                        expiresAtField,
+                        expiryPolicy: "freeze_draws",
+                        lender,
+                        limit,
+                        name: decl.name.name,
+                        obligation,
+                        origin: decl.span,
+                    });
+                }
+                break;
+            }
+            case "recurring_collection": {
+                const obligationEntry = entries.get("obligation");
+                const obligation = obligationEntry
+                    ? parseSettlementReference(obligationEntry, owner)
+                    : undefined;
+                const mandate = parsePortEntry(entries.get("mandate"), owner, "mandate evidence");
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("attempt_policy"), owner, "explicit", "every attempt is a separate receipted call"),
+                    requireIdentPolicy(entries.get("period_idempotency"), owner, "obligation_and_anchor", "the parent obligation and stored anchor form the period identity"),
+                    requireIdentPolicy(entries.get("retry_policy"), owner, "explicit_attempt", "PRINCIPLES.md bans hidden retries; a retry needs a new explicit idempotency key"),
+                    requireIdentPolicy(entries.get("failure_policy"), owner, "parent_delinquency", "the scheduled obligation owns due state and delinquency"),
+                ].every(Boolean);
+                if (obligation && mandate && policiesSound) {
+                    settlements.push({
+                        archetype: "recurring_collection",
+                        attemptPolicy: "explicit",
+                        failurePolicy: "parent_delinquency",
+                        mandate,
+                        name: decl.name.name,
+                        obligation,
+                        origin: decl.span,
+                        periodIdempotency: "obligation_and_anchor",
+                        retryPolicy: "explicit_attempt",
+                    });
+                }
+                break;
+            }
+            case "conditional_disbursement": {
+                const source = party("source", "source");
+                const destination = party("destination", "destination");
+                const cap = parseAmount(entries.get("cap"), owner);
+                const amount = parseAmount(entries.get("amount"), owner);
+                const decision = parsePortEntry(entries.get("decision"), owner, "capped disbursement decision");
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("reopen_policy"), owner, "refuse", "a closed decision cannot be reopened; create a new linked disbursement"),
+                    requireIdentPolicy(entries.get("recovery_policy"), owner, "separate_transfer", "recovery is a new money movement with its own receipt"),
+                ].every(Boolean);
+                const sound = distinct(source, destination, `pays ${source} from itself; source and destination must differ`);
+                if (cap && amount && cap.currency !== amount.currency) {
+                    error(amount.origin, `${owner} mixes ${cap.currency} and ${amount.currency}; cap and approved amount need one currency`);
+                }
+                if (cap && amount && cap.name === amount.name) {
+                    error(amount.origin, `${owner} uses ${cap.name} for both cap and approved amount; the fields must differ`);
+                }
+                if (source &&
+                    destination &&
+                    cap &&
+                    amount &&
+                    cap.currency === amount.currency &&
+                    cap.name !== amount.name &&
+                    decision &&
+                    policiesSound &&
+                    sound) {
+                    settlements.push({
+                        amount,
+                        archetype: "conditional_disbursement",
+                        cap,
+                        decision,
+                        destination,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        recoveryPolicy: "separate_transfer",
+                        reopenPolicy: "refuse",
+                        source,
+                    });
+                }
+                break;
+            }
+            case "rotating_pool": {
+                const members = parsePartyList(entries.get("members"), owner, "members", 2, 5);
+                const payoutOrder = parsePartyList(entries.get("payout_order"), owner, "payout_order", 2, 5);
+                const contribution = parseAmount(entries.get("contribution"), owner);
+                const schedule = parseSchedule(entries, owner, decl.span, 12);
+                const guarantor = entries.has("guarantor")
+                    ? party("guarantor", "guarantor")
+                    : undefined;
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("default_policy"), owner, "due_condition", "default follows an unmet stored contribution due condition"),
+                    requireIdentPolicy(entries.get("guarantee_policy"), owner, "funded_only", "a guarantee changes money only through an explicit funded contribution"),
+                    requireIdentPolicy(entries.get("exit_policy"), owner, "before_activation_only", "membership and order freeze before the first contribution"),
+                ].every(Boolean);
+                let rosterSound = true;
+                if (members && payoutOrder) {
+                    const memberSet = new Set(members);
+                    if (payoutOrder.length !== members.length ||
+                        payoutOrder.some((name) => !memberSet.has(name))) {
+                        error(entries.get("payout_order")?.span ?? decl.span, `${owner} payout_order must contain every member exactly once`);
+                        rosterSound = false;
+                    }
+                }
+                if (members && schedule && schedule.count !== members.length) {
+                    error(entries.get("count")?.span ?? decl.span, `${owner} count ${schedule.count} must equal its ${members.length}-member roster`);
+                    rosterSound = false;
+                }
+                if (members && guarantor && members.includes(guarantor)) {
+                    error(entries.get("guarantor")?.span ?? decl.span, `${owner} guarantor must differ from every member`);
+                    rosterSound = false;
+                }
+                if (members && guarantor && members.length > 4) {
+                    error(entries.get("members")?.span ?? decl.span, `${owner} supports at most 4 members with a guarantor so every generated child binding stays within the 8-entry cap`);
+                    rosterSound = false;
+                }
+                if (members &&
+                    payoutOrder &&
+                    contribution &&
+                    schedule &&
+                    policiesSound &&
+                    rosterSound) {
+                    settlements.push({
+                        archetype: "rotating_pool",
+                        contribution,
+                        defaultPolicy: "due_condition",
+                        exitPolicy: "before_activation_only",
+                        guaranteePolicy: "funded_only",
+                        ...(guarantor ? { guarantor } : {}),
+                        members,
+                        name: decl.name.name,
+                        origin: decl.span,
+                        payoutOrder,
+                        schedule,
+                    });
+                }
+                break;
+            }
             case "swap": {
                 const betweenEntry = entries.get("between");
                 let sideA;
@@ -796,18 +1238,70 @@ export function checkProgram(program) {
                 const commissionBps = parsePercentEntry(entries.get("commission"), owner, "commission") ??
                     0;
                 const onCancel = parseCancelPolicy(entries.get("on_cancel"), owner, [payer, carrier].filter((name) => name !== undefined), "this settlement's payer or carrier");
-                if (payer && carrier && amount && bind && sound) {
-                    settlements.push({
+                const extensionKeys = [
+                    "policy_ref",
+                    "renewal_due",
+                    "renewal_policy",
+                    "endorsement",
+                    "endorsement_policy",
+                    "lapse_policy",
+                ];
+                const extendsPolicy = extensionKeys.some((key) => entries.has(key));
+                if (extendsPolicy) {
+                    for (const key of extensionKeys) {
+                        if (!entries.has(key))
+                            error(decl.span, `${owner} is missing ${key}`);
+                    }
+                }
+                const policyReferenceField = extendsPolicy
+                    ? parseFieldName(entries.get("policy_ref"), owner)
+                    : undefined;
+                const renewalDueField = extendsPolicy
+                    ? parseDateField(entries.get("renewal_due"), owner)
+                    : undefined;
+                const endorsement = extendsPolicy
+                    ? parsePortEntry(entries.get("endorsement"), owner, "endorsement evidence")
+                    : undefined;
+                const extensionPoliciesSound = !extendsPolicy
+                    ? true
+                    : [
+                        requireIdentPolicy(entries.get("renewal_policy"), owner, "explicit_new_forward", "each renewal creates a new premium_forward instead of moving money from policy state"),
+                        requireIdentPolicy(entries.get("endorsement_policy"), owner, "non_money_only", "a money adjustment needs a separate corrected movement"),
+                        requireIdentPolicy(entries.get("lapse_policy"), owner, "due_condition", "lapse follows the stored renewal due condition"),
+                    ].every(Boolean);
+                if (payer &&
+                    carrier &&
+                    amount &&
+                    bind &&
+                    sound &&
+                    extensionPoliciesSound &&
+                    (!extendsPolicy ||
+                        (policyReferenceField && renewalDueField && endorsement))) {
+                    const checked = {
                         amount,
                         archetype: "premium_forward",
                         bind,
                         carrier,
                         commissionBps,
+                        ...(endorsement ? { endorsement } : {}),
+                        ...(extendsPolicy &&
+                            policyReferenceField &&
+                            renewalDueField &&
+                            endorsement
+                            ? {
+                                endorsementPolicy: "non_money_only",
+                                lapsePolicy: "due_condition",
+                                policyReferenceField,
+                                renewalDueField,
+                                renewalPolicy: "explicit_new_forward",
+                            }
+                            : {}),
                         name: decl.name.name,
                         ...(onCancel ? { onCancel } : {}),
                         origin: decl.span,
                         payer,
-                    });
+                    };
+                    settlements.push(checked);
                 }
                 break;
             }
@@ -841,15 +1335,90 @@ export function checkProgram(program) {
                 const payee = party("payee", "payee");
                 const sound = distinct(payer, payee, `pays ${payer} from ${payer}; payer and payee must differ`);
                 const amount = parseAmount(entries.get("amount"), owner);
-                const schedule = parseSchedule(entries, owner, decl.span);
+                const requestedMode = entries.get("mode")?.value;
+                const obligationModeRequested = requestedMode?.kind === "ident" &&
+                    requestedMode.name === "obligation";
+                const schedule = parseSchedule(entries, owner, decl.span, obligationModeRequested ? 7 : 12);
                 if (amount && schedule && amount.name === schedule.firstDueField) {
                     error(schedule.origin, `${owner} uses ${amount.name} as both the amount and the first_due date field; they need distinct names`);
                     break;
                 }
-                if (payer && payee && amount && schedule && sound) {
+                const modeEntry = entries.get("mode");
+                const obligationKeys = [
+                    "advance_to",
+                    "debtor",
+                    "delinquency_policy",
+                    "partial_payment",
+                    "refund_policy",
+                    "repayment_matching",
+                    "reschedule_policy",
+                ];
+                const hasObligationKey = obligationKeys.some((key) => entries.has(key));
+                if (!modeEntry && hasObligationKey) {
+                    error(decl.span, `${owner} uses obligation policies without mode: obligation`);
+                    break;
+                }
+                if (!modeEntry) {
+                    if (payer && payee && amount && schedule && sound) {
+                        settlements.push({
+                            amount,
+                            archetype: "scheduled",
+                            mode: "transfer",
+                            name: decl.name.name,
+                            origin: decl.span,
+                            payee,
+                            payer,
+                            schedule,
+                        });
+                    }
+                    break;
+                }
+                if (!requireIdentPolicy(modeEntry, owner, "obligation", "omit mode for a fixed transfer schedule")) {
+                    break;
+                }
+                const requiredPolicies = [
+                    "debtor",
+                    "partial_payment",
+                    "repayment_matching",
+                    "refund_policy",
+                    "reschedule_policy",
+                    "delinquency_policy",
+                ];
+                for (const key of requiredPolicies) {
+                    if (!entries.has(key))
+                        error(decl.span, `${owner} is missing ${key}`);
+                }
+                const debtor = party("debtor", "debtor");
+                const advanceTo = entries.has("advance_to")
+                    ? party("advance_to", "advance recipient")
+                    : undefined;
+                const policiesSound = [
+                    requireIdentPolicy(entries.get("partial_payment"), owner, "anchor_bound", "payments must bind to one stored installment anchor"),
+                    requireIdentPolicy(entries.get("repayment_matching"), owner, "obligation_and_anchor", "each payment must name both the obligation and its installment anchor; fuzzy or balance-wide matching is refused"),
+                    requireIdentPolicy(entries.get("refund_policy"), owner, "full_payment_only", "a refund reverses one stored payment whole so it cannot exceed that payment"),
+                    requireIdentPolicy(entries.get("reschedule_policy"), owner, "refuse", "forward-version carryover is not mechanically proven; create a new obligation after closing this one"),
+                    requireIdentPolicy(entries.get("delinquency_policy"), owner, "due_condition", "delinquency must come from an unmet stored due anchor"),
+                ].every(Boolean);
+                const rolesSound = [
+                    distinct(debtor, payee, `${owner} names ${debtor} as both debtor and settlement recipient; they must differ`),
+                    advanceTo
+                        ? distinct(advanceTo, debtor, `${owner} advances to its debtor ${debtor}; advance_to must name a distinct recipient`)
+                        : true,
+                ].every(Boolean);
+                if (payer &&
+                    payee &&
+                    amount &&
+                    schedule &&
+                    sound &&
+                    debtor &&
+                    policiesSound &&
+                    rolesSound) {
                     settlements.push({
+                        ...(advanceTo ? { advanceTo } : {}),
                         amount,
                         archetype: "scheduled",
+                        debtor,
+                        mode: "obligation",
                         name: decl.name.name,
                         origin: decl.span,
                         payee,
@@ -893,12 +1462,19 @@ export function checkProgram(program) {
                 const closeByField = parseDateField(entries.get("close_by"), owner);
                 const rates = [];
                 const ratesEntry = entries.get("rates");
+                let withinEventCap = true;
                 if (ratesEntry) {
                     noQualifiers(ratesEntry, owner);
                     if (ratesEntry.value.kind !== "block") {
                         error(ratesEntry.value.span, `rates is a block of per-unit prices, like: rates { api_call: unitFee: money(SAR) }`);
                     }
                     else {
+                        const maxRates = ARCHETYPE_DEFINITIONS.metered.maxRates ??
+                            ARCHETYPE_DEFINITIONS.metered.eventCap;
+                        if (ratesEntry.value.entries.length > maxRates) {
+                            error(ratesEntry.value.span, `${owner} prices ${ratesEntry.value.entries.length} meters, but metered allows at most ${maxRates} so one settlement stays within its ${ARCHETYPE_DEFINITIONS.metered.eventCap}-event cap`);
+                            withinEventCap = false;
+                        }
                         for (const rate of ratesEntry.value.entries) {
                             if (!SNAKE_CASE.test(rate.key.name)) {
                                 error(rate.key.span, `meter names are snake_case; "${rate.key.name}" is not`);
@@ -932,7 +1508,12 @@ export function checkProgram(program) {
                     error(decl.span, `${owner} uses ${closeByField} as both a rate field and the close_by date field; they need distinct names`);
                     break;
                 }
-                if (payer && payee && closeByField && rates.length > 0 && sound) {
+                if (payer &&
+                    payee &&
+                    closeByField &&
+                    rates.length > 0 &&
+                    sound &&
+                    withinEventCap) {
                     settlements.push({
                         archetype: "metered",
                         closeByField,
@@ -958,6 +1539,12 @@ export function checkProgram(program) {
                     error(splitEntry.value.span, `${owner} splits to a single recipient; a pool distributes between at least two`);
                     break;
                 }
+                const maxRecipients = ARCHETYPE_DEFINITIONS.pooled_split.maxRecipients ??
+                    Math.floor(ARCHETYPE_DEFINITIONS.pooled_split.eventCap / 2);
+                const withinEventCap = !split || split.shares.length <= maxRecipients;
+                if (!withinEventCap) {
+                    error(splitEntry.value.span, `${owner} splits to ${split.shares.length} recipients, but pooled_split allows at most ${maxRecipients} so funding and payout stay within its ${ARCHETYPE_DEFINITIONS.pooled_split.eventCap}-event cap`);
+                }
                 // The lowering names each share field ${camelCase(party)}ShareAmount;
                 // camelCasing is not injective (a_2b and a2b collide), so two shares
                 // must never map onto one generated field.
@@ -982,7 +1569,7 @@ export function checkProgram(program) {
                     error(decl.span, `${owner} uses ${amount.name} as both the amount and the payout_due date field; they need distinct names`);
                     break;
                 }
-                if (payer && amount && distributeDueField && split) {
+                if (payer && amount && distributeDueField && split && withinEventCap) {
                     settlements.push({
                         amount,
                         archetype: "pooled_split",
@@ -1074,6 +1661,63 @@ export function checkProgram(program) {
     }
     const checkedPortByName = new Map(ports.map((port) => [port.name, port]));
     for (const settlement of settlements) {
+        if (settlement.archetype === "captured_payment") {
+            const correctionPort = checkedPortByName.get(settlement.correction.port);
+            if (correctionPort &&
+                (correctionPort.allowed.length !== 1 ||
+                    correctionPort.allowed[0] !== settlement.payee)) {
+                error(correctionPort.origin, `captured_payment ${settlement.name} correction port ${correctionPort.name} must allow only its payee ${settlement.payee}`);
+            }
+            const reversalPort = checkedPortByName.get(settlement.externalReversal.port);
+            if (reversalPort &&
+                !reversalPort.fields.some((field) => field.name === "externalReference" && field.type.kind === "text")) {
+                error(reversalPort.origin, `captured_payment ${settlement.name} external reversal port ${reversalPort.name} needs shape { externalReference: text }`);
+            }
+            continue;
+        }
+        if (settlement.archetype === "settlement_batch") {
+            const acknowledgementPort = checkedPortByName.get(settlement.payoutAcknowledgement.port);
+            if (acknowledgementPort &&
+                !acknowledgementPort.fields.some((field) => field.name === "acknowledgementReference" &&
+                    field.type.kind === "text")) {
+                error(acknowledgementPort.origin, `settlement_batch ${settlement.name} payout acknowledgement port ${acknowledgementPort.name} needs shape { acknowledgementReference: text }`);
+            }
+            continue;
+        }
+        if (settlement.archetype === "weighted_distribution") {
+            const port = checkedPortByName.get(settlement.snapshot.port);
+            if (port &&
+                !port.fields.some((field) => field.name === "evidenceReference" && field.type.kind === "text")) {
+                error(port.origin, `weighted_distribution ${settlement.name} snapshot port ${port.name} needs shape { evidenceReference: text }`);
+            }
+            continue;
+        }
+        if (settlement.archetype === "recurring_collection") {
+            const port = checkedPortByName.get(settlement.mandate.port);
+            if (port &&
+                !port.fields.some((field) => field.name === "evidenceReference" && field.type.kind === "text")) {
+                error(port.origin, `recurring_collection ${settlement.name} mandate port ${port.name} needs shape { evidenceReference: text }`);
+            }
+            continue;
+        }
+        if (settlement.archetype === "conditional_disbursement") {
+            const port = checkedPortByName.get(settlement.decision.port);
+            if (port &&
+                (!port.fields.some((field) => field.name === "evidenceReference" && field.type.kind === "text") ||
+                    port.allowed.length !== 1 ||
+                    port.allowed[0] !== settlement.source)) {
+                error(port.origin, `conditional_disbursement ${settlement.name} decision port ${port.name} must allow only ${settlement.source} and needs shape { evidenceReference: text }`);
+            }
+            continue;
+        }
+        if (settlement.archetype === "premium_forward" && settlement.endorsement) {
+            const port = checkedPortByName.get(settlement.endorsement.port);
+            if (port &&
+                !port.fields.some((field) => field.name === "evidenceReference" && field.type.kind === "text")) {
+                error(port.origin, `premium_forward ${settlement.name} endorsement port ${port.name} needs shape { evidenceReference: text }`);
+            }
+            continue;
+        }
         if (settlement.archetype !== "swap")
             continue;
         const parties = new Set(settlement.sides.map((side) => side.party));
@@ -1094,11 +1738,50 @@ export function checkProgram(program) {
             }
         }
     }
+    const scheduledObligations = new Map(settlements
+        .filter((settlement) => settlement.archetype === "scheduled" &&
+        settlement.mode === "obligation")
+        .map((settlement) => [settlement.name, settlement]));
+    const collectionOwnerByObligation = new Map();
+    for (const settlement of settlements) {
+        if (settlement.archetype !== "credit_facility" &&
+            settlement.archetype !== "recurring_collection") {
+            continue;
+        }
+        const target = scheduledObligations.get(settlement.obligation.settlement);
+        const owner = `settlement ${settlement.name}`;
+        if (!target) {
+            error(settlement.obligation.origin, `${owner} must compose with scheduled in mode: obligation; ${settlement.obligation.settlement} is not one`);
+            continue;
+        }
+        if (settlement.archetype === "credit_facility") {
+            if (target.advanceTo) {
+                error(settlement.obligation.origin, `${owner} references ${target.name}, which already owns an advance; facility draws and obligation repayment must have one disbursement owner`);
+            }
+            if (target.payee !== settlement.lender ||
+                target.debtor !== settlement.borrower ||
+                target.amount.currency !== settlement.limit.currency) {
+                error(settlement.obligation.origin, `${owner} must link an obligation whose payee is ${settlement.lender}, debtor is ${settlement.borrower}, and currency is ${settlement.limit.currency}`);
+            }
+            continue;
+        }
+        const mandatePort = checkedPortByName.get(settlement.mandate.port);
+        const firstCollection = collectionOwnerByObligation.get(target.name);
+        if (firstCollection) {
+            error(settlement.obligation.origin, `${owner} and settlement ${firstCollection} both collect ${target.name}; one obligation may have one collection policy owner`);
+        }
+        else {
+            collectionOwnerByObligation.set(target.name, settlement.name);
+        }
+        if (mandatePort &&
+            (mandatePort.allowed.length !== 1 ||
+                mandatePort.allowed[0] !== target.payer)) {
+            error(mandatePort.origin, `${owner} mandate port ${mandatePort.name} must allow only the obligation payer ${target.payer}`);
+        }
+    }
     // --- Carved advances: the hold each one draws against -----------------------
-    // `against: retention.release` is the only cross-declaration reference in the
-    // language, so it is the only place a settlement's terms are judged against
-    // another's. Everything here resolves at check time; nothing is left for a
-    // caller to pick.
+    // The generic reference checker above has resolved the named target and exit.
+    // This pass proves the business terms required by an advance carve.
     const heldByName = new Map(settlements
         .filter((settlement) => settlement.archetype === "held_payment")
         .map((settlement) => [settlement.name, settlement]));
@@ -1111,16 +1794,9 @@ export function checkProgram(program) {
         const owner = `settlement ${settlement.name}`;
         const target = settlement.source.settlement;
         const origin = settlement.source.origin;
-        const targetDecl = settlementDecls.find((decl) => decl.name.name === target);
-        if (!targetDecl) {
-            const other = declared.get(target);
-            error(origin, other
-                ? `${owner} draws against ${target}, which is a ${other.kind}; an advance carves a held payment's release`
-                : `${owner} draws against ${target}, but no settlement with that name is declared`);
-            continue;
-        }
-        if (targetDecl.archetype.name !== "held_payment") {
-            error(origin, `${owner} draws against ${target}, which is a ${targetDecl.archetype.name}; only a held payment has a release to carve`);
+        if (settlement.source.targetArchetype !== "held_payment" ||
+            settlement.source.exit !== "release") {
+            error(origin, `${owner} can only carve held_payment.release; ${target}.${settlement.source.exit} is a ${settlement.source.targetArchetype} exit`);
             continue;
         }
         const hold = heldByName.get(target);
@@ -1132,6 +1808,22 @@ export function checkProgram(program) {
             error(origin, `${owner} advances ${settlement.advanced}, but ${target} releases to ${hold.payee}; an advance carves the release of the party it finances`);
             continue;
         }
+        if (hold.amount.name !== settlement.amount.name) {
+            error(origin, `${owner} advances field ${settlement.amount.name}, but ${target}.release carries ${hold.amount.name}; a carve must name the same money field`);
+            continue;
+        }
+        if (hold.amount.currency !== settlement.amount.currency) {
+            error(origin, `${owner} advances ${settlement.amount.currency}, but ${target}.release carries ${hold.amount.currency}; a carve must use one currency`);
+            continue;
+        }
+        if (settlement.feeBps > 0) {
+            error(origin, `${owner} adds a fee to a carved advance, but ${target}.release can only prove repayment of the principal field; use a fee-free carve or a scheduled advance`);
+            continue;
+        }
+        if (hold.fees.some((fee) => fee.bearer === hold.payee && fee.bps > 0)) {
+            error(origin, `${owner} carves ${target}.release after a payee fee reduces it; a carved hold must release the full principal field to the funder`);
+            continue;
+        }
         if (hold.payer === settlement.funder) {
             error(origin, `${settlement.funder} funds ${target} and finances it too; the party who pays the hold cannot be the funder its release repays`);
             continue;
@@ -1147,8 +1839,11 @@ export function checkProgram(program) {
         // the author chose to declare, so an uncovered one is an error; the
         // pre-funding abandonment every hold carries is a lint.
         const recourse = settlements.some((other) => other.archetype === "scheduled" &&
+            other.mode === "transfer" &&
             other.payer === settlement.advanced &&
-            other.payee === settlement.funder);
+            other.payee === settlement.funder &&
+            other.amount.name === settlement.amount.name &&
+            other.amount.currency === settlement.amount.currency);
         if (recourse)
             continue;
         const repayment = `add a scheduled settlement collecting from the ${settlement.advanced.replaceAll("_", " ")} to the ${settlement.funder.replaceAll("_", " ")}`;
@@ -1182,6 +1877,7 @@ export function checkProgram(program) {
         diagnostics,
         program: {
             assets: [...assets.values()],
+            derivedAmounts,
             name: header.name.name,
             parties: [...parties.values()],
             ports,