@hyperscale0/hsx 2.4.1 → 3.0.0

package/std/insurance.hsx

@@ -0,0 +1,59 @@
+header insurance
+
+instrument cover(holder: party, insurer: party, commission: percent = 0%, covers: ref, premium: money = runtime) {
+  summary: "Recurring cover with separate premium slices and commission clawback."
+  fields { covers: ref<covers>, holder: account of holder, insurer: account of insurer, expiresAt: date }
+  lifecycle { states: [pending, active, cancelled, expired], initial: pending }
+  action create {}
+  action activate { from: pending, to: active, actor: { party: insurer } }
+  action cancel {
+    from: active, to: cancelled
+    invoke: [{ selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
+  }
+  action expire { from: active, to: expired, actor: clock, due: { at: self.expiresAt } }
+  records {
+    slice: {
+      summary: "A whole premium period, collected once and refundable only before it starts."
+      fields {
+        cover: ref<parent>, covers: ref<covers>, premium: money = premium, startsAt: date, endsAt: date
+        commission: money = rate(self.premium, commission)
+        carrierNet: money = subtract(self.premium, self.commission)
+      }
+      lifecycle { states: [pending, paid, active, expired, refunded], initial: pending }
+      action create {
+        requires self.covers == self.cover.covers
+        requires self.startsAt < self.endsAt
+        requires unique "premium_period" on [self.cover, self.startsAt, self.endsAt]
+      }
+      action collect {
+        from: pending, to: paid
+        requires self.cover in [active]
+        moves self.premium from holder to insurer
+        moves self.commission from insurer to programOperator
+      }
+      action start { from: paid, to: active, actor: clock, due: { at: self.startsAt } }
+      action expire { from: active, to: expired, actor: clock, due: { at: self.endsAt } }
+      action refund {
+        from: paid, to: refunded, deadline: { at: self.startsAt }
+        moves self.commission from programOperator to insurer
+        moves self.premium from insurer to holder
+      }
+    }
+  }
+}
+
+instrument claim(cover: ref<insurance.cover>, approved_by: approval) {
+  summary: "A carrier decision reserves one claim payment before settlement."
+  fields { cover: ref<cover>, amount: money, expiresAt: date, evidence: text, reservation: text? }
+  lifecycle { states: [submitted, approved, paid, denied, expired], initial: submitted }
+  action create { requires self.cover in [active] }
+  action approve {
+    from: submitted, to: approved, actor: { party: approved_by }
+    requires approval by approved_by
+    deadline: { at: self.expiresAt }
+    moves reserve self.amount from self.cover.insurer to self.cover.holder capture "reservation"
+  }
+  action pay { from: approved, to: paid, deadline: { at: self.expiresAt }, moves post self.reservation }
+  action deny { from: submitted, to: denied, requires approval by approved_by for approve is "declined" }
+  action expire { from: approved, to: expired, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
+}

package/std/lending.hsx

@@ -0,0 +1,115 @@
+header lending
+
+instrument round(borrower: party, capital: party, plan: ref<financing.installments> = object(financing.installments), months: integer(1, 366) = 3, profit: percent = 3%, 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."
+  fields {
+    borrower: account of borrower, capital: account(capital, cash, "capital"), plan: ref<plan>, price: money, closesAt: date
+    months: integer = months, profit: money = rate(self.price, profit)
+    minimumTicket: money = minimum_ticket, maximumTicket: money = rate(self.price, investor_cap)
+    held: account of self
+  }
+  lifecycle { states: [open, funded, failed], initial: open }
+  action create { requires unique "funding_plan" on [self.plan]; requires self.months == self.plan.months; requires self.profit == self.plan.profit; requires self.price == self.plan.principal; requires self.borrower == self.plan.funds.payer }
+  action close {
+    from: open, to: funded
+    requires sum "amount" of { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 } == self.price
+    requires self.held.balance == self.price
+    moves self.price from self.held to self.plan.capital
+    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 }, action: fund, input: {} }]
+  }
+  action fail {
+    from: open, to: failed, actor: clock, due: { at: self.closesAt }
+    requires self.held.balance < self.price
+    invoke: [{ selection: { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 }, action: refund, input: {} }]
+  }
+}
+
+instrument commitment(round: ref<lending.round>, wallet: ref<wallet.balance>, investor: party = party(person)) {
+  summary: "One investor's original-wallet contribution, capped cumulatively within the round."
+  fields { round: ref<round>, wallet: ref<wallet>, 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: { wallet: { field: self.wallet } } } <= self.round.maximumTicket
+  invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 366 } <= self.round.price
+  action create {
+    requires self.round in [open]
+    requires self.wallet in [active]
+    requires self.amount >= self.round.minimumTicket
+    deadline: { at: self.round.closesAt }
+    moves self.amount from self.wallet.held to self.round.held
+  }
+  action fund { from: committed, to: funded, actor: { parent: round } }
+  action withdraw {
+    from: committed, to: withdrawn
+    requires self.round in [open]
+    deadline: { at: self.round.closesAt }
+    moves self.amount from self.round.held to self.wallet.held
+  }
+  action refund {
+    from: committed, to: refunded, actor: { parent: round }
+    moves self.amount from self.round.held to self.wallet.held
+  }
+}
+
+instrument distribution(round: ref<lending.round>, receipt: ref, commitments: ref<lending.commitment> = object(lending.commitment), mode: enum(cash, loss) = cash, residual_to: party = programOperator, fee: percent = 1%, tax: percent = 15%) {
+  summary: "Frozen weighted shares, floored once, with residual assigned to the chosen party."
+  fields {
+    round: ref<round>, source: ref<receipt>, mode: enum(cash, loss) = mode
+    principal: money?, profit: money?, grossTotal: money?, charge: money?, vat: money?, net: money?
+    held: account of self, losses: account(self, claim), residualLoss: account(residual_to, claim, "loss")
+  }
+  lifecycle { states: [pending, cash_ready, loss_ready, distributed], initial: pending }
+  action create { requires self.round in [funded]; requires self.source.plan == self.round.plan; requires unique "settlement_consumption" on [self.source.plan, self.source.identity] }
+  action prepare_cash {
+    from: pending, to: cash_ready
+    requires self.mode == "cash"; requires self.source.kind == "cash"
+    calculate: [
+      { target: "principal", op: "sum", values: [{ field: self.source.principal }] }
+      { target: "profit", op: "sum", values: [{ field: self.source.profit }] }
+      { target: "charge", op: "rate", base: { field: self.profit }, bps: { literal: fee }, rounding: "floor" }
+      { target: "vat", op: "rate", base: { field: self.charge }, bps: { literal: tax }, rounding: "floor" }
+      { target: "grossTotal", op: "sum", values: [{ field: self.principal }, { field: self.profit }] }
+      { target: "net", op: "subtract", base: { field: self.grossTotal }, subtract: [{ field: self.charge }, { field: self.vat }] }
+    ]
+  }
+  action prepare_loss {
+    from: pending, to: loss_ready
+    requires self.mode == "loss"; requires self.source.kind == "loss"
+    calculate: [{ target: "net", op: "sum", values: [{ field: self.source.loss }] }]
+  }
+  action distribute_cash {
+    from: cash_ready, to: distributed
+    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 {
+    from: distributed, to: distributed, actor: { parent: current() }
+    moves self.held.balance from self.held to residual_to
+  }
+  action distribute_loss {
+    from: loss_ready, to: distributed
+    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 {
+    from: distributed, to: distributed, actor: { parent: current() }
+    moves self.losses.balance from self.losses to self.residualLoss
+  }
+  records {
+    share: {
+      fields {
+        distribution: ref<parent>, commitment: ref<commitments>
+        weight: money = self.commitment.amount
+        gross: money = ratio(self.distribution.net, self.weight, self.distribution.round.price)
+      }
+      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 {
+        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 }
+    }
+  }
+}

package/std/marketplace.hsx

@@ -0,0 +1,24 @@
+header marketplace
+
+instrument listing(seller: party) {
+  summary: "A seller's offer and its asking price."
+  fields { seller: account of seller, title: text, price: money }
+  lifecycle { states: [draft, active, withdrawn, sold], initial: draft }
+  action create { actor: { party: seller } }
+  action publish { from: draft, to: active, actor: { party: seller } }
+  action withdraw { from: active, to: withdrawn, actor: { party: seller } }
+  action sell { from: active, to: sold, actor: { party: seller } }
+}
+
+instrument order(listing: ref<marketplace.listing>, buyer: party) {
+  summary: "A buyer's order for one listing at its declared price."
+  fields { listing: ref<listing>, buyer: account of buyer, price: money }
+  lifecycle { states: [placed, fulfilled, cancelled], initial: placed }
+  action create {
+    actor: { party: buyer }
+    requires self.listing in [active]
+    requires self.price == self.listing.price
+  }
+  action fulfill { from: placed, to: fulfilled }
+  action cancel { from: placed, to: cancelled, actor: { party: buyer } }
+}

package/std/money.hsx

@@ -0,0 +1,195 @@
+header money
+
+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 pay {
+    from: pending, to: paid, actor: { party: payer }
+    moves self.amount from payer to payee
+  }
+  action cancel { from: pending, to: cancelled, actor: { party: payer } }
+}
+
+instrument hold(payer: party, payee: party, amount: money = runtime) {
+  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 }
+  lifecycle { states: [pending, funded, released, refunded, cancelled], initial: pending }
+  action create { }
+  action fund {
+    from: pending, to: funded, actor: { party: payer }
+    moves self.amount from payer to self.held
+  }
+  action confirm {
+    from: pending, to: funded
+    requires self.held.balance == self.amount
+  }
+  action release {
+    from: funded, to: released
+    moves self.amount from self.held to payee
+  }
+  action refund {
+    from: funded, to: refunded
+    moves self.amount from self.held to payer
+  }
+  action cancel { from: pending, to: cancelled }
+}
+
+instrument split(payer: party, amount: money = runtime, shares: split = { programOperator: 100% }) {
+  summary: "Split one amount; the last declared recipient receives the rounding remainder."
+  fields { amount: money = amount }
+  lifecycle { states: [pending, paid, cancelled], initial: pending }
+  action create {}
+  action pay { from: pending, to: paid, moves self.amount from payer shares shares }
+  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) }
+  lifecycle { states: [draft, active, complete, cancelled], initial: draft }
+  action create {}
+  action activate {
+    from: draft, to: active
+    requires count of { instrument: occurrence, reference: "schedule", anchor: self.id, states: [pending], limit: 366 } == self.count
+  }
+  action complete {
+    from: active, to: complete
+    requires count of { instrument: occurrence, reference: "schedule", anchor: self.id, states: [pending], limit: 366 } == 0
+  }
+  action cancel { from: [draft, active], to: cancelled }
+  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)
+      }
+      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 cancel { from: pending, to: cancelled, requires self.schedule in [cancelled] }
+    }
+  }
+}
+
+instrument pool(payer: party, payee: party, target: money, closes: date) {
+  summary: "Contributions fund one threshold or return to their original contributor."
+  fields { target: money = target, closesAt: date = closes, held: account of self }
+  lifecycle { states: [open, paid, failed], initial: open }
+  action create { }
+  action pay {
+    from: open, to: paid
+    requires self.held.balance == self.target
+    moves self.target from self.held to payee
+  }
+  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: {} }]
+  }
+  records {
+    contribution: {
+      fields { pool: ref<parent>, payer: account of payer, amount: money }
+      lifecycle { states: [pending, paid, refunded], initial: pending }
+      action create { requires self.pool in [open] }
+      action pay { from: pending, to: paid, deadline: { at: self.pool.closesAt }, requires self.pool in [open], 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 }
+    }
+  }
+}
+
+instrument swap(first: party, second: party, first_amount: money, second_amount: money, expires: date) {
+  summary: "Two reservations settle together or both return."
+  fields { firstAmount: money = first_amount, secondAmount: money = second_amount, expiresAt: date = expires, firstReceipt: text?, secondReceipt: text? }
+  lifecycle { states: [pending, first_ready, second_ready, both_ready, exchanged, cancelled], initial: pending }
+  action create {}
+  action fund_first { from: pending, to: first_ready, actor: { party: first }, deadline: { at: self.expiresAt }, moves reserve self.firstAmount from first to second capture "firstReceipt" }
+  action fund_second { from: first_ready, to: both_ready, actor: { party: second }, deadline: { at: self.expiresAt }, moves reserve self.secondAmount from second to first capture "secondReceipt" }
+  action start_second { from: pending, to: second_ready, actor: { party: second }, deadline: { at: self.expiresAt }, moves reserve self.secondAmount from second to first capture "secondReceipt" }
+  action finish_first { from: second_ready, to: both_ready, actor: { party: first }, deadline: { at: self.expiresAt }, moves reserve self.firstAmount from first to second capture "firstReceipt" }
+  action expire_second { from: second_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.secondReceipt }
+  action exchange { from: both_ready, to: exchanged, moves post self.firstReceipt; moves post self.secondReceipt }
+  action cancel { from: pending, to: cancelled }
+  action expire_first { from: first_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.firstReceipt }
+  action expire_both { from: both_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.firstReceipt; moves void self.secondReceipt }
+}
+
+instrument deposit(payer: party, payee: party, amount: money, expires: date, approval: approval) {
+  fields { amount: money = amount, expiresAt: date = expires, reservation: text? }
+  lifecycle { states: [pending, held, claimed, returned, cancelled], initial: pending }
+  action create {}
+  action fund { from: pending, to: held, actor: { party: payer }, moves reserve self.amount from payer to payee capture "reservation" }
+  action claim { from: held, to: claimed, deadline: { at: self.expiresAt }, requires approval by approval, moves post self.reservation }
+  action return { from: held, to: returned, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
+  action cancel { from: pending, to: cancelled }
+}
+
+instrument payout(payer: party, payee: party, amount: money = runtime, reconcile_within: duration = 3d) {
+  summary: "A bank-linked transfer with confirmation bound to its captured identity."
+  fields { amount: money = amount, bank: account(payee, cash, external, "bank"), receipt: text?, expectedAt: date = after(self.createdAt, reconcile_within) }
+  lifecycle { states: [pending, instructed, settled, exception, reversed], initial: pending }
+  action create {}
+  action instruct { from: pending, to: instructed, actor: { party: payer }, moves self.amount from payer to self.bank capture "receipt" }
+  action confirm {
+    from: [instructed, exception], to: settled
+    requires self.receipt.status == "settled"
+  }
+  action expire {
+    from: instructed, to: exception, actor: clock, due: { at: self.expectedAt }
+    requires self.receipt.status != "settled"
+  }
+  action reverse {
+    from: [instructed, exception], to: reversed
+    requires self.receipt.status == "reversed"
+  }
+}
+
+instrument metered(payer: party, payee: party, unit_price: money, units: integer = 1, fee: fee = { seller: 0% }) {
+  summary: "A unique usage event priced once at the fixed unit price."
+  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, moves self.amount from payer to payee fee fee }
+  action cancel { from: recorded, to: cancelled }
+}
+
+instrument batch(payer: party, payee: party, closes: date, approval: approval, reconcile_within: duration = 3d) {
+  summary: "A frozen positive net of credit and debit entries, paid once."
+  fields { closesAt: date = closes, credits: money, debits: money, amount: money = subtract(self.credits, self.debits), bank: account(payee, cash, external, "bank"), receipt: text?, instructedAt: date?, expectedAt: date? }
+  lifecycle { states: [open, closed, approved, instructed, exception, paid, reversed], initial: open }
+  action create {}
+  action close {
+    from: open, to: closed, actor: clock, due: { at: self.closesAt }
+    requires sum "amount" of { instrument: credit, reference: "batch", anchor: self.id, states: [recorded], limit: 366 } == self.credits
+    requires sum "amount" of { instrument: debit, reference: "batch", anchor: self.id, states: [recorded], limit: 366 } == self.debits
+    requires self.amount > "0"
+  }
+  action approve { from: closed, to: approved, requires approval by approval }
+  action pay {
+    from: approved, to: instructed
+    set: { instructedAt: { field: self.now } }
+    calculate: [{ target: "expectedAt", op: "shift", date: { field: self.now }, milliseconds: { literal: reconcile_within }, direction: "after" }]
+    moves self.amount from payer to self.bank capture "receipt"
+  }
+  action confirm { from: [instructed, exception], to: paid, requires self.receipt.status == "settled" }
+  action expire { from: instructed, to: exception, actor: clock, due: { at: self.expectedAt }, requires self.receipt.status != "settled" }
+  action reverse { from: [instructed, exception], to: reversed, requires self.receipt.status == "reversed" }
+  records {
+    credit: {
+      fields { batch: ref<parent>, identity: text, amount: money }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { requires self.batch in [open]; requires unique "batch_credit" on [self.identity] }
+    }
+    debit: {
+      fields { batch: ref<parent>, identity: text, amount: money }
+      lifecycle { states: [recorded], initial: recorded }
+      action create { requires self.batch in [open]; requires unique "batch_debit" on [self.identity] }
+    }
+  }
+}

