@hyperscale0/hsx 2.4.1 → 3.0.1

package/std/money_flows/index.hsx

@@ -1,4 +0,0 @@
-module std.money_flows
-
-// Import named exports from "std/money_flows".
-// SEMANTICS.md groups modules by lifecycle and explains their money effects.

package/std/money_flows/instant_transfer.hsx

@@ -1,231 +0,0 @@
-module std.money_flows.instant_transfer
-
-// Direct, single-step push transfer from payer to payee with optional tiered or percentage fees.
-//
-// ### Purpose
-// `instant_transfer` debits a payer and credits a payee immediately in a single execution step.
-// It fits peer-to-peer transfers, direct disbursements, instant payouts, wallet reloads, and simple point-of-sale payments.
-//
-// ### Selection guidance
-// - vs `captured_payment`: `instant_transfer` moves money in one atomic step without prior authorization holds,
-//   incremental captures, voids, or post-settlement correction ports. Use `captured_payment` when authorization must precede capture.
-// - vs `conditional_disbursement`: `instant_transfer` executes immediately without external decision evidence
-//   or cumulative cap tracking. Use `conditional_disbursement` when payments require evidence submission or aggregate milestone caps.
-// - vs `held_payment`: `instant_transfer` never holds funds in an intermediary escrow account.
-//
-// ### Parameters
-// - `payer`: Funding party whose account is debited.
-// - `payee`: Recipient party whose account is credited.
-// - `amount`: Transfer amount in minor units of currency `C`.
-// - `fees`: Optional fee configuration block specifying flat fees, percentage fees, or bracketed fee tiers for payer and/or payee.
-// - `derived_amount`: Optional block declaring derived platform fees calculated from the transfer amount.
-//
-// ### Decision ports
-// None. Transfers execute immediately upon invocation.
-//
-// ### Example
-// ```hsx
-// program instant_transfer_example "Instant transfer example"
-// import { instant_transfer } from "std/money_flows"
-// party customer: person
-// party merchant: business
-// settlement transfer = instant_transfer {
-//   payer: customer
-//   payee: merchant
-//   amount: transferAmount: money(SAR)
-//   fees {
-//     customer: checkoutFee: money(SAR)
-//     merchant {
-//       tier { from: 0, to: 10000, fee: 1% }
-//       tier { from: 10000, fee: highValueFee: money(SAR) }
-//     }
-//   }
-// }
-// ```
-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);
-  let(payee_fee): get(fees, payee);
-  let(payer_fee_kind): kind(payer_fee);
-  let(payee_fee_kind): kind(payee_fee);
-  let(payer_account_field): camel(concat(payer, "_account_id"));
-  let(payee_account_field): camel(concat(payee, "_account_id"));
-  let(net_bps): sub(10000, payee_fee);
-  let(net_percent): percent_text(net_bps);
-  let(payee_bps): basis_points(payee_fee);
-  let(payee_tiers): values(payee_fee);
-  let(first_tier): at(payee_tiers, 1);
-  let(second_tier): at(payee_tiers, 2);
-  let(second_tier_fee): get(second_tier, "fee");
-  when(derived_amount) {
-    let(derived_field): get(derived_amount, "field");
-    let(derived_source): get(derived_amount, "source");
-    let(derived_rule): get(derived_amount, "rule");
-    let(derived_bearer): get(derived_amount, "bearer");
-  }
-  agent_description: concat("Reach for instant transfer when the ", words(payer), " pays the ", words(payee), " straight through with no custody step. The money leaves and lands in one call. Pick deposit when the money must be held first, and captured payment when the payee takes it in slices.");
-  summary: concat("Instant payment from ", words(payer), " to ", words(payee));
-  title: sentence(instrument);
-  description: concat("Instant transfer: the ", words(payer), " pays ", amount, " straight through to the ", words(payee), ", no custody");
-  fields {
-    when_not(fees) {
-      when(derived_amount) {
-        let(fee_collection_key): "x-hyperscale-fee-collection-port";
-        let(reference_filter_key): "x-hyperscale-reference-filter";
-        platformAccountId {
-          type: account<C>;
-          description: "The product fee collection account";
-          [fee_collection_key]: true;
-          [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
-        }
-      }
-    }
-    when(fees) {
-      let(fee_collection_key): "x-hyperscale-fee-collection-port";
-      let(reference_filter_key): "x-hyperscale-reference-filter";
-      platformAccountId {
-        type: account<C>;
-        description: "The product fee collection account";
-        [fee_collection_key]: true;
-        [reference_filter_key]: { column: role; values: [customer_balance, product_revenue]; };
-      }
-    }
-    when_not(fees) {
-      amount { type: money<C>; description: "The amount in {C} minor units, paid through whole"; }
-    }
-    when(fees) {
-      amount { type: money<C>; description: "The gross amount in {C} minor units; the piece fields below partition it exactly"; }
-      when_eq(payee_fee_kind, percent) {
-        piece1Amount { type: money<C>; description: concat(net_percent, " of ", amount, " (carries the integer-division remainder): released to the ", payee, ". Computed as floor(", amount, " * ", net_bps, " / 10000) in ", C, " minor units"); pattern: "^[1-9][0-9]{0,17}$"; }
-        piece2Amount { type: money<C>; description: concat(payee_fee, " of ", amount, ": released to the platform. Computed as floor(", amount, " * ", payee_bps, " / 10000) in ", C, " minor units"); pattern: "^[1-9][0-9]{0,17}$"; optional: true; }
-      }
-      when_eq(payee_fee_kind, block) {
-        netOfCarvedFeeAmount { type: money<C>; description: "The remainder of {amount} after the carved platform fee"; pattern: "^[1-9][0-9]{0,17}$"; }
-        carvedFeeAmount { type: money<C>; description: "The carved platform fee selected from {amount}"; pattern: "^[1-9][0-9]{0,17}$"; optional: true; }
-      }
-      when_eq(payer_fee_kind, percent) {
-        serviceFeeAmount { type: money<C>; description: "Machine-owned {payer_fee} service fee computed from {amount}; charged on top"; pattern: "^[1-9][0-9]{0,17}$"; optional: true; }
-      }
-      when_eq(payer_fee_kind, binding) {
-        [payer_fee] { type: payer_fee; description: "Immutable exact {payer} fee in {C} minor units"; pattern: "^[1-9][0-9]{0,17}$"; }
-      }
-      when_eq(payee_fee_kind, block) {
-        [second_tier_fee] { type: second_tier_fee; description: "Immutable exact {payee} fee in {C} minor units"; pattern: "^[1-9][0-9]{0,17}$"; }
-      }
-    }
-    when(derived_amount) {
-      [derived_field] { type: money<C>; description: "Machine-computed {derived_rule} of {derived_source}; callers never supply it"; pattern: "^[1-9][0-9]{0,17}$"; optional: true; }
-    }
-  }
-  lifecycle {
-    when_not(fees) { states created paid; }
-    when(fees) { states created paying_1 paying_2 paid; }
-    initial created;
-    when_not(fees) { on pay_piece_1: created -> paid; }
-    when(fees) {
-      on pay_piece_1: created -> paying_1;
-      on pay_piece_2: paying_1 -> paying_2;
-      on collect_service_fee: paying_2 -> paid;
-    }
-  }
-  parties {
-    payer: payer;
-    beneficiary: payee;
-  }
-  when(derived_amount) {
-    computes derived: { field: derived_field; source_field: derived_source; rounding: floor; rule: { kind: percentage_of; bps: derived_rule; }; };
-  }
-  when(fees) {
-    when_eq(payer_fee_kind, percent) {
-      computes fees: { amount_field: serviceFeeAmount; base_field: amount; bearer_field: payer_account_field; position: on_top; rule: { kind: bps; bps: payer_fee; }; };
-    }
-    when_eq(payer_fee_kind, binding) {
-      computes fees: { amount_field: camel(payer_fee); base_field: amount; bearer_field: payer_account_field; position: on_top; rule: { kind: exact; field: camel(payer_fee); currency_field: currency; }; };
-    }
-    when_eq(payee_fee_kind, percent) {
-      computes fees: { amount_field: piece2Amount; base_field: amount; bearer_field: payee_account_field; position: carved; rule: { kind: bps; bps: payee_fee; }; };
-      partitions: { total_field: amount; piece_fields: [piece1Amount, piece2Amount]; };
-    }
-    when_eq(payee_fee_kind, block) {
-      computes fees: { amount_field: carvedFeeAmount; base_field: amount; bearer_field: payee_account_field; position: carved; rule: { kind: tiered; tiers: [{ from_inclusive: concat("", get(first_tier, "from")); to_exclusive: concat("", get(first_tier, "to")); rule: { kind: bps; bps: get(first_tier, "fee"); }; }, { from_inclusive: concat("", get(second_tier, "from")); rule: { kind: exact; field: camel(second_tier_fee); currency_field: currency; }; }]; }; };
-      partitions: { total_field: amount; piece_fields: [netOfCarvedFeeAmount, carvedFeeAmount]; };
-    }
-  }
-  action create {
-    let(metadata_instrument): "metadata.instrumentId";
-    let(metadata_instance): "metadata.instrumentInstanceId";
-    let(metadata_phase): "metadata.phase";
-    agent_description: "Open the payment row before anything moves. The caller supplies the {amount}, the currency, and both party accounts. Fee and derived pieces are computed from the {amount}, callers never supply them. Call pay piece 1 to move the money.";
-    summary: concat("Create a ", words(instrument), " payment");
-    when(derived_amount) {
-      moves: [{
-        key: "derived_amount";
-        operation: internal_transfer.create;
-        bind: {
-          amount: { from: instance; path: concat("fields.", derived_field); };
-          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: create; };
-          productId: { from: instance; path: productId; };
-          sourceAccountId: { from: instance; path: concat("fields.", camel(derived_bearer), "AccountId"); };
-        };
-        capture: { createDerivedAmountTransferId: transferId; };
-      }];
-    }
-    steps: [];
-  }
-  action pay_piece_1 {
-    let(metadata_instrument): "metadata.instrumentId";
-    let(metadata_instance): "metadata.instrumentInstanceId";
-    let(metadata_phase): "metadata.phase";
-    agent_description: concat("Move the first piece from the ", words(payer), " to the ", words(payee), ". The payment must be created. This moves the whole amount unless the product carves a payee fee, in which case it moves the net share and pay piece 2 takes the fee.");
-    summary: "Pay piece 1 of the amount through";
-    when_not(fees) {
-      moves: [{ key: transfer; amount: amount; from: payer; to: beneficiary; }];
-    }
-    when(fees) {
-      when_eq(payee_fee_kind, none) {
-        moves: [{ key: transfer; amount: amount; from: payer; to: beneficiary; }];
-      }
-      when_eq(payee_fee_kind, percent) {
-        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: pay_piece_1; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { payPiece1TransferTransferId: transferId; }; }];
-      }
-      when_eq(payee_fee_kind, block) {
-        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) {
-    action pay_piece_2 {
-      let(metadata_instrument): "metadata.instrumentId";
-      let(metadata_instance): "metadata.instrumentInstanceId";
-      let(metadata_phase): "metadata.phase";
-      agent_description: concat("Move the carved platform fee out of the amount. Call this after pay piece 1. When the product carves no ", words(payee), " fee this only steps the payment forward and moves nothing.");
-      summary: "Pay piece 2 of the amount through";
-      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: fields.platformAccountId; }; [metadata_instrument]: { from: const; value: instrument; }; [metadata_instance]: { from: instance; path: instrumentInstanceId; }; [metadata_phase]: { from: const; value: pay_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { payPiece2TransferTransferId: transferId; }; }];
-      }
-      when_eq(payee_fee_kind, block) {
-        moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.carvedFeeAmount; }; 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: pay_piece_2; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { payPiece2TransferTransferId: transferId; }; }];
-      }
-      steps: [];
-    }
-    action collect_service_fee {
-      let(metadata_instrument): "metadata.instrumentId";
-      let(metadata_instance): "metadata.instrumentInstanceId";
-      let(metadata_phase): "metadata.phase";
-      agent_description: concat("Finish the payment and collect the service fee the ", words(payer), " owes on top of the amount. Both pieces must already be paid. When the product charges no payer fee this only closes the payment out.");
-      summary: "Collect the payer-side service fee";
-      when_eq(payer_fee_kind, percent) {
-        moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: fields.serviceFeeAmount; }; 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: collect_service_fee; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { collectServiceFeeTransferTransferId: transferId; }; }];
-      }
-      when_eq(payer_fee_kind, binding) {
-        moves: [{ key: transfer; 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: collect_service_fee; }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", payer_account_field); }; }; capture: { collectServiceFeeTransferTransferId: transferId; }; }];
-      }
-      steps: [];
-    }
-  }
-}

