@hyperscale0/hsx 1.0.0 → 1.0.123

package/std/financing.hsx

@@ -0,0 +1,683 @@
+header financing
+
+// Economics: Principal advances and repayments are excluded from earnings. Claims, waivers,
+// write-offs and allocations are internal. Paid profit and company charges are
+// earnings; receipt refunds reverse captured cash. Outside recovery recipients
+// receive payouts from held company cash, or pass-through direct customer cash.
+
+// Expose create and sign on installments, then collect_down_payment as checkout
+// for disburse_to: funds. Checkout requires a signed plan and pending escrow;
+// it tops up only the missing down payment, without advancing lender principal.
+// Disburse still collects any missing down payment, activates slices, and confirms
+// the fully funded hold. Existing escrow credit counts once toward the down payment.
+// Disburse first credits an active marketplace.reservation on the same hold,
+// so list the plan in its converters; the deposit then counts as escrow credit.
+// Borrower-directed disbursement excludes collect_down_payment. A down_payment
+// there reduces principal but does not collect cash. Price is subject metadata,
+// not the borrower limit. The escrow payer and price must match the plan.
+// Expose escrow cancel to return checkout cash if financing is abandoned; plan
+// void alone cancels the agreement and does not refund its separate escrow.
+// Approve borrower and portfolio limits before disbursement. Create builds the
+// dated slice records; payments need a separate payment record and pay action.
+// Expose parent payoff separately and create a current, unexpired payoff_quote.
+// Expose late_charge.create as propose_assessment before the clock can assess;
+// provide matching plan, slice and borrower. Fine is fixed money, not a percentage.
+// Collection uses the minimum of payment cash and outstanding fine; a partial
+// payment does not settle the remaining fine. Recovery cost needs its own record.
+// Profit share credits capital's allocatedProfitPayable, not an outside agency.
+// Credit lines need adapter binding at activation; draws are ledger advances,
+// not evidence of outside funding. Caller-authorized limit approvals and advances
+// need the Product's operation authority. No clock declaration proves retries.
+
+// Cost: installments include cash and claim moves, child-account creation and
+// bounded invocations across slices and assessments. Month and charge limits affect
+// the bound. Run hsx cost on the selected policies; profit is not a platform tariff.
+
+instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3, profit: percent, disburse_to: enum(funds, borrower) = funds, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref<escrow.hold>?, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits), portfolio: ref<financing.portfolio_limit> = object(financing.portfolio_limit)) {
+  dependencies {
+    funds {
+      selector: disburse_to, is: funds
+      message: "Attachment `{attachment}` disburses into a hold, but `funds` is not bound."
+      fix: "Bind `funds: sale` to an escrow attachment. Choose `disburse_to: borrower` only if the borrower should receive the money directly."
+    }
+  }
+  revisioned: true
+  familyRevision: 1
+  summary: "Funding, profit recognition and payment order chosen by the program."
+  fields {
+    funds: ref<funds>?, borrower: account of borrower, settlementIdentity: text, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>
+    months: integer = months, dates: list(date, months)
+    allocatedPayable: account(capital, cash, "allocatedProfitPayable"), capital: account(capital, cash, "capital"), profitIncome: account(capital, cash, "profitIncome"), loss: account(capital, claim, "loss")
+    downPaymentRemaining: money?, downPaymentCredit: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money?
+    price: money = subject.price
+    downPayment: money = rate(self.price, down_payment)
+    principal: money = subtract(self.price, self.downPayment)
+    profit: money = rate(self.principal, profit)
+    total: money = sum(self.principal, self.profit)
+  }
+  lifecycle { states: [quoted, signed, active, paid, written_off, cancelled], initial: quoted }
+  invariants count of { instrument: all(financing.installments), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [active], limit: 366 } <= self.borrowerLimit.activePlans
+  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [pending, due, paid], limit: 366 } <= self.borrowerLimit.limit
+  invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "portfolioLimit", anchor: self.portfolioLimit, states: [pending, due, paid], limit: 366 } <= self.portfolioLimit.limit
+  action create {
+    subject { price: money }
+    requires self.borrowerLimit.borrower == self.borrower
+    when disburse_to is funds { requires self.borrower == self.funds.payer; requires self.price == self.funds.price }
+    invoke: [{ range: { count: { literal: months }, maximum: months, bind: position }, instrument: slice, action: create, input: { plan: { field: self.id }, borrowerLimit: { field: self.borrowerLimit }, portfolioLimit: { field: self.portfolioLimit }, position: { field: position } } }]
+  }
+  action sign {
+    from: quoted, to: signed, actor: { party: borrower }, input { signedOffer: text, affordabilityReference: text }
+    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366 } == self.months
+  }
+  action collect_down_payment { allowZero: true,
+    from: signed, to: signed, actor: { party: borrower }
+    when disburse_to is borrower { requires true == false }
+    when disburse_to is funds {
+      requires self.funds in [pending]
+      calculate: [{ target: downPaymentCredit, op: minimum, values: [{ field: self.funds.held.balance }, { field: self.downPayment }] }, { target: downPaymentRemaining, op: subtract, base: { field: self.downPayment }, subtract: [{ field: self.downPaymentCredit }] }]
+      moves self.downPaymentRemaining from self.borrower to self.funds.held economics { purpose: principal, sourceParty: borrower }
+    }
+  }
+  action disburse { allowZero: true,
+    from: signed, to: active, actor: { party: capital }
+    requires self.borrowerLimit in [approved]
+    requires self.portfolioLimit in [approved]
+    when disburse_to is funds {
+      requires self.funds in [pending]
+      invoke: [{ selection: { instrument: all(marketplace.reservation), reference: "funds", anchor: self.funds, states: [active], limit: 1 }, action: credit, input: { funds: { field: self.funds }, contribution: { field: self.downPayment } } }, { reference: self.id, action: fund_down_payment, input: {} }]
+    }
+    when disburse_to is borrower { moves self.principal from self.capital to self.borrower economics { purpose: principal, sourceParty: capital } }
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366, order: [position] }, action: activate, input: {} }]
+    when disburse_to is funds { invoke: [{ reference: self.funds, action: confirm, input: {} }] }
+  }
+  action fund_down_payment { allowZero: true,
+    from: active, to: active, actor: { parent: current() }
+    when disburse_to is funds {
+      calculate: [{ target: downPaymentCredit, op: minimum, values: [{ field: self.funds.held.balance }, { field: self.downPayment }] }, { target: downPaymentRemaining, op: subtract, base: { field: self.downPayment }, subtract: [{ field: self.downPaymentCredit }] }]
+      moves self.downPaymentRemaining from self.funds.payer to self.funds.held economics { purpose: principal, sourceParty: borrower }
+      moves self.principal from self.capital to self.funds.held economics { purpose: principal, sourceParty: capital }
+    }
+  }
+  action complete {
+    from: active, to: paid
+    requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 } == 0
+    requires sum "receivable.balance" of { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 } == "0"
+    requires sum "receivable.balance" of { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366 } == "0"
+  }
+  action restore { from: [active, paid], to: active, actor: { parent: payment } }
+  action payoff {
+    from: active, to: paid, actor: { party: borrower }
+    input { quote: ref<payoff_quote> }
+    requires input.quote.plan == self.id; requires input.quote.revision == self.productRevision
+    deadline: { at: input.quote.expiresAt }
+    calculate: [
+      { target: "principalReturned", op: "aggregate", selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
+    ]
+    invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: payoff, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.id, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: payoff, input: {} }]
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: payoff, input: { identity: { field: self.settlementIdentity } } }, { reference: self.id, action: record_payoff, input: {} }]
+  }
+  action record_payoff {
+    from: paid, to: paid, actor: { parent: current() }
+    calculate: [{ target: profitReturned, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.id, states: [paid], limit: 366, where: { payoffIdentity: { field: self.settlementIdentity } } }, measure: { sum: "payoffProfit" } }]
+    invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
+  }
+  action write_off {
+    from: active, to: written_off, actor: { parent: write_off_request }
+    input { overdueSlice: ref<slice> }
+    calculate: [{ target: "lossRecorded", op: "aggregate", selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }]
+    due: { at: input.overdueSlice.lossEligibleAt }
+    requires input.overdueSlice.plan == self.id; requires input.overdueSlice.principalReceivable.balance > "0"
+    invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: write_off, input: {} }, { instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { literal: "0" }, profit: { literal: "0" }, loss: { field: self.lossRecorded }, kind: { literal: "loss" } } }]
+  }
+  action record_payment {
+    from: active, to: active, actor: { parent: payment }
+    input { identity: text, principal: money, profit: money }
+    invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: input.identity }, principal: { field: input.principal }, profit: { field: input.profit }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
+  }
+  action cancel { from: quoted, to: cancelled }
+  action void { from: signed, to: cancelled, actor: { party: borrower } }
+  records {
+    write_off_request: {
+      fields { plan: ref<parent>, overdueSlice: ref<slice> }
+      lifecycle { states: [requested, applied, cancelled], initial: requested }
+      action create { requires self.overdueSlice.plan == self.plan; requires self.plan in [active] }
+      action apply {
+        from: requested, to: applied, actor: { party: capital }
+        invoke: [{ reference: self.plan, action: write_off, input: { overdueSlice: { field: self.overdueSlice } } }]
+      }
+      action cancel { from: requested, to: cancelled }
+    }
+    payoff_quote: {
+      fields {
+        plan: ref<parent>, revision: text?, effectiveAt: date?, expiresAt: date = after(self.createdAt, payoff_quote_expiry)
+        principal: money?, earnedProfit: money?, unearnedProfit: money?, rebate: money?, fines: money?, costs: money?, gross: money?, amount: money?
+      }
+      lifecycle { states: [quoted], initial: quoted }
+      action create {
+        requires self.plan in [active]
+        set: { revision: { field: self.productRevision }, effectiveAt: { field: self.now } }
+        invoke: [
+          { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending], limit: 366 }, action: quote_pending, input: { quote: { field: self.id } } }
+          { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [due], limit: 366 }, action: quote_due, input: { quote: { field: self.id } } }
+          { reference: self.id, action: record, input: {} }
+        ]
+      }
+      action record {
+        from: quoted, to: quoted, actor: { parent: current() }
+        calculate: [
+          { target: principal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
+          { target: earnedProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitEarned.balance" } }
+          { target: unearnedProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitReceivable.balance" } }
+          { target: rebate, op: aggregate, selection: { instrument: quote_piece, reference: "quote", anchor: self.id, states: [recorded], limit: 366 }, measure: { sum: "rebate" } }
+          { target: fines, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+          { target: costs, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+          { target: gross, op: sum, values: [{ field: self.principal }, { field: self.earnedProfit }, { field: self.unearnedProfit }, { field: self.fines }, { field: self.costs }] }
+          { target: amount, op: subtract, base: { field: self.gross }, subtract: [{ field: self.rebate }] }
+        ]
+      }
+    }
+    quote_piece: {
+      fields { quote: ref<payoff_quote>, slice: ref<slice>, rebate: money = rate(self.slice.profitReceivable.balance, payoff_rebate) }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { actor: { parent: slice }, input { quote: ref<payoff_quote>, slice: ref<slice> }, requires unique "payoff_slice_quote" on [self.quote, self.slice] }
+    }
+    amendment: {
+      fields {
+        plan: ref<parent>, dates: list(date, months), agreement: text, waiverPercent: percent, waiverEvidence: text, maximumWaiver: percent = waiver_limit
+        revision: text?, acceptedAt: date?, staleReason: text?, expiresAt: date = after(self.createdAt, amendment_expiry)
+        fineDisposition: enum(carry, require_waiver) = assessed_fines, addedProfit: money = 0 SAR
+        principalSnapshot: money?, earnedProfitSnapshot: money?, unearnedProfitSnapshot: money?, finesSnapshot: money?, costsSnapshot: money?
+        extension: duration = max_extension, maximum: integer = max_amendments
+      }
+      lifecycle { states: [proposed, applied, declined, withdrawn, expired, superseded], initial: proposed }
+      action create {
+        actor: { party: capital }
+        requires self.plan in [active]; requires self.waiverPercent <= self.maximumWaiver
+        set: { revision: { field: self.productRevision } }
+        calculate: [
+          { target: principalSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "principalReceivable.balance" } }
+          { target: earnedProfitSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitEarned.balance" } }
+          { target: unearnedProfitSnapshot, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, measure: { sum: "profitReceivable.balance" } }
+          { target: finesSnapshot, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+          { target: costsSnapshot, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, measure: { sum: "receivable.balance" } }
+        ]
+        requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [applied], limit: 366 } < self.maximum
+        invoke: [{ range: { count: { literal: months }, maximum: months, bind: position }, instrument: proposed_date, action: create, input: { amendment: { field: self.id }, position: { field: position } } }, { selection: { instrument: proposed_date, reference: "amendment", anchor: self.id, states: [recorded], limit: 366, where: { first: { literal: 0 } } }, action: check_order, input: {} }]
+      }
+      action accept {
+        from: proposed, to: applied, actor: { party: borrower }, deadline: { at: self.expiresAt }
+        requires self.plan in [active]; requires self.revision == self.productRevision
+        requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [applied], limit: 366 } < self.maximum
+        set: { acceptedAt: { field: self.now } }
+        when assessed_fines is require_waiver { requires self.waiverPercent == 10000 }
+        invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366 }, action: waive_for_amendment, input: { amendment: { field: self.id } } }]
+        invoke: [{ selection: { instrument: all(collections.case), reference: "plan", anchor: self.plan, states: [opened, assigned], limit: 366 }, action: recall, input: {} }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [proposed], limit: 366 }, action: cancel, input: {} }, { selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [proposed], limit: 366 }, action: cancel, input: {} }]
+        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: amend, input: { amendment: { field: self.id } } }]
+        invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [paid], limit: 366 }, action: verify_fixed_date, input: { amendment: { field: self.id } } }]
+      }
+      action withdraw { from: proposed, to: withdrawn, actor: { party: capital } }
+      action decline { from: proposed, to: declined, actor: { party: borrower } }
+      action expire { from: proposed, to: expired, actor: clock, due: { at: self.expiresAt } }
+      action supersede { from: proposed, to: superseded, requires self.revision != self.productRevision, set: { staleReason: { literal: "economic_revision_changed" } } }
+    }
+    proposed_date: {
+      fields { amendment: ref<amendment>, position: integer(1, months), date: date = at(self.amendment.dates, self.position), first: integer = divide(1, self.position), prior: integer = subtract(self.position, 1), previousPosition: integer = sum(self.prior, self.first), previous: date = at(self.amendment.dates, self.previousPosition) }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { actor: { parent: amendment }, input { amendment: ref<amendment>, position: integer(1, months) }, requires self.date >= self.previous }
+      action check_order { from: recorded, to: recorded, actor: { parent: amendment }, requires self.date > self.previous }
+    }
+    date_change: {
+      fields { amendment: ref<amendment>, slice: ref<slice>, oldDate: date, newDate: date }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { actor: { parent: slice }, input { amendment: ref<amendment>, slice: ref<slice>, oldDate: date, newDate: date }, requires unique "amended_slice" on [self.amendment, self.slice] }
+    }
+    settlement: {
+      fields { plan: ref<parent>, identity: text, principal: money, profit: money, loss: money, kind: enum(cash, loss), share: money?, retainedProfit: money?
+        allocatedPayable: account(capital, cash, "allocatedProfitPayable"), capital: account(capital, cash, "capital"), profitIncome: account(capital, cash, "profitIncome"), lossAccount: account(capital, claim, "loss") }
+      lifecycle { states: [recorded, refunded], initial: recorded }
+      action create { allowZero: true,
+        actor: { parent: parent }
+        input { plan: ref<parent>, identity: text, principal: money, profit: money, loss: money, kind: enum(cash, loss) }
+        requires unique "settlement_identity" on [self.plan, self.identity]
+        calculate: [{ target: "share", op: "rate", base: { field: self.profit }, bps: { literal: share }, rounding: "floor" }, { target: retainedProfit, op: "subtract", base: { field: self.profit }, subtract: [{ field: self.share }] }]
+        moves self.share from self.profitIncome to self.allocatedPayable economics { purpose: internal, sourceParty: capital }
+      }
+      action refund { allowZero: true,
+        from: recorded, to: refunded, actor: { parent: payment }
+        moves self.share from self.allocatedPayable to self.profitIncome economics { purpose: internal, sourceParty: capital }
+      }
+    }
+    slice: {
+      revisioned: true
+      fields {
+        plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months)
+        originalDueAt: date = at(self.plan.dates, self.position), dueAt: date?, nextDueAt: date?, previousDueAt: date?, previousPosition: integer?, previousDate: date?, extensionLimit: date = after(self.originalDueAt, max_extension), lossEligibleAt: date?
+        principalBase: money = divide(self.plan.principal, months)
+        principalAllocated: money = multiply(self.principalBase, months)
+        principalRemainder: money = subtract(self.plan.principal, self.principalAllocated)
+        profitBase: money = divide(self.plan.profit, months)
+        profitAllocated: money = multiply(self.profitBase, months)
+        profitRemainder: money = subtract(self.plan.profit, self.profitAllocated)
+        first: integer = divide(1, self.position)
+        principalAdjustment: money = multiply(self.principalRemainder, self.first)
+        profitAdjustment: money = multiply(self.profitRemainder, self.first)
+        principal: money = sum(self.principalBase, self.principalAdjustment)
+        profit: money = sum(self.profitBase, self.profitAdjustment)
+        principalReceivable: account(self, claim), profitReceivable: account(self, claim), profitEarned: account(self, claim)
+        payoffIdentity: text?, payoffRebate: money?, payoffProfitTotal: money?, payoffProfit: money?
+        paymentBudget: money?, principalPayment: money?, principalBasePayment: money?, principalRatio: money?, profitPayment: money?, profitBudget: money?, collectibleProfit: money?, collectibleTotal: money?, ratioDenominator: integer = sum(10000, profit)
+        debt: account(borrower, claim, contra, "debt"), loss: account(capital, claim, "loss")
+      }
+      lifecycle { states: [draft, pending, due, paid, written_off], initial: draft }
+      action create {
+        actor: { parent: parent }
+        input { plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months) }
+        set: { dueAt: { field: self.originalDueAt } }
+        invoke: [{ reference: self.id, action: refresh_loss_date, input: {} }]
+        requires self.plan in [quoted]; requires unique "signed_position" on [self.plan, self.position]; requires self.borrowerLimit == self.plan.borrowerLimit; requires self.portfolioLimit == self.plan.portfolioLimit
+      }
+      action quote_pending {
+        from: pending, to: pending, actor: { parent: payoff_quote }, input { quote: ref<payoff_quote> }
+        requires input.quote.plan == self.plan
+        invoke: [{ instrument: quote_piece, action: create, input: { quote: { field: input.quote }, slice: { field: self.id } } }]
+      }
+      action quote_due {
+        from: due, to: due, actor: { parent: payoff_quote }, input { quote: ref<payoff_quote> }
+        requires input.quote.plan == self.plan
+        invoke: [{ instrument: quote_piece, action: create, input: { quote: { field: input.quote }, slice: { field: self.id } } }]
+      }
+      action refresh_loss_date {
+        from: [draft, pending, due], to: draft, actor: { parent: current() }
+        calculate: [{ target: lossEligibleAt, op: shift, date: { field: self.dueAt }, milliseconds: { literal: write_off_after }, direction: after }]
+      }
+      action amend {
+        from: [pending, due], to: pending, actor: { parent: amendment }, input { amendment: ref<amendment> }
+        requires input.amendment.plan == self.plan
+        when allow_overdue is blocked { requires self.dueAt > self.now }
+        calculate: [
+          { target: nextDueAt, op: at, list: input.amendment.dates, position: { field: self.position } }
+          { target: lossEligibleAt, op: shift, date: { field: self.nextDueAt }, milliseconds: { literal: write_off_after }, direction: after }
+        ]
+        requires self.nextDueAt > self.now; requires self.nextDueAt >= self.dueAt; requires self.nextDueAt <= self.extensionLimit
+        set: { previousDueAt: { field: self.dueAt }, dueAt: { field: self.nextDueAt } }
+        invoke: [{ instrument: date_change, action: create, input: { amendment: { field: input.amendment }, slice: { field: self.id }, oldDate: { field: self.previousDueAt }, newDate: { field: self.nextDueAt } } }]
+        when profit_earned is by_schedule { invoke: [{ selection: { instrument: recognition, reference: "slice", anchor: self.id, states: [pending], limit: 1 }, action: reschedule, input: {} }] }
+      }
+      action verify_fixed_date {
+        from: paid, to: paid, actor: { parent: amendment }, input { amendment: ref<amendment> }
+        calculate: [{ target: nextDueAt, op: at, list: input.amendment.dates, position: { field: self.position } }]
+        requires self.nextDueAt == self.dueAt
+      }
+      action activate { allowZero: true,
+        from: draft, to: pending, actor: { parent: parent }
+        moves self.principal from self.debt to self.principalReceivable economics { purpose: internal, sourceParty: borrower }
+        moves self.profit from self.debt to self.profitReceivable economics { purpose: internal, sourceParty: borrower }
+        when profit_earned is at_disbursement { moves self.profit from self.profitReceivable to self.profitEarned economics { purpose: internal, sourceParty: programOperator } }
+        when profit_earned is by_schedule { invoke: [{ instrument: recognition, action: create, input: { slice: { field: self.id } } }] }
+      }
+      action mature {
+        from: pending, to: due, actor: clock, due: { at: self.dueAt }
+      }
+      action collect {
+        from: [pending, due], to: preserve, actor: { parent: payment }
+        input { payment: ref<payment> }
+        requires input.payment.plan == self.plan
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        when apply is principal_profit {
+          invoke: [
+            { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalReceivable.balance } } }
+            { instrument: profit_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.collectibleProfit } } }
+            { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
+          ]
+        }
+      }
+      action collect_waterfall {
+        from: [pending, due], to: preserve, actor: { parent: payment }, input { payment: ref<payment> }
+        requires input.payment.plan == self.plan
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        invoke: [
+          { selection: { instrument: all(financing.late_charge), reference: "slice", anchor: self.id, states: [assessed], limit: charge_limit, order: [overdueAt] }, action: collect, input: { payment: { field: input.payment } } }
+          { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed], limit: charge_limit, order: [overdueAt], where: { assessment.slice: { field: self.id } } }, action: collect, input: { payment: { field: input.payment } } }
+          { instrument: profit_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.collectibleProfit } } }
+          { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalReceivable.balance } } }
+          { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
+        ]
+      }
+      action collect_pro_rata {
+        from: [pending, due], to: preserve, actor: { parent: payment }, input { payment: ref<payment> }
+        requires input.payment.plan == self.plan
+        when profit_earned is on_payment { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitReceivable.balance }] }] }
+        when profit_earned is by_schedule { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        when profit_earned is at_disbursement { calculate: [{ target: collectibleProfit, op: sum, values: [{ field: self.profitEarned.balance }] }] }
+        calculate: [
+          { target: collectibleTotal, op: sum, values: [{ field: self.principalReceivable.balance }, { field: self.collectibleProfit }] }
+          { target: paymentBudget, op: minimum, values: [{ field: input.payment.held.balance }, { field: self.collectibleTotal }] }
+          { target: principalRatio, op: ratio, amount: { field: self.paymentBudget }, numerator: { literal: 10000 }, denominator: { field: self.ratioDenominator }, rounding: floor }
+          { target: principalBasePayment, op: minimum, values: [{ field: self.principalRatio }, { field: self.principalReceivable.balance }] }
+          { target: profitBudget, op: subtract, base: { field: self.paymentBudget }, subtract: [{ field: self.principalBasePayment }] }
+          { target: profitPayment, op: minimum, values: [{ field: self.profitBudget }, { field: self.collectibleProfit }] }
+          { target: principalPayment, op: subtract, base: { field: self.paymentBudget }, subtract: [{ field: self.profitPayment }] }
+        ]
+        invoke: [
+          { instrument: principal_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.principalPayment } } }
+          { instrument: profit_piece, action: create, input: { slice: { field: self.id }, payment: { field: input.payment }, limit: { field: self.profitPayment } } }
+          { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [pending, due], limit: 1, where: { id: { field: self.id }, principalReceivable.balance: { literal: "0" }, profitReceivable.balance: { literal: "0" }, profitEarned.balance: { literal: "0" } } }, action: complete, input: {} }
+        ]
+      }
+      action complete {
+        from: [pending, due], to: paid
+        requires self.principalReceivable.balance == "0"; requires self.profitReceivable.balance == "0"; requires self.profitEarned.balance == "0"
+      }
+      action restore { from: [pending, due, paid], to: pending, actor: { parent: payment } }
+      action payoff { allowZero: true,
+        from: [pending, due], to: paid, actor: { parent: parent }, input { identity: text }
+        set: { payoffIdentity: { field: input.identity } }
+        calculate: [{ target: payoffRebate, op: rate, base: { field: self.profitReceivable.balance }, bps: { literal: payoff_rebate }, rounding: floor }, { target: payoffProfitTotal, op: sum, values: [{ field: self.profitReceivable.balance }, { field: self.profitEarned.balance }] }, { target: payoffProfit, op: subtract, base: { field: self.payoffProfitTotal }, subtract: [{ field: self.payoffRebate }] }]
+        moves self.principalReceivable.balance from self.plan.borrower to self.plan.capital economics { purpose: principal, sourceParty: borrower }
+        moves self.payoffProfit from self.plan.borrower to self.plan.profitIncome economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
+        moves self.principalReceivable.balance from self.principalReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+        moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+        moves self.profitEarned.balance from self.profitEarned to self.debt economics { purpose: internal, sourceParty: programOperator }
+      }
+      action write_off { allowZero: true,
+        from: [pending, due], to: written_off, actor: { parent: parent }
+        moves self.principalReceivable.balance from self.principalReceivable to self.loss economics { purpose: internal, sourceParty: programOperator }; moves self.profitReceivable.balance from self.profitReceivable to self.debt economics { purpose: internal, sourceParty: programOperator }; moves self.profitEarned.balance from self.profitEarned to self.loss economics { purpose: internal, sourceParty: programOperator }
+      }
+    }
+    recognition: {
+      fields { slice: ref<slice>, dueAt: date = after(self.slice.dueAt, 0) }
+      lifecycle { states: [pending, recognised], initial: pending }
+      action create { actor: { parent: slice }, input { slice: ref<slice> }, requires unique "profit_recognition" on [self.slice] }
+      action reschedule { from: pending, to: pending, actor: { parent: slice }, calculate: [{ target: dueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: 0 }, direction: after }] }
+      action mature { allowZero: true, from: pending, to: recognised, actor: clock, due: { at: self.dueAt }, moves self.slice.profitReceivable.balance from self.slice.profitReceivable to self.slice.profitEarned economics { purpose: internal, sourceParty: programOperator } }
+    }
+    payment: {
+      revisioned: true
+      fields { plan: ref<parent>, amount: money, paymentIdentity: text, held: account of self
+        outstandingPrincipal: money?, outstandingProfit: money?, outstandingFines: money?, outstandingCosts: money?, outstandingTotal: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money? }
+
+      lifecycle { states: [pending, paid, refunded], initial: pending }
+      action create { input { plan: ref<parent>, amount: money, paymentIdentity: text } requires self.plan in [active]; requires unique "payment_identity" on [self.plan, self.paymentIdentity] }
+      action pay {
+        expansionLimit: 8192
+        from: pending, to: paid, actor: { party: borrower }
+        calculate: [{ target: outstandingPrincipal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "principalReceivable.balance" } }]
+        when profit_earned is on_payment { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitReceivable.balance" } }] }
+        when profit_earned is by_schedule { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitEarned.balance" } }] }
+        when profit_earned is at_disbursement { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitEarned.balance" } }] }
+        when apply is fines_profit_principal {
+          calculate: [{ target: outstandingFines, op: aggregate, selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, measure: { sum: "receivable.balance" } }, { target: outstandingCosts, op: aggregate, selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, measure: { sum: "receivable.balance" } }, { target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }, { field: self.outstandingFines }, { field: self.outstandingCosts }] }]
+        }
+        when apply is principal_profit { calculate: [{ target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }] }] }
+        when apply is pro_rata { calculate: [{ target: outstandingTotal, op: sum, values: [{ field: self.outstandingPrincipal }, { field: self.outstandingProfit }] }] }
+        requires self.plan in [active]; requires self.amount <= self.outstandingTotal
+        moves self.amount from self.plan.borrower to self.held economics { purpose: principal, sourceParty: borrower }
+        when apply is principal_profit {
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+        }
+        when apply is fines_profit_principal {
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect_waterfall, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+        }
+        when apply is pro_rata {
+          invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: collect_pro_rata, guard: { kind: compare, left: { field: self.held.balance }, operator: ">", right: { literal: "0" } }, input: { payment: { field: self.id } } }]
+        }
+        invoke: [{ reference: self.id, action: record, input: {} }]
+      }
+      action record {
+        from: paid, to: paid, actor: { parent: current() }
+        requires self.held.balance == "0"
+        calculate: [{ target: principalReturned, op: aggregate, selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, measure: { sum: "amount" } }, { target: profitReturned, op: aggregate, selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, measure: { sum: "amount" } }]
+        invoke: [{ reference: self.plan, action: record_payment, input: { identity: { field: self.paymentIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned } } }]
+      }
+      action refund {
+        from: paid, to: refunded, actor: { party: capital }
+        requires unique "settlement_consumption" on [self.plan, self.paymentIdentity]; requires self.plan in [active, paid]
+        requires count of { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } } == 1
+        invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } }, action: refund, input: {} }]
+        when apply is fines_profit_principal {
+          invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }]
+        }
+        invoke: [{ reference: self.plan, action: restore, input: {} }, { selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366 }, action: restore, input: {} }, { selection: { instrument: principal_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }, { selection: { instrument: profit_piece, reference: "payment", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
+      }
+    }
+    principal_piece: {
+      fields { slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
+      lifecycle { states: [paid, refunded], initial: paid }
+      action create { allowZero: true,
+        calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.slice.principalReceivable.balance }, { field: self.limit }] }]
+        actor: { parent: slice }
+        input { slice: ref<slice>, payment: ref<payment>, limit: money }
+        requires unique "principal_receipt" on [self.slice, self.payment]
+        moves self.amount from self.payment.held to self.slice.plan.capital economics { purpose: principal, sourceParty: programOperator }; moves self.amount from self.slice.principalReceivable to self.slice.debt economics { purpose: internal, sourceParty: programOperator }
+      }
+      action refund { allowZero: true,
+        from: paid, to: refunded, actor: { parent: payment }
+        moves self.amount from self.slice.plan.capital to self.slice.plan.borrower economics { purpose: principal, sourceParty: capital }; moves self.amount from self.slice.debt to self.slice.principalReceivable economics { purpose: internal, sourceParty: borrower }
+      }
+    }
+    profit_piece: {
+      fields { cashReceipt: text?, slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
+      lifecycle { states: [paid, refunded], initial: paid }
+      action create { allowZero: true,
+        calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.limit }] }]
+        actor: { parent: slice }
+        input { slice: ref<slice>, payment: ref<payment>, limit: money }
+        requires unique "profit_receipt" on [self.slice, self.payment]
+        moves self.amount from self.payment.held to self.slice.plan.profitIncome capture "cashReceipt" economics { recipient: capital, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: participant_payout, sourceParty: programOperator } }
+        when profit_earned is on_payment { moves self.amount from self.slice.profitReceivable to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
+        when profit_earned is by_schedule { moves self.amount from self.slice.profitEarned to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
+        when profit_earned is at_disbursement { moves self.amount from self.slice.profitEarned to self.slice.debt economics { purpose: internal, sourceParty: programOperator } }
+      }
+      action refund { allowZero: true,
+        from: paid, to: refunded, actor: { parent: payment }
+        moves self.amount from self.slice.plan.profitIncome to self.slice.plan.borrower economics { recipient: capital, company: { purpose: earning, sourceParty: capital, reversalOf: self.cashReceipt }, participant: unclassified }
+        when profit_earned is on_payment { moves self.amount from self.slice.debt to self.slice.profitReceivable economics { purpose: internal, sourceParty: borrower } }
+        when profit_earned is by_schedule { moves self.amount from self.slice.debt to self.slice.profitEarned economics { purpose: internal, sourceParty: borrower } }
+        when profit_earned is at_disbursement { moves self.amount from self.slice.debt to self.slice.profitEarned economics { purpose: internal, sourceParty: borrower } }
+      }
+    }
+  }
+}
+
+instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d, fine: money = 50 SAR, cap: money = 25 SAR, fines_to: party = programOperator, costs_to: party = programOperator, borrower: party = party(person)) {
+  parameterDiagnostics {
+    fine {
+      accepts: "a fixed amount"
+      percentage: "a percentage of overdue debt"
+      fix: "Use a fixed amount only if that is the intended policy. A percentage charge needs an authored rate calculation; do not approximate it with a cash amount."
+    }
+  }
+  revisioned: true
+  familyRevision: 1
+  summary: "Separate fine and evidenced recovery claims on an overdue installment."
+  fields {
+    plan: ref<on>, slice: ref<on.slice>, borrower: account of borrower, fine: money = fine, overdueAt: date?
+    receivable: account(self, claim), debt: account(borrower, claim, contra, "debt")
+  }
+  lifecycle { states: [proposed, assessed, collected, waived], initial: proposed }
+  action create { input { slice: ref<on.slice>? }, calculate: [{ target: overdueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: grace }, direction: after }], requires unique "late_assessment" on [self.slice, self.overdueAt]; requires self.borrower == self.slice.plan.borrower; requires self.plan == self.slice.plan }
+  action assess { allowZero: true,
+    from: proposed, to: assessed, actor: clock, due: { at: self.overdueAt }
+    requires self.slice.principalReceivable.balance > "0"
+    moves self.fine from self.debt to self.receivable economics { purpose: internal, sourceParty: borrower }
+  }
+  action collect {
+    from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
+    requires input.payment in [paid]
+    requires input.payment.plan == self.plan
+    invoke: [{ instrument: receipt, action: create, input: { assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+  }
+  action payoff { allowZero: true,
+    from: [assessed, collected], to: collected, actor: { parent: on }
+    requires self.plan in [paid]
+    moves self.receivable.balance from self.plan.borrower to fines_to economics { recipient: fines_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
+    moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+  }
+  action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.receivable.balance == "0" }
+  action cancel { from: proposed, to: waived }
+  action waive_for_amendment {
+    from: [assessed, collected], to: assessed, actor: { parent: child(on, amendment) }, input { amendment: ref<on.amendment> }
+    requires input.amendment.plan == self.plan; requires input.amendment in [applied]
+    invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
+  }
+  action waive { allowZero: true, from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
+  action refund {
+    from: [assessed, collected], to: assessed, actor: { party: fines_to }, input { payment: ref<on.payment> }
+    requires input.payment in [paid, refunded]
+    requires input.payment.plan == self.plan
+    invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+  }
+  records {
+    waiver_request: {
+      fields { assessment: ref<parent>, reason: text, evidence: text }
+      lifecycle { states: [requested, applied, cancelled], initial: requested }
+      action create { requires self.assessment in [assessed, collected] }
+      action apply {
+        from: requested, to: applied, actor: { party: fines_to }, input { reason: text, evidence: text }
+        invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
+      }
+      action cancel { from: requested, to: cancelled }
+    }
+    waiver: {
+      fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { allowZero: true,
+        actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment> }
+        calculate: [{ target: amount, op: rate, base: { field: self.assessment.receivable.balance }, bps: { field: self.amendment.waiverPercent }, rounding: floor }]
+        requires unique "amendment_waiver" on [self.assessment, self.amendment]
+        moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator }
+      }
+    }
+    receipt: {
+      fields { cashReceipt: text?, assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
+      lifecycle { states: [paid, refunded], initial: paid }
+      action create { allowZero: true, calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.assessment.receivable.balance }] }], actor: { parent: parent }, input { assessment: ref<parent>, payment: ref<on.payment> }, requires input.payment.plan == self.assessment.plan; requires unique "fine_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to fines_to capture "cashReceipt" economics { recipient: fines_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: participant_payout, sourceParty: programOperator } }; moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator } }
+      action refund { allowZero: true, from: paid, to: refunded, actor: { parent: parent }, moves self.amount from fines_to to self.payment.plan.borrower economics { recipient: fines_to, company: { purpose: earning, sourceParty: fines_to, reversalOf: self.cashReceipt }, participant: unclassified }; moves self.amount from self.assessment.debt to self.assessment.receivable economics { purpose: internal, sourceParty: borrower } }
+    }
+
+    cost: {
+      revisioned: true
+      fields {
+        plan: ref<on>, assessment: ref<parent>, overdueAt: date?, evidence: text, evidencedCost: money, amount: money = minimum(self.evidencedCost, cap)
+        receivable: account(self, claim), debt: account(borrower, claim, contra, "debt")
+      }
+      lifecycle { states: [proposed, assessed, collected, waived], initial: proposed }
+      action create { calculate: [{ target: overdueAt, op: shift, date: { field: self.assessment.overdueAt }, milliseconds: { literal: 0 }, direction: after }], requires unique "recovery_assessment" on [self.assessment]; requires self.plan == self.assessment.plan }
+      action assess { allowZero: true,
+        from: proposed, to: assessed, actor: clock, due: { at: self.assessment.overdueAt }
+        requires self.assessment.slice.principalReceivable.balance > "0"
+        moves self.amount from self.debt to self.receivable economics { purpose: internal, sourceParty: borrower }
+      }
+      action collect {
+        from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
+        requires input.payment in [paid]
+        requires input.payment.plan == self.plan
+        invoke: [{ instrument: receipt, action: create, input: { assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+      }
+      action payoff { allowZero: true,
+        from: [assessed, collected], to: collected, actor: { parent: on }
+        requires self.plan in [paid]
+        moves self.receivable.balance from self.plan.borrower to costs_to economics { recipient: costs_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: pass_through, sourceParty: borrower } }
+        moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator }
+      }
+      action finish { from: assessed, to: collected, actor: { parent: current() }, requires self.receivable.balance == "0" }
+      action cancel { from: proposed, to: waived }
+      action waive_for_amendment {
+        from: [assessed, collected], to: assessed, actor: { parent: child(on, amendment) }, input { amendment: ref<on.amendment> }
+        requires input.amendment.plan == self.plan; requires input.amendment in [applied]
+        invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
+      }
+      action waive { allowZero: true, from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt economics { purpose: internal, sourceParty: programOperator } }
+      action refund {
+        from: [assessed, collected], to: assessed, actor: { party: costs_to }, input { payment: ref<on.payment> }
+        requires input.payment in [paid, refunded]
+        requires input.payment.plan == self.plan
+        invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
+      }
+      records {
+        waiver_request: {
+          fields { assessment: ref<parent>, reason: text, evidence: text }
+          lifecycle { states: [requested, applied, cancelled], initial: requested }
+          action create { requires self.assessment in [assessed, collected] }
+          action apply {
+            from: requested, to: applied, actor: { party: costs_to }, input { reason: text, evidence: text }
+            invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
+          }
+          action cancel { from: requested, to: cancelled }
+        }
+        waiver: {
+          fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
+          lifecycle { states: [recorded], initial: recorded }
+          action create { allowZero: true,
+            actor: { parent: parent }, input { assessment: ref<parent>, amendment: ref<on.amendment> }
+            calculate: [{ target: amount, op: rate, base: { field: self.assessment.receivable.balance }, bps: { field: self.amendment.waiverPercent }, rounding: floor }]
+            requires unique "amendment_waiver" on [self.assessment, self.amendment]
+            moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator }
+          }
+        }
+        receipt: {
+          fields { cashReceipt: text?, assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
+          lifecycle { states: [paid, refunded], initial: paid }
+          action create { allowZero: true, calculate: [{ target: amount, op: minimum, values: [{ field: self.payment.held.balance }, { field: self.assessment.receivable.balance }] }], actor: { parent: parent }, input { assessment: ref<parent>, payment: ref<on.payment> }, requires input.payment.plan == self.assessment.plan; requires unique "cost_receipt" on [self.assessment, self.payment]; moves self.amount from self.payment.held to costs_to capture "cashReceipt" economics { recipient: costs_to, company: { purpose: earning, sourceParty: borrower }, participant: { purpose: participant_payout, sourceParty: programOperator } }; moves self.amount from self.assessment.receivable to self.assessment.debt economics { purpose: internal, sourceParty: programOperator } }
+          action refund { allowZero: true, from: paid, to: refunded, actor: { parent: parent }, moves self.amount from costs_to to self.payment.plan.borrower economics { recipient: costs_to, company: { purpose: earning, sourceParty: costs_to, reversalOf: self.cashReceipt }, participant: unclassified }; moves self.amount from self.assessment.debt to self.assessment.receivable economics { purpose: internal, sourceParty: borrower } }
+        }
+      }
+    }
+  }
+}
+
+instrument limits(per_borrower: money, borrower: party = party(person), active_plans: integer = 1) {
+  familyRevision: 1
+  scope: product
+  summary: "One outstanding balance ceiling per borrower."
+  fields { borrower: account of borrower, limit: money = per_borrower, activePlans: integer = active_plans }
+  lifecycle { states: [pending, approved], initial: pending }
+  action create { requires unique "borrower_limit" on [self.borrower] }
+  action approve { from: pending, to: approved }
+}
+
+instrument portfolio_limit(limit: money) {
+  familyRevision: 1
+  scope: product
+  summary: "One shared ceiling on the principal the product may hold."
+  fields { key: text = "portfolio", limit: money = limit }
+  lifecycle { states: [pending, approved], initial: pending }
+  action create { requires unique "portfolio_limit" on [self.key] }
+  action approve { from: pending, to: approved }
+}
+
+instrument credit_line(borrower: party = programOperator, adapter: text, limit: money, expires: date) {
+  familyRevision: 1
+  summary: "A revolving facility from an outside lender; each draw is a separate immutable advance."
+  fields { borrower: account of borrower, facility: account(borrower, cash, "facility"), debt: account(borrower, claim, contra, "debt"), limit: money = limit, expiresAt: date = expires }
+  lifecycle { states: [pending, active, suspended, closed], initial: pending }
+  action create {}
+  action activate {
+    from: pending, to: active, actor: { party: borrower }
+    subject { adapter: adapter }
+  }
+  action suspend { from: active, to: suspended, actor: { party: borrower } }
+  action resume { from: suspended, to: active, actor: { party: borrower } }
+  action close { from: [active, suspended], to: closed, due: { at: self.expiresAt }, requires count of { instrument: all(financing.advance), reference: "line", anchor: self.id, states: [drawn], limit: 366 } == 0 }
+}
+
+instrument advance(line: ref<financing.credit_line>, amount: money = runtime) {
+  familyRevision: 1
+  summary: "A single facility draw with an immutable principal and full repayment."
+  fields { line: ref<line>, amount: money = amount, principalReceivable: account(self, claim) }
+  lifecycle { states: [pending, drawn, repaid, cancelled], initial: pending }
+  action create { requires self.amount <= self.line.limit }
+  invariants sum "principalReceivable.balance" of { instrument: all(financing.advance), reference: "line", anchor: self.line, states: [drawn], limit: 366 } <= self.line.limit
+  action draw {
+    from: pending, to: drawn
+    requires self.line in [active]
+    deadline: { at: self.line.expiresAt }
+    moves self.amount from self.line.facility to self.line.borrower; moves self.amount from self.line.debt to self.principalReceivable
+  }
+  action repay { from: drawn, to: repaid, moves self.amount from self.line.borrower to self.line.facility; moves self.amount from self.principalReceivable to self.line.debt }
+  action cancel { from: pending, to: cancelled }
+}