@hyperscale0/hsx 1.0.0-beta.1 → 1.0.0

package/std/settlements/threshold_pool.hsx

@@ -0,0 +1,221 @@
+module std.settlements.threshold_pool
+
+export instrument threshold_pool<C>(
+  contributor: optional<party>,
+  beneficiary: optional<party>,
+  target: money<C>,
+  commitment: money<C>,
+  max_contributors: optional<integer>,
+  close_by: date,
+  close_policy: optional<text>,
+  overfund_policy: optional<text>,
+  cancel_policy: optional<text>,
+  fail_policy: optional<text>,
+  beneficiary_account: optional<account<C>>,
+  memo: optional<text>,
+  contribution_instrument: optional<block>,
+  wording: optional<block>,
+) {
+  when(wording) {
+    let(wording_unknown_keys): keys_except(wording, "pool_summary", "pool_description", "create_summary", "commitment_create_summary", "commitment_cancel_summary", "commitment_refund_summary");
+    when(wording_unknown_keys) {
+      unsupported {
+        code: HSX1407;
+        message: "threshold_pool wording contains an unknown key";
+        fix: "use only the six declared threshold_pool wording keys";
+      }
+    }
+  }
+  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]; }; }
+    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; }
+    target { type: money<C>; description: "Funding target in {C} minor units"; }
+  }
+  lifecycle {
+    states open active failed settled;
+    initial open;
+    on activate: open -> active;
+    on fail: open -> failed;
+    on close: active -> settled;
+  }
+  parties { beneficiary: concat(camel(beneficiary), "AccountId"); }
+  required: [concat(camel(beneficiary), "AccountId"), currency, target, close_by, maxContributors];
+  title: sentence(instrument);
+  id_prefix: prefix(instrument);
+  let(pool_summary): get(wording, "pool_summary");
+  when_not(pool_summary) { summary: concat("Threshold contribution pool for ", words(beneficiary)); }
+  when(pool_summary) { summary: pool_summary; }
+  let(pool_description): get(wording, "pool_description");
+  when_not(pool_description) { description: "All-or-nothing aggregate contribution threshold"; }
+  when(pool_description) { description: pool_description; }
+  aggregate_invariants { childField: amount; childInstrumentId: concat(instrument, "_commitment"); childRefField: concat(camel(instrument), "Id"); childStatuses: [committed]; parentField: target; }
+  aggregate_invariants { childInstrumentId: concat(instrument, "_commitment"); childRefField: concat(camel(instrument), "Id"); childStatuses: [committed]; count: true; parentField: maxContributors; }
+  action create {
+    agent_description: "Open the pool before any commitment exists. The caller supplies the target, the currency, the beneficiary account, the close anchor, and the pinned contributor count. No money moves and the pool opens for commitments.";
+    let(create_summary): get(wording, "create_summary");
+    when_not(create_summary) { summary: "Open the contribution pool"; }
+    when(create_summary) { summary: create_summary; }
+    moves: [];
+    steps: [];
+  }
+  action activate {
+    summary: "Activate when commitments meet the target";
+    due { field: close_by; }
+    requires aggregate { instrumentId: concat(instrument, "_commitment"); over: children; refField: concat(camel(instrument), "Id"); statuses: [committed]; check: { kind: sum_at_least; amountField: amount; targetField: target; }; }
+    moves: [];
+    steps: [];
+  }
+  action fail {
+    summary: "Fail when commitments remain below target";
+    due { field: close_by; }
+    requires aggregate { instrumentId: concat(instrument, "_commitment"); over: children; refField: concat(camel(instrument), "Id"); statuses: [committed]; check: { kind: sum_below; amountField: amount; targetField: target; }; }
+    moves: [];
+    steps: [];
+  }
+  action close {
+    agent_description: "Settle the pool once every admitted commitment is collected or was cancelled before activation. The pool must be active. No money moves here, collect already paid the beneficiary.";
+    summary: "Settle after every admitted row is collected or was cancelled before activation";
+    requires aggregate { instrumentId: concat(instrument, "_commitment"); over: children; refField: concat(camel(instrument), "Id"); statuses: [cancelled, collected]; check: { kind: all_in; }; }
+    moves: [];
+    steps: [];
+  }
+  instruments {
+    instrument {
+      let(parent_name): instrument;
+      id: concat(parent_name, "_commitment");
+      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]; }; }
+        [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]; }; }
+        currency { type: text; description: "ISO 4217 currency code"; minLength: 3; maxLength: 3; pattern: "^[A-Z]{3}$"; }
+      }
+      lifecycle {
+        states committed cancelled collected refunded;
+        initial committed;
+        on cancel: committed -> cancelled;
+        on collect: committed -> collected;
+        on refund: committed -> refunded;
+      }
+      parties { beneficiary: concat(camel(beneficiary), "AccountId"); payer: concat(camel(contributor), "AccountId"); }
+      required: [concat(camel(beneficiary), "AccountId"), concat(camel(contributor), "AccountId"), amount, currency, concat(camel(parent_name), "Id")];
+      title: concat(sentence(parent_name), " Commitment");
+      agent_description: concat("Reach for this child row to record one whole commitment into a ", words(parent_name), ". Each contributor commits once, the money sits in the product escrow, and whether it is collected or refunded depends on the pool reaching its target.");
+      summary: concat("Whole commitment to ", parent_name);
+      description: concat("One whole commitment linked to ", parent_name);
+      action create {
+        agent_description: "Commit one whole amount into the pool escrow. The pool must still be open, the currency and beneficiary account must match it, and the committed total plus this amount must stay within the target. The money leaves the contributor now.";
+        let(commitment_create_summary): get(wording, "commitment_create_summary");
+        when_not(commitment_create_summary) { summary: "Store one whole commitment without exceeding the pool target"; }
+        when(commitment_create_summary) { summary: commitment_create_summary; }
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [open]; bind: { [beneficiary]AccountId: concat("fields.", camel(beneficiary), "AccountId"); currency: "fields.currency"; }; }
+        requires exposure { amountField: amount; anchorField: concat(camel(parent_name), "Id"); capField: target; capOnAnchor: true; childInstrumentId: concat(parent_name, "_commitment"); statuses: [committed]; }
+        moves: [{ amount: amount; from: payer; to: refs.escrowAccountId; key: commit; }];
+        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; }; }];
+      }
+      action cancel {
+        agent_description: "Pull one commitment back out of escrow to the contributor. The pool must still be open, so this is unavailable once the pool activates or fails. The money returns and the commitment is closed.";
+        let(commitment_cancel_summary): get(wording, "commitment_cancel_summary");
+        when_not(commitment_cancel_summary) { summary: "Cancel one commitment while the pool is open"; }
+        when(commitment_cancel_summary) { summary: commitment_cancel_summary; }
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [open]; match: { "fields.[beneficiary]AccountId": concat("fields.", camel(beneficiary), "AccountId"); "fields.currency": "fields.currency"; }; }
+        moves: [{ amount: amount; from: refs.escrowAccountId; to: payer; key: cancel; }];
+        steps: [];
+      }
+      action collect {
+        agent_description: "Release one commitment out of escrow to the beneficiary. The pool must be active, which happens only once commitments meet the target. The money moves for good.";
+        summary: "Collect one successful commitment whole";
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [active]; match: { "fields.[beneficiary]AccountId": concat("fields.", camel(beneficiary), "AccountId"); "fields.currency": "fields.currency"; }; }
+        moves: [{ amount: amount; from: refs.escrowAccountId; to: beneficiary; key: collect; }];
+        steps: [];
+      }
+      action refund {
+        agent_description: "Return one commitment out of escrow to the contributor after the pool failed to reach its target. The pool must be in failed. The money returns and the commitment is closed.";
+        let(commitment_refund_summary): get(wording, "commitment_refund_summary");
+        when_not(commitment_refund_summary) { summary: "Refund one failed-pool commitment whole"; }
+        when(commitment_refund_summary) { summary: commitment_refund_summary; }
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [failed]; match: { "fields.[beneficiary]AccountId": concat("fields.", camel(beneficiary), "AccountId"); "fields.currency": "fields.currency"; }; }
+        moves: [{ amount: amount; from: refs.escrowAccountId; to: payer; key: refund; }];
+        steps: [];
+      }
+    }
+  }
+  }
+
+  when(contribution_instrument) {
+    let(contribution_id): get(contribution_instrument, "instrument");
+    let(contribution_ref_field): get(contribution_instrument, "ref_field");
+    let(contribution_amount_field): get(contribution_instrument, "amount_field");
+    let(committed_status): get(contribution_instrument, "committed_status");
+    let(collected_status): get(contribution_instrument, "collected_status");
+    let(instrument_id_prefix): get(contribution_instrument, "id_prefix");
+    let(active_parked): get(contribution_instrument, "active_parked");
+    let(custody_ref): get(contribution_instrument, "custody_ref");
+    let(beneficiary_account_description): get(contribution_instrument, "beneficiary_account_description");
+    let(target_description): get(contribution_instrument, "target_description");
+    let(currency_description): get(contribution_instrument, "currency_description");
+    let(create_examples): get(contribution_instrument, "create_examples");
+    let(activate_examples): get(contribution_instrument, "activate_examples");
+    let(fail_examples): get(contribution_instrument, "fail_examples");
+    let(close_examples): get(contribution_instrument, "close_examples");
+    let(beneficiary_account_field): camel(beneficiary_account);
+    let(target_field): camel(target);
+    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]; }; }
+      [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; } }
+      [target_field] { type: money<C>; description: target_description; }
+    }
+    lifecycle {
+      states open active failed settled;
+      initial open;
+      on activate: open -> active;
+      on close: active -> settled;
+      on fail: open -> failed;
+    }
+    parties { beneficiary: beneficiary_account_field; }
+    required: [beneficiary_account_field, target_field, currency, close_field];
+    aggregate_invariants { childField: contribution_amount_field; childInstrumentId: contribution_id; childRefField: contribution_ref_field; childStatuses: [committed_status, collected_status]; parentField: target_field; }
+    caller_parked_states { active: active_parked; }
+    id_prefix: instrument_id_prefix;
+    action create {
+      public: none;
+      agent_description: "Open the pool before any contribution exists. The caller supplies the target, the currency, the beneficiary account, and the close anchor, and the pool provisions its escrow account. No money moves.";
+      examples: create_examples;
+      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: { [custody_ref]: accountId; }; }];
+    }
+    action activate {
+      public: none;
+      due { field: close_field; }
+      examples: activate_examples;
+      requires aggregate { instrumentId: contribution_id; over: children; refField: contribution_ref_field; statuses: [committed_status]; check: { kind: sum_at_least; amountField: contribution_amount_field; targetField: target_field; }; }
+      moves: [];
+      steps: [];
+    }
+    action fail {
+      public: none;
+      due { field: close_field; }
+      examples: fail_examples;
+      requires aggregate { instrumentId: contribution_id; over: children; refField: contribution_ref_field; statuses: [committed_status]; check: { kind: sum_below; amountField: contribution_amount_field; targetField: target_field; }; }
+      moves: [];
+      steps: [];
+    }
+    action close {
+      public: none;
+      agent_description: "Settle the pool once every contribution has been collected into the beneficiary account. No money moves. Refused while any contribution is still uncollected, so wait for the per-contribution collections to run rather than retrying.";
+      examples: close_examples;
+      requires aggregate { instrumentId: contribution_id; over: children; refField: contribution_ref_field; statuses: [collected_status]; check: { kind: all_in; }; }
+      moves: [];
+      steps: [];
+    }
+  }
+}