package/std/money_flows/metered.hsx

@@ -1,104 +0,0 @@
-module std.money_flows.metered
-
-// Usage-based billing against a committed rate card over an open period until a stored close date.
-//
-// ### Purpose
-// `metered` bills customers for variable resource consumption such as API requests, compute hours,
-// storage gigabytes, or utility consumption. The rate card is fixed when the period opens, and individual
-// usage events are charged incrementally until the billing period closes on `close_by`.
-//
-// ### Selection guidance
-// - vs `scheduled`: `metered` charges variable amounts per event calculated from consumed units and committed
-//   rate card prices. `scheduled` executes transfers on fixed calendar recurrence intervals (`every`, `first_due`)
-//   with predetermined amounts or installments.
-//
-// ### Parameters
-// - `payer`: The customer being billed for usage.
-// - `payee`: The service provider receiving usage revenue.
-// - `close_by`: Date when the metering period closes, preventing further usage charges.
-// - `rates`: Block mapping rate metric names to their per-unit money prices committed at period open.
-//
-// ### Decision ports
-// None. Charges are driven by caller billing actions and period closure.
-//
-// ### Example
-// ```hsx
-// program metered_example "Metered example"
-// import { metered } from "std/money_flows"
-// party customer: business
-// party provider: business
-// settlement usage = metered {
-//   payer: customer
-//   payee: provider
-//   close_by: periodEnd
-//   rates {
-//     api_call: callRate: money(SAR)
-//     storage_gib: storageRate: money(SAR)
-//   }
-// }
-// ```
-export instrument metered(
-  payer: party,
-  payee: party,
-  close_by: date,
-  rates: unknown,
-) {
-  let(instrument_words): words(instrument);
-  title: sentence(instrument);
-  agent_description: "Reach for metered when the {payer} is billed per unit at a rate card fixed when the period opens, and the period closes on {close_by}. Every charge is its own transfer. Pick scheduled for a flat repeating amount and instant transfer for a one-off payment.";
-  summary: "Metered charges from {payer} on a committed rate card";
-  description: "Metered usage: the {payer} is charged per unit at the committed rate card until the period closes on its stored end date";
-
-  fields {
-    close_by: {
-      type: date;
-      description: "End of this metering period; the close makes further charges unreachable";
-    }
-    for item in keys(rates) {
-      let(amount_binding): get(rates, item);
-      let(rate_words): words(item);
-      [amount_binding]: {
-        type: amount_binding;
-        description: "Per-unit price of {rate_words} in SAR minor units, committed at period open";
-      }
-    }
-  }
-
-  parties {
-    payer: payer;
-    beneficiary: payee;
-  }
-
-  lifecycle {
-    states open closed;
-    initial open;
-    for item in keys(rates) {
-      on charge_[item]: open -> open;
-    }
-    on close_period: open -> closed;
-  }
-
-  action create {
-    agent_description: "Open the metering period with its committed rate card. The caller supplies the {close_by} anchor and every per-unit price. The prices are fixed here and no later charge can change them. No money moves.";
-    summary: "Open a {instrument_words} period with its committed rate card";
-    steps: [];
-  }
-
-  for item in keys(rates) {
-    action charge_[item] {
-      let(amount_binding): get(rates, item);
-      let(amount_field): concat(amount_binding);
-      let(rate_words): words(item);
-      agent_description: "Charge one metered {rate_words} at the committed price. The period must still be open, so charge before {close_by}. The transfer posts from the {payer} to the {payee} at once and there is no reversal action.";
-      summary: "Charge one metered {rate_words}; the emission is the transfer itself";
-      moves: [{ amount: amount_field; from: payer; to: beneficiary; key: transfer; }];
-      steps: [];
-    }
-  }
-
-  action close_period {
-    summary: "Close the metering period; no further usage can be charged";
-    due: { field: close_by; };
-    steps: [];
-  }
-}

