@hyperscale0/hsx 1.0.0 → 2.0.1

package/src/version.ts

@@ -1,5 +1,5 @@
 /** Package version reported by the command line. */
-export const HSX_VERSION = "1.0.0";
+export const HSX_VERSION = "2.0.1";
 
 /** Canonical UDL contract version emitted by this compiler. */
 export const HSX_TARGET_UDL_VERSION = 1;

package/std/SEMANTICS.md

@@ -1,9 +1,8 @@
 # Settlement semantics frozen before legacy teardown
 
 This note records the behavior that the former archetype branches emitted on
-2026-09-01. The 48 canonical documents under
-`test/fixtures/general-path-oracle/` are the byte-level authority. This note is
-the human porting index.
+2026-09-01. The in-place compiler family specs under `test/` are the semantic
+authority. This note is the human porting index.
 
 ## Direct and held payments
 
@@ -34,6 +33,12 @@ the human porting index.
   amount. Void and expiry release the reserve. Correction and external reversal
   use their declared ports and windows. Derived fees use the same floor,
   partition, bearer, and position rules as direct payment.
+- `cancellable_booking` holds the booking amount in escrow away from guest and
+  host until the booking ends or is cancelled. Cancellation quotes a penalty
+  against the time remaining before the start date, frozen with offer life.
+  Lifecycle moves through `created`, `held`, `cancellation_quoted`, `canceled`,
+  `settled`, and `completed`. Penalty retention moves penalty funds to host and
+  remainder to guest; completion releases full amount to host.
 - `premium_forward` holds premium pieces, then forwards the net pieces after a
   bind decision. It can abandon unbound custody. Policy reference, renewal due,
   endorsement evidence, and lapse actions appear only when declared. Its fee
@@ -128,3 +133,7 @@ the human porting index.
   beneficiary for that cycle. The final close requires the escrow account to be
   drained. Its referenced-membership form delegates those member cycles to a
   published membership instrument and emits only the parent.
+- `reconciled_payout` instructs an external payout with a tolerance dial,
+  waits for a matching bank debit statement line, and treats unmatched amounts
+  at the settle date as break rows. Lifecycle moves through `created`,
+  `instructed`, and `settled`.

package/std/{settlements → money_flows}/advance.hsx