package/std/savings.hsx

@@ -0,0 +1,44 @@
+header savings
+
+instrument circle(contribution: money, members: integer(1, 366), 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 }
+  action create { }
+  action activate {
+    from: forming, to: active, actor: clock, due: { at: self.startsAt }
+    requires count of { instrument: memberships, reference: "circle", anchor: self.id, states: [joined], limit: 60 } == self.members
+  }
+  action close {
+    from: active, to: closed
+    requires count of { instrument: memberships, reference: "circle", anchor: self.id, states: [paid], limit: 60 } == self.members
+    requires self.held.balance == "0"
+  }
+  action disband { from: forming, to: disbanded }
+}
+
+instrument membership(circle: ref<savings.circle>, member: party) {
+  fields { circle: ref<circle>, member: account of member, position: integer(1, 60), preceding: integer = subtract(self.position, 1), receivesAt: date = at(self.circle.dates, self.position), contribution: money = self.circle.contribution, total: money = self.circle.pot, dates: list(date, 60) }
+  lifecycle { states: [joined, active, paid, withdrawn], initial: joined }
+  action create { requires self.position <= self.circle.members; requires self.circle in [forming]; requires unique "circle_seat" on [self.circle, self.position]; requires unique "circle_member" on [self.circle, self.member] }
+  action activate {
+    from: joined, to: active
+    requires self.circle in [active]
+    requires count of { instrument: contribution, reference: "membership", anchor: self.id, states: [pending], limit: 60 } == self.circle.members
+  }
+  action receive {
+    from: active, to: paid, actor: clock, due: { at: self.receivesAt }
+    requires self.circle in [active]
+    requires count of { instrument: all(savings.membership), reference: "circle", anchor: self.circle, states: [paid], limit: 60 } == self.preceding
+    moves self.total from self.circle.held to self.member
+  }
+  action withdraw { from: joined, to: withdrawn, requires self.circle in [disbanded] }
+  records {
+    contribution: {
+      fields { membership: ref<parent>, position: integer(1, 60), dueAt: date = at(self.membership.circle.dates, self.position), amount: money = self.membership.contribution }
+      lifecycle { states: [pending, paid], initial: pending }
+      action create { requires self.position <= self.membership.circle.members; requires self.membership in [joined]; requires unique "seat_period" on [self.membership, self.position] }
+      action pay { from: pending, to: paid, actor: clock, due: { at: self.dueAt }, requires self.membership in [active, paid]; requires self.membership.circle in [active], moves self.amount from self.membership.member to self.membership.circle.held }
+    }
+  }
+}

