@hyperscale0/hsx 4.2.0 → 5.0.0

package/src/version.ts

@@ -1,2 +1,2 @@
-export const HSX_VERSION = "4.2.0";
+export const HSX_VERSION = "5.0.0";
 export const HSX_TARGET_UDL_VERSION = 4;

package/std/collections.hsx

@@ -13,7 +13,7 @@ instrument case(on: ref<financing.installments>[], agency: party, capital: party
   }
   action assign { from: opened, to: assigned, actor: { party: capital } }
   action recover { expansionLimit: 8192, from: assigned, to: recovered, actor: { party: agency }, requires self.payment.plan == self.plan, invoke: [{ reference: self.payment, action: pay, input: {} }, { reference: self.id, action: pay_fee, input: {} }] }
-  action pay_fee { from: recovered, to: recovered, actor: { parent: current() }, moves self.agencyFee from self.plan.capital to agency }
+  action pay_fee { allowZero: true, from: recovered, to: recovered, actor: { parent: current() }, moves self.agencyFee from self.plan.capital to agency }
   action recall { from: [opened, assigned], to: recalled, actor: { party: capital } }
   action return_uncollected { from: assigned, to: returned_uncollected, actor: { party: agency } }
 }

package/std/escrow.hsx

@@ -26,7 +26,7 @@ instrument hold(payer: party = party(person), payee: party = programOperator, ac
     from: funded, to: delivered, actor: { party: payee }
     set: { deliveredAt: { field: self.now } }
   }
-  action accept {
+  action accept { allowZero: true, requires self.price > "0";
     from: delivered, to: released, actor: { party: payer }
     input { acceptanceReference: text }
     deadline: { at: self.deliveredAt, offset: accept_within }

package/std/financing.hsx

@@ -1,6 +1,13 @@
 header financing
 
 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."
@@ -29,7 +36,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     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 disburse {
+  action disburse { allowZero: true,
     from: signed, to: active, actor: { party: capital }
     requires self.borrowerLimit in [approved]
     requires self.portfolioLimit in [approved]
@@ -41,7 +48,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     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 {
+  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 }] }]
@@ -186,14 +193,14 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       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 {
+      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
       }
-      action refund {
+      action refund { allowZero: true,
         from: recorded, to: refunded, actor: { parent: payment }
         moves self.share from self.allocatedPayable to self.profitIncome
       }
@@ -259,7 +266,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         calculate: [{ target: nextDueAt, op: at, list: input.amendment.dates, position: { field: self.position } }]
         requires self.nextDueAt == self.dueAt
       }
-      action activate {
+      action activate { allowZero: true,
         from: draft, to: pending, actor: { parent: parent }
         moves self.principal from self.debt to self.principalReceivable
         moves self.profit from self.debt to self.profitReceivable
@@ -324,7 +331,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         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 {
+      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 }] }]
@@ -334,7 +341,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         moves self.profitReceivable.balance from self.profitReceivable to self.debt
         moves self.profitEarned.balance from self.profitEarned to self.debt
       }