@@ -1,4 +1,4 @@
-module std.settlements.advance
+module std.money_flows.advance
 
 export instrument advance<C>(
   funder: party,

package/std/{settlements → money_flows}/cancellable_booking.hsx

@@ -1,4 +1,4 @@
-module std.settlements.cancellable_booking
+module std.money_flows.cancellable_booking
 
 export instrument cancellable_booking<C>(
   guest: party,
@@ -19,8 +19,8 @@ export instrument cancellable_booking<C>(
     amount { type: money<C>; description: concat("Booking price in minor units, held away from both the ", words(guest), " and the ", words(host), " until the booking ends"); }
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     starts_at { type: date; description: "When the booking starts; the cancellation penalty is priced against the time left before it"; }
-    [guest_account_field] { type: account<C>; description: concat("The ", words(guest), " account the booking is taken from and the refund returns to"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
-    [host_account_field] { type: account<C>; description: concat("The ", words(host), " account the booking and any penalty end up in"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+    [guest_account_field] { type: account<C>; description: concat("The ", words(guest), " account the booking is taken from and the refund returns to"); [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+    [host_account_field] { type: account<C>; description: concat("The ", words(host), " account the booking and any penalty end up in"); [reference_filter_key]: { column: role; values: [customer_balance]; }; }
   }
   lifecycle {
     states created held cancellation_quoted canceled settled completed;
@@ -48,6 +48,7 @@ export instrument cancellable_booking<C>(
     agent_description: concat("Move the whole booking price out of the ", words(guest), " account into the holding account. This moves money. Only a created booking takes. Neither party can spend the money until the booking completes or a cancellation is confirmed.");
     summary: concat("Take the booking price from the ", words(guest), " into the holding account");
     moves: [{ key: booking; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", amount); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.bookingHoldingAccountId; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", guest_account_field); }; }; capture: { bookingTransferId: transferId; }; }];
+    sandbox_failure_point: funding;
     steps: [];
   }
   action complete {

package/std/{settlements → money_flows}/captured_payment.hsx

@@ -1,4 +1,4 @@
-module std.settlements.captured_payment
+module std.money_flows.captured_payment
 
 export instrument captured_payment<C>(payer: party, payee: party, amount: money<C>, reserve_until: date, correction: condition, external_reversal: condition, capture_mode: text, correction_mode: text, negative_position: text, timeout: text, derived_amount: optional<block>) {
   let(correction_name): correction;
@@ -22,7 +22,6 @@ export instrument captured_payment<C>(payer: party, payee: party, amount: money<
       platformAccountId {
         type: account<C>;
         description: "The product fee collection account";
-        pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
         [fee_collection_key]: true;
         [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
       }
@@ -69,6 +68,7 @@ export instrument captured_payment<C>(payer: party, payee: party, amount: money<
     agent_description: "Reserve the {amount} against the {payer} in the {payee}'s favor until {reserve_until}. The payment must be created. The money is held, not paid: capture and settle post it, void and expiry release it.";
     summary: "Reserve the {amount} until {reserve_until}";
     moves: [{ key: reservation; amount: amount; from: payer; to: beneficiary; operation: reserve; }];
+    sandbox_failure_point: funding;
     steps: [];
   }
   action capture {
@@ -77,6 +77,7 @@ export instrument captured_payment<C>(payer: party, payee: party, amount: money<
     deadline { field: reserve_until; };
     input { type: object; additional_properties: false; properties: { captureAmount: { description: "Positive partial capture amount in minor units"; pattern: "^[1-9][0-9]{0,17}$"; type: string; }; }; required: [captureAmount]; }
     moves: [{ key: post; operation: internal_transfer.post; bind: { amount: { from: input; path: captureAmount; }; currency: { from: instance; path: fields.currency; }; postMode: { from: const; value: partial_only; }; transferId: { from: instance; path: refs.authorizeReservationTransferId; }; }; capture: { capturedAmount: postedAmount; }; }];
+    sandbox_failure_point: "release";
     steps: [];
   }
   action capture_more {
@@ -122,7 +123,22 @@ export instrument captured_payment<C>(payer: party, payee: party, amount: money<
     let(correction_capture): camel(concat(correction_name, "_transfer_transfer_id"));
     agent_description: "Return the whole captured amount to the {payer} after the payment settled. Only a settled payment corrects, and only the party the product authorized may call it. The money moves back and there is no undo.";
     summary: "Return the full captured amount on payee correction";
-    port { allowed_parties: [if_eq(at(correction_allowed, 1), payee, "beneficiary", "payer")]; };
+    when(correction_fields) {
+      input {
+        type: object;
+        additional_properties: false;
+        properties {
+          for input_name in keys(correction_fields) {
+            [input_name]: get(correction_fields, input_name);
+          }
+        }
+        required: keys(correction_fields);
+      }
+      capture_input: {
+        for item in keys(correction_fields) { [item]: item; }
+      };
+    }
+    port { allowed_parties: correction_allowed; };
     moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: refs.capturedAmount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payer, "AccountId"); }; [metadata_clawback]: { from: instance; path: refs.authorizeReservationTransferId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: correction_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payee, "AccountId"); }; }; capture: { [correction_capture]: transferId; }; }];
     steps: [];
   }
@@ -134,10 +150,23 @@ export instrument captured_payment<C>(payer: party, payee: party, amount: money<
     let(reversal_capture): camel(concat(reversal_name, "_transfer_transfer_id"));
     agent_description: "Return the whole captured amount to the {payer} on an external reversal. The payment must be settled and the call must land before reversalUntil. The caller passes externalReference, which stays in the receipt. There is no undo.";
     summary: "Return the full captured amount on an external reversal";
-    capture(input) { externalReference: externalReference; };
     deadline { field: reversalUntil; };
-    input { type: object; additional_properties: false; properties: { externalReference: { description: "Required decision reference retained in the operation receipt"; max_length: 180; min_length: 1; type: string; }; }; required: [externalReference]; }
-    port { allowed_parties: [if_eq(at(external_reversal_allowed, 1), payee, "beneficiary", "payer")]; };
+    when(external_reversal_fields) {
+      capture_input: {
+        for item in keys(external_reversal_fields) { [item]: item; }
+      };
+      input {
+        type: object;
+        additional_properties: false;
+        properties {
+          for input_name in keys(external_reversal_fields) {
+            [input_name]: get(external_reversal_fields, input_name);
+          }
+        }
+        required: keys(external_reversal_fields);
+      }
+    }
+    port { allowed_parties: external_reversal_allowed; };
     moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: refs.capturedAmount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payer, "AccountId"); }; [metadata_clawback]: { from: instance; path: refs.authorizeReservationTransferId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: reversal_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payee, "AccountId"); }; }; capture: { [reversal_capture]: transferId; }; }];
     steps: [];
   }