package/std/travel.hsx

@@ -0,0 +1,98 @@
+header travel
+
+instrument package(price: money, supplier_cost: money, departure: date) {
+  constraints { supplier_cost: at_most(price) }
+  summary: "Immutable package price, supplier cost and departure."
+  fields { price: money = price, supplierCost: money = supplier_cost, departure: date = departure }
+  lifecycle { states: [draft, published, closed], initial: draft }
+  action create { requires self.supplierCost <= self.price }
+  action publish { from: draft, to: published }
+  action close { from: published, to: closed, actor: clock, due: { at: self.departure } }
+}
+
+instrument booking(package: ref<travel.package>, buyer: party, supplier: approval, cover: ref<insurance.cover>, deposit: percent = 30%, balance_before: duration = 14d, confirm_within: duration = 24h, tax: percent = 15%, early_before: duration = 30d, middle_before: duration = 15d, middle_penalty: percent = 10%, late_penalty: percent = 30%) {
+  constraints { early_before: greater_than(middle_before) }
+  summary: "A deposited booking with three cancellation bands and supplier confirmation."
+  fields {
+    package: ref<package>, bookingReference: text, buyer: account of buyer, supplier: account of supplier
+    price: money = self.package.price, supplierCost: money = self.package.supplierCost
+    deposit: money = rate(self.price, deposit), balance: money = subtract(self.price, self.deposit)
+    margin: money = subtract(self.price, self.supplierCost)
+    tax: money = rate(self.margin, tax), operatorNet: money = subtract(self.margin, self.tax)
+    middlePenalty: money = rate(self.supplierCost, middle_penalty)
+    latePenalty: money = rate(self.supplierCost, late_penalty)
+    balanceAt: date = before(self.package.departure, balance_before)
+    earlyAt: date = before(self.package.departure, early_before)
+    middleAt: date = before(self.package.departure, middle_before)
+    lateAt: date = after(self.middleAt, 1ms)
+    confirmBy: date = after(self.package.departure, confirm_within)
+    held: account of self
+    refund: money?, retainedMargin: money?, retainedTax: money?, retainedNet: money?
+  }
+  lifecycle { states: [created, deposit_paid, paid, completed, cancelled, refunded], initial: created }
+  action create {
+    requires self.package in [published]
+    requires unique "booking_reference" on [self.bookingReference]
+  }
+  action deposit {
+    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 {
+    from: deposit_paid, to: paid, actor: { party: buyer }, deadline: { at: self.balanceAt }
+    moves self.balance from buyer to self.held
+  }
+  action confirm {
+    from: paid, to: completed, actor: { party: supplier }
+    due: { at: self.package.departure }, deadline: { at: self.confirmBy }
+    requires approval by supplier
+    moves self.supplierCost from self.held to supplier
+    moves self.tax from self.held to programTax
+    moves self.operatorNet from self.held to programOperator
+  }
+  action timeout {
+    from: paid, to: refunded, actor: clock, due: { at: self.confirmBy }
+    moves self.price from self.held to buyer
+  }
+  action cancel_early {
+    from: [deposit_paid, paid], to: cancelled, deadline: { at: self.earlyAt }
+    moves self.held.balance from self.held to buyer
+  }
+  action cancel_middle {
+    from: [deposit_paid, paid], to: cancelled, due: { at: self.earlyAt }, deadline: { at: self.lateAt }
+    calculate: [
+      { target: refund, op: "subtract", base: { field: self.held.balance }, subtract: [{ field: self.deposit }] }
+      { target: retainedMargin, op: "subtract", base: { field: self.deposit }, subtract: [{ field: self.middlePenalty }] }
+      { target: retainedTax, op: "rate", base: { field: self.retainedMargin }, bps: { literal: tax }, rounding: "floor" }
+      { target: retainedNet, op: "subtract", base: { field: self.retainedMargin }, subtract: [{ field: self.retainedTax }] }
+    ]
+    moves self.refund from self.held to buyer
+    moves self.middlePenalty from self.held to supplier
+    moves self.retainedTax from self.held to programTax
+    moves self.retainedNet from self.held to programOperator
+  }
+  action cancel_late {
+    from: [deposit_paid, paid], to: cancelled, actor: caller, due: { at: self.lateAt }
+    calculate: [
+      { target: retainedMargin, op: "subtract", base: { field: self.held.balance }, subtract: [{ field: self.latePenalty }] }
+      { target: retainedTax, op: "rate", base: { field: self.retainedMargin }, bps: { literal: tax }, rounding: "floor" }
+      { target: retainedNet, op: "subtract", base: { field: self.retainedMargin }, subtract: [{ field: self.retainedTax }] }
+    ]
+    moves self.latePenalty from self.held to supplier
+    moves self.retainedTax from self.held to programTax
+    moves self.retainedNet from self.held to programOperator
+  }
+  action default_balance {
+    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 }] }
+      { target: retainedTax, op: "rate", base: { field: self.retainedMargin }, bps: { literal: tax }, rounding: "floor" }
+      { target: retainedNet, op: "subtract", base: { field: self.retainedMargin }, subtract: [{ field: self.retainedTax }] }
+    ]
+    moves self.latePenalty from self.held to supplier
+    moves self.retainedTax from self.held to programTax
+    moves self.retainedNet from self.held to programOperator
+  }
+}

