@hyperscale0/hsx 1.0.337 → 1.0.339

package/std/insurance.hsx

@@ -16,6 +16,9 @@ header insurance
 // Cover.cancel invokes refund only on paid slices, before each startsAt. It returns
 // insurerPremium from insurer and commission from broker to holder. Active or
 // expired periods are excluded; insufficient recipient funds refuse the reversal.
+// Each refund is two transfers, so cancel refunds 126 paid slices per operation.
+// A cover with more reads cancelling, and its cancel_step clock refunds the next
+// 126 a second later until none remain; then it reads cancelled.
 // Slice refund is parent-owned, not a public alias. Expose cover.cancel instead.
 // Claims require active cover. Expose claim.create, approve, deny and pay as needed.
 // Inspector approves OR denies from submitted. After approval only pay or clock
@@ -25,21 +28,34 @@ header insurance
 
 // Cost: each slice collection or refund declares two transfers. Claim approval
 // reserves once; pay posts once and expiry voids once. Cover cancellation adds
-// bounded slice invocations. Run hsx cost for composed counts, not provider prices.
+// at most 252 transfers per step. Run hsx cost for composed counts, not provider prices.
 
 instrument cover(holder: party, adapter: text, commission: percent = 0%, broker: party = programOperator, covers: ref?, premium: money = runtime, claim_limit: money = runtime) {
   summary: "Recurring cover bound to an outside insurer across an ADL boundary."
-  fields { covers: ref<covers>?, holder: account of holder, insurer: account(adapter(adapter), cash, "premium"), expiresAt: date, claimLimit: money = claim_limit }
-  lifecycle { states: [pending, active, cancelled, expired], initial: pending }
+  fields { covers: ref<covers>?, holder: account of holder, insurer: account(adapter(adapter), cash, "premium"), expiresAt: date, claimLimit: money = claim_limit, cancelAt: date?, slicesLeft: integer? }
+  lifecycle { states: [pending, active, cancelling, cancelled, expired], initial: pending }
   action create { actor: { party: holder } }
   action activate {
     from: pending, to: active, actor: { party: programOperator }
     subject { adapter: adapter }
   }
   action cancel {
-    from: active, to: cancelled, actor: { party: holder }
-    invoke: [{ selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
+    from: active, to: cancelling, actor: { party: holder }
+    invoke: [{ reference: self.id, action: cancel_batch, input: {} }]
   }
+  action cancel_step { from: cancelling, to: preserve, actor: clock, due: { at: self.cancelAt }, invoke: [{ reference: self.id, action: cancel_batch, input: {} }] }
+  action cancel_batch {
+    from: cancelling, to: preserve, actor: { parent: current() }
+    calculate: [{ target: cancelAt, op: shift, date: { field: self.now }, milliseconds: { literal: 1000 }, direction: after }]
+    invoke: [{ selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 126, batch: true, order: [startsAt] }, action: refund, input: {} }]
+    invoke: [{ reference: self.id, action: cancel_check, input: {} }]
+  }
+  action cancel_check {
+    from: cancelling, to: preserve, actor: { parent: current() }
+    calculate: [{ target: slicesLeft, op: aggregate, selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 1, batch: true }, measure: count }]
+    invoke: [{ reference: self.id, action: finish_cancel, guard: { kind: compare, left: { field: self.slicesLeft }, operator: "==", right: { literal: 0 } }, input: {} }]
+  }
+  action finish_cancel { from: cancelling, to: cancelled, actor: { parent: current() } }
   action expire { from: active, to: expired, actor: clock, due: { at: self.expiresAt } }
   records {
     slice: {

package/std/lending.hsx

@@ -26,6 +26,9 @@ header lending
 // Cost: round.create declares one owned account. Close transfers its balance
 // and invokes commitments; failure invokes their refunds. Distribution adds moves
 // and bounded share invocations. Run hsx cost for counts after policy selection.
+// A round takes at most 248 commitments, so failure refunds them in 248 ledger
+// transfers and a cash distribution pays every share in 253, the most one
+// ledger request takes.
 
 instrument round(borrower: party, plan: ref<financing.installments> = object(financing.installments), operator: party = programOperator, minimum_ticket: money = 100 SAR, investor_cap: percent = 20%, commitments: ref<lending.commitment> = object(lending.commitment)) {
   summary: "A threshold funding round; failed rounds return each original wallet contribution."
@@ -38,14 +41,14 @@ instrument round(borrower: party, plan: ref<financing.installments> = object(fin
   action create { actor: { party: operator }, requires unique "funding_plan" on [self.plan]; requires self.borrower == self.plan.borrower }
   action close {
     from: open, to: funded, actor: { party: operator }
-    requires sum "amount" of { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 } == self.price
+    requires sum "amount" of { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 248 } == self.price
     requires self.held.balance == self.price
     moves self.price from self.held to self.plan.capital economics { purpose: principal, sourceParty: programOperator }
-    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 }, action: fund, input: {} }]
+    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 248 }, action: fund, input: {} }]
   }
   action fail {
     from: open, to: failed, actor: clock, due: { at: self.closesAt }
-    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 }, action: refund, input: {} }]
+    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 248 }, action: refund, input: {} }]
   }
 }
 