package/std/{settlements → money_flows}/conditional_disbursement.hsx

@@ -1,4 +1,4 @@
-module std.settlements.conditional_disbursement
+module std.money_flows.conditional_disbursement
 
 export instrument conditional_disbursement<C>(
   source: party,
@@ -48,21 +48,22 @@ export instrument conditional_disbursement<C>(
   action deny {
     agent_description: "Refuse the whole disbursement without moving money. Every child amount under it must still be unapproved, so call this before any approval lands. The caller passes evidenceReference, which stays in the receipt. Denial is final.";
     summary: "Record a denial without moving money";
-    input: {
-      additional_properties: false;
-      properties: {
-        evidence_reference: {
-          description: "Required decision reference retained in the operation receipt";
-          max_length: 180;
-          min_length: 1;
-          type: "string";
-        };
+    when(decision_fields) {
+      input {
+        type: object;
+        additional_properties: false;
+        properties {
+          for input_name in keys(decision_fields) {
+            [input_name]: get(decision_fields, input_name);
+          }
+        }
+        required: keys(decision_fields);
+      }
+      capture_input: {
+        for item in keys(decision_fields) { [item]: item; }
       };
-      required: [evidenceReference];
-      type: "object";
-    };
-    capture_input: { decision_evidence_reference: evidenceReference; };
-    port: { allowed_parties: [payer]; };
+    }
+    port { allowed_parties: decision_allowed; };
     requires aggregate: {
       check: { kind: all_in; };
       instrument_id: child_id;
@@ -144,7 +145,7 @@ export instrument conditional_disbursement<C>(
           type: "object";
         };
         capture_input: { decision_evidence_reference: evidenceReference; };
-        port: { allowed_parties: [payer]; };
+        port: { allowed_parties: decision_allowed; };
         requires exposure: {
           amount_field: child_amount;
           anchor_field: parent_field;

package/std/{settlements → money_flows}/credit_facility.hsx

@@ -1,4 +1,4 @@
-module std.settlements.credit_facility
+module std.money_flows.credit_facility
 
 export instrument credit_facility<C>(
   lender: party,
@@ -32,7 +32,6 @@ export instrument credit_facility<C>(
     [borrower_field] {
       type: account<C>;
       description: "The {borrower} account";
-      pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
       [reference_filter]: {
         column: role;
         values: [customer_balance];

package/std/{settlements → money_flows}/held_payment.hsx

@@ -1,13 +1,8 @@
-module std.settlements.held_payment
+module std.money_flows.held_payment
 
 export instrument held_payment<C>(payer: party, payee: party, amount: money<C>, release: condition, fees: optional<block>, on_cancel: optional<block>, derived_amount: optional<block>, release_to: optional<party>, whole_amount: optional<block>, release_action: optional<text>, whole_fee: optional<money<C>>, reference: optional<text>, upstream: optional<ref>, id_prefix_override: optional<text>) {
   let(release_name): release;
-  let(release_actor): at(release_allowed, 1);
-  let(release_actor_2): at(release_allowed, 2);
-  let(release_multiple): lt(1, len(release_allowed));
-  let(release_role): if_eq(release_actor, payer, "payer", "beneficiary");
-  let(release_role_2): if_eq(release_actor_2, payer, "payer", "beneficiary");
-  let(release_actor_text): if_eq(len(release_allowed), 2, concat(words(release_actor), " or ", words(release_actor_2)), words(release_actor));
+  let(release_actor_text): if_eq(len(release_allowed), 1, words(at(release_allowed, 1)), concat("a party allowed by ", release));
   let(payer_account_field): camel(concat(payer, "_account_id"));
   let(payee_account_field): camel(concat(payee, "_account_id"));
   let(release_to_account_field): camel(concat(release_to, "_account_id"));
@@ -54,12 +49,11 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
     let(fee_collection_key): "x-hyperscale-fee-collection-port";
     let(reference_filter_key): "x-hyperscale-reference-filter";
     when(release_to) {
-      [release_to_account_field] { type: account<C>; description: concat("The ", words(release_to), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+      [release_to_account_field] { type: account<C>; description: concat("The ", words(release_to), " account"); [reference_filter_key]: { column: role; values: [customer_balance]; }; }
     }
     platformAccountId {
       type: account<C>;
       description: "The product fee collection account";
-      pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
       [fee_collection_key]: true;
       [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
     }
@@ -107,18 +101,18 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
   lifecycle {
     when_not(payee_fee) {
       when_not(cancel_splits) {
-        states created funded released;
+        states created funded disputed released;
         when(on_cancel) { states cancelled; }
         states abandoned;
       }
-      when(cancel_splits) { states created funding_1 funded releasing_1 released cancelling_1 cancelled abandoned; }
+      when(cancel_splits) { states created funding_1 funded disputed releasing_1 released cancelling_1 cancelled abandoned; }
     }
     when(payee_fee) {
-      when_not(on_cancel) { states created funding_1 funded releasing_1 released abandoned; }
+      when_not(on_cancel) { states created funding_1 funded disputed releasing_1 released abandoned; }
       when(on_cancel) {
-        when_eq(payer_fee_kind, percent) { states created funding_1 funding_2 funding_3 funded releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned abandoning_2; }
-        when_eq(payer_fee_kind, none) { states created funding_1 funding_2 funded releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned; }
-        when_eq(payer_fee_kind, binding) { states created funding_1 funding_2 funded releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned; }
+        when_eq(payer_fee_kind, percent) { states created funding_1 funding_2 funding_3 funded disputed releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned abandoning_2; }
+        when_eq(payer_fee_kind, none) { states created funding_1 funding_2 funded disputed releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned; }
+        when_eq(payer_fee_kind, binding) { states created funding_1 funding_2 funded disputed releasing_1 releasing_2 released cancelling_1 cancelling_2 cancelled abandoning_1 abandoned; }
       }
     }
     initial created;
@@ -172,6 +166,8 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         on unfund_piece_1: funding_1 | abandoning_1 -> abandoned;
       }
     }
+    on dispute: funded -> disputed;
+    on resume: disputed -> funded;
     on abandon: created -> abandoned;
   }
   parties {
@@ -193,6 +189,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         agent_description: concat("Move piece 2 of the split amount from the ", words(payer), " into escrow. Piece 1 must be in escrow first. It debits the ", words(payer), " for real, and the hold is still short of funded until piece 3 lands.");
         summary: "Fund piece 2 of the held amount into escrow";
         moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece2Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.escrowAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece2TransferTransferId: transferId; }; }];
+        sandbox_failure_point: funding;
         steps: [];
       }
       action fund_piece_3 {
@@ -202,6 +199,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         agent_description: concat("Move piece 3 of the split amount from the ", words(payer), " into escrow. Pieces 1 and 2 must be in escrow first. It debits the ", words(payer), " for real. Where the product charges a percentage payer fee, one more call collects that fee before the hold counts as funded.");
         summary: "Fund piece 3 of the held amount into escrow";
         moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece3Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.escrowAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_3; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece3TransferTransferId: transferId; }; }];
+        sandbox_failure_point: funding;
         steps: [];
       }
       when_eq(payer_fee_kind, percent) {
@@ -346,6 +344,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
       }
     }
     when_eq(payer_fee_kind, binding) { moves: [{ key: service_fee; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", payer_fee); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: fields.platformAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_1; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece1ServiceFeeTransferId: transferId; }; }]; }
+    sandbox_failure_point: funding;
     steps: [];
   }
   action [release_name] {
@@ -362,14 +361,13 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         additional_properties: false;
         properties {
           for input_name in keys(release_fields) {
-            [input_name] { type: string; description: "Required decision reference retained in the operation receipt"; max_length: 180; min_length: 1; }
+            [input_name]: get(release_fields, input_name);
           }
         }
         required: keys(release_fields);
       }
     }
-    when_not(release_multiple) { port { allowed_parties: [release_role]; }; }
-    when(release_multiple) { port { allowed_parties: [release_role, release_role_2]; }; }
+    port { allowed_parties: release_allowed; };
     when_not(payee_fee) {
       when_not(cancel_splits) {
         when_not(release_to) { moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", amount); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payee_account_field); }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: release_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: refs.escrowAccountId; }; }; capture: { [release_capture]: transferId; }; }]; }
@@ -378,6 +376,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
       when(cancel_splits) { moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece1Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payee_account_field); }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: release_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: refs.escrowAccountId; }; }; capture: { [release_capture]: transferId; }; }]; }
     }
     when(payee_fee) { moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece1Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payee_account_field); }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: release_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: refs.escrowAccountId; }; }; capture: { [release_capture]: transferId; }; }]; }