package/std/wallet.hsx

@@ -0,0 +1,41 @@
+header wallet
+
+instrument balance(holder: party, spend_limit: money = 100000 SAR) {
+  summary: "A holder's reusable balance with an immutable per-spend ceiling."
+  fields { holder: account of holder, held: account of self, spendLimit: money = spend_limit }
+  lifecycle { states: [pending, active, frozen, closed], initial: pending }
+  action create { }
+  action activate { from: pending, to: active, actor: { party: holder } }
+  action topup {
+    from: active, to: active, actor: { party: holder }
+    input { amount: money }
+    moves input.amount from holder to self.held
+  }
+  action withdraw {
+    from: active, to: active, actor: { party: holder }
+    input { amount: money }
+    moves input.amount from self.held to holder
+  }
+  action freeze { from: active, to: frozen, }
+  action unfreeze { from: frozen, to: active, }
+  action close { from: [pending, active], to: closed, requires self.held.balance == "0" }
+}
+
+instrument spend(wallet: ref<wallet.balance>, payee: party) {
+  summary: "Reserve one wallet spend, then post or void the same reservation."
+  fields { wallet: ref<wallet>, amount: money, expiresAt: date, reservation: text? }
+  lifecycle { states: [pending, reserved, paid, cancelled, expired], initial: pending }
+  action create {
+    requires self.wallet in [active]
+    requires self.amount <= self.wallet.spendLimit
+  }
+  action reserve {
+    from: pending, to: reserved
+    requires self.wallet in [active]
+    deadline: { at: self.expiresAt }
+    moves reserve self.amount from self.wallet.held to payee capture "reservation"
+  }
+  action pay { from: reserved, to: paid, moves post self.reservation }
+  action cancel { from: reserved, to: cancelled, moves void self.reservation }
+  action expire { from: reserved, to: expired, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
+}

package/dist/src/diagnostics.d.ts

@@ -1,13 +0,0 @@
-export interface HsxDiagnosticCatalogEntry {
-    readonly code: `HSX${number}`;
-    readonly stage: "bind" | "lower" | "parse" | "typecheck";
-    readonly title: string;
-    readonly fix: string;
-    readonly example: string | null;
-    readonly reason?: string;
-}
-/** Stable public descriptions for every diagnostic code emitted by HSX. */
-export declare const hsxDiagnostics: readonly HsxDiagnosticCatalogEntry[];
-/** Preserve the UDL diagnostic family when reporting a typed clause. */
-export declare function hsxClauseDiagnosticCode(code: string): string;
-//# sourceMappingURL=diagnostics.d.ts.map

package/dist/src/diagnostics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAiBD,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,SAAS,yBAAyB,EAqkBrD,CAAC;AAEX,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU5D"}