@hyperscale0/hsx 5.4.0 → 5.4.2

package/src/version.ts

@@ -1 +1 @@
-export const HSX_VERSION = "5.4.0";
+export const HSX_VERSION = "5.4.2";

package/std/cards.hsx

@@ -12,6 +12,10 @@ header cards
 // Disputes need a posted transaction, issuer review and win before their deadline;
 // win invokes the same refund. The alias never changes the declared action actor.
 
+// Cost: authorization approve, capture and reverse each declare one transfer
+// instruction. Transaction refund declares one transfer; a successful dispute
+// invokes that refund. Card state changes alone declare no transfers.
+
 instrument cardholder(holder: party) {
   summary: "An account holder whose card access can be activated, suspended or closed."
   fields { holder: account of holder }

package/std/collections.hsx

@@ -11,6 +11,10 @@ header collections
 // before_due/overdue are clock-owned and require active debt. Scheduled admission
 // does not prove delivery or retry. No collector can infer authority from an alias.
 
+// Cost: case recovery invokes the linked payment and then charges its agency
+// fee. Its count includes those child effects. Contact and reminder delivery costs
+// are not provider prices in hsx cost; the executor supplies commercial tariffs.
+
 instrument case(on: ref<financing.installments>[], agency: party, capital: party = programOperator, overdue: duration = 3d, fee: percent = 20%) {
   revisioned: true
   summary: "Refer an overdue installment without creating another debt."

package/std/escrow.hsx

@@ -11,6 +11,10 @@ header escrow
 // it returns its credited balance to payer before cancelling. Confirm requires
 // the whole captured price in held. This flow has no partial release or refund.
 
+// Cost: create declares one owned account. Fund and refund each declare one
+// transfer; accept expands the configured fee and tax into moves. Run hsx cost
+// on the composed program for instruction counts. The executor supplies prices.
+
 instrument hold(payer: party = party(person), payee: party = programOperator, accept_within: duration = 48h, fee: fee = { seller: 0%, tax: 0% }, dispute: policy = { refund_after: return_verified }) {
   revisioned: true
   summary: "Hold the subject price through delivery, acceptance and verified return."

package/std/financing.hsx

@@ -22,6 +22,10 @@ header financing
 // not evidence of outside funding. Caller-authorized limit approvals and advances
 // need the Product's operation authority. No clock declaration proves retries.
 
+// Cost: installments include cash and claim moves, child-account creation and
+// bounded invocations across slices and assessments. Month and charge limits affect
+// the bound. Run hsx cost on the selected policies; profit is not a platform tariff.
+
 instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3, profit: percent, disburse_to: enum(funds, borrower) = funds, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref<escrow.hold>?, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits), portfolio: ref<financing.portfolio_limit> = object(financing.portfolio_limit)) {
   dependencies {
     funds {

package/std/insurance.hsx

@@ -15,6 +15,10 @@ header insurance
 // Inspector is a bound party, not necessarily staff. These are ledger transfers;
 // outside settlement needs the boundary protocol, not a claim of provider success.
 
+// 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.
+
 instrument cover(holder: party, adapter: text, commission: percent = 0%, broker: party = programOperator, covers: ref, premium: 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 }

package/std/lending.hsx

@@ -14,6 +14,10 @@ header lending
 // floored residual goes to residual_to. Loss mode moves claim balances, not cash.
 // Child share execution is parent-owned. No report or clock proves outside payout.
 
+// 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.
+
 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."
   fields {

package/std/marketplace.hsx

@@ -14,6 +14,10 @@ header marketplace
 // cancellation return the whole reservation balance. Converted money is in escrow,
 // so subsequent return verification and refund use the escrow aliases.
 
+// Cost: listing and order actions declare no transfers. Reservation.create
+// declares one owned account; activate declares one deposit transfer. Cancellation
+// and credit split that balance into moves. Run hsx cost for the composed counts.
+
 instrument listing(seller: party) {
   revisioned: true
   summary: "A seller's offer and its asking price."

package/std/money.hsx

@@ -13,6 +13,10 @@ header money
 // matching terminal instruction evidence. An acknowledgement cannot settle it.
 // Metered bill charges a unique usage identity at the fixed unit price.
 
+// 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
+// child invocations. Run hsx cost on the composed program for counts, not SAR prices.
+
 instrument transfer(payer: party, payee: party, amount: money = runtime) {
   summary: "One transfer between the bound parties."
   fields { amount: money = amount }

package/std/reporting.hsx

@@ -10,6 +10,10 @@ header reporting
 // explicitly refuse until their unavailable governed facts exist. No bureau
 // submission, provider layout, external transport or restructuring proof is supplied.
 
+// Cost: portfolio.create declares no transfers, owned accounts or invocations.
+// That zero instruction count does not price report capture, rendering, storage or
+// release. The host owns those charges and their execution.
+
 instrument portfolio(on: ref<financing.installments>[], default_days: integer(1, 3650) = 90, retention_years: integer(1, 100) = 10, aging_first_days: integer(1, 3650) = 30, aging_second_days: integer(1, 3650) = 60, aging_third_days: integer(1, 3650) = 90, ratio_scale: integer(1, 1000000) = 10000, ratio_rounding: enum(floor, halfUp) = floor, lock_wait_ms: integer(1, 2000) = 2000, capture_ms: integer(1, 10000) = 10000, max_rows: integer(1, 100000) = 10000, max_join_rows: integer(1, 1000000) = 100000, max_bytes: integer(1024, 16777216) = 8388608) {
   summary: "Declared financing reports evaluated over frozen Product facts."
   fields {}

package/std/savings.hsx

@@ -17,6 +17,10 @@ header savings
 // Circle.close needs every membership received and an empty held account.
 // Circle creation collects circleDates, one date per member for contributions and payouts.
 
+// Cost: circle.create declares one owned account. Each contribution payment
+// and each pot payout declares one transfer. Multiply by the actual member and
+// period counts for a completed circle; hsx cost reports per-action bounds.
+
 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, circleDates: list(date, members), pot: money = multiply(self.contribution, self.members), held: account of self }

package/std/travel.hsx

@@ -18,6 +18,11 @@ header travel
 // price from paid only. A penalty above held cash or retained deposit refuses;
 // this header does not subsidize a shortfall or reduce the configured penalty.
 
+// Cost: booking.create declares one owned account. Deposit also invokes premium
+// collections; cancellation declares the selected refund, penalty, tax and retained
+// moves. Run hsx cost for bounded counts. Supplier penalties are business terms,
+// not compiler or executor fees.
+
 instrument package(price: money, supplier_cost: money, departure: date) {
   constraints { supplier_cost: at_most(price) }
   summary: "Immutable package price, supplier cost and departure."

package/std/wallet.hsx

@@ -9,6 +9,10 @@ header wallet
 // Existing reservations may still post after the wallet freezes. There is no
 // daily aggregate limit, partial spend or card-network settlement in this header.
 
+// Cost: balance.create declares one owned account; topup and withdraw each
+// declare one transfer. Spend reserve, pay and cancel each declare one transfer
+// instruction. These are counts, not the executor tariff.
+
 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 }