+    sandbox_failure_point: "release";
     steps: [];
   }
   when(release_deadline) {
@@ -422,6 +421,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         summary: "Fund piece 2 of the held amount into escrow";
         when_eq(payee_fee_kind, percent) { moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece2Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.escrowAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece2TransferTransferId: transferId; }; }]; }
         when_eq(payee_fee_kind, binding) { moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", payee_fee); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.escrowAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece2TransferTransferId: transferId; }; }]; }
+        sandbox_failure_point: funding;
         steps: [];
       }
       action release_piece_2 {
@@ -454,6 +454,7 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
         agent_description: concat("Move piece 2 of the split amount from the ", words(payer), " into escrow, which completes funding. Piece 1 must be in escrow first. It debits the ", words(payer), " for real, and the whole held amount then sits in escrow.");
         summary: "Fund piece 2 of the held amount into escrow";
         moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.piece2Amount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: refs.escrowAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: fund_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { fundPiece2TransferTransferId: transferId; }; }];
+        sandbox_failure_point: funding;
         steps: [];
       }
       action release_piece_2 {
@@ -492,6 +493,21 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
     moves: [];
     steps: [];
   }
+  action dispute {
+    agent_description: concat("Freeze a funded ", words(instrument), " so neither release nor refund can run until the parties settle the disagreement. No money moves and the whole balance stays put. Only a funded ", words(instrument), " disputes.");
+    description: concat("Freezes funded ", words(instrument), ", preserving the entire balance while the parties decide what happens next.");
+    summary: concat("Dispute a ", words(instrument), " settlement");
+    when(release_deadline) { deadline { field: release_deadline; }; }
+    moves: [];
+    steps: [];
+  }
+  action resume {
+    agent_description: concat("Lift the dispute hold and put the ", words(instrument), " back where it was, funded and ready to release. No money moves and the balance was never touched. Only a disputed ", words(instrument), " resumes. Use this when the parties settled without a refund.");
+    description: concat("Ends the dispute hold without moving money and returns the fully funded ", words(instrument), " to its first milestone.");
+    summary: concat("Resume a ", words(instrument), " settlement");
+    moves: [];
+    steps: [];
+  }
   }
   when(whole_amount) {
     let(fee_collection_key): "x-hyperscale-fee-collection-port";
@@ -502,26 +518,31 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
     summary: concat("Escrow-held payment from ", words(payer), " to ", words(payee));
     description: concat("Held payment: the ", words(payer), " funds ", amount, " into this settlement's own escrow; ", release_actor_text, " confirms through ", release, " to release");
     distinct_parties: true;
-    caller_parked_states: { created: "The tenant either funds the hold or abandons it before any money moves."; };
+    caller_parked_states: {
+      created: "The tenant either funds the hold or abandons it before any money moves.";
+      disputed: "Dispute resolution is a human judgment; the parties resume the hold to continue.";
+    };
     fields {
       currency { type: text; description: "One currency for the hold and its fee"; const: C; }
       amount { type: money<C>; description: "Amount held in custody, in {C} minor units"; }
-      [payee]AccountId { type: account<C>; description: "Party the hold protects and pays on release"; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
-      [payer]AccountId { type: account<C>; description: "Party whose money is held until the hold resolves"; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
-      platformAccountId { type: account<C>; description: "Product revenue or customer balance account collecting the custody fee"; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [fee_collection_key]: true; [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; }; }
+      [payee]AccountId { type: account<C>; description: "Party the hold protects and pays on release"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+      [payer]AccountId { type: account<C>; description: "Party whose money is held until the hold resolves"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+      platformAccountId { type: account<C>; description: "Product revenue or customer balance account collecting the custody fee"; [fee_collection_key]: true; [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; }; }
       when(reference) { reference { type: text; description: "The tenant's own identifier for what is held: invoice number, project code, contract reference"; optional: true; max_length: 180; min_length: 1; } }
       [release_deadline] { type: date; description: "Date the hold releases to the payee on its own; fixed at creation and the cutoff for both the release port and cancellation"; }
       whole_fee { type: money<C>; description: "Custody fee charged on top at funding and never placed in escrow"; }
       when(upstream) { upstream { type: ref<instrument>; description: "Hold this one is carved out of, when a chain of holds passes the same money down"; optional: true; pattern: concat("^", id_prefix_override, "_(sandbox|live)_[a-z0-9]{8,64}$"); } }
     }
     lifecycle {
-      states created funded released cancelled abandoned;
+      states created funded disputed released cancelled abandoned;
       initial created;
       on abandon: created -> abandoned;
       on cancel: funded -> cancelled;
+      on dispute: funded -> disputed;
       on fund: created -> funded;
       on [release_action]: funded -> released;
       on release_on_deadline: funded -> released;
+      on resume: disputed -> funded;
     }
     parties { beneficiary: payee_account_field; payer: payer_account_field; }
     required: [payer_account_field, payee_account_field, platformAccountId, amount, whole_fee_field, currency, release_deadline];
@@ -544,10 +565,10 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
       steps: [];
     }
     action [release_action] {
-      agent_description: concat("Pay the ", words(payee), " the whole ", amount, " out of escrow ahead of ", release_deadline, ". This moves money and does not reverse. Only a funded hold releases, the caller must act as the ", release_actor_text, ", and the call is refused once ", release_deadline, " passes. The custody fee stays posted.");
+      agent_description: concat("Pay the ", words(payee), " the whole ", amount, " out of escrow ahead of ", release_deadline, ". This moves money and does not reverse. Only a funded hold releases, the caller must act as ", words(at(release_allowed, 1)), ", and the call is refused once ", release_deadline, " passes. The custody fee stays posted.");
       summary: concat("Release the hold to the ", words(payee), " early");
       deadline: { field: release_deadline; };
-      port: { allowed_parties: [release_role]; };
+      port: { allowed_parties: [at(release_allowed, 1)]; };
       moves: [{ key: release_action; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", amount); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payee_account_field); }; "metadata.instrumentId": { from: const; value: instrument; }; "metadata.instrumentInstanceId": { from: instance; path: instrumentInstanceId; }; "metadata.phase": { from: const; value: release_action; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: refs.escrowAccountId; }; }; capture: { releaseTransferId: transferId; }; }];
       sandbox_failure_point: "release";
       steps: [];
@@ -574,5 +595,20 @@ export instrument held_payment<C>(payer: party, payee: party, amount: money<C>,
       requires_drained: { path: refs.escrowAccountId; };
       steps: [];
     }
+    action dispute {
+      agent_description: concat("Freeze a funded ", words(instrument), " so neither release nor refund can run until the parties settle the disagreement. No money moves and the whole balance stays put. Only a funded ", words(instrument), " disputes.");
+      description: concat("Freezes funded ", words(instrument), ", preserving the entire balance while the parties decide what happens next.");
+      summary: concat("Dispute a ", words(instrument), " settlement");
+      deadline: { field: release_deadline; };
+      moves: [];
+      steps: [];
+    }
+    action resume {
+      agent_description: concat("Lift the dispute hold and put the ", words(instrument), " back where it was, funded and ready to release. No money moves and the balance was never touched. Only a disputed ", words(instrument), " resumes. Use this when the parties settled without a refund.");
+      description: concat("Ends the dispute hold without moving money and returns the fully funded ", words(instrument), " to its first milestone.");
+      summary: concat("Resume a ", words(instrument), " settlement");
+      moves: [];
+      steps: [];
+    }
   }
 }

package/std/money_flows/index.hsx

@@ -0,0 +1,3 @@
+module std.money_flows
+
+// Money flows are imported by their full std.money_flows.<name> path.

package/std/{settlements → money_flows}/instant_transfer.hsx

@@ -1,4 +1,4 @@
-module std.settlements.instant_transfer
+module std.money_flows.instant_transfer
 
 export instrument instant_transfer<C>(payer: party, payee: party, amount: money<C>, fees: optional<block>, derived_amount: optional<block>) {
   let(payer_fee): get(fees, payer);
@@ -32,7 +32,6 @@ export instrument instant_transfer<C>(payer: party, payee: party, amount: money<
         platformAccountId {
           type: account<C>;
           description: "The product fee collection account";
-          pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
           [fee_collection_key]: true;
           [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
         }
@@ -44,7 +43,6 @@ export instrument instant_transfer<C>(payer: party, payee: party, amount: money<
       platformAccountId {
         type: account<C>;
         description: "The product fee collection account";
-        pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
         [fee_collection_key]: true;
         [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
       }
@@ -155,6 +153,7 @@ export instrument instant_transfer<C>(payer: party, payee: party, amount: money<
         moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.netOfCarvedFeeAmount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", payee_account_field); }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: pay_piece_1; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { payPiece1TransferTransferId: transferId; }; }];
       }
     }
+    sandbox_failure_point: funding;
     steps: [];
   }
   when(fees) {

package/std/{settlements → money_flows}/metered.hsx

@@ -1,4 +1,4 @@
-module std.settlements.metered
+module std.money_flows.metered
 
 export instrument metered(
   payer: party,

package/std/{settlements → money_flows}/pooled_split.hsx

@@ -1,4 +1,4 @@
-module std.settlements.pooled_split
+module std.money_flows.pooled_split
 
 export instrument pooled_split<C>(payer: party, amount: money<C>, payout_due: date, split: block) {
   let(recipients): keys_except(split, "remainder_to");
@@ -6,13 +6,13 @@ export instrument pooled_split<C>(payer: party, amount: money<C>, payout_due: da
   let(remainder_recipient): get(split, "remainder_to");
   fields {
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
-    [payer]AccountId { type: account<C>; description: concat("The ", words(payer), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+    [payer]AccountId { type: account<C>; description: concat("The ", words(payer), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
     amount { type: money<C>; description: concat("The pooled period total in {C} minor units; the share fields below partition it exactly"); }
     payout_due { type: date; description: "The period's payout date; the pool distributes from it"; }
     for index in recipient_count {
       let(recipient): at(recipients, index);
       let(share_bps): get(split, recipient);
-      [recipient]AccountId { type: account<C>; description: concat("The ", words(recipient), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+      [recipient]AccountId { type: account<C>; description: concat("The ", words(recipient), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
       [recipient]ShareAmount {
         type: money<C>;
         description: concat(div_floor(basis_points(share_bps), 100), "% of ", amount, if_eq(recipient, remainder_recipient, " (carries the integer-division remainder): ", ": "), "the ", words(recipient), "'s share. Computed as floor(", amount, " * ", basis_points(share_bps), " / 10000) in {C} minor units");

package/std/{settlements → money_flows}/premium_forward.hsx

@@ -1,4 +1,4 @@
-module std.settlements.premium_forward
+module std.money_flows.premium_forward
 
 export instrument premium_forward<C>(
   payer: party,
@@ -17,9 +17,8 @@ export instrument premium_forward<C>(
   let(amount_field): concat(amount);
   let(net_bps): sub(10000, commission);
   let(fee_bps): add(commission, 0);
-  let(net_percent): if_eq(net_bps, 9500, "95%", if_eq(net_bps, 9800, "98%", "87.5%"));
-  let(fee_percent): if_eq(fee_bps, 500, "5%", if_eq(fee_bps, 200, "2%", "12.5%"));
-  let(bind_roles): if_eq(len(bind_allowed), 2, ["payer", "beneficiary"], ["beneficiary"]);
+  let(net_percent): percent_text(net_bps);
+  let(fee_percent): percent_text(fee_bps);
   let(owner_id_key): "owner.id";
   let(owner_type_key): "owner.type";
   let(metadata_instrument_key): "metadata.instrumentId";
@@ -39,7 +38,6 @@ export instrument premium_forward<C>(
     platform_account_id: {
       type: account;
       description: "The product fee collection account";
-      pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
       [fee_port_key]: true;
       [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
     }
@@ -122,6 +120,7 @@ export instrument premium_forward<C>(
       };
       capture: { fund_piece_1_transfer_transfer_id: transferId; };
     }];
+    sandbox_failure_point: funding;
     steps: [];
   }
 
@@ -142,6 +141,7 @@ export instrument premium_forward<C>(
       };
       capture: { fund_piece_2_transfer_transfer_id: transferId; };
     }];
+    sandbox_failure_point: funding;
     steps: [];
   }
 
@@ -152,16 +152,13 @@ export instrument premium_forward<C>(
       additional_properties: false;
       properties: {
         for item in keys(bind_fields) {
-          [item]: {
-            description: "Required decision reference retained in the operation receipt";
-            max_length: 180; min_length: 1; type: string;
-          }
+          [item]: get(bind_fields, item);
         }
       };
       required: keys(bind_fields);
       type: object;
     };
-    port: { allowed_parties: bind_roles; };
+    port: { allowed_parties: bind_allowed; };
     moves: [{
       key: transfer; operation: "internal_transfer.create";
       bind: {
@@ -176,6 +173,7 @@ export instrument premium_forward<C>(
       };
       capture: { [bind_capture_key]: transferId; };
     }];
+    sandbox_failure_point: "release";
     steps: [];
   }
 
@@ -230,21 +228,22 @@ export instrument premium_forward<C>(
     action [endorsement] {
       agent_description: "Record one endorsement against a policy that already forwarded, from evidence the caller supplies. The forward must be released first, and only the {carrier} may call it. It moves no money and it does not change the premium.";
       summary: "Record one non-money endorsement from external evidence";
-      input: {
-        additional_properties: false;
-        properties: {
-          for item in keys(endorsement_fields) {
-            [item]: {
-              description: "Required decision reference retained in the operation receipt";
-              max_length: 180; min_length: 1; type: string;
+      when(endorsement_fields) {
+        input: {
+          additional_properties: false;
+          properties: {
+            for item in keys(endorsement_fields) {
+              [item]: get(endorsement_fields, item);
             }
-          }
+          };
+          required: keys(endorsement_fields);
+          type: object;
         };
-        required: keys(endorsement_fields);
-        type: object;
-      };
-      capture_input: { endorsement_evidence_reference: evidenceReference; };
-      port: { allowed_parties: [beneficiary]; };
+        capture_input: {
+          for item in keys(endorsement_fields) { [item]: item; }
+        };
+      }
+      port { allowed_parties: endorsement_allowed; };
       steps: [];
     }
     action lapse {