@hyperscale0/hsx 1.0.0 → 2.0.1

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

@@ -1,4 +1,4 @@
-module std.settlements.reconciled_payout
+module std.money_flows.reconciled_payout
 
 export instrument reconciled_payout<C>(
   payer: party,
@@ -17,8 +17,8 @@ export instrument reconciled_payout<C>(
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     settle_by { type: date; description: "Instant the expectation stops waiting and the unmatched amount becomes a break"; }
     beneficiary_ref { type: text; description: "Beneficiary ID for the payout instruction"; pattern: "^ben_(sandbox|live)_[a-z0-9]{8,64}$"; }
-    [beneficiary_account_field] { type: account<C>; description: concat("The ", words(beneficiary), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
-    [payer_account_field] { type: account<C>; description: concat("The ", words(payer), " account the payout leaves"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+    [beneficiary_account_field] { type: account<C>; description: concat("The ", words(beneficiary), " account"); [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+    [payer_account_field] { type: account<C>; description: concat("The ", words(payer), " account the payout leaves"); [reference_filter_key]: { column: role; values: [customer_balance]; }; }
   }
   lifecycle {
     states created instructed settled;

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

@@ -1,4 +1,4 @@
-module std.settlements.recurring_collection
+module std.money_flows.recurring_collection
 
 export instrument recurring_collection(marker: optional<text>) {
   agent_description: concat("Reach for ", words(instrument), " to track a bounded run of scheduled collections, one call per recorded installment. It carries no amount and no account, and every action only advances its own state. A settlement that debits an account on a schedule is a different shape.");

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

@@ -1,4 +1,4 @@
-module std.settlements.rotating_pool
+module std.money_flows.rotating_pool
 
 export instrument rotating_pool<C>(members: optional<list<party>>, contribution: money<C>, count: integer, every: optional<text>, first_due: date, payout_order: optional<list<party>>, default_policy: optional<text>, guarantee_policy: optional<text>, guarantor: optional<party>, exit_policy: optional<text>, memo: optional<text>, membership: optional<block>) {
   when_not(membership) {
@@ -9,8 +9,8 @@ export instrument rotating_pool<C>(members: optional<list<party>>, contribution:
   let(parent_ref_field): concat(camel(instrument), "Id");
   let(reference_filter): "x-hyperscale-reference-filter";
   fields {
-    for member in members { [member]AccountId { type: account<C>; description: concat("The ", words(member), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter]: { column: role; values: [customer_balance]; }; } }
-    [guarantor_field] { type: account<C>; description: concat("The ", words(guarantor), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter]: { column: role; values: [customer_balance]; }; }
+    for member in members { [member]AccountId { type: account<C>; description: concat("The ", words(member), " account"); [reference_filter]: { column: role; values: [customer_balance]; }; } }
+    [guarantor_field] { type: account<C>; description: concat("The ", words(guarantor), " account"); [reference_filter]: { column: role; values: [customer_balance]; }; }
     [contribution_field] { type: money<C>; description: "Exact contribution in {C} minor units"; }
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     [first_due_field] { type: date; description: "Stored first contribution due date"; }
@@ -83,8 +83,8 @@ export instrument rotating_pool<C>(members: optional<list<party>>, contribution:
         summary: concat(words(member), " contribution row");
         description: concat("Fixed contribution row for ", words(member));
         fields {
-          for roster_member in payout_order { [roster_member]AccountId { type: account<C>; description: concat("The ", words(roster_member), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter]: { column: role; values: [customer_balance]; }; } }
-          [guarantor_field] { type: account<C>; description: concat("The ", words(guarantor), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter]: { column: role; values: [customer_balance]; }; }
+          for roster_member in payout_order { [roster_member]AccountId { type: account<C>; description: concat("The ", words(roster_member), " account"); [reference_filter]: { column: role; values: [customer_balance]; }; } }
+          [guarantor_field] { type: account<C>; description: concat("The ", words(guarantor), " account"); [reference_filter]: { column: role; values: [customer_balance]; }; }
           [contribution_field] { type: money<C>; description: "Exact contribution amount shared by every cycle"; }
           currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
           [first_due_field] { type: date; description: "First due anchor derived from the pool"; }
@@ -140,7 +140,7 @@ export instrument rotating_pool<C>(members: optional<list<party>>, contribution:
           action contribute_cycle_[cycle] {
             summary: concat("Fund ", words(member), "'s cycle ", cycle, " contribution");
             let(first): if_eq(cycle, 1, true, false);
-            when(first) { due: { field: first_due_field; }; }
+            when(first) { due: { field: first_due_field; }; sandbox_failure_point: funding; }
             when_not(first) { due: { field: first_due_field; offset: due_offset; }; }
             requires refs { field: parent_ref_field; statuses: [active_state]; }
             moves: [{ key: "contribution"; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", contribution_field); }; currency: { from: instance; path: "fields.currency"; }; destinationAccountId: { from: instance; path: "refs.escrowAccountId"; }; "metadata.instrumentId": { from: const; value: child_id; }; "metadata.instrumentInstanceId": { from: instance; path: instrumentInstanceId; }; "metadata.phase": { from: const; value: contribute_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", camel(member), "AccountId"); }; }; capture: { [contribute_capture]: transferId; }; }];
@@ -167,6 +167,8 @@ export instrument rotating_pool<C>(members: optional<list<party>>, contribution:
             summary: concat("Pay this member's stored contribution into cycle ", cycle, "'s shared pot recipient");
             requires refs { field: parent_ref_field; statuses: [ready_state]; }
             moves: [{ key: payout; operation: internal_transfer.create; bind: { amount: { from: instance; path: concat("fields.", contribution_field); }; currency: { from: instance; path: "fields.currency"; }; destinationAccountId: { from: instance; path: concat("fields.", payout_field); }; "metadata.instrumentId": { from: const; value: child_id; }; "metadata.instrumentInstanceId": { from: instance; path: instrumentInstanceId; }; "metadata.phase": { from: const; value: pay_name; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.escrowAccountId"; }; }; capture: { [pay_capture]: transferId; }; }];
+            let(first): if_eq(cycle, 1, true, false);
+            when(first) { sandbox_failure_point: "release"; }
             steps: [];
           }
           action pay_guaranteed_cycle_[cycle] {

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

@@ -1,4 +1,4 @@
-module std.settlements.scheduled
+module std.money_flows.scheduled
 
 export instrument scheduled<C>(
   payer: party,
@@ -76,7 +76,7 @@ export instrument scheduled<C>(
         let(offset): scale_duration(every, sub(i, 1));
         let(installment_field): concat("installment", i, "Amount");
         summary: "Collect installment {i} of {count}";
-        when(first) { due: { field: first_due; }; }
+        when(first) { due: { field: first_due; }; sandbox_failure_point: funding; }
         when_not(first) { due: { field: first_due; offset: offset; }; }
         moves: [{ amount: installment_field; from: payer; to: beneficiary; key: transfer; }];
         steps: [];
@@ -194,7 +194,6 @@ export instrument scheduled<C>(
           [payee_field]: {
             type: account;
             description: "The {payee_words} account";
-            pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
             [reference_filter_key]: { column: role; values: [customer_balance]; };
           }
         }
@@ -202,7 +201,6 @@ export instrument scheduled<C>(
           [payer_field]: {
             type: account;
             description: "The {payer_words} account";
-            pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
             [reference_filter_key]: { column: role; values: [customer_balance]; };
           }
         }
@@ -210,7 +208,6 @@ export instrument scheduled<C>(
           [debtor_field]: {
             type: account;
             description: "The {debtor_words} account";
-            pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
             [reference_filter_key]: { column: role; values: [customer_balance]; };
           }
         }
@@ -218,7 +215,6 @@ export instrument scheduled<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]; };
           }
@@ -471,7 +467,7 @@ export instrument scheduled<C>(
               steps: [];
             }
             action repay {
-              agent_description: concat("Pay this record's amount toward installment ", i, ". The record must be created and its obligation live. Refused when this amount plus the records already paid against that installment would pass the stored amount. This moves the payer's money. Where a mandate applies, only the payer may call it and an evidence reference is required.");
+              agent_description: concat("Pay this record's amount toward installment ", i, ". The record must be created and its obligation live. Refused when this amount plus the records already paid against that installment would pass the stored amount. This moves the payer's money. Where a mandate applies, its declared parties may call it and an evidence reference is required.");
               summary: concat("Pay a partial or full amount against installment ", i);
               when(has_mandate) {
                 input: {
@@ -488,7 +484,7 @@ export instrument scheduled<C>(
                   type: object;
                 };
                 capture_input: { mandate_evidence_reference: evidenceReference; };
-                port: { allowed_parties: ["payer"]; };
+                port: { allowed_parties: mandate_allowed; };
               }
               requires refs: {
                 field: parent_ref_field;
@@ -591,7 +587,7 @@ export instrument scheduled<C>(
       }
 
       action collect_period {
-        agent_description: "Collect one open period charge from the payer, with the mandate evidence reference kept in the receipt. A period must be open. Only the payer may call it. This moves the period amount and does not reverse.";
+        agent_description: "Collect one open period charge from the payer, with the mandate evidence reference kept in the receipt. A period must be open. The mandate's declared parties may call it, or the payer when no mandate is wired. This moves the period amount and does not reverse.";
         summary: "Collect one authored period charge with mandate evidence";
         input: {
           additional_properties: false;
@@ -607,33 +603,32 @@ export instrument scheduled<C>(
           type: object;
         };
         capture_input: { mandate_evidence_reference: evidenceReference; };
-        port: { allowed_parties: ["payer"]; };
+        when(mandate) { port: { allowed_parties: mandate_allowed; }; }
+        when_not(mandate) { port: { allowed_parties: [payer]; }; }
         moves: [{ amount: amount_field; from: payer; to: beneficiary; key: period_collection; }];
+        sandbox_failure_point: funding;
         steps: [];
       }
 
       action [until] {
         agent_description: "Cancel the open schedule for good and drain any period liability still standing. Only the payer may call it, and the reference fields the port declares are required. No further period opens and there is no reactivation.";
         summary: "Cancel the open schedule and drain any period liability";
-        input: {
-          additional_properties: false;
-          properties: {
-            for item in keys(until_fields) {
-              [item]: {
-                description: "Required decision reference retained in the operation receipt";
-                max_length: 180;
-                min_length: 1;
-                type: string;
+        when(until_fields) {
+          input: {
+            additional_properties: false;
+            properties: {
+              for item in keys(until_fields) {
+                [item]: get(until_fields, item);
               }
-            }
+            };
+            required: keys(until_fields);
+            type: object;
           };
-          required: keys(until_fields);
-          type: object;
-        };
-        capture_input: {
-          for item in keys(until_fields) { [item]: item; }
-        };
-        port: { allowed_parties: ["payer"]; };
+          capture_input: {
+            for item in keys(until_fields) { [item]: item; }
+          };
+        }
+        port { allowed_parties: until_allowed; };
         steps: [];
       }
     }

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

@@ -1,19 +1,15 @@
-module std.settlements.security_deposit
+module std.money_flows.security_deposit
 
 export instrument security_deposit<C>(payer: party, holder: party, amount: money<C>, claim: optional<condition>, return: optional<condition>, claim_amount: optional<block>, deadline: optional<date>, claim_to: optional<party>, return_to: optional<party>, memo: optional<text>, claim_input: optional<block>, claim_capture: optional<block>, fund_failure_point: optional<text>, id_prefix_override: optional<text>) {
   let(claim_name): claim;
   let(return_name): return;
   let(payer_account_field): camel(concat(payer, "_account_id"));
   let(holder_account_field): camel(concat(holder, "_account_id"));
-  let(claim_actor): at(claim_allowed, 1);
-  let(claim_role): if_eq(claim_actor, payer, "payer", "beneficiary");
   let(claim_field): get(claim_amount, "field");
   let(claim_bound): get(claim_amount, "bound");
   let(claim_remainder): get(claim_amount, "remainder");
   let(deadline_field): concat(deadline);
   let(memo_field): concat(memo);
-  let(claim_to_role): if_eq(claim_to, payer, "payer", "beneficiary");
-  let(return_to_role): if_eq(return_to, payer, "payer", "beneficiary");
   agent_description: "Reach for security deposit when money is reserved against the {payer} in the {holder}'s favor and later claimed or returned. The funds stay reserved and move only on the claim. Pick captured payment when the holder takes the money in slices, and instant transfer when nothing is held.";
   summary: "Refundable deposit from {payer} held for {holder}";
   title: sentence(instrument);
@@ -34,8 +30,8 @@ export instrument security_deposit<C>(payer: party, holder: party, amount: money
       let(reference_filter_key): "x-hyperscale-reference-filter";
       amount { type: money<C>; description: "Positive minor-unit integer amount serialized as a string (at most 18 digits)"; }
       [deadline_field] { type: date; }
-      [holder_account_field] { type: account<C>; description: "Hyperscale account ID"; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
-      [payer_account_field] { type: account<C>; description: "Hyperscale account ID"; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+      [holder_account_field] { type: account<C>; description: "Hyperscale account ID"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
+      [payer_account_field] { type: account<C>; description: "Hyperscale account ID"; [reference_filter_key]: { column: role; values: [customer_balance]; }; }
       when(memo) { [memo_field] { type: text; max_length: 180; min_length: 1; optional: true; } }
     }
   }
@@ -75,11 +71,13 @@ export instrument security_deposit<C>(payer: party, holder: party, amount: money
     let(metadata_phase): "metadata.phase";
     summary: "Reserve the {amount} against the {payer}'s account";
     moves: [{ key: reservation; operation: internal_transfer.reserve; bind: { amount: { from: instance; path: concat("fields.", amount); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", holder_account_field); }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: place_deposit; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { placeDepositReservationTransferId: transferId; }; }];
+    sandbox_failure_point: funding;
     steps: [];
     }
     action [claim_name] {
     agent_description: "Claim the held deposit for the {holder}. The deposit must be in held. The reservation settles here, whole or up to the decided amount with the exact remainder released back to the {payer}. There is no return afterwards.";
     summary: "Claim the deposit for the {holder} through {claim}";
+    when(claim_allowed) { port { allowed_parties: claim_allowed; }; }
     when_not(claim_amount) {
       moves: [{ key: post; operation: internal_transfer.post; bind: { transferId: { from: instance; path: refs.placeDepositReservationTransferId; }; }; }];
     }
@@ -90,14 +88,12 @@ export instrument security_deposit<C>(payer: party, holder: party, amount: money
         additional_properties: false;
         properties {
           for input_name in keys(claim_fields) {
-            [input_name] { type: string; description: "Required decision reference retained in the operation receipt"; max_length: 180; min_length: 1; }
+            [input_name]: get(claim_fields, input_name);
           }
-          [claim_field] { type: string; description: "Caller-decided amount in minor units"; pattern: "^(0|[1-9][0-9]{0,17})$"; }
         }
         required: keys(claim_fields);
       }
       [decided_clause]: { field: claim_field; bound_field: claim_bound; remainder_action: return_name; };
-      port { allowed_parties: [claim_role]; };
       moves: [{ key: post; operation: internal_transfer.post; bind: { amount: { from: input; path: claim_field; }; currency: { from: instance; path: fields.currency; }; postMode: { from: const; value: partial_only; }; transferId: { from: instance; path: refs.placeDepositReservationTransferId; }; }; }, { key: remainder; operation: internal_transfer.void; bind: { reason: { from: const; value: "Return the unclaimed deposit remainder"; }; transferId: { from: instance; path: refs.placeDepositReservationTransferId; }; }; }];
     }
     steps: [];
@@ -105,6 +101,22 @@ export instrument security_deposit<C>(payer: party, holder: party, amount: money
     action [return_name] {
       agent_description: "Return the held deposit to the {payer}. The deposit must be in held and unclaimed. This releases the reservation whole and the {holder} receives nothing.";
       summary: "Return the deposit to the {payer} through {return}";
+      when(return_fields) {
+        input {
+          type: object;
+          additional_properties: false;
+          properties {
+            for input_name in keys(return_fields) {
+              [input_name]: get(return_fields, input_name);
+            }
+          }
+          required: keys(return_fields);
+        }
+        capture_input: {
+          for item in keys(return_fields) { [item]: item; }
+        };
+      }
+      port { allowed_parties: return_allowed; };
       moves: [{ key: void; operation: internal_transfer.void; bind: { reason: { from: const; value: "Deposit returned in full"; }; transferId: { from: instance; path: refs.placeDepositReservationTransferId; }; }; }];
       steps: [];
     }
@@ -126,26 +138,38 @@ export instrument security_deposit<C>(payer: party, holder: party, amount: money
       deadline: { field: deadline_field; };
       moves: [{ key: reservation; operation: internal_transfer.reserve; bind: { amount: { from: instance; path: concat("fields.", amount); }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", holder_account_field); }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { holdTransferId: transferId; }; }];
       when(fund_failure_point) { sandbox_failure_point: fund_failure_point; }
+      when_not(fund_failure_point) { sandbox_failure_point: funding; }
       steps: [];
       summary: "Fund the security deposit";
     }
     action claim {
-      agent_description: "Post the {holder}'s decided amount out of the reservation and void the remainder back to the {payer} in one linked group. This moves money and does not reverse. Only a funded hold claims, and the claimed amount cannot exceed the held {amount}.";
+      when_not(claim_amount) {
+        agent_description: "Post the whole reservation to the {holder}. This moves money and does not reverse. Only a funded hold claims.";
+        moves: [{ key: "claim"; operation: internal_transfer.post; bind: { transferId: { from: instance; path: refs.holdTransferId; }; }; }];
+      }
       deadline: { field: deadline_field; };
       when(claim_capture) { capture_input: claim_capture; }
       when(claim_amount) {
+        agent_description: "Post the {holder}'s decided amount out of the reservation and void the remainder back to the {payer} in one linked group. This moves money and does not reverse. Only a funded hold claims, and the claimed amount cannot exceed the held {amount}.";
         decided_amount: { field: claim_field; bound_field: claim_bound; remainder_action: claim_remainder; };
+        sandbox_failure_point: "release";
+        moves: [{ key: "claim"; operation: internal_transfer.post; bind: { amount: { from: input; path: claim_field; }; currency: { from: instance; path: fields.currency; }; postMode: { from: const; value: partial_only; }; transferId: { from: instance; path: refs.holdTransferId; }; }; }, { key: remainder; operation: internal_transfer.void; bind: { reason: { from: const; value: "Return unclaimed deposit remainder"; }; transferId: { from: instance; path: refs.holdTransferId; }; }; }];
       }
       when(claim_input) { input: claim_input; }
-      when(claim_to) { port { allowed_parties: [claim_to_role]; }; }
-      moves: [{ key: "claim"; operation: internal_transfer.post; bind: { amount: { from: input; path: claim_field; }; currency: { from: instance; path: fields.currency; }; postMode: { from: const; value: partial_only; }; transferId: { from: instance; path: refs.holdTransferId; }; }; }, { key: remainder; operation: internal_transfer.void; bind: { reason: { from: const; value: "Return unclaimed deposit remainder"; }; transferId: { from: instance; path: refs.holdTransferId; }; }; }];
+      when(claim_allowed) { port { allowed_parties: claim_allowed; }; }
+      when_not(claim_allowed) {
+        when(claim_to) { port { allowed_parties: [claim_to]; }; }
+      }
       steps: [];
       summary: "Claim the security deposit";
     }
     action return {
       agent_description: "Void the whole reservation so the {payer} gets every unit back. Use this when the {holder} decides to keep nothing. This moves money and does not reverse. Only a funded hold returns.";
       deadline: { field: deadline_field; };
-      when(return_to) { port { allowed_parties: [return_to_role]; }; }
+      when(return_allowed) { port { allowed_parties: return_allowed; }; }
+      when_not(return_allowed) {
+        when(return_to) { port { allowed_parties: [return_to]; }; }
+      }
       moves: [{ key: "return"; operation: internal_transfer.void; bind: { reason: { from: const; value: "Deposit returned in full"; }; transferId: { from: instance; path: refs.holdTransferId; }; }; }];
       steps: [];
       summary: "Return the security deposit";

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

@@ -1,4 +1,4 @@
-module std.settlements.settlement_batch
+module std.money_flows.settlement_batch
 
 export instrument settlement_batch<C>(
   settlement_account: party,
@@ -15,8 +15,8 @@ export instrument settlement_batch<C>(
     close_trigger { type: date; description: "Date the open batch freezes against later entries"; }
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     payout_beneficiary_ref { type: text; description: "Beneficiary ID for the payout instruction"; pattern: "^ben_(sandbox|live)_[a-z0-9]{8,64}$"; }
-    [payout_destination]AccountId { type: account<C>; description: concat("The ", words(payout_destination), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
-    [settlement_account]AccountId { type: account<C>; description: concat("The ", words(settlement_account), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+    [payout_destination]AccountId { type: account<C>; description: concat("The ", words(payout_destination), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+    [settlement_account]AccountId { type: account<C>; description: concat("The ", words(settlement_account), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
   }
   lifecycle {
     states open closed calculated approved instructed acknowledged reconciled;

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

@@ -1,4 +1,4 @@
-module std.settlements.swap;
+module std.money_flows.swap;
 export instrument swap<C>(between: list<party>, amounts: block, fees: block, release: condition, dispute: condition, side_names: optional<block>, lifecycle_state_order: optional<list<text>>, action_bindings: optional<block>, parked_states: optional<block>, fixed_prefix: optional<text>) {
   let(side_a): at(between, 1);
   let(side_b): at(between, 2);
@@ -29,8 +29,8 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
   distinct_parties: true;
   when(side_names) {
     parties {
-      payer: side_a_account;
-      beneficiary: side_b_account;
+      payer: { party: side_a; account: side_a_account; };
+      beneficiary: { party: side_b; account: side_b_account; };
     }
   }
   when_not(side_names) {
@@ -82,7 +82,6 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       "[side_a_account]" {
         type: account<C>;
         description: "First trade party and funder";
-        pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
         "x-hyperscale-reference-filter" {
           column: role;
           values: [customer_balance];
@@ -99,7 +98,6 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       "[side_b_account]" {
         type: account<C>;
         description: "Second trade party and funder";
-        pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
         "x-hyperscale-reference-filter" {
           column: role;
           values: [customer_balance];
@@ -144,7 +142,6 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       when_not(side_names) {
         description: "The product fee collection account";
       }
-      pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
       "x-hyperscale-fee-collection-port": true;
       "x-hyperscale-reference-filter" {
         column: role;
@@ -240,15 +237,28 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       }];
     }
     action dispute {
-      agent_description: "Claw back a released trade inside its dispute window. Both cross-payment reservations void and both principals return from escrow in one batch. The trade must be released and the clawback moment must not have passed. Either trading party may call it.";
+      agent_description: "Claw back a released trade inside its dispute window. Both cross-payment reservations void and both principals return from escrow in one batch. The trade must be released and the clawback moment must not have passed. The dispute port's declared parties may call it.";
       summary: "Void both reservations, then refund both principals atomically";
       public_action: concat("dispute", title(camel(instrument)));
       deadline {
         field: clawbackAt;
       }
-      port {
-        allowedParties: [payer, beneficiary];
+      when(dispute_fields) {
+        input {
+          type: object;
+          additional_properties: false;
+          properties {
+            for input_name in keys(dispute_fields) {
+              [input_name]: get(dispute_fields, input_name);
+            }
+          }
+          required: keys(dispute_fields);
+        }
+        capture_input: {
+          for item in keys(dispute_fields) { [item]: item; }
+        };
       }
+      port { allowedParties: dispute_allowed; }
       moves: [{
         bind {
           reason {
@@ -370,6 +380,7 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       agent_description: "Fund both sides at once. Each side pays its principal into escrow and its service fee to the platform account, four transfers in one batch. The trade must be created and unfunded. This moves real money from both parties.";
       summary: "Fund both trade sides and collect on-top fees atomically";
       public_action: concat("fund", title(camel(instrument)));
+      sandbox_failure_point: "funding";
       moves: [{
         amount: concat(side_a_amount);
         from: side_a;
@@ -420,12 +431,13 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       steps: [];
     }
     action release {
-      agent_description: "Reserve each side's principal for the other side and start the dispute window. The trade must be funded. Money is reserved, not settled. It posts on its own when the window matures, and dispute unwinds it before then. Either trading party may call it.";
+      agent_description: "Reserve each side's principal for the other side and start the dispute window. The trade must be funded. Money is reserved, not settled. It posts on its own when the window matures, and dispute unwinds it before then. The release port's declared parties may call it.";
       summary: "Reserve both cross-payments for the whole-trade clawback window";
       public_action: concat("release", title(camel(instrument)));
       port {
-        allowedParties: [payer, beneficiary];
+        allowedParties: release_allowed;
       }
+      sandbox_failure_point: "release";
       sets_at {
         field: clawbackAt;
         offset: dispute_within;
@@ -753,12 +765,12 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       steps: [];
     }
     action release {
-      agent_description: "Reserve each side's principal for the other side and start the dispute window. The trade must be funded. Money is reserved, not settled. It posts on its own when the window matures, and dispute unwinds it before then. Either trading party may call it.";
+      agent_description: "Reserve each side's principal for the other side and start the dispute window. The trade must be funded. Money is reserved, not settled. It posts on its own when the window matures, and dispute unwinds it before then. The release port's declared parties may call it.";
       summary: "Reserve both cross-payments for the whole-trade clawback window";
       public_action: concat("release", title(camel(instrument)));
       event_name: concat(event_prefix, ".released");
       port {
-        allowedParties: [payer, beneficiary];
+        allowedParties: release_allowed;
       }
       sandbox_failure_point: "release";
       sets_at {
@@ -884,16 +896,29 @@ export instrument swap<C>(between: list<party>, amounts: block, fees: block, rel
       steps: [];
     }
     action dispute {
-      agent_description: "Claw back a released trade inside its dispute window. Both cross-payment reservations void and both principals return from escrow in one batch. The trade must be released and the clawback moment must not have passed. Either trading party may call it.";
+      agent_description: "Claw back a released trade inside its dispute window. Both cross-payment reservations void and both principals return from escrow in one batch. The trade must be released and the clawback moment must not have passed. The dispute port's declared parties may call it.";
       summary: "Void both reservations, then refund both principals atomically";
       public_action: concat("dispute", title(camel(instrument)));
       event_name: concat(event_prefix, ".clawed_back");
       deadline {
         field: clawbackAt;
       }
-      port {
-        allowedParties: [payer, beneficiary];
+      when(dispute_fields) {
+        input {
+          type: object;
+          additional_properties: false;
+          properties {
+            for input_name in keys(dispute_fields) {
+              [input_name]: get(dispute_fields, input_name);
+            }
+          }
+          required: keys(dispute_fields);
+        }
+        capture_input: {
+          for item in keys(dispute_fields) { [item]: item; }
+        };
       }
+      port { allowedParties: dispute_allowed; }
       moves: [{
         bind {
           reason {

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

@@ -1,4 +1,4 @@
-module std.settlements.threshold_pool
+module std.money_flows.threshold_pool
 
 export instrument threshold_pool<C>(
   contributor: optional<party>,
@@ -29,7 +29,7 @@ export instrument threshold_pool<C>(
   agent_description: "Reach for threshold pool when many contributors commit toward one target and nothing is collected unless the pool reaches it by the close date. Commitments sit in escrow until the pool activates or fails. Pick weighted distribution to pay a pool out and instant transfer for a single payment.";
   when_not(contribution_instrument) {
   fields {
-    [beneficiary]AccountId { type: account<C>; description: concat("The ", words(beneficiary), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+    [beneficiary]AccountId { type: account<C>; description: concat("The ", words(beneficiary), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
     close_by { type: date; description: "Stored close anchor"; }
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     maxContributors { type: integer; description: concat("Exactly ", max_contributors, " admitted contributors"); const: max_contributors; }
@@ -90,9 +90,9 @@ export instrument threshold_pool<C>(
       generatedPrefix: true;
       fields {
         amount { type: money<C>; description: "One whole commitment amount"; }
-        [beneficiary]AccountId { type: account<C>; description: concat("The ", words(beneficiary), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+        [beneficiary]AccountId { type: account<C>; description: concat("The ", words(beneficiary), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
         [parent_name]Id { type: ref<parent_name>; description: concat("The exact ", parent_name); pattern: concat("^", prefix(parent_name), "_(sandbox|live)_[a-z0-9]{8,64}$"); }
-        [contributor]AccountId { type: account<C>; description: concat("The ", words(contributor), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+        [contributor]AccountId { type: account<C>; description: concat("The ", words(contributor), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
         currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
       }
       lifecycle {
@@ -168,7 +168,7 @@ export instrument threshold_pool<C>(
     let(close_field): camel(close_by);
 
     fields {
-      [beneficiary_account_field] { type: account<C>; description: beneficiary_account_description; pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+      [beneficiary_account_field] { type: account<C>; description: beneficiary_account_description; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
       [close_field] { type: date; }
       currency { type: text; description: currency_description; maxLength: 3; minLength: 3; pattern: "^[A-Z]{3}$"; }
       when(memo) { [memo] { type: text; optional: true; maxLength: 180; minLength: 1; } }

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

@@ -1,4 +1,4 @@
-module std.settlements.weighted_distribution
+module std.money_flows.weighted_distribution
 
 export instrument weighted_distribution<C>(
   source: party,
@@ -18,7 +18,7 @@ export instrument weighted_distribution<C>(
   fields {
     currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
     amount { type: money<C>; description: "Distribution pool in {C} minor units"; }
-    [source]AccountId { type: account<C>; description: concat("The ", words(source), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+    [source]AccountId { type: account<C>; description: concat("The ", words(source), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
     maxRecipients { type: integer; description: concat("Exactly ", max_recipients, " frozen entitlement rows"); const: max_recipients; }
     record_at { type: date; description: "Stored record date"; }
   }
@@ -48,10 +48,10 @@ export instrument weighted_distribution<C>(
       generatedPrefix: true;
       fields {
         currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
-        [source]AccountId { type: account<C>; description: concat("The ", words(source), " account"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+        [source]AccountId { type: account<C>; description: concat("The ", words(source), " account"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
         [weight] { type: money<C>; description: "Stored non-negative entitlement weight"; }
         [parent_name]Id { type: ref<parent_name>; description: concat("The exact ", parent_name); pattern: concat("^", prefix(parent_name), "_(sandbox|live)_[a-z0-9]{8,64}$"); }
-        [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]; }; }
       }
       lifecycle { states recorded paid; initial recorded; on payout: recorded -> paid; }
       parties { beneficiary: concat(camel(recipient), "AccountId"); payer: concat(camel(source), "AccountId"); }
@@ -106,8 +106,8 @@ export instrument weighted_distribution<C>(
       currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
       [weight_ref] { type: weight_ref; description: get(weight_source, "description"); pattern: get(weight_source, "pattern"); }
       [group_ref] { type: group_ref; description: get(group, "description"); pattern: get(group, "pattern"); }
-      [recipient]AccountId { type: account<C>; description: get(flat, "recipient_account_description"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
-      [source]AccountId { type: account<C>; description: get(flat, "source_account_description"); pattern: "^acct_(sandbox|live)_[a-z0-9]{8,64}$"; "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+      [recipient]AccountId { type: account<C>; description: get(flat, "recipient_account_description"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
+      [source]AccountId { type: account<C>; description: get(flat, "source_account_description"); "x-hyperscale-reference-filter": { column: role; values: [customer_balance]; }; }
     }
     lifecycle { states claimed paid; initial claimed; on payout: claimed -> paid; }
     parties { beneficiary: recipient_account_field; }

package/docs/sessions/2026-09-02-two-instruments.hsx

@@ -1,21 +0,0 @@
-program juniper_forge_contract "Juniper Forge contract"
-import { instant_transfer, scheduled } from "std/settlements"
-
-party samira_nassar: person
-party juniper_forge_interiors: business
-
-settlement concept_fee = instant_transfer {
-  payer: samira_nassar
-  payee: juniper_forge_interiors
-  amount: conceptFee: money(SAR)
-  fees { samira_nassar: 1% }
-}
-
-settlement build_installments = scheduled {
-  payer: samira_nassar
-  payee: juniper_forge_interiors
-  amount: buildPrice: money(SAR)
-  count: 3
-  every: P30D
-  first_due: firstBuildPaymentAt
-}

package/docs/sessions/2026-09-02-two-instruments.md

@@ -1,41 +0,0 @@
-# Two-instrument reading session, 2026-09-02
-
-The reader worked only inside the HSX public export. It read the README, skill,
-guide, grammar, types, and generated standard-library pages.
-
-## First run
-
-Attempts: 3. Result: environment refusal before language checking.
-
-```text
-$ hsx check reading-test.hsx
-zsh: command not found: hsx
-exit 127
-
-$ npm exec --offline --package=. -- hsx check reading-test.hsx
-sh: hsx: command not found
-exit 127
-
-$ bun run src/cli.ts check reading-test.hsx
-SyntaxError: Export named 'udlEffectKinds' not found in the cached UDL beta package
-exit 1
-```
-
-The public docs did not distinguish the installed command from the source
-checkout command. The provisional pre-publication clone also resolved an old
-UDL package. The README and first-program guide now name the exact checkout
-command. The rerun used the local UDL rc.1 package already proved by the
-exporter.
-
-## Rerun after the docs repair
-
-Attempts: 1. Result: accepted with no diagnostics.
-
-```text
-$ bun run bin/hsx.ts check reading-test.hsx
-[no diagnostics]
-exit 0
-```
-
-The accepted program is in
-[`2026-09-02-two-instruments.hsx`](./2026-09-02-two-instruments.hsx).