@hyperscale0/hsx 1.0.338 → 1.0.340

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

@@ -13,17 +13,21 @@ header money
 // 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 and only the payer activates or cancels it; the
-// payee stops it. Without every, create makes count occurrences on the listed
-// dates and they 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. Each due occurrence pays
-// only while the schedule is active, and one clock drain charges at most 126
-// pieces; the next drain continues a plan that fell further behind.
+// 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.
@@ -32,15 +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. 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.
+// 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
@@ -59,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 }
@@ -79,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 }
 }
@@ -92,12 +120,22 @@ 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, every: period?) {
-  summary: "Pieces due on listed dates that sum to the total, or one amount each period from a start date."
+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 every is set {
+      startsAt: date
+      when count is set { count: integer = count }
+    }
   }
   lifecycle { states: [draft, active, complete, cancelled], initial: draft }
   action create {
@@ -167,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 } }
@@ -239,24 +277,42 @@ instrument late_fee(payer: party, payee: party, amount: money, cap: money, perio
   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?, stoppedAt: date?
+    stride: integer?, strideAt: date?, elapsed: integer?, lastAt: date?
   }
   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 }]
-    set: { left: { field: self.remaining }, nextAt: { field: self.followingAt } }
+    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 }

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
             },