-      action write_off {
+      action write_off { allowZero: true,
         from: [pending, due], to: written_off, actor: { parent: parent }
         moves self.principalReceivable.balance from self.principalReceivable to self.loss; moves self.profitReceivable.balance from self.profitReceivable to self.debt; moves self.profitEarned.balance from self.profitEarned to self.loss
       }
@@ -344,7 +351,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       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 } }
-      action mature { from: pending, to: recognised, actor: clock, due: { at: self.dueAt }, moves self.slice.profitReceivable.balance from self.slice.profitReceivable to self.slice.profitEarned }
+      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 }
     }
     payment: {
       revisioned: true
@@ -398,14 +405,14 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     principal_piece: {
       fields { slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create {
+      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; moves self.amount from self.slice.principalReceivable to self.slice.debt
       }
-      action refund {
+      action refund { allowZero: true,
         from: paid, to: refunded, actor: { parent: payment }
         moves self.amount from self.slice.plan.capital to self.slice.plan.borrower; moves self.amount from self.slice.debt to self.slice.principalReceivable
       }
@@ -413,7 +420,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     profit_piece: {
       fields { slice: ref<slice>, payment: ref<payment>, limit: money, amount: money? }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create {
+      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 }
@@ -423,7 +430,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         when profit_earned is by_schedule { moves self.amount from self.slice.profitEarned to self.slice.debt }
         when profit_earned is at_disbursement { moves self.amount from self.slice.profitEarned to self.slice.debt }
       }
-      action refund {
+      action refund { allowZero: true,
         from: paid, to: refunded, actor: { parent: payment }
         moves self.amount from self.slice.plan.profitIncome to self.slice.plan.borrower
         when profit_earned is on_payment { moves self.amount from self.slice.debt to self.slice.profitReceivable }
@@ -435,6 +442,13 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
 }
 
 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 approved fine and evidenced recovery claims on an overdue installment."
@@ -444,7 +458,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
   }
   lifecycle { states: [proposed, assessed, collected, waived, refunded], initial: proposed }
   action create { 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 {
+  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
@@ -455,7 +469,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     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 {
+  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
@@ -468,7 +482,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     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 { from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt }
+  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 }
   action refund {
     from: [assessed, collected], to: assessed, actor: { party: fines_to }, input { payment: ref<on.payment> }
     requires input.payment in [paid, refunded]
@@ -489,7 +503,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     waiver: {
       fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
       lifecycle { states: [recorded], initial: recorded }
-      action create {
+      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]
@@ -499,8 +513,8 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     receipt: {
       fields { assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
       lifecycle { states: [paid, refunded], initial: paid }
-      action create { 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; moves self.amount from self.assessment.receivable to self.assessment.debt }
-      action refund { from: paid, to: refunded, actor: { parent: parent }, moves self.amount from fines_to to self.payment.plan.borrower; moves self.amount from self.assessment.debt to self.assessment.receivable }
+      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; moves self.amount from self.assessment.receivable to self.assessment.debt }
+      action refund { allowZero: true, from: paid, to: refunded, actor: { parent: parent }, moves self.amount from fines_to to self.payment.plan.borrower; moves self.amount from self.assessment.debt to self.assessment.receivable }
     }
 
     cost: {
@@ -522,7 +536,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         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 {
+      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
@@ -535,7 +549,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         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 { from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt }
+      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 }
       action refund {
         from: [assessed, collected], to: assessed, actor: { party: costs_to }, input { payment: ref<on.payment> }
         requires input.payment in [paid, refunded]
@@ -556,7 +570,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         waiver: {
           fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
           lifecycle { states: [recorded], initial: recorded }
-          action create {
+          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]
@@ -566,8 +580,8 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         receipt: {
           fields { assessment: ref<parent>, payment: ref<on.payment>, amount: money? }
           lifecycle { states: [paid, refunded], initial: paid }
-          action create { 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; moves self.amount from self.assessment.receivable to self.assessment.debt }
-          action refund { from: paid, to: refunded, actor: { parent: parent }, moves self.amount from costs_to to self.payment.plan.borrower; moves self.amount from self.assessment.debt to self.assessment.receivable }
+          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; moves self.amount from self.assessment.receivable to self.assessment.debt }
+          action refund { allowZero: true, from: paid, to: refunded, actor: { parent: parent }, moves self.amount from costs_to to self.payment.plan.borrower; moves self.amount from self.assessment.debt to self.assessment.receivable }
         }
       }
     }

package/std/lending.hsx

@@ -76,23 +76,23 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
     requires self.mode == "loss"; requires self.source.kind == "loss"; requires self.source in [recorded]
     calculate: [{ target: "net", op: "sum", values: [{ field: self.source.loss }] }]
   }
-  action distribute_cash {
+  action distribute_cash { allowZero: true,
     from: cash_ready, to: distributed, actor: { party: operator }
     requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == 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; moves self.vat from self.held to programTax
     invoke: [{ selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: cash, input: {} }, { reference: self.id, action: residual_cash, input: {} }]
   }
-  action residual_cash {
+  action residual_cash { allowZero: true,
     from: distributed, to: distributed, actor: { parent: current() }
     moves self.held.balance from self.held to residual_to
   }
-  action distribute_loss {
+  action distribute_loss { allowZero: true,
     from: loss_ready, to: distributed, actor: { party: operator }
     requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == self.round.price
     moves self.net from self.source.lossAccount to self.losses
     invoke: [{ selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: loss, input: {} }, { reference: self.id, action: residual_loss, input: {} }]
   }
-  action residual_loss {
+  action residual_loss { allowZero: true,
     from: distributed, to: distributed, actor: { parent: current() }
     moves self.losses.balance from self.losses to self.residualLoss
   }
@@ -105,11 +105,11 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
       }
       lifecycle { states: [pending, paid], initial: pending }
       action create { requires self.distribution in [cash_ready, loss_ready]; requires self.commitment in [funded]; requires unique "distribution_weight" on [self.distribution, self.commitment]; requires self.commitment.round == self.distribution.round }
-      action cash {
+      action cash { allowZero: true,
         from: pending, to: paid, actor: { parent: parent }
         moves self.gross from self.distribution.held to self.commitment.wallet.held
       }
-      action loss { from: pending, to: paid, actor: { parent: parent }, moves self.gross from self.distribution.losses to self.commitment.loss }
+      action loss { allowZero: true, from: pending, to: paid, actor: { parent: parent }, moves self.gross from self.distribution.losses to self.commitment.loss }
     }
   }
 }

package/std/marketplace.hsx

@@ -71,7 +71,7 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
     from: active, to: active, actor: { party: buyer }, deadline: { at: self.expiresAt }
     invoke: [{ reference: self.funds, action: fund, input: {} }]
   }
-  action credit {
+  action credit { allowZero: true,
     from: active, to: converted, actor: { parent: converters }, deadline: { at: self.expiresAt }
     input { funds: ref<funds>, contribution: money }
     requires input.funds == self.funds; requires input.funds in [pending, funded]; requires input.funds.payer == self.buyer; requires input.funds.price == self.price
@@ -81,7 +81,7 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
     moves self.credit from self.held to input.funds.held
     moves self.refund from self.held to self.buyer
   }
-  action cancel {
+  action cancel { allowZero: true,
     from: active, to: cancelled, actor: { party: buyer }, input { reason: text }
     calculate: [{ target: refund, op: rate, base: { field: self.held.balance }, bps: { literal: cancellation_refund }, rounding: floor }, { target: retained, op: subtract, base: { field: self.held.balance }, subtract: [{ field: self.refund }] }]
     set: { reason: { field: input.reason }, dispositionAt: { field: self.now } }
@@ -98,7 +98,7 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
     moves self.held.balance from self.held to self.buyer
   }
   action withdraw { from: proposed, to: cancelled, actor: { party: buyer } }
-  action expire {
+  action expire { allowZero: true,
     from: active, to: expired, actor: clock, due: { at: self.expiresAt }
     calculate: [{ target: refund, op: rate, base: { field: self.held.balance }, bps: { literal: expiry_refund }, rounding: floor }, { target: retained, op: subtract, base: { field: self.held.balance }, subtract: [{ field: self.refund }] }]
     set: { dispositionAt: { field: self.now } }

package/std/money.hsx

@@ -4,7 +4,7 @@ instrument transfer(payer: party, payee: party, amount: money = runtime) {
   summary: "One transfer between the bound parties."
   fields { amount: money = amount }
   lifecycle { states: [pending, paid, cancelled], initial: pending }
-  action create { actor: { party: payer } }
+  action create { actor: { party: payer }, requires self.amount > "0" }
   action pay {
     from: pending, to: paid, actor: { party: payer }
     moves self.amount from payer to payee
@@ -41,7 +41,7 @@ instrument split(payer: party, amount: money = runtime, shares: split = { progra
   fields { amount: money = amount }
   lifecycle { states: [pending, paid, cancelled], initial: pending }
   action create {}
-  action pay { from: pending, to: paid, actor: { party: payer }, moves self.amount from payer shares shares }
+  action pay { allowZero: true, requires self.amount > "0"; from: pending, to: paid, actor: { party: payer }, moves self.amount from payer shares shares }
   action cancel { from: pending, to: cancelled }
 }
 
@@ -72,7 +72,7 @@ instrument schedule(payer: party, payee: party, amount: money = runtime, count:
       }
       lifecycle { states: [pending, paid, cancelled], initial: pending }
       action create { requires self.schedule in [draft]; requires unique "scheduled_position" on [self.schedule, self.position] }
-      action pay { from: pending, to: paid, actor: clock, due: { at: self.dueAt }, requires self.schedule in [active], moves self.amount from payer to payee }
+      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 cancel { from: pending, to: cancelled, requires self.schedule in [cancelled] }
     }
   }
@@ -95,10 +95,10 @@ instrument pool(payer: party, payee: party, target: money, closes: date) {
   }
   records {
     contribution: {
-      fields { pool: ref<parent>, payer: account of payer, amount: money }
+      fields { pool: ref<parent>, payer: account of payer, amount: money, remaining: money? }
       lifecycle { states: [pending, paid, refunded], initial: pending }
       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], moves self.amount from self.payer to self.pool.held }
+      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 }
       action refund { from: paid, to: refunded, actor: { parent: parent }, moves self.amount from self.pool.held to self.payer }
     }
   }
@@ -146,6 +146,6 @@ instrument metered(payer: party, payee: party, unit_price: money, units: integer
   fields { usageIdentity: text, unitPrice: money = unit_price, units: integer = units, amount: money = multiply(self.unitPrice, self.units) }
   lifecycle { states: [recorded, billed, cancelled], initial: recorded }
   action create { requires unique "usage_event" on [self.usageIdentity] }
-  action bill { from: recorded, to: billed, actor: { party: payee }, moves self.amount from payer to payee fee fee }
+  action bill { allowZero: true, requires self.amount > "0"; from: recorded, to: billed, actor: { party: payee }, moves self.amount from payer to payee fee fee }
   action cancel { from: recorded, to: cancelled }
 }

package/std/savings.hsx

@@ -1,6 +1,6 @@
 header savings
 
-instrument circle(contribution: money, members: integer(1, 366), starts: date, memberships: ref<savings.membership> = object(savings.membership)) {
+instrument circle(contribution: money, members: integer(1, 60), starts: date, memberships: ref<savings.membership> = object(savings.membership)) {
   summary: "A fixed group contributes on its explicit calendar and takes the pot in order."
   fields { contribution: money = contribution, members: integer = members, startsAt: date = starts, dates: list(date, members), pot: money = multiply(self.contribution, self.members), held: account of self }
   lifecycle { states: [forming, active, closed, disbanded], initial: forming }

package/std/travel.hsx

@@ -33,17 +33,17 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: party,
   action create {
     requires self.package in [published]
   }
-  action deposit {
+  action deposit { allowZero: true, requires self.price > "0";
     from: created, to: deposit_paid, actor: { party: buyer }, deadline: { at: self.balanceAt }
     requires count of { instrument: child(cover, slice), reference: "covers", anchor: self.id, states: [pending], limit: 366 } >= 1
     moves self.deposit from buyer to self.held
     invoke: [{ selection: { instrument: child(cover, slice), reference: "covers", anchor: self.id, states: [pending], limit: 366 }, action: collect, input: {} }]
   }
-  action balance {
+  action balance { allowZero: true, requires self.price > "0";
     from: deposit_paid, to: paid, actor: { party: buyer }, deadline: { at: self.balanceAt }
     moves self.balance from buyer to self.held
   }
-  action confirm {
+  action confirm { allowZero: true, requires self.price > "0";
     from: paid, to: completed, actor: { party: operator }
     due: { at: self.package.departure }, deadline: { at: self.confirmBy }
     moves self.supplierCost from self.held to supplier
@@ -54,11 +54,11 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: party,
     from: paid, to: refunded, actor: clock, due: { at: self.confirmBy }
     moves self.price from self.held to buyer
   }
-  action cancel_early {
+  action cancel_early { allowZero: true, requires self.price > "0";
     from: [deposit_paid, paid], to: cancelled, actor: { party: buyer }, deadline: { at: self.earlyAt }
     moves self.held.balance from self.held to buyer
   }
-  action cancel_middle {
+  action cancel_middle { allowZero: true, requires self.price > "0";
     from: [deposit_paid, paid], to: cancelled, actor: { party: buyer }, due: { at: self.earlyAt }, deadline: { at: self.lateAt }
     calculate: [
       { target: refund, op: "subtract", base: { field: self.held.balance }, subtract: [{ field: self.deposit }] }
@@ -71,7 +71,7 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: party,
     moves self.retainedTax from self.held to programTax
     moves self.retainedNet from self.held to programOperator
   }
-  action cancel_late {
+  action cancel_late { allowZero: true, requires self.price > "0";
     from: [deposit_paid, paid], to: cancelled, actor: { party: buyer }, due: { at: self.lateAt }
     calculate: [
       { target: retainedMargin, op: "subtract", base: { field: self.held.balance }, subtract: [{ field: self.latePenalty }] }
@@ -82,7 +82,7 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: party,
     moves self.retainedTax from self.held to programTax
     moves self.retainedNet from self.held to programOperator
   }
-  action default_balance {
+  action default_balance { allowZero: true, requires self.price > "0";
     from: deposit_paid, to: cancelled, actor: clock, due: { at: self.balanceAt }
     calculate: [
       { target: retainedMargin, op: "subtract", base: { field: self.held.balance }, subtract: [{ field: self.latePenalty }] }