package/std/settlements/weighted_distribution.hsx

@@ -0,0 +1,141 @@
+module std.settlements.weighted_distribution
+
+export instrument weighted_distribution<C>(
+  source: party,
+  recipient: party,
+  amount: money<C>,
+  record_at: date,
+  weight: optional<money<C>>,
+  max_recipients: optional<integer>,
+  snapshot: optional<condition>,
+  rounding_policy: optional<text>,
+  withholding_policy: optional<text>,
+  correction_policy: optional<text>,
+  flat: optional<block>,
+  id_prefix_override: optional<text>,
+) {
+  when_not(flat) {
+  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]; }; }
+    maxRecipients { type: integer; description: concat("Exactly ", max_recipients, " frozen entitlement rows"); const: max_recipients; }
+    record_at { type: date; description: "Stored record date"; }
+  }
+  lifecycle { states open snapshotted; initial open; on [snapshot]: open -> snapshotted; }
+  parties { payer: concat(camel(source), "AccountId"); }
+  required: [concat(camel(source), "AccountId"), currency, amount, record_at, maxRecipients];
+  title: sentence(instrument);
+  id_prefix: prefix(instrument);
+  agent_description: "Reach for weighted distribution when one pool splits across many recipients by declared weights. Record one entitlement per recipient, freeze the set with the snapshot port, then each entitlement pays its own largest-remainder share, so the shares add back to the pool exactly. Settlement batch goes the other way, many charges into one payout.";
+  summary: "Frozen largest-remainder distribution";
+  description: "Evidence-frozen weighted distribution";
+  aggregate_invariants { childInstrumentId: concat(instrument, "_entitlement"); childRefField: concat(camel(instrument), "Id"); childStatuses: [recorded, paid]; count: true; parentField: maxRecipients; }
+  action create { agent_description: "Open a distribution and start recording entitlements. No money moves. The pool amount, the record date, and the exact recipient count are fixed here."; summary: "Open entitlement recording"; moves: []; steps: []; }
+  action [snapshot] {
+    agent_description: "Freeze the entitlement set against a stated evidence reference. The distribution must still be open and its recorded entitlements must match the declared recipient count. Nothing can be recorded afterwards and there is no unfreeze. No money moves.";
+    summary: "Freeze the entitlement set from stored evidence";
+    port { allowedParties: [payer]; }
+    input { type: object; properties: { evidenceReference: { type: string; description: "Required decision reference retained in the operation receipt"; minLength: 1; maxLength: 180; }; }; required: [evidenceReference]; additionalProperties: false; }
+    capture_input { snapshotEvidenceReference: evidenceReference; }
+    moves: [];
+    steps: [];
+  }
+  instruments {
+    instrument {
+      let(parent_name): instrument;
+      id: concat(parent_name, "_entitlement");
+      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]; }; }
+        [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]; }; }
+      }
+      lifecycle { states recorded paid; initial recorded; on payout: recorded -> paid; }
+      parties { beneficiary: concat(camel(recipient), "AccountId"); payer: concat(camel(source), "AccountId"); }
+      required: [concat(camel(recipient), "AccountId"), concat(camel(source), "AccountId"), currency, concat(camel(parent_name), "Id"), weight];
+      title: concat(sentence(parent_name), " Entitlement");
+      agent_description: concat("One recipient weighted claim on ", parent_name, ". Record one per recipient before the snapshot. Its share is derived from its weight against the frozen set, never supplied by the caller.");
+      summary: concat("Frozen entitlement in ", parent_name);
+      description: concat("One frozen weighted entitlement in ", parent_name);
+      action create {
+        agent_description: "Record one recipient weight against an open distribution. The parent distribution must still be open, and the currency and source account are copied from it. No money moves. Do not supply a share. It is derived later from the frozen set.";
+        summary: "Record one entitlement before snapshot";
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [open]; bind: { currency: "fields.currency"; [source]AccountId: concat("fields.", camel(source), "AccountId"); }; }
+        moves: [];
+        steps: [];
+      }
+      action payout {
+        agent_description: "Pay this recipient their largest-remainder share of the pool. The parent distribution must already be snapshotted. The amount is computed from the recorded weights, not supplied by the caller, and a zero share moves nothing. This moves money and does not reverse.";
+        summary: "Pay the deterministic largest-remainder share once";
+        requires refs { field: concat(camel(parent_name), "Id"); statuses: [snapshotted]; match: { "fields.currency": "fields.currency"; "fields.[source]AccountId": concat("fields.", camel(source), "AccountId"); }; }
+        computes distribute { amountRef: payoutShare; onZero: skip_steps; pool: { from: parent; path: concat("fields.", amount); }; refField: concat(camel(parent_name), "Id"); statuses: [recorded, paid]; weightField: weight; }
+        moves: [{ amount: refs.payoutShare; from: payer; to: beneficiary; key: payout; }];
+        steps: [];
+      }
+    }
+  }
+  }
+  when(flat) {
+    let(pool): get(flat, "pool");
+    let(pool_ref): get(pool, "field");
+    let(pool_ref_field): camel(pool_ref);
+    let(pool_instrument): get(pool, "instrument");
+    let(pool_create_statuses): get(pool, "create_statuses");
+    let(pool_payout_statuses): get(pool, "payout_statuses");
+    let(pool_bind): get(pool, "bind");
+    let(pool_match): get(pool, "match");
+    let(pool_amount_path): get(pool, "amount_path");
+    let(weight_source): get(flat, "weight_source");
+    let(weight_ref): get(weight_source, "field");
+    let(weight_ref_field): camel(weight_ref);
+    let(weight_statuses): get(weight_source, "statuses");
+    let(weight_bind): get(weight_source, "bind");
+    let(weight_match): get(weight_source, "match");
+    let(unique_weight_source): get(weight_source, "unique");
+    let(group): get(flat, "group");
+    let(group_ref): get(group, "field");
+    let(source_account_field): camel(concat(source, "_account_id"));
+    let(recipient_account_field): camel(concat(recipient, "_account_id"));
+    fields {
+      [amount] { type: money<C>; description: get(flat, "amount_description"); }
+      [record_at] { type: date; }
+      [pool_ref] { type: pool_ref; description: get(pool, "description"); pattern: get(pool, "pattern"); }
+      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]; }; }
+    }
+    lifecycle { states claimed paid; initial claimed; on payout: claimed -> paid; }
+    parties { beneficiary: recipient_account_field; }
+    required: get(flat, "required");
+    title: sentence(instrument);
+    id_prefix: if_eq(id_prefix_override, false, prefix(instrument), id_prefix_override);
+    agent_description: concat("One weighted claim on a distribution pool that another instrument owns. Record one claim per recipient before the pool settles. Its share is derived from its weight against the settled pool, never supplied by the caller, and the shares add back to the pool exactly.");
+    summary: "Flat largest-remainder distribution claim";
+    description: "One weighted claim on a settled distribution pool";
+    action create {
+      public: none;
+      agent_description: concat("Record one recipient weight against a pool that is still open. Both the pool and the weight source must be in an accepting state, and the same weight source cannot be claimed twice. No money moves. Do not supply a share. It is derived at payout from the settled pool.");
+      summary: "Open one weighted distribution claim";
+      requires_refs: [
+        { field: pool_ref_field; statuses: pool_create_statuses; bind: pool_bind; match: pool_match; },
+        { field: weight_ref_field; statuses: weight_statuses; bind: weight_bind; match: weight_match; unique: unique_weight_source; }
+      ];
+      moves: [];
+      steps: [];
+    }
+    action payout {
+      public: none;
+      summary: "Pay one largest-remainder share from the settled pool";
+      due { field: record_at; whenParentStatus: { instrumentId: pool_instrument; refField: pool_ref_field; statuses: pool_payout_statuses; }; }
+      requires refs { field: pool_ref_field; statuses: pool_payout_statuses; }
+      computes distribute { amountRef: payoutShare; onZero: skip_steps; pool: { from: parent; path: pool_amount_path; }; refField: pool_ref_field; statuses: [claimed, paid]; weightField: amount; }
+      moves: [{ key: transfer; operation: internal_transfer.create; bind: { amount: { from: instance; path: refs.payoutShare; }; currency: { from: instance; path: fields.currency; }; destinationAccountId: { from: instance; path: concat("fields.", recipient_account_field); }; productId: { from: instance; path: productId; }; sourceAccountId: { from: instance; path: concat("fields.", source_account_field); }; }; capture: { payoutTransferId: transferId; }; }];
+      steps: [];
+    }
+  }
+}

