@hyperscale0/hsx 2.1.1 → 2.2.0

package/std/money_flows/advance.hsx

@@ -24,6 +24,9 @@ module std.money_flows.advance
 // - `count`: Optional number of scheduled installment repayments.
 // - `every`: Optional recurrence duration between installments (e.g. `"P30D"`).
 // - `first_due`: Optional date for the first installment repayment.
+// - `repayment_source`: Optional party repaying when distinct from the capital recipient.
+// - `profit_to`: Optional recipient of profit, separated from principal repayments.
+// - `dated`: Require an explicit signed date for each repayment instead of duration offsets.
 // - `against`: Optional reference to a hold instrument whose release will be carved to repay the advance.
 //
 // ### Decision ports
@@ -54,6 +57,9 @@ export instrument advance<C>(
   every: optional<text>,
   first_due: optional<date>,
   against: optional<ref>,
+  repayment_source: optional<party>,
+  profit_to: optional<party>,
+  dated: optional<boolean>,
 ) {
   let(amount_path): concat("fields.", amount);
   let(currency_path): "fields.currency";
@@ -66,6 +72,8 @@ export instrument advance<C>(
   parties {
     payer: funder;
     beneficiary: to;
+    when(repayment_source) { repayment: repayment_source; }
+    when(profit_to) { profit: profit_to; }
   }
 
   when(against) {
@@ -131,6 +139,8 @@ export instrument advance<C>(
   }
 
   when_not(against) {
+    let(repayment_role): if_eq(repayment_source, false, "beneficiary", "repayment");
+    when(fee) { computes derived: { field: feeAmount; source_field: amount; rule: { kind: percentage_of; bps: basis_points(fee); }; rounding: floor; }; }
     let(repayment_fields): names("repayment", count, "Amount");
     let(first_target): if_eq(count, 1, "repaid", "repaying_1");
     let(states_key): "states";
@@ -144,6 +154,7 @@ export instrument advance<C>(
       }
       fee_amount {
         type: money<C>;
+        when(fee) { optional: true; }
         description: concat(fee, " of ", amount, ", the funder's discount repaid on top of the advance");
       }
       repayable_amount {
@@ -154,16 +165,13 @@ export instrument advance<C>(
         type: date;
         description: concat("Due date of the first repayment; repayment k falls ", every, " after its predecessor");
       }
-      repayment_1_amount {
-        type: money<C>;
-        description: concat("Repayment 1 of ", count, " (carries the integer-division remainder): about 33.34% of repayableAmount, collected on its own stored-date anchor");
-      }
-      for repayment in sub(count, 1) {
-        let(index): add(repayment, 1);
-        repayment[index]Amount {
-          type: money<C>;
-          description: concat("Repayment ", index, " of ", count, ": about 33.33% of repayableAmount, collected on its own stored-date anchor");
+      for i in count {
+        repayment[i]Amount { type: money<C>; description: "Stored total for repayment {i}"; }
+        when(profit_to) {
+          repayment[i]Principal { type: money<C>; description: "Principal returned to the funder by repayment {i}"; }
+          repayment[i]Profit { type: money<C>; description: "Profit paid to the named recipient by repayment {i}"; }
         }
+        when(dated) { repayment[i]DueAt { type: date; description: "Signed calendar due date for repayment {i}"; } }
       }
     }
     lifecycle {
@@ -187,8 +195,15 @@ export instrument advance<C>(
       piece_fields: [amount, feeAmount];
       total_field: repayableAmount;
     }];
+    when(profit_to) {
+      partitions: { total_field: amount; piece_fields: names("repayment", count, "Principal"); };
+      partitions: { total_field: feeAmount; piece_fields: names("repayment", count, "Profit"); };
+      for i in count {
+        partitions: { total_field: concat("repayment", i, "Amount"); piece_fields: [concat("repayment", i, "Principal"), concat("repayment", i, "Profit")]; };
+      }
+    }
     action create {
-      agent_description: "Open the advance row before any money moves. The caller supplies the {amount}, the fee amount, the repayable total, and the first repayment date. The repayment fields must partition the repayable total exactly. Nothing is disbursed here.";
+      agent_description: "Open the advance row before any money moves. The caller supplies the {amount}, the repayable total, and repayment dates. A declared fee derives the fee amount from principal. The repayment fields must partition the repayable total exactly. Nothing is disbursed here.";
       summary: concat("Create a ", words(instrument));
       steps: [];
       moves: [];
@@ -199,22 +214,20 @@ export instrument advance<C>(
       moves: [{ amount: amount; from: payer; to: beneficiary; key: transfer; operation: create; }];
       steps: [];
     }
-    action collect_repayment_1 {
-      summary: concat("Collect repayment 1 of ", count);
-      due: { field: first_due_field; };
-      moves: [{ amount: repayment1Amount; from: beneficiary; to: payer; key: transfer; operation: create; }];
-      steps: [];
-    }
-    for repayment in sub(count, 1) {
-      let(index): add(repayment, 1);
-      let(repayment_field): concat("repayment", index, "Amount");
-      action collect_repayment_[index] {
-        summary: concat("Collect repayment ", index, " of ", count);
-        due: {
-          field: first_due_field;
-          offset: scale_duration(every, sub(index, 1));
-        };
-        moves: [{ amount: repayment_field; from: beneficiary; to: payer; key: transfer; operation: create; }];
+    for i in count {
+      let(repayment_field): concat("repayment", i, "Amount");
+      action collect_repayment_[i] {
+        agent_description: "Collect repayment {i} once on its stored due anchor, returning principal to the funder and any separately routed profit to its recipient.";
+        summary: "Collect repayment {i} of {count}";
+        when(dated) { due: { field: concat("repayment", i, "DueAt"); }; }
+        when_not(dated) { due: { field: first_due_field; offset: scale_duration(every, sub(i, 1)); }; }
+        when_not(profit_to) { moves: [{ amount: repayment_field; from: repayment_role; to: payer; key: transfer; }]; }
+        when(profit_to) {
+          moves: [
+            { amount: concat("repayment", i, "Principal"); from: repayment_role; to: payer; key: principal; },
+            { amount: concat("repayment", i, "Profit"); from: repayment_role; to: profit; key: profit; }
+          ];
+        }
         steps: [];
       }
     }

package/std/money_flows/cancellable_booking.hsx

@@ -45,16 +45,38 @@ module std.money_flows.cancellable_booking
 //   offer_life: "PT30M"
 // }
 // ```
+// ### Finite cancellation bands
+// Supply cancel_bands to select deposit/balance custody instead of quoted cancellation.
+// Each band has name, refund (full, balance or none), starts_at after the first band,
+// and supplier_bps when money is retained. The unpaid_band index selects a retained
+// deposit policy. Omit it to return the deposit; a full-refund band also returns it. price_value and supplier_cost fix the price; deposit_bps derives
+// the deposit. balance_before and confirmation_window are positive fixed durations
+// relative to departure. tax_bps applies to margin after the supplier share.
+// authority_type and supplier_role bind release to a consumed confirmation decision.
+// acceptance optionally supplies an aggregate gate. All actions are private until
+// expose selects them. Ordered band starts and deadlines prevent a late sweep from
+// extending an earlier band's cancellation rights. Full timeout refund returns price.
+// Seven derivations suffice for three bands; larger finite policies use up to the
+// UDL bound of 64 derived amounts. shift_date(date, duration, "before") subtracts a
+// fixed duration; omitting the direction adds it. Invalid dates or durations refuse.
+//
 export instrument cancellable_booking<C>(
-  guest: party,
-  host: party,
-  amount: money<C>,
-  starts_at: date,
-  late_penalty_bps: integer,
-  late_within: text,
-  early_penalty_bps: integer,
-  offer_life: text,
+  guest: optional<party>,
+  host: optional<party>,
+  amount: optional<money<C>>,
+  starts_at: optional<date>,
+  late_penalty_bps: optional<integer>,
+  late_within: optional<text>,
+  early_penalty_bps: optional<integer>,
+  offer_life: optional<text>,
+  cancel_bands: optional<list<block>>,
+  price_value: optional<text>, supplier_cost: optional<text>, departure: optional<text>,
+  balance_before: optional<text>, confirmation_window: optional<text>, unpaid_band: optional<integer>,
+  acceptance: optional<block>, deposit_bps: optional<integer>, tax_bps: optional<integer>,
+  authority_type: optional<text>, supplier_role: optional<text>,
+
 ) {
+  when_not(cancel_bands) {
   let(guest_account_field): camel(concat(guest, "_account_id"));
   let(host_account_field): camel(concat(host, "_account_id"));
   let(reference_filter_key): "x-hyperscale-reference-filter";
@@ -130,4 +152,249 @@ export instrument cancellable_booking<C>(
     moves: [{ key: penalty; operation: internal_transfer.create; bind: { amount: { from: instance; path: refs.cancellationPenaltyAmount; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", host_account_field); }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: refs.bookingHoldingAccountId; }; }; capture: { penaltyTransferId: transferId; }; }];
     steps: [];
   }
+  }
+  when(cancel_bands) {
+    let(band_count): len(cancel_bands);
+    for band in cancel_bands {
+      let(refund): get(band, "refund");
+      let(not_full): if_eq(refund, "full", false, true);
+      let(not_balance): if_eq(refund, "balance", false, true);
+      let(not_none): if_eq(refund, "none", false, true);
+      when(not_full) { when(not_balance) { when(not_none) {
+        unsupported { code: HSX1407; message: "Unknown cancellation refund policy"; fix: "Choose full, balance or none"; }
+      } } }
+    }
+    let(deposit_states): names("deposit_", len(cancel_bands), "");
+    let(full_states): names("full_", len(cancel_bands), "");
+    fields {
+      bookingKey { type: text; min_length: 1; }
+      signedTermsReference { type: text; min_length: 1; }
+      currency { type: text; const: C; }
+      customerAccountId: account<C>;
+      supplierAccountId: account<C>;
+      operatorAccountId: account<C>;
+      taxAccountId: account<C>;
+      authorityId { type: ref<authority_type>; optional: true; }
+      supplierRole { type: text; const: supplier_role; }
+      travellerCount { type: integer; minimum: 1; maximum: 20; }
+      departureAt { type: date; const: departure; }
+      balanceDueAt { type: date; const: shift_date(departure, balance_before, "before"); }
+      confirmationDeadline { type: date; const: shift_date(departure, confirmation_window); }
+      price { type: money<C>; const: price_value; }
+      supplierCost { type: money<C>; const: supplier_cost; }
+      depositAmount { type: money<C>; optional: true; }
+      balanceAmount: money<C>;
+      margin: money<C>;
+      operatorNet: money<C>;
+      marginVat { type: money<C>; optional: true; }
+      for i in len(cancel_bands) {
+        let(band): at(cancel_bands, i);
+      let(refund_mode): get(band, "refund");
+      let(full_refund): if_eq(refund_mode, "full", true, false);
+      let(balance_refund): if_eq(refund_mode, "balance", true, false);
+      let(retains): if_eq(refund_mode, "full", false, true);
+        let(later): if_eq(i, 1, false, true);
+        when(later) { band[i]Start { type: date; const: get(band, "starts_at"); } }
+
+        when(retains) {
+          band[i]Supplier { type: money<C>; optional: true; }
+          let(portions): if_eq(refund_mode, "balance", ["deposit"], ["deposit", "full"]);
+          for paid in portions {
+          let(is_full): if_eq(paid, "full", true, false);
+            let(portion): if_eq(refund_mode, "balance", "deposit", paid);
+            let(margin_field): concat("band", i, title(portion), "Margin");
+            let(net_field): concat("band", i, title(portion), "Net");
+            let(vat_field): concat("band", i, title(portion), "Vat");
+            [margin_field]: money<C>;
+            [net_field]: money<C>;
+            [vat_field] { type: money<C>; optional: true; }
+          }
+        }
+      }
+    }
+    parties { payer: customerAccountId; beneficiary: supplierAccountId; fee: operatorAccountId; tax: taxAccountId; }
+    distinct_parties: true;
+    computes derived: { field: depositAmount; source_field: price; rule: { kind: percentage_of; bps: deposit_bps; }; rounding: floor; };
+    computes derived: { field: marginVat; source_field: margin; rule: { kind: percentage_of; bps: tax_bps; }; rounding: floor; };
+    for i in len(cancel_bands) {
+      let(band): at(cancel_bands, i);
+      let(refund_mode): get(band, "refund");
+      let(balance_refund): if_eq(refund_mode, "balance", true, false);
+      when(balance_refund) {
+        partitions: { total_field: price; piece_fields: [balanceAmount, concat("band", i, "Supplier"), concat("band", i, "DepositNet"), concat("band", i, "DepositVat")]; };
+      }
+    }
+    partitions: { total_field: price; piece_fields: [supplierCost, operatorNet, marginVat]; };
+    partitions: { total_field: price; piece_fields: [depositAmount, balanceAmount]; };
+    partitions: { total_field: price; piece_fields: [supplierCost, margin]; };
+    partitions: { total_field: margin; piece_fields: [operatorNet, marginVat]; };
+    date order: { before_field: balanceDueAt; after_field: departureAt; operator: "<"; };
+    date order: { before_field: departureAt; after_field: confirmationDeadline; operator: "<"; };
+    for i in len(cancel_bands) {
+      let(band): at(cancel_bands, i);
+      let(refund_mode): get(band, "refund");
+      let(full_refund): if_eq(refund_mode, "full", true, false);
+      let(balance_refund): if_eq(refund_mode, "balance", true, false);
+      let(retains): if_eq(refund_mode, "full", false, true);
+      let(later): if_eq(i, 1, false, true);
+      let(band_start): concat("band", i, "Start");
+      when(later) {
+        date order: { before_field: band_start; after_field: departureAt; operator: "<"; };
+        let(after_second): if_eq(i, 2, false, true);
+        when(after_second) { date order: { before_field: concat("band", sub(i, 1), "Start"); after_field: band_start; operator: "<"; }; }
+      }
+
+      when(retains) {
+        let(supplier_field): concat("band", i, "Supplier");
+        computes derived: { field: supplier_field; source_field: supplierCost; rule: { kind: percentage_of; bps: get(band, "supplier_bps"); }; rounding: floor; };
+        let(portions): if_eq(refund_mode, "balance", ["deposit"], ["deposit", "full"]);
+        for paid in portions {
+          let(is_full): if_eq(paid, "full", true, false);
+          let(portion): if_eq(refund_mode, "balance", "deposit", paid);
+            let(margin_field): concat("band", i, title(portion), "Margin");
+          let(net_field): concat("band", i, title(portion), "Net");
+          let(vat_field): concat("band", i, title(portion), "Vat");
+          let(retained): if_eq(paid, "deposit", "depositAmount", if_eq(refund_mode, "balance", "depositAmount", "price"));
+          computes derived: { field: vat_field; source_field: margin_field; rule: { kind: percentage_of; bps: tax_bps; }; rounding: floor; };
+          partitions: { total_field: retained; piece_fields: [supplier_field, net_field, vat_field]; };
+          partitions: { total_field: retained; piece_fields: [supplier_field, margin_field]; };
+          partitions: { total_field: margin_field; piece_fields: [net_field, vat_field]; };
+        }
+      }
+    }
+    agent_description: "Hold deposit and balance in one booking account. Apply a finite dated cancellation policy and release the supplier, operator and tax partition only after the named authority confirms. Refund the entire price when confirmation times out.";
+    lifecycle {
+      states created awaiting_confirmation confirmed released refunded canceled expired;
+      let(states_key): "states";
+      [states_key]: concat_lists(deposit_states, full_states);
+      initial created;
+      on deposit: created -> deposit_1;
+      on expire: created -> expired;
+      for i in len(cancel_bands) {
+        let(band): at(cancel_bands, i);
+      let(refund_mode): get(band, "refund");
+      let(full_refund): if_eq(refund_mode, "full", true, false);
+      let(balance_refund): if_eq(refund_mode, "balance", true, false);
+      let(retains): if_eq(refund_mode, "full", false, true);
+        let(band_name): get(band, "name");
+        let(deposit_state): concat("deposit_", i);
+        let(full_state): concat("full_", i);
+        let(balance_action): concat("balance_", band_name);
+        let(cancel_deposit): concat("cancel_deposit_", band_name);
+        let(cancel_full): concat("cancel_full_", band_name);
+        on [balance_action]: deposit_state -> full_state;
+        on [cancel_deposit]: deposit_state -> canceled;
+        on [cancel_full]: full_state -> canceled;
+        let(later): if_eq(i, 1, false, true);
+        when(later) {
+          let(previous_deposit): names("deposit_", sub(i, 1), "");
+          let(previous_full): names("full_", sub(i, 1), "");
+          let(open_deposit): concat("open_deposit_", band_name);
+          let(open_full): concat("open_full_", band_name);
+          on [open_deposit]: previous_deposit -> deposit_state;
+          on [open_full]: previous_full -> full_state;
+        }
+      }
+      on cancel_unpaid: deposit_states -> canceled;
+      on await_confirmation: full_states -> awaiting_confirmation;
+      on confirm: awaiting_confirmation -> confirmed;
+      on release: confirmed -> released;
+      on refund_unconfirmed: full_states | awaiting_confirmation -> refunded;
+    }
+    caller_parked_states: { confirmed: "Release pays the confirmed supplier and frozen partition."; };
+    action create {
+      public: none;
+      agent_description: "Freeze the booking terms and provision its holding account.";
+      unique: { namespace: instrument; by_fields: [bookingKey]; };
+      deadline: { field: balanceDueAt; };
+      steps: { operation: "account.escrow.provision"; bind: { currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; "owner.id": { from: instance; path: productId; }; "owner.type": { from: const; value: product; }; role: { from: const; value: product_escrow; }; }; capture: { heldAccountId: accountId; }; };
+    }
+    action deposit {
+      public: none;
+      agent_description: "Collect the derived deposit after the acceptance requirements pass.";
+      when(acceptance) { requires aggregate: acceptance; }
+      deadline: { field: balanceDueAt; }; port: { allowedParties: [payer]; };
+      moves: { key: deposit; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "depositAmount"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "fields.customerAccountId"; }; destinationAccountId: { from: instance; path: "refs.heldAccountId"; }; }; };
+      steps: [];
+    }
+    action expire { public: none; agent_description: "Close an unfunded booking."; due: { field: balanceDueAt; }; requires_drained: { path: refs.heldAccountId; }; steps: []; }
+    for i in len(cancel_bands) {
+      let(band): at(cancel_bands, i);
+      let(refund_mode): get(band, "refund");
+      let(full_refund): if_eq(refund_mode, "full", true, false);
+      let(balance_refund): if_eq(refund_mode, "balance", true, false);
+      let(retains): if_eq(refund_mode, "full", false, true);
+      let(band_name): get(band, "name");
+      let(balance_action): concat("balance_", band_name);
+      let(next_index): add(i, 1);
+      let(next_field): concat("band", next_index, "Start");
+      let(band_end): if_eq(i, band_count, "departureAt", next_field);
+      let(later): if_eq(i, 1, false, true);
+      action [balance_action] {
+        public: none; agent_description: "Collect the remaining balance once before its deadline.";
+        deadline: { field: balanceDueAt; }; port: { allowedParties: [payer]; };
+        moves: { key: balance; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "balanceAmount"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "fields.customerAccountId"; }; destinationAccountId: { from: instance; path: "refs.heldAccountId"; }; }; };
+        steps: [];
+      }
+      for paid in ["deposit", "full"] {
+          let(is_full): if_eq(paid, "full", true, false);
+        when(later) {
+          let(open_action): concat("open_", paid, "_", band_name);
+          action [open_action] { public: none; agent_description: "Open the next dated cancellation band."; due: { field: concat("band", i, "Start"); }; steps: []; }
+        }
+        let(portion): if_eq(refund_mode, "balance", "deposit", paid);
+        let(cancel_action): concat("cancel_", paid, "_", band_name);
+        action [cancel_action] {
+          public: none; agent_description: "Settle this paid amount under the active cancellation band.";
+          deadline: { field: band_end; }; port: { allowedParties: [payer]; };
+          when(full_refund) { moves: { key: refund; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", if_eq(paid, "deposit", "depositAmount", "price")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.customerAccountId"; }; }; }; }
+          when(retains) {
+            when(is_full) { when(balance_refund) { moves: { key: refund; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "balanceAmount"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.customerAccountId"; }; }; }; } }
+            moves: { key: supplier; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", i, "Supplier")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.supplierAccountId"; }; }; };
+            moves: { key: operator; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", i, title(portion), "Net")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.operatorAccountId"; }; }; };
+            moves: { key: vat; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", i, title(portion), "Vat")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.taxAccountId"; }; }; };
+          }
+          steps: [];
+        }
+      }
+    }
+    action cancel_unpaid {
+      public: none; agent_description: "Settle the deposit under the declared unpaid-balance band and end the remaining obligation.";
+      due: { field: balanceDueAt; };
+      when_not(unpaid_band) { moves: { key: refund; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: "fields.depositAmount"; }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.customerAccountId"; }; }; }; }
+      when(unpaid_band) {
+        let(unpaid_policy): at(cancel_bands, unpaid_band);
+        let(unpaid_full_refund): if_eq(get(unpaid_policy, "refund"), "full", true, false);
+        when(unpaid_full_refund) { moves: { key: refund; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: "fields.depositAmount"; }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.customerAccountId"; }; }; }; }
+        when_not(unpaid_full_refund) {
+      moves: { key: supplier; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", unpaid_band, "Supplier")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.supplierAccountId"; }; }; };
+      moves: { key: operator; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", unpaid_band, "DepositNet")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.operatorAccountId"; }; }; };
+      moves: { key: vat; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", concat("band", unpaid_band, "DepositVat")); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.taxAccountId"; }; }; };
+        }
+      }
+      steps: [];
+    }
+    action await_confirmation { public: none; agent_description: "Open confirmation at the booked departure."; due: { field: departureAt; }; steps: []; }
+    action confirm {
+      public: none; agent_description: "Consume the named supplier's approved decision for this booking before timeout.";
+      deadline: { field: confirmationDeadline; };
+      input: { type: object; additionalProperties: false; properties: { authorityId: { type: string; pattern: concat("^", prefix(authority_type), "_(sandbox|live)_[a-z0-9]{8,64}$"); }; }; required: [authorityId]; };
+      updates: [authorityId];
+      requires refs: { field: authorityId; statuses: [approved]; match: { instrumentInstanceId: fields.requestInstanceId; "fields.supplierAccountId": fields.decidingActorAccountId; "fields.supplierRole": fields.decidingRole; }; attests: { instrument: fields.requestInstrumentId; party: decider; action: fields.requestAction; digest: fields.inputDigest; role: fields.decidingRole; expires_at: fields.expiresAt; consume: consume; }; };
+      steps: [];
+    }
+    action release {
+      public: none; agent_description: "Pay supplier cost, operator net and VAT after confirmation.";
+      moves: { key: supplier; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "supplierCost"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.supplierAccountId"; }; }; };
+      moves: { key: operator; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "operatorNet"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.operatorAccountId"; }; }; };
+      moves: { key: vat; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "marginVat"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.taxAccountId"; }; }; };
+      steps: [];
+    }
+    action refund_unconfirmed {
+      public: none; agent_description: "Return the entire booking price when supplier confirmation times out.";
+      due: { field: confirmationDeadline; };
+      moves: { key: refund; operation: "internal_transfer.create"; bind: { amount: { from: instance; path: concat("fields.", "price"); }; currency: { from: instance; path: fields.currency; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: "refs.heldAccountId"; }; destinationAccountId: { from: instance; path: "fields.customerAccountId"; }; }; };
+      steps: [];
+    }
+  }
 }

package/std/money_flows/captured_payment.hsx

@@ -21,10 +21,6 @@ module std.money_flows.captured_payment
 // - `reserve_until`: Expiration date for the authorization hold.
 // - `correction`: Condition port allowing post-settlement amount corrections.
 // - `external_reversal`: Condition port allowing external processor chargebacks/reversals.
-// - `capture_mode`: Text specifying capture behavior (`"slice"` or `"full"`).
-// - `correction_mode`: Text specifying correction behavior.
-// - `negative_position`: Text policy when correction creates an overdraft.
-// - `timeout`: Timeout duration string for pending authorizations.
 // - `derived_amount`: Optional block declaring percentage fee calculation.
 //
 // ### Decision ports
@@ -44,10 +40,6 @@ module std.money_flows.captured_payment
 //   reserve_until: reserveUntil
 //   correction: port correct_capture
 //   external_reversal: port reverse_capture within P14D
-//   capture_mode: partial_then_full
-//   correction_mode: full_only
-//   negative_position: reject
-//   timeout: reject
 // }
 // port correct_capture { allowed: [payee] }
 // port reverse_capture {
@@ -55,7 +47,7 @@ module std.money_flows.captured_payment
 //   shape: { externalReference: text }
 // }
 // ```
-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>) {
+export instrument captured_payment<C>(payer: party, payee: party, amount: money<C>, reserve_until: date, correction: condition, external_reversal: condition, derived_amount: optional<block>) {
   let(correction_name): correction;
   let(reversal_name): external_reversal;
   let(reversal_window): external_reversal_within;

package/std/money_flows/conditional_disbursement.hsx

@@ -20,8 +20,6 @@ module std.money_flows.conditional_disbursement
 // - `cap`: Maximum total amount that can be disbursed across all child approvals in minor units of currency `C`.
 // - `amount`: Binding name for child approval amount values.
 // - `decision`: Port conditioning approval, requiring evidence reference.
-// - `reopen_policy`: Policy for reopening closed disbursements (`refuse`).
-// - `recovery_policy`: Policy for recovering overpayments (`separate_transfer`).
 //
 // ### Decision ports
 // - `decision`: External port providing decision evidence required to approve child disbursement amounts.
@@ -38,8 +36,6 @@ module std.money_flows.conditional_disbursement
 //   cap: policyLimit: money(SAR)
 //   amount: approvedAmount: money(SAR)
 //   decision: port approve_claim
-//   reopen_policy: refuse
-//   recovery_policy: separate_transfer
 // }
 // port approve_claim {
 //   allowed: [source]
@@ -52,8 +48,6 @@ export instrument conditional_disbursement<C>(
   cap: money<C>,
   amount: money<C>,
   decision: condition,
-  reopen_policy: text,
-  recovery_policy: text,
 ) {
   let(child_id): concat(instrument, "_approved_amount");
   let(child_amount): "amount";

package/std/money_flows/credit_facility.hsx

@@ -20,9 +20,6 @@ module std.money_flows.credit_facility
 // - `limit`: Total revolving borrowing limit in minor units of currency `C`.
 // - `expires_at`: Expiration date after which new draws cannot be opened.
 // - `obligation`: Reference to a scheduled obligation instrument handling draw repayments.
-// - `availability_policy`: Facility capacity availability policy (`revolving`).
-// - `expiry_policy`: Policy on facility expiration (`freeze_draws`).
-// - `close_policy`: Policy on facility closure (`no_open_draws`).
 //
 // ### Decision ports
 // None on the facility itself. Mandates and decision ports are declared on the linked `obligation` instrument.
@@ -52,9 +49,6 @@ module std.money_flows.credit_facility
 //   limit: facilityLimit: money(SAR)
 //   expires_at: expiresAt
 //   obligation: repayment.obligation
-//   availability_policy: revolving
-//   expiry_policy: freeze_draws
-//   close_policy: no_open_draws
 // }
 // ```
 export instrument credit_facility<C>(
@@ -64,9 +58,6 @@ export instrument credit_facility<C>(
   limit: money<C>,
   expires_at: date,
   obligation: ref,
-  availability_policy: text,
-  expiry_policy: text,
-  close_policy: text,
 ) {
   let(draw_id): concat(instrument, "_draw");
   let(parent_field): camel(concat(instrument, "_id"));