package/std/money_flows/pooled_split.hsx

@@ -1,109 +0,0 @@
-module std.money_flows.pooled_split
-
-// Fixed multi-recipient revenue or period pool funded share-by-share and released automatically on a due date.
-//
-// ### Purpose
-// `pooled_split` pools a period total from one payer and splits it across a fixed roster of recipients
-// according to predetermined percentage shares (with integer division remainder assigned to `remainder_to`).
-// Callers fund the pool share-by-share, and payouts disburse automatically to each recipient on `payout_due`.
-//
-// ### Selection guidance
-// - vs `weighted_distribution`: `pooled_split` hardcodes a fixed set of recipients and static percentage shares
-//   directly in the contract. `weighted_distribution` handles dynamic recipient counts where arbitrary weights
-//   are recorded as child records and frozen via a snapshot port before distribution.
-// - vs `settlement_batch`: `settlement_batch` aggregates multiple payments from many sources into one net payout.
-//   `pooled_split` takes one period total from one payer and partitions it out to multiple recipients.
-//
-// ### Parameters
-// - `payer`: The funding party providing the pooled amount.
-// - `amount`: Total pooled amount in minor units of currency `C`.
-// - `payout_due`: Stored payout date when the pool distributes to all recipients.
-// - `split`: Block declaring each recipient's percentage share and `remainder_to` recipient for rounding remainders.
-//
-// ### Decision ports
-// None. Payout distribution triggers automatically from the stored `payout_due` date.
-//
-// ### Example
-// ```hsx
-// program pooled_split_example "Pooled split example"
-// import { pooled_split } from "std/money_flows"
-// party payer: business
-// party first_recipient: business
-// party second_recipient: business
-// settlement pool = pooled_split {
-//   payer: payer
-//   amount: poolAmount: money(SAR)
-//   payout_due: payoutDueAt
-//   split {
-//     first_recipient: 60%
-//     second_recipient: 40%
-//     remainder_to: first_recipient
-//   }
-// }
-// ```
-export instrument pooled_split<C>(payer: party, amount: money<C>, payout_due: date, split: block) {
-  let(recipients): keys_except(split, "remainder_to");
-  let(recipient_count): len(recipients);
-  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"); "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"); "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");
-      }
-    }
-  }
-  lifecycle {
-    states created;
-    initial created;
-    for index in sub(recipient_count, 1) { states pooling_[index]; }
-    states pooled;
-    for index in sub(recipient_count, 1) { states distributing_[index]; }
-    states distributed;
-    for index in recipient_count {
-      let(fund_from): if_eq(index, 1, "created", concat("pooling_", sub(index, 1)));
-      let(fund_to): if_eq(index, recipient_count, "pooled", concat("pooling_", index));
-      on fund_share_[index]: [fund_from] -> [fund_to];
-      let(distribute_from): if_eq(index, 1, "pooled", concat("distributing_", sub(index, 1)));
-      let(distribute_to): if_eq(index, recipient_count, "distributed", concat("distributing_", index));
-      on distribute_share_[index]: [distribute_from] -> [distribute_to];
-    }
-  }
-  parties { beneficiary: concat(camel(at(recipients, 1)), "AccountId"); payer: concat(camel(payer), "AccountId"); }
-  required: concat_lists([concat(camel(payer), "AccountId")], suffix_each(recipients, "AccountId"), [concat("", amount), concat("", payout_due)], suffix_each(recipients, "ShareAmount"), ["currency"]);
-  title: sentence(instrument);
-  id_prefix: prefix(instrument);
-  agent_description: concat("Reach for ", words(instrument), " when the ", words(payer), " funds one period total that is then split across ", recipient_count, " fixed recipients by stored share amounts. Callers fund the pool one share at a time. Each recipient's payout fires from the stored payout date, not from a call.");
-  summary: concat("Period pool from ", words(payer), " split ", recipient_count, " ways");
-  description: concat("Pooled split: the ", words(payer), " pools the period's ", amount, " share by share; the pool distributes to every recipient in full on the stored payout date");
-  partitions { totalField: amount; pieceFields: suffix_each(recipients, "ShareAmount"); }
-  action create {
-    agent_description: concat("Open a ", words(instrument), " period and provision the escrow account the pool sits in. This is the first call on the period, and funding a share refuses until it lands. It moves no money.");
-    summary: concat("Open a ", words(instrument), " period");
-    moves: [];
-    steps: [{ operation: "account.escrow.provision"; bind: { currency: { from: instance; path: "fields.currency"; }; "owner.id": { from: instance; path: productId; }; "owner.type": { from: const; value: product; }; productId: { from: instance; path: productId; }; role: { from: const; value: product_escrow; }; }; capture: { escrowAccountId: accountId; }; }];
-  }
-  for index in recipient_count {
-    let(recipient): at(recipients, index);
-    let(share_field): concat(camel(recipient), "ShareAmount");
-    action fund_share_[index] {
-      agent_description: concat("Move share ", index, " of the period total, the ", words(recipient), "'s cut, from the ", words(payer), " into the pool escrow. Shares fund in order, so every earlier share must be in already. It debits the ", words(payer), " for real. The pool pays out from the stored payout date with no release call.");
-      summary: concat("Pool share ", index, " of the period total");
-      moves: [{ amount: share_field; from: payer; to: refs.escrowAccountId; key: transfer; }];
-      steps: [];
-    }
-    action distribute_share_[index] {
-      summary: concat("Distribute the ", words(recipient), "'s share of the pool");
-      due { field: payout_due; }
-      moves: [{ amount: share_field; from: refs.escrowAccountId; to: recipient; key: transfer; }];
-      steps: [];
-    }
-  }
-}