@@ -53,8 +56,9 @@ instrument commitment(round: ref<lending.round>, wallet: ref<wallet.balance>, in
   summary: "One investor's original-wallet contribution, capped cumulatively within the round."
   fields { round: ref<round>, wallet: ref<wallet>, investor: account of investor, amount: money, loss: account(investor, claim, "loss") }
   lifecycle { states: [committed, funded, withdrawn, refunded], initial: committed }
-  invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 366, where: { investor: { field: self.investor } } } <= self.round.maximumTicket
-  invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 366 } <= self.round.price
+  invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 248, where: { investor: { field: self.investor } } } <= self.round.maximumTicket
+  invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 248 } <= self.round.price
+  invariants count of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 248 } <= 248
   action create {
     actor: { party: investor }
     requires self.round in [open]
@@ -108,9 +112,9 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
   action distribute_cash { allowZero: true,
     from: cash_ready, to: distributed, actor: { party: operator }
     requires self.source in [recorded]; requires unique "settlement_consumption" on [self.source.plan, self.source.identity]
-    requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == self.round.price
+    requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 248 } == self.round.price
     moves self.principal from self.source.capital to self.held; moves self.profit from self.source.profitIncome to self.held; moves self.charge from self.held to programOperator economics { purpose: internal, sourceParty: programOperator }; moves self.vat from self.held to programTax economics { purpose: pass_through, sourceParty: programOperator }
-    invoke: [{ reference: self.source, action: distribute, input: {} }, { selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: cash, input: {} }, { reference: self.id, action: residual_cash, input: {} }]
+    invoke: [{ reference: self.source, action: distribute, input: {} }, { selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 248 }, action: cash, input: {} }, { reference: self.id, action: residual_cash, input: {} }]
   }
   action residual_cash { allowZero: true,
     from: distributed, to: distributed, actor: { parent: current() }
@@ -119,9 +123,9 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
   action distribute_loss { allowZero: true,
     from: loss_ready, to: distributed, actor: { party: operator }
     requires self.source in [recorded]; requires unique "settlement_consumption" on [self.source.plan, self.source.identity]
-    requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == self.round.price
+    requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 248 } == self.round.price
     moves self.net from self.source.lossAccount to self.losses
-    invoke: [{ reference: self.source, action: distribute, input: {} }, { selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: loss, input: {} }, { reference: self.id, action: residual_loss, input: {} }]
+    invoke: [{ reference: self.source, action: distribute, input: {} }, { selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 248 }, action: loss, input: {} }, { reference: self.id, action: residual_loss, input: {} }]
   }
   action residual_loss { allowZero: true,
     from: distributed, to: distributed, actor: { parent: current() }

package/std/money.hsx

@@ -12,12 +12,22 @@ header money
 // payee, so a shop that is payee keeps a deposit without acting for its customer.
 // Bind released_by: payer for an escrow-style hold that only the payer releases.
 // Only the payee refunds. A hold has no dispute or damage decision.
-// The payee proposes a schedule, which creates its count occurrences, and only
-// the payer activates or cancels it. Each due occurrence pays only while the
-// schedule is active. A due time promises no retry.
+// The payee proposes a schedule and only the payer activates or cancels it; the
+// payee stops it. Without every, count is required and create makes count
+// occurrences on the listed dates that sum to amount. With every (1 month, 2
+// weeks), each occurrence charges amount, the first at startsAt, and paying one
+// creates the next, so only one piece waits ahead. Months step from startsAt and
+// clamp to the month's end. create refuses a startsAt in the past. An authored
+// count ends it after count pieces; without one it runs until stopped or
+// cancelled. The schedule keeps count as a field only when it is set, so reads
+// name a piece "2 of 12" or, open-ended, "#2". Each due occurrence pays
+// only while the schedule is active, and one clock drain posts at most the 253
+// ledger transfers one request takes, 253 one-transfer pieces; the next drain
+// continues a plan that fell further behind.
 // A pool accepts whole contributions only up to its remaining target and at most
-// 366 paid records. Expose pay to release the exact target. Clock failure refunds
-// original contributors; excess acceptance and partial contribution are absent.
+// 253 paid records, so a failure refunds every contributor in one ledger request.
+// Expose pay to release the exact target. Clock failure refunds original
+// contributors; excess acceptance and partial contribution are absent.
 // A swap reserves both legs before exchange or voids reservations on expiry.
 // Payout instruct reserves across the selected adapter; confirm/reject require
 // matching terminal instruction evidence. An acknowledgement cannot settle it.
@@ -26,13 +36,30 @@ header money
 // most 366 billed events across every metered attachment on the mandate may sum
 // their payer debit, buyer fee and tax included, to its limit. The payer revokes
 // it to stop billing. Only the payee cancels its own unbilled usage.
-// The payer creates a late fee against its dueAt, which rename can bind to the
-// record's own due field. Once dueAt plus grace plus one period has passed, the
-// clock charges amount from payer to payee for each whole period, and the last
-// charge takes only what is left under cap; then the fee is capped. The payee runs
-// stop when the obligation is met, which ends charging. A charge the payer cannot
-// fund refuses as clock work and charging waits for its retry. Grace is at least
-// one second; there are no percentage or interest-style fees.
+// The company starts a late fee against its dueAt, so late tracking never waits
+// on the payer; rename can bind dueAt to the record's own due field. Once dueAt
+// plus grace plus one period has passed, the clock charges amount from payer to
+// payee for each whole period, and the last charge takes only what is left under
+// cap; then the fee is capped. Charge k is due at dueAt plus grace plus k
+// periods. create copies dueAt. When any action on the record changes the bound
+// field, follow runs on the fee in the same request and reads the field as it
+// stands; the payee's reschedule runs follow directly. Follow keeps the charges
+// already posted and moves the rest later, never earlier, because fees run from
+// the dueAt set at create; past ones post on the next clock run. The clock never
+// runs twice at one instant, so follow also needs the next charge after the last
+// posted one. A move that breaks either rule refuses reschedule, while another
+// action's change leaves the fee where it was and still runs. Period counts
+// whole seconds. The payee runs stop when the obligation is met. Stop keeps what
+// was owed: each charge due at or before it still posts, and the fee settles
+// until the last of those posts, then stops. A period still running at the stop
+// is not charged. A charge the payer cannot fund refuses as clock work and
+// charging waits for its retry; the payee runs waive to forgive what is still
+// owed. Grace is at least one second; there are no percentage or interest-style
+// fees. Bind a hold's late_fee to the late fee on its object and refund also
+// runs stop on that fee while it is running, so returning the deposit ends both.
+// The link sits on refund because every good return refunds, and a fee already
+// capped or stopped is skipped rather than blocking the refund. The hold links
+// the fee at create, so the fee is agreed first, with the same payer and payee.
 
 // Cost: transfer.pay declares one transfer. Hold.create declares one owned account;
 // fund, release and refund each declare one transfer. Schedules and pools add bounded
@@ -51,11 +78,19 @@ instrument transfer(payer: party, payee: party, amount: money = runtime) {
   action cancel { from: pending, to: cancelled, actor: { party: payer } }
 }
 
-instrument hold(payer: party, payee: party, amount: money = runtime, released_by: party = payee) {
+instrument hold(payer: party, payee: party, amount: money = runtime, released_by: party = payee, late_fee: ref<money.late_fee>?) {
   summary: "Hold the declared amount until release or refund."
-  fields { payer: account of payer, payee: account of payee, amount: money = amount, price: money = self.amount, held: account of self }
+  fields {
+    payer: account of payer, payee: account of payee, amount: money = amount, price: money = self.amount, held: account of self
+    when late_fee is set { lateFee: ref<late_fee> }
+  }
   lifecycle { states: [pending, funded, released, refunded, cancelled], initial: pending }
-  action create { }
+  action create {
+    when late_fee is set {
+      requires self.lateFee.payer == self.payer
+      requires self.lateFee.payee == self.payee
+    }
+  }
   action fund {
     from: pending, to: funded, actor: { party: payer }
     moves self.amount from payer to self.held economics { purpose: principal, sourceParty: payer }
@@ -71,6 +106,7 @@ instrument hold(payer: party, payee: party, amount: money = runtime, released_by
   action refund {
     from: funded, to: refunded, actor: { party: payee }
     moves self.amount from self.held to payer economics { purpose: principal, sourceParty: programOperator }
+    when late_fee is set { invoke: [{ selection: { instrument: late_fee, reference: "payer", anchor: self.payer, states: [running], limit: 1, where: { id: { field: self.lateFee } } }, action: stop, input: {} }] }
   }
   action cancel { from: pending, to: cancelled }
 }
@@ -84,13 +120,31 @@ instrument split(payer: party, amount: money = runtime, shares: split = { progra
   action cancel { from: pending, to: cancelled }
 }
 
-instrument schedule(payer: party, payee: party, amount: money = runtime, count: integer(1, 366) = 12) {
-  summary: "A finite schedule whose dated pieces sum exactly to the declared total."
-  fields { amount: money = amount, count: integer = count, dates: list(date, count) }
+instrument schedule(payer: party, payee: party, amount: money = runtime, count: integer(1, 366)?, every: period?) {
+  summary: "Pieces due on listed dates that sum to the total, or one amount each period from a start date until stopped, or for count periods."
+  dependencies {
+    count {
+      selector: every, is: unset
+      message: "Attachment `{attachment}` charges on a list of dates, so it needs `count`, the number of dates."
+      fix: "Add `count: 3` for three dated pieces, or add `every: 1 month` to charge each month until stopped or cancelled."
+    }
+  }
+  fields {
+    amount: money = amount
+    when every is unset { count: integer = count, dates: list(date, count) }
+    when every is set {
+      startsAt: date
+      when count is set { count: integer = count }
+    }
+  }
   lifecycle { states: [draft, active, complete, cancelled], initial: draft }
   action create {
     actor: { party: payee }
-    invoke: [{ range: { count: { literal: count }, maximum: count, bind: position }, instrument: occurrence, action: create, input: { schedule: { field: self.id }, position: { field: position } } }]
+    when every is unset { invoke: [{ range: { count: { literal: count }, maximum: count, bind: position }, instrument: occurrence, action: create, input: { schedule: { field: self.id }, position: { field: position } } }] }
+    when every is set {
+      requires self.startsAt >= self.now
+      invoke: [{ instrument: occurrence, action: create, input: { schedule: { field: self.id }, position: { literal: 1 } } }]
+    }
   }
   action activate { from: draft, to: active, actor: { party: payer } }
   action complete {
@@ -98,20 +152,41 @@ instrument schedule(payer: party, payee: party, amount: money = runtime, count:
     requires count of { instrument: occurrence, reference: "schedule", anchor: self.id, states: [pending], limit: 366 } == 0
   }
   action cancel { from: [draft, active], to: cancelled, actor: { party: payer } }
+  action stop { from: active, to: cancelled, actor: { party: payee } }
   records {
     occurrence: {
       fields {
-        schedule: ref<parent>, position: integer(1, count), dueAt: date = at(self.schedule.dates, self.position)
-        base: money = divide(self.schedule.amount, count)
-        allocated: money = multiply(self.base, count)
-        remainder: money = subtract(self.schedule.amount, self.allocated)
-        first: integer = divide(1, self.position)
-        adjustment: money = multiply(self.remainder, self.first)
-        amount: money = sum(self.base, self.adjustment)
+        schedule: ref<parent>
+        when every is unset {
+          position: integer(1, count), dueAt: date = at(self.schedule.dates, self.position)
+          base: money = divide(self.schedule.amount, count)
+          allocated: money = multiply(self.base, count)
+          remainder: money = subtract(self.schedule.amount, self.allocated)
+          first: integer = divide(1, self.position)
+          adjustment: money = multiply(self.remainder, self.first)
+          amount: money = sum(self.base, self.adjustment)
+        }
+        when every is set {
+          position: integer, offset: integer = subtract(self.position, 1), following: integer = sum(self.position, 1)
+          dueAt: date = after(self.schedule.startsAt, every, self.offset)
+          amount: money = self.schedule.amount
+        }
       }
       lifecycle { states: [pending, paid, cancelled], initial: pending }
-      action create { actor: { parent: parent }, input { schedule: ref<parent>, position: integer(1, count) }, requires unique "scheduled_position" on [self.schedule, self.position] }
-      action pay { allowZero: true, from: pending, to: paid, actor: clock, due: { at: self.dueAt }, requires self.schedule in [active], moves self.amount from payer to payee }
+      action create {
+        actor: { parent: [parent, current()] }
+        input { schedule: ref<parent>, when every is unset { position: integer(1, count) } when every is set { position: integer } }
+        requires unique "scheduled_position" on [self.schedule, self.position]
+      }
+      action pay {
+        allowZero: true, from: pending, to: paid, actor: clock, due: { at: self.dueAt }
+        requires self.schedule in [active]
+        moves self.amount from payer to payee
+        when every is set {
+          when count is set { invoke: [{ instrument: current(), action: create, guard: { kind: compare, left: { field: self.position }, operator: "<", right: { literal: count } }, input: { schedule: { field: self.schedule }, position: { field: self.following } } }] }
+          when count is unset { invoke: [{ instrument: current(), action: create, input: { schedule: { field: self.schedule }, position: { field: self.following } } }] }
+        }
+      }
       action cancel { from: pending, to: cancelled, requires self.schedule in [cancelled] }
     }
   }
@@ -130,13 +205,13 @@ instrument pool(payer: party, payee: party, target: money, closes: date) {
   action fail {
     from: open, to: failed, actor: clock, due: { at: self.closesAt }
     requires self.held.balance < self.target
-    invoke: [{ selection: { instrument: contribution, reference: "pool", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
+    invoke: [{ selection: { instrument: contribution, reference: "pool", anchor: self.id, states: [paid], limit: 253 }, action: refund, input: {} }]
   }
   records {
     contribution: {
       fields { pool: ref<parent>, payer: account of payer, amount: money, remaining: money? }
       lifecycle { states: [pending, paid, refunded], initial: pending }
-      invariants count of { instrument: current(), reference: "pool", anchor: self.pool, states: [paid], limit: 366 } <= 366
+      invariants count of { instrument: current(), reference: "pool", anchor: self.pool, states: [paid], limit: 253 } <= 253
       action create { requires self.pool in [open] }
       action pay { from: pending, to: paid, actor: { party: payer }, deadline: { at: self.pool.closesAt }, requires self.pool in [open], calculate: [{ target: remaining, op: subtract, base: { field: self.pool.target }, subtract: [{ field: self.pool.held.balance }] }], requires self.amount <= self.remaining, moves self.amount from self.payer to self.pool.held economics { purpose: principal, sourceParty: payer } }
       action refund { from: paid, to: refunded, actor: { parent: parent }, moves self.amount from self.pool.held to self.payer economics { purpose: principal, sourceParty: programOperator } }
@@ -201,25 +276,60 @@ instrument late_fee(payer: party, payee: party, amount: money, cap: money, perio
   summary: "Charge a fixed fee for each period a due time stays unmet, up to a cap."
   fields {
     payer: account of payer, payee: account of payee, amount: money = amount, cap: money = cap, ceiling: money = multiply(self.amount, 366)
-    dueAt: date, graceEndsAt: date?, firstAt: date?, nextAt: date?, followingAt: date?, charge: money?, left: money?, remaining: money?
+    dueAt: date, graceEndsAt: date?, firstAt: date?, nextAt: date?, followingAt: date?, charge: money?, left: money?, remaining: money?, stoppedAt: date?
+    stride: integer?, strideAt: date?, elapsed: integer?, lastAt: date?
   }
-  lifecycle { states: [running, capped, stopped], initial: running }
+  lifecycle { states: [running, settling, capped, stopped], initial: running }
   action create {
-    actor: { party: payer }
+    actor: { party: programOperator }
     requires self.amount > "0"
     requires self.cap >= self.amount
     requires self.cap <= self.ceiling
-    calculate: [{ target: graceEndsAt, op: shift, date: { field: self.dueAt }, milliseconds: { literal: grace }, direction: after }, { target: firstAt, op: shift, date: { field: self.graceEndsAt }, milliseconds: { literal: period }, direction: after }]
-    set: { nextAt: { field: self.firstAt }, left: { field: self.cap } }
+    calculate: [{ target: graceEndsAt, op: shift, date: { field: self.dueAt }, milliseconds: { literal: grace }, direction: after }, { target: firstAt, op: shift, date: { field: self.graceEndsAt }, milliseconds: { literal: period }, direction: after }, { target: stride, op: divide, amount: { literal: period }, divisor: { literal: 1000 }, rounding: floor }, { target: strideAt, op: step, date: { field: self.graceEndsAt }, period: { literal: "PT1S" }, times: { field: self.stride } }, { target: elapsed, op: sum, values: [{ literal: 0 }] }]
+    requires self.strideAt == self.firstAt
+    set: { nextAt: { field: self.firstAt }, left: { field: self.cap }, lastAt: { literal: "1970-01-01T00:00:00.000Z" } }
   }
   action charge {
     summary: "Charge late fee"
     from: running, to: running, actor: clock, due: { at: self.nextAt }
+    calculate: [{ target: charge, op: minimum, values: [{ field: self.amount }, { field: self.left }] }, { target: remaining, op: subtract, base: { field: self.left }, subtract: [{ field: self.charge }] }, { target: followingAt, op: shift, date: { field: self.nextAt }, milliseconds: { literal: period }, direction: after }, { target: elapsed, op: sum, values: [{ field: self.elapsed }, { field: self.stride }] }]
+    set: { left: { field: self.remaining }, nextAt: { field: self.followingAt }, lastAt: { field: self.nextAt } }
+    moves self.charge from payer to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: pass_through, sourceParty: payer } }
+    invoke: [{ selection: { instrument: current(), reference: "payer", anchor: self.payer, states: [running], limit: 1, where: { id: { field: self.id }, left: { literal: "0" } } }, action: finish, input: {} }]
+  }
+  action reschedule {
+    summary: "Move the due time"
+    from: running, to: running, actor: { party: payee }
+    subject { dueAt: date }
+    invoke: [{ reference: self.id, action: follow, input: {} }]
+  }
+  action follow {
+    summary: "Follow the due time"
+    from: running, to: running, follows: dueAt
+    subject { dueAt: date }
+    // Fees run from the dueAt set at create, so the date only moves later.
+    requires subject.dueAt >= self.dueAt
+    calculate: [{ target: graceEndsAt, op: shift, date: { field: subject.dueAt }, milliseconds: { literal: grace }, direction: after }, { target: firstAt, op: shift, date: { field: self.graceEndsAt }, milliseconds: { literal: period }, direction: after }, { target: followingAt, op: step, date: { field: self.firstAt }, period: { literal: "PT1S" }, times: { field: self.elapsed } }]
+    requires self.followingAt > self.lastAt
+    set: { dueAt: { field: subject.dueAt }, nextAt: { field: self.followingAt } }
+  }
+  action collect {
+    summary: "Collect owed late fee"
+    from: settling, to: settling, actor: clock, due: { at: self.nextAt }
     calculate: [{ target: charge, op: minimum, values: [{ field: self.amount }, { field: self.left }] }, { target: remaining, op: subtract, base: { field: self.left }, subtract: [{ field: self.charge }] }, { target: followingAt, op: shift, date: { field: self.nextAt }, milliseconds: { literal: period }, direction: after }]
     set: { left: { field: self.remaining }, nextAt: { field: self.followingAt } }
     moves self.charge from payer to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: pass_through, sourceParty: payer } }
-    invoke: [{ selection: { instrument: current(), reference: "payer", anchor: self.payer, states: [running], limit: 1, where: { id: { field: self.id }, left: { literal: "0" } } }, action: finish, input: {} }]
+    invoke: [
+      { reference: self.id, action: settle, guard: { kind: compare, left: { field: self.nextAt }, operator: ">", right: { field: self.stoppedAt } }, input: {} }
+      { selection: { instrument: current(), reference: "payer", anchor: self.payer, states: [settling], limit: 1, where: { id: { field: self.id }, left: { literal: "0" } } }, action: finish, input: {} }
+    ]
+  }
+  action finish { from: [running, settling], to: capped, actor: { parent: current() } }
+  action stop {
+    from: running, to: settling, actor: { party: payee }
+    set: { stoppedAt: { field: self.now } }
+    invoke: [{ reference: self.id, action: settle, guard: { kind: compare, left: { field: self.nextAt }, operator: ">", right: { field: self.stoppedAt } }, input: {} }]
   }
-  action finish { from: running, to: capped, actor: { parent: current() } }
-  action stop { from: running, to: stopped, actor: { party: payee } }
+  action settle { from: settling, to: stopped, actor: { parent: current() } }
+  action waive { from: settling, to: stopped, actor: { party: payee } }
 }

package/std/reporting.hsx

@@ -119,19 +119,19 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
             },
             {
               name: "principal",
-              field: "principalReceivable.balance",
+              field: "openPrincipal",
               type: { kind: "money", currency: "SAR" },
               required: true
             },
             {
               name: "profit",
-              field: "profitReceivable.balance",
+              field: "openProfit",
               type: { kind: "money", currency: "SAR" },
               required: true
             },
             {
               name: "earnedProfit",
-              field: "profitEarned.balance",
+              field: "earnedProfit",
               type: { kind: "money", currency: "SAR" },
               required: true
             },
@@ -468,19 +468,19 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
             },
             {
               name: "principal",
-              field: "principalReceivable.balance",
+              field: "openPrincipal",
               type: { kind: "money", currency: "SAR" },
               required: true
             },
             {
               name: "profit",
-              field: "profitReceivable.balance",
+              field: "openProfit",
               type: { kind: "money", currency: "SAR" },
               required: true
             },
             {
               name: "earnedProfit",
-              field: "profitEarned.balance",
+              field: "earnedProfit",
               type: { kind: "money", currency: "SAR" },
               required: true
             },