package/dist/src/archetypes.d.ts

@@ -1,17 +0,0 @@
-/**
- * Settlement declarations shared by checking and lowering. A local event cap
- * limits one settlement before the whole-program budget applies.
- */
-export declare const SETTLEMENT_ARCHETYPES: readonly ["advance", "captured_payment", "conditional_disbursement", "credit_facility", "deposit", "funding_round", "held_payment", "instant_transfer", "metered", "pooled_split", "premium_forward", "recurring_collection", "rotating_pool", "scheduled", "settlement_batch", "swap", "weighted_distribution"];
-export type ArchetypeName = (typeof SETTLEMENT_ARCHETYPES)[number];
-interface ArchetypeDefinition {
-    readonly eventCap: number;
-    readonly keys: readonly string[];
-    readonly maxRates?: number;
-    readonly maxRecipients?: number;
-    readonly referenceableExits: readonly string[];
-    readonly required: readonly string[];
-}
-export declare const ARCHETYPE_DEFINITIONS: Record<ArchetypeName, ArchetypeDefinition>;
-export {};
-//# sourceMappingURL=archetypes.d.ts.map

package/dist/src/archetypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"archetypes.d.ts","sourceRoot":"","sources":["../../src/archetypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB,kTAkBxB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,aAAa,EAAE,mBAAmB,CA+S1E,CAAC"}