@hyperscale0/hsx 5.0.1 → 5.2.0

package/dist/src/std-bundle.js.map

@@ -1 +1 @@
-{"version":3,"file":"std-bundle.js","sourceRoot":"","sources":["../../src/std-bundle.ts"],"names":[],"mappings":"AAAA,oEAAoE;AAEpE,MAAM,CAAC,MAAM,iBAAiB,GAAgC,IAAI,GAAG,CAAiB;IACpF,CAAC,WAAW,EAAE,i8HAAi8H,CAAC;IACh9H,CAAC,iBAAiB,EAAE,ooKAAooK,CAAC;IACzpK,CAAC,YAAY,EAAE,o8DAAo8D,CAAC;IACp9D,CAAC,eAAe,EAAE,m5vDAAm5vD,CAAC;IACt6vD,CAAC,eAAe,EAAE,g7FAAg7F,CAAC;IACn8F,CAAC,aAAa,EAAE,8pPAA8pP,CAAC;IAC/qP,CAAC,iBAAiB,EAAE,m0PAAm0P,CAAC;IACx1P,CAAC,WAAW,EAAE,ytRAAytR,CAAC;IACxuR,CAAC,eAAe,EAAE,gs5CAAgs5C,CAAC;IACnt5C,CAAC,aAAa,EAAE,wrGAAwrG,CAAC;IACzsG,CAAC,YAAY,EAAE,8kMAA8kM,CAAC;IAC9lM,CAAC,YAAY,EAAE,m6DAAm6D,CAAC;CACp7D,CAAC,CAAC"}
+{"version":3,"file":"std-bundle.js","sourceRoot":"","sources":["../../src/std-bundle.ts"],"names":[],"mappings":"AAAA,oEAAoE;AAEpE,MAAM,CAAC,MAAM,iBAAiB,GAAgC,IAAI,GAAG,CAAiB;IACpF,CAAC,WAAW,EAAE,uhIAAuhI,CAAC;IACtiI,CAAC,iBAAiB,EAAE,ooKAAooK,CAAC;IACzpK,CAAC,YAAY,EAAE,o8DAAo8D,CAAC;IACp9D,CAAC,eAAe,EAAE,o6vDAAo6vD,CAAC;IACv7vD,CAAC,eAAe,EAAE,+0GAA+0G,CAAC;IACl2G,CAAC,aAAa,EAAE,mvPAAmvP,CAAC;IACpwP,CAAC,iBAAiB,EAAE,m0PAAm0P,CAAC;IACx1P,CAAC,WAAW,EAAE,y1RAAy1R,CAAC;IACx2R,CAAC,eAAe,EAAE,w77CAAw77C,CAAC;IAC387C,CAAC,aAAa,EAAE,wrGAAwrG,CAAC;IACzsG,CAAC,YAAY,EAAE,8kMAA8kM,CAAC;IAC9lM,CAAC,YAAY,EAAE,m6DAAm6D,CAAC;CACp7D,CAAC,CAAC"}

package/dist/src/version.d.ts

@@ -1,3 +1,3 @@
-export declare const HSX_VERSION = "5.0.1";
+export declare const HSX_VERSION = "5.2.0";
 export declare const HSX_TARGET_UDL_VERSION = 4;
 //# sourceMappingURL=version.d.ts.map

package/dist/src/version.js

@@ -1,3 +1,3 @@
-export const HSX_VERSION = "5.0.1";
+export const HSX_VERSION = "5.2.0";
 export const HSX_TARGET_UDL_VERSION = 4;
 //# sourceMappingURL=version.js.map

package/docs/README.md

@@ -1,4 +1,4 @@
-# HSX 4
+# HSX 5.0.1
 
 A program declares business objects and financial instruments. Objects contain
 optional metadata. Attachments expose named actions against an object.
@@ -69,8 +69,22 @@ keeps it internal. Callers create objects and run their attached actions.
 Accounts use cash or claim books. A move stays in one book. `account of buyer`
 aliases the default cash account; `account of self` provisions an owned account.
 `account(lender, cash, "capital")` binds a named account.
+`account(adapter(insurer), cash, "premium")` binds the account of the provider
+selected by `insurer`. Declare that binding with `subject { adapter: insurer }`
+in an action of the same instrument. A text tunable may supply its binding name.
+The agreement retains the provider identity; aliases for that provider share the
+same book and key within the Product. Providers remain outside parties.
+A missing binding refuses before money moves. Reference paths such as
+`self.cover.insurer` use the referenced agreement's account.
+
+Insurance collection credits the premium to the operator, then moves the premium
+net of commission to the insurer account. Refunds reverse those two portions.
+Claims reserve from the cover's insurer account. These moves record ledger money;
+external confirmation still needs the boundary protocol.
 `account(buyer, claim, contra, "debt")` declares the borrower's claim contra account.
-`account(seller, cash, external, "bank")` binds the executor-managed bank destination.
+Provider confirmation belongs on a reserved move with `boundary adapter`,
+followed by instruction-bound evidence and a post or void. External account
+mode is not supported.
 Outstanding debt is an account balance. The library pairs cash repayment with
 claim reduction and represents receipts as immutable child records. Cash and loss
 shares round down; the declared residual account receives leftover minor units.
@@ -123,7 +137,8 @@ maxAge 1d` requires a recent completed provider check.
 `moves reserve amount from payer to payee capture receipt` reserves a transfer;
 `moves post self.receipt` posts it and `moves void self.receipt` releases it.
 `moves amount from payer shares shares` expands a declared split. Optional `fee`,
-`capture` and `key` modifiers follow a move in that order. Repeated clauses keep
+`capture`, `key` and `boundary` modifiers describe a move. `boundary` applies
+only to reservations. Fees settle with create moves, never reservations. Repeated clauses keep
 their declaration order. The JSON-like clause form remains accepted and lowers
 to the same [UDL clauses](../../udl/spec/README.md).
 They cannot add kernel instructions. `at(list, position)` reads a dated list;
@@ -140,16 +155,16 @@ and a correction. No artifact is returned with diagnostics.
 activation. The company chooses where funding goes and when profit becomes earned.
 All choices use accounts, calculations and moves in the same two books.
 
-| Tunable                            | Default                  | Selected behavior                                                                                                                                                                                                                                                                                                                                                   |
-| ---------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `disburse_to`                      | `funds`                  | `funds` pays down payment and principal into the hold and confirms it. `borrower` credits principal to the borrower's balance.                                                                                                                                                                                                                                      |
-| `profit_earned`                    | `on_payment`             | `on_payment` collects unearned profit on payment. `by_schedule` moves unearned claims to earned claims at each slice's date. `at_disbursement` makes that move at activation. Cash arrives only on payment.                                                                                                                                                         |
-| `apply`                            | `fines_profit_principal` | Collect assessed fines by overdue date, then evidenced costs, then each slice in position order, profit before principal. `principal_profit` collects each slice in position order, principal before profit. `pro_rata` uses the slice's fixed principal:profit ratio, caps each side by its collectible balance, and assigns the remainder without stranding cash. |
-| `payoff_rebate`                    | `100%`                   | Reverse this share of unearned profit to borrower debt. Collect the remainder and all earned profit with outstanding principal.                                                                                                                                                                                                                                     |
-| `late_charge.fines_to`             | `programOperator`        | Receive fine cash and fund its refunds.                                                                                                                                                                                                                                                                                                                             |
-| `late_charge.costs_to`             | `programOperator`        | Receive evidenced recovery cash and fund its refunds.                                                                                                                                                                                                                                                                                                               |
-| `collections.case.fee`             | `20%`                    | After payment succeeds, transfer this share of the payment amount from plan capital to the agency.                                                                                                                                                                                                                                                                  |
-| `lending.distribution.residual_to` | `programOperator`        | Receive the cash remainder and own the claim loss remainder after weighted distribution.                                                                                                                                                                                                                                                                            |
+| Tunable                            | Default                  | Selected behavior                                                                                                                                                                                                                                                                                                                                                                |
+| ---------------------------------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `disburse_to`                      | `funds`                  | `funds` pays down payment and principal into the hold and confirms it. `borrower` credits principal to the borrower's balance.                                                                                                                                                                                                                                                   |
+| `profit_earned`                    | `on_payment`             | `on_payment` collects unearned profit on payment. `by_schedule` moves unearned claims to earned claims at each slice's date. `at_disbursement` makes that move at activation. Cash arrives only on payment.                                                                                                                                                                      |
+| `apply`                            | `fines_profit_principal` | Visit each slice in position order; within that slice collect assessed fines by overdue date, evidenced costs, profit, then principal. `principal_profit` collects each slice in position order, principal before profit. `pro_rata` uses the slice's fixed principal:profit ratio, caps each side by its collectible balance, and assigns the remainder without stranding cash. |
+| `payoff_rebate`                    | `100%`                   | Reverse this share of unearned profit to borrower debt. Collect the remainder and all earned profit with outstanding principal.                                                                                                                                                                                                                                                  |
+| `late_charge.fines_to`             | `programOperator`        | Receive fine cash and fund its refunds.                                                                                                                                                                                                                                                                                                                                          |
+| `late_charge.costs_to`             | `programOperator`        | Receive evidenced recovery cash and fund its refunds.                                                                                                                                                                                                                                                                                                                            |
+| `collections.case.fee`             | `20%`                    | After payment succeeds, transfer this share of the payment amount from plan capital to the agency.                                                                                                                                                                                                                                                                               |
+| `lending.distribution.residual_to` | `programOperator`        | Receive the cash remainder and own the claim loss remainder after weighted distribution.                                                                                                                                                                                                                                                                                         |
 
 Each slice owns separate unearned and earned claim accounts. Scheduled recognition
 uses a dated child record so a partial payment cannot disable the maturity clock.
@@ -159,7 +174,8 @@ costs stay assessed until their receivable reaches zero. Immutable receipts let
 a refund restore only what that payment collected. The plan's payment receipt
 records actual principal and profit after all ordered collections finish.
 Write-off moves principal and earned profit claims to loss and reverses unearned
-profit to debt. There is no provision policy or write-off tunable.
+profit to debt. `write_off_after` sets how long a slice must be overdue before a capital-authorized
+write-off request can apply. There is no provision policy.
 
 ## Header branches and bounds
 
@@ -173,9 +189,7 @@ when disburse_to is borrower {
 
 `when <reference tunable> has <field>` includes its clauses only when the bound
 object declares that field. The compiler checks the object's declared shape,
-regardless of declaration order, and emits no runtime branch. Financing uses
-this to commit marketplace orders for order-backed holds while plain money
-holds need no order relation.
+regardless of declaration order, and emits no runtime branch.
 
 `when <enum tunable> is <value>` accepts requirements, calculations, moves and
 invocations, including nested branches. The compiler emits only the selected
@@ -253,7 +267,7 @@ adapters are bound, participants have funds, or the flow can finish.
 | `financing.limits`                         | `per_borrower` caps outstanding principal. Both borrower and portfolio limits must be approved before disbursement; attaching them does not approve them.                                                                                                                                                                    |
 | `lending.round`                            | The target is the linked plan's principal. Closing requires commitments and held funds to equal that amount.                                                                                                                                                                                                                 |
 | `lending.distribution`                     | Cash distribution needs an eligible recorded settlement, `prepare_cash`, one share record per funded commitment, then `distribute_cash`. Attaching it moves nothing.                                                                                                                                                         |
-| `insurance.cover.slice`                    | `commission` is calculated, but `collect` sends the whole premium to `programOperator`; that action makes no broker commission transfer.                                                                                                                                                                                     |
+| `insurance.cover.slice`                    | `collect` credits premium net of commission to the insurer account. The tenant retains commission. `refund` returns both portions; claims reserve insurer funds. External settlement uses the boundary protocol.                                                                                                             |
 | `travel.booking`                           | From `deposit_paid` or `paid`, early cancellation returns the full held balance, middle returns held balance minus deposit, and late has no buyer refund transfer. State, time and balance requirements still apply. A deposit-only early cancellation refunds the deposit; a deposit-only middle cancellation refunds zero. |
 | `financing.installments`, `savings.circle` | Supply explicit date lists when creating agreements. A term count does not generate a monthly calendar. Savings supports at most 60 distinct member positions.                                                                                                                                                               |
 | `escrow.hold`                              | `fund` takes the whole price. Financing into pending escrow collects the remaining down payment and adds capital principal at disbursement; `fund` is not a down-payment checkout.                                                                                                                                           |

package/examples/insurance.hsx

@@ -11,9 +11,9 @@ object device "Insured device" {
     payer: owner, payee: operator
     expose pay as pay_for_device
   }
-  // Bind device_insurer to an ADL adapter before activating cover.
+  // Bind device_insurer to an ADL adapter before creating cover. Premiums net of commission go to its account.
   attach protection = insurance.cover {
-    holder: owner, adapter: "device_insurer", covers: purchase
+    holder: owner, adapter: "device_insurer", commission: 10%, covers: purchase
     expose activate as activate_cover
     expose cancel as cancel_cover
   }

package/examples/travel.hsx

@@ -11,9 +11,9 @@ object holiday "Holiday booking" {
     price: 5000 SAR, supplier_cost: 3500 SAR, departure: 2027-07-01
     expose publish as publish_trip
   }
-  // Bind travel_insurer to an ADL adapter before activating cover.
+  // Bind travel_insurer to an ADL adapter before creating cover. Premiums net of commission go to its account.
   attach protection = insurance.cover {
-    holder: actor, adapter: "travel_insurer", covers: reservation
+    holder: actor, adapter: "travel_insurer", commission: 10%, covers: reservation
     expose activate as activate_cover
   }
   attach reservation = travel.booking {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperscale0/hsx",
-  "version": "5.0.1",
+  "version": "5.2.0",
   "description": "The strictly typed HSX language: compile total financial programs into canonical UDL.",
   "keywords": [
     "hsx",
@@ -86,7 +86,7 @@
   },
   "dependencies": {
     "@hyperscale0/adl": "1.0.0-beta.8",
-    "@hyperscale0/udl": "4.2.1",
+    "@hyperscale0/udl": "4.4.0",
     "fast-sha256": "1.3.0"
   },
   "devDependencies": {
@@ -98,5 +98,5 @@
     "Amir Ayub",
     "Sara AlBakaawi"
   ],
-  "gitHead": "2ba5fb5f926f8f78ac3a5f2531c0b5b9266de9ac"
+  "gitHead": "f8eb5c255acd23edba069d63962611b81280c85d"
 }

package/src/compile.ts

@@ -643,6 +643,8 @@ export function compile(
         renames: Map<string, string>;
         exposed: Map<string, string>;
         parties: Record<string, AttachmentPartyBinding>;
+        attachments: UdlObjectAttachment[];
+        child?: boolean;
       },
       familyDeclaration?: {
         module: string;
@@ -1709,7 +1711,16 @@ export function compile(
                   "account needs an owner, optional book, mode and key",
                   "write account(buyer, claim, contra)",
                 );
-              f.owner = text(resolve(t.args[0]!));
+              const owner = t.args[0]!;
+              if (owner.kind === "call" && owner.name === "adapter") {
+                if (owner.args.length !== 1)
+                  fail(
+                    owner,
+                    "adapter needs one binding",
+                    'write account(adapter(binding), cash, "premium")',
+                  );
+                f.owner = { adapter: text(resolve(owner.args[0]!)) };
+              } else f.owner = text(resolve(owner));
               f.book = t.args[1] ? text(t.args[1]) : "cash";
               if (t.args[2]) {
                 const mode = text(t.args[2]);
@@ -2549,7 +2560,7 @@ export function compile(
             }
           } else (a as unknown as Record<string, unknown>)[key] = data(expr);
         }
-        if (attachmentInfo) {
+        if (attachmentInfo && !attachmentInfo.child) {
           if (attachmentInfo.exposed.has(name)) {
             a.publicAction = attachmentInfo.exposed.get(name)!;
           } else {
@@ -2619,6 +2630,21 @@ export function compile(
       }
       document.instruments.push(inst);
       for (const [key, definition] of records) {
+        const childAttachment = attachmentInfo
+          ? {
+              ...attachmentInfo,
+              attachmentName: `${attachmentInfo.attachmentName}_${key}`,
+              child: true,
+              exposed: new Map<string, string>(),
+            }
+          : undefined;
+        if (childAttachment)
+          childAttachment.attachments.push({
+            name: childAttachment.attachmentName,
+            parent: attachmentInfo!.attachmentName,
+            instrument: `${id}_${key}`,
+            parties: childAttachment.parties,
+          });
         const child: InstrumentDecl = {
           kind: "instrument",
           name: key,
@@ -2649,9 +2675,7 @@ export function compile(
             ["parent", { kind: "name", value: id, span: origin } as Expr],
           ]),
           enums,
-          attachmentInfo
-            ? { ...attachmentInfo, exposed: new Map() }
-            : undefined,
+          childAttachment,
           childFamily,
         );
       }
@@ -2746,6 +2770,7 @@ export function compile(
         };
 
         const templateFamily = resolveFamily(targetTemplate, entry, false);
+        const firstAttachedInstrument = document.instruments.length;
         try {
           addInstrument(
             template,
@@ -2760,6 +2785,7 @@ export function compile(
               renames,
               exposed,
               parties,
+              attachments,
             },
             templateFamily ? { ...templateFamily } : undefined,
           );
@@ -2769,17 +2795,24 @@ export function compile(
           continue;
         }
         const attachedInst = document.instruments.find((i) => i.id === instId);
-        if (attachedInst?.actions.create) {
+        for (const createdInst of document.instruments
+          .slice(firstAttachedInstrument)
+          .filter(
+            (instrument) =>
+              instrument.id === instId ||
+              instrument.actions.create?.publicAction,
+          )) {
+          if (!createdInst.actions.create) continue;
           const owned = new Set(
-            attachedInst.calculate.map((node) => node.target),
+            createdInst.calculate.map((node) => node.target),
           );
-          for (const action of Object.values(attachedInst.actions)) {
+          for (const action of Object.values(createdInst.actions)) {
             for (const node of action.calculate ?? []) owned.add(node.target);
             for (const move of action.moves)
               if ("capture" in move && move.capture) owned.add(move.capture);
           }
-          const create = attachedInst.actions.create;
-          for (const field of attachedInst.fields) {
+          const create = createdInst.actions.create;
+          for (const field of createdInst.fields) {
             if (
               field.type === "account" ||
               (field.type === "ref" && field.targetKind === "instrument") ||
@@ -2788,7 +2821,8 @@ export function compile(
                 field.targetKind === "instrument") ||
               field.optional ||
               "value" in field ||
-              owned.has(field.name)
+              owned.has(field.name) ||
+              create.input.some((input) => input.name === field.name)
             )
               continue;
             create.subject ??= { requirements: [], adapters: [] };
@@ -2800,7 +2834,7 @@ export function compile(
                 failWithCode(
                   entry,
                   "subject_field_conflict",
-                  `${instId}.create.subject.${field.name} conflicts with its instrument field`,
+                  `${createdInst.id}.create.subject.${field.name} conflicts with its instrument field`,
                   "use the instrument field's type and constraints",
                 );
               continue;
@@ -2814,7 +2848,7 @@ export function compile(
             requirementOrigins.set(requirement, {
               source: declarationSources.get(template) ?? "program",
               span: entry.span,
-              message: `${instId}.create.fields.${field.name}`,
+              message: `${createdInst.id}.create.fields.${field.name}`,
             });
           }
         }
@@ -2913,16 +2947,15 @@ export function compile(
           .sort((a, b) => a.span.start - b.span.start)
           .map((d) => diagnostic(d, "check")),
       };
-    // Propagate mandatory invoked action requirements
+    // Propagate invoked requirements with the conditions on each invocation path.
     let changedInvocations = true;
     let invocationIterations = 0;
     while (changedInvocations && invocationIterations < 32) {
       changedInvocations = false;
       invocationIterations++;
       for (const inst of document.instruments) {
-        for (const action of Object.values(inst.actions)) {
+        for (const [actionName, action] of Object.entries(inst.actions)) {
           for (const call of action.invoke ?? []) {
-            if (call.guard) continue;
             let targetIds: string[] = [];
             if ("instrument" in call) {
               targetIds = [call.instrument];
@@ -2962,7 +2995,9 @@ export function compile(
                 if (!action.subject) {
                   action.subject = { requirements: [], adapters: [] };
                 }
-                for (const adapter of targetAction.subject.adapters) {
+                for (const adapter of call.guard
+                  ? []
+                  : targetAction.subject.adapters) {
                   if (
                     !action.subject.adapters.some(
                       (existing) => existing.binding === adapter.binding,
@@ -2979,9 +3014,65 @@ export function compile(
                     (cr) =>
                       (cr.objectField ?? cr.field.name) === targetObjFieldName,
                   );
+                  const guardValue = (value: UdlValue): UdlValue => {
+                    if (
+                      !("field" in value) ||
+                      !value.field.startsWith("subject.")
+                    )
+                      return value;
+                    const requirement = action.subject?.requirements.find(
+                      (item) => item.field.name === value.field.slice(8),
+                    );
+                    return {
+                      field: `subject.${requirement?.objectField ?? requirement?.field.name ?? value.field.slice(8)}`,
+                    };
+                  };
+                  const guardType =
+                    call.guard &&
+                    [call.guard.left, call.guard.right]
+                      .flatMap((value) =>
+                        "field" in value
+                          ? [
+                              resolveField(
+                                document,
+                                inst,
+                                value.field,
+                                action.input,
+                                action,
+                              )?.type,
+                            ]
+                          : [],
+                      )
+                      .find((type) => type === "money" || type === "date");
+                  const condition:
+                    | NonNullable<UdlSubjectRequirement["when"]>[number][number]
+                    | undefined = call.guard
+                    ? {
+                        instrument: inst.id,
+                        action: actionName,
+                        guard: {
+                          ...call.guard,
+                          left: guardValue(call.guard.left),
+                          right: guardValue(call.guard.right),
+                        },
+                        ...(guardType === "money" || guardType === "date"
+                          ? { valueType: guardType }
+                          : {}),
+                      }
+                    : undefined;
+                  const when = condition
+                    ? (targetReq.when ?? [[]]).map((path) => [
+                        condition,
+                        ...path.filter(
+                          (item) =>
+                            canonicalJson(item) !== canonicalJson(condition),
+                        ),
+                      ])
+                    : targetReq.when;
                   if (!existing) {
-                    const inherited = {
+                    const inherited: UdlSubjectRequirement = {
                       field: { ...targetReq.field, name: targetObjFieldName },
+                      ...(when ? { when: when.map((path) => [...path]) } : {}),
                     };
                     action.subject.requirements.push(inherited);
                     requirementOrigins.set(
@@ -3002,6 +3093,23 @@ export function compile(
                       source: first.source,
                       related: [first, second],
                     });
+                  } else if (existing.when) {
+                    if (!when) {
+                      delete existing.when;
+                      changedInvocations = true;
+                    } else {
+                      for (const path of when) {
+                        if (
+                          !existing.when.some(
+                            (known) =>
+                              canonicalJson(known) === canonicalJson(path),
+                          )
+                        ) {
+                          existing.when.push(path);
+                          changedInvocations = true;
+                        }
+                      }
+                    }
                   }
                 }
               }

package/src/examples-bundle.ts

@@ -5,7 +5,7 @@ export const examples: HsxExample[] = [
   {"id":"collections","title":"Small business collections","summary":"A business lender refers overdue instalments to an agency with limits on collection contacts.","headers":["collections","financing"],"source":"// A business lender refers overdue instalments to an agency with limits on collection contacts.\nprogram business_collections \"Small business collections\"\nuse collections\nuse financing\nparty agency: business\n\nobject facility \"Business loan\" {\n  fields { businessName: text, purpose: text, price: money }\n  columns: [businessName, purpose, price]\n  attach allowance = financing.limits { borrower: owner, per_borrower: 100000 SAR }\n  attach budget = financing.portfolio_limit { limit: 2000000 SAR }\n  attach loan = financing.installments {\n    borrower: owner, capital: operator\n    months: 12, profit: 6%, disburse_to: borrower\n    limits: allowance, portfolio: budget\n    expose sign as sign_loan\n    expose disburse as release_loan\n  }\n  attach recovery = collections.case {\n    on: loan, agency: agency\n    expose assign as assign_case\n    expose recover as recover_payment\n    expose recall as recall_case\n  }\n  attach contact = collections.contact {\n    case: recovery, agency: agency\n  }\n}\n"},
   {"id":"escrow","title":"Used device sales","summary":"Buyers fund a used device purchase, then accept delivery or raise a dispute before release.","headers":["escrow"],"source":"// Buyers fund a used device purchase, then accept delivery or raise a dispute before release.\nprogram used_device_sales \"Used device sales\"\nuse escrow\n\nobject device \"Device\" {\n  fields {\n    model: text\n    condition: text\n    serialNumber: text\n    price: money\n  }\n  columns: [model, condition, price]\n  attach sale = escrow.hold {\n    payer: actor, payee: owner\n    expose fund as pay_for_device\n    expose deliver as confirm_delivery\n    expose accept as accept_device\n    expose dispute as report_problem\n    expose verify_return as verify_return\n    expose refund as refund_buyer\n  }\n}\n"},
   {"id":"financing","title":"Tuition instalments","summary":"A tuition lender funds a student's fees over three interest-free instalments with borrowing limits.","headers":["financing"],"source":"// A tuition lender funds a student's fees over three interest-free instalments with borrowing limits.\nprogram tuition_instalments \"Tuition instalments\"\nuse financing\n\nobject enrolment \"Enrolment\" {\n  fields { student: text, course: text, price: money }\n  columns: [student, course, price]\n  attach allowance = financing.limits {\n    borrower: owner, per_borrower: 12000 SAR\n    expose approve as approve_student\n  }\n  attach budget = financing.portfolio_limit {\n    limit: 500000 SAR\n    expose approve as approve_budget\n  }\n  attach tuition = financing.installments {\n    borrower: owner, capital: operator\n    months: 3, profit: 0%, disburse_to: borrower\n    limits: allowance, portfolio: budget\n    expose sign as sign_tuition_plan\n    expose disburse as fund_tuition\n    expose payoff as repay_early\n  }\n}\n"},
-  {"id":"insurance","title":"Device insurance","summary":"A device retailer collects the purchase price and attaches cover with a claim review process.","headers":["insurance","money"],"source":"// A device retailer collects the purchase price and attaches cover with a claim review process.\nprogram device_insurance \"Device insurance\"\nuse insurance\nuse money\nparty inspector: staff role claims\n\nobject device \"Insured device\" {\n  fields { model: text, serialNumber: text, purchaseDate: date }\n  columns: [model, serialNumber, purchaseDate]\n  attach purchase = money.transfer {\n    payer: owner, payee: operator\n    expose pay as pay_for_device\n  }\n  // Bind device_insurer to an ADL adapter before activating cover.\n  attach protection = insurance.cover {\n    holder: owner, adapter: \"device_insurer\", covers: purchase\n    expose activate as activate_cover\n    expose cancel as cancel_cover\n  }\n  attach claim = insurance.claim {\n    cover: protection, inspector: inspector\n    expose approve as approve_claim\n    expose deny as deny_claim\n    expose pay as pay_claim\n  }\n}\n"},
+  {"id":"insurance","title":"Device insurance","summary":"A device retailer collects the purchase price and attaches cover with a claim review process.","headers":["insurance","money"],"source":"// A device retailer collects the purchase price and attaches cover with a claim review process.\nprogram device_insurance \"Device insurance\"\nuse insurance\nuse money\nparty inspector: staff role claims\n\nobject device \"Insured device\" {\n  fields { model: text, serialNumber: text, purchaseDate: date }\n  columns: [model, serialNumber, purchaseDate]\n  attach purchase = money.transfer {\n    payer: owner, payee: operator\n    expose pay as pay_for_device\n  }\n  // Bind device_insurer to an ADL adapter before creating cover. Premiums net of commission go to its account.\n  attach protection = insurance.cover {\n    holder: owner, adapter: \"device_insurer\", commission: 10%, covers: purchase\n    expose activate as activate_cover\n    expose cancel as cancel_cover\n  }\n  attach claim = insurance.claim {\n    cover: protection, inspector: inspector\n    expose approve as approve_claim\n    expose deny as deny_claim\n    expose pay as pay_claim\n  }\n}\n"},
   {"id":"lending","title":"Community business lending","summary":"A lending composition with limit approvals, wallet commitments and cash distribution transitions. Repayment and distribution-share child actions still need an execution path; this is not a complete public repayment flow.","headers":["lending","financing","wallet"],"source":"// A lending composition with limit approvals, wallet commitments and cash distribution transitions.\n// Repayment and distribution-share child actions still need an execution path; this is not a complete public repayment flow.\nprogram community_business_lending \"Community business lending\"\nuse lending\nuse financing\nuse wallet\n\nobject business \"Business funding\" {\n  fields { businessName: text, purpose: text, price: money }\n  columns: [businessName, purpose, price]\n  attach allowance = financing.limits {\n    borrower: owner, per_borrower: 100000 SAR\n    expose approve as approve_borrower\n  }\n  attach budget = financing.portfolio_limit {\n    limit: 2000000 SAR\n    expose approve as approve_budget\n  }\n  attach loan = financing.installments {\n    borrower: owner, capital: operator\n    months: 12, profit: 6%, disburse_to: borrower\n    limits: allowance, portfolio: budget\n    expose sign as sign_loan\n    expose disburse as release_loan\n  }\n  attach investor_balance = wallet.balance {\n    holder: actor\n    expose activate as open_wallet\n    expose topup as add_funds\n  }\n  attach funding = lending.round {\n    borrower: owner, plan: loan\n    expose create as open_funding\n    expose close as close_funding\n  }\n  attach investment = lending.commitment {\n    round: funding, wallet: investor_balance, investor: actor\n    expose create as invest\n    expose withdraw as withdraw_investment\n  }\n  attach returns = lending.distribution {\n    round: funding, receipt: loan.settlement\n    expose prepare_cash as prepare_returns\n    expose distribute_cash as distribute_returns\n  }\n}\n"},
   {"id":"library","title":"Financed car sales","summary":"A minimal financed car sale connects escrow to a three-instalment plan and lending limits.","headers":["escrow","financing"],"source":"// A minimal financed car sale connects escrow to a three-instalment plan and lending limits.\nprogram cars \"Financed car sales\"\nuse escrow\nuse financing\nobject car \"Cars\" {\n fields { make: text, model: text, year: integer }\n attach sale = escrow.hold { payer: actor, payee: owner, expose fund as sell }\n attach limits = financing.limits { borrower: actor, per_borrower: 60000 SAR }\n attach ceiling = financing.portfolio_limit { limit: 1500000 SAR }\n attach plan = financing.installments {\n  borrower: actor, capital: operator, share: 25%\n  months: 3, profit: 2.5%, funds: sale, limits: limits, portfolio: ceiling\n  expose create as finance\n }\n}\n"},
   {"id":"marketplace","title":"Freelance marketplace","summary":"Freelancers publish offers and clients place orders with funds held until work is accepted.","headers":["marketplace","escrow"],"source":"// Freelancers publish offers and clients place orders with funds held until work is accepted.\nprogram freelance_marketplace \"Freelance marketplace\"\nuse marketplace\nuse escrow\n\nobject project \"Project\" {\n  fields { brief: text, deliverable: text, price: money }\n  columns: [brief, deliverable, price]\n  attach offer = marketplace.listing {\n    seller: owner\n    expose publish as publish_offer\n    expose withdraw as withdraw_offer\n  }\n  attach order = marketplace.order {\n    listing: offer, buyer: actor\n    expose commit as place_order\n    expose fulfill as finish_order\n  }\n  attach payment = escrow.hold {\n    payer: actor, payee: owner\n    expose fund as fund_project\n    expose deliver as submit_work\n    expose accept as accept_work\n    expose dispute as dispute_work\n  }\n}\n"},
@@ -14,6 +14,6 @@ export const examples: HsxExample[] = [
   {"id":"reporting","title":"Equipment loan reports","summary":"An equipment lender keeps an ageing report over its financed purchases and recorded repayments.","headers":["reporting","financing"],"source":"// An equipment lender keeps an ageing report over its financed purchases and recorded repayments.\nprogram equipment_loan_reports \"Equipment loan reports\"\nuse reporting\nuse financing\n\nobject purchase \"Equipment loan\" {\n  fields { businessName: text, equipment: text, price: money }\n  columns: [businessName, equipment, price]\n  attach allowance = financing.limits {\n    borrower: owner, per_borrower: 200000 SAR\n    expose approve as approve_business\n  }\n  attach budget = financing.portfolio_limit {\n    limit: 5000000 SAR\n    expose approve as approve_budget\n  }\n  attach loan = financing.installments {\n    borrower: owner, capital: operator\n    months: 12, profit: 6%, disburse_to: borrower\n    limits: allowance, portfolio: budget\n    expose sign as sign_purchase_loan\n    expose disburse as fund_purchase\n  }\n  attach reports = reporting.portfolio { on: loan }\n}\n"},
   {"id":"savings","title":"Savings circle","summary":"Six members contribute to a shared pot and receive it in their agreed calendar order.","headers":["savings"],"source":"// Six members contribute to a shared pot and receive it in their agreed calendar order.\nprogram neighbourhood_savings \"Savings circle\"\nuse savings\n\nobject group \"Savings group\" {\n  fields { groupName: text, purpose: text }\n  columns: [groupName, purpose]\n  attach circle = savings.circle {\n    contribution: 500 SAR, members: 6, starts: 2027-01-01\n    expose disband as disband_circle\n    expose close as close_circle\n  }\n  attach membership = savings.membership {\n    circle: circle, member: actor\n    expose activate as confirm_membership\n    expose withdraw as leave_circle\n  }\n  // Contributions and each member's payout follow the declared calendar.\n}\n"},
   {"id":"serviced","title":"Car financing","summary":"A car finance company services loans with late charges, payment reminders and early repayment.","headers":["escrow","financing","collections"],"source":"// A car finance company services loans with late charges, payment reminders and early repayment.\nprogram car_financing \"Car financing\"\nuse escrow\nuse financing\nuse collections\nobject car \"Car\" {\n fields { make: text, model: text, year: integer, vin: text, price: money }\n columns: [make, model, year, vin, price]\n attach sale = escrow.hold { payer: actor, payee: operator, expose fund as purchase }\n attach limits = financing.limits { borrower: actor, per_borrower: 250000 SAR }\n attach ceiling = financing.portfolio_limit { limit: 10000000 SAR }\n attach plan = financing.installments {\n  borrower: actor, capital: operator\n  months: 36, profit: 8.5%, down_payment: 10%\n  apply: fines_profit_principal, payoff_rebate: 100%, write_off_after: 90d\n  funds: sale, limits: limits, portfolio: ceiling\n  expose create as finance, expose sign as sign_contract, expose payoff as payoff\n }\n attach late = financing.late_charge {\n  on: plan, grace: 3d, fine: 50 SAR, cap: 25 SAR\n  fines_to: operator, costs_to: operator, borrower: actor\n }\n attach reminders = collections.reminder { on: plan, operator: operator, before_days: 3, overdue_days: 1 }\n}\n"},
-  {"id":"travel","title":"Travel agency","summary":"A travel agency takes deposits for an insured holiday and pays its supplier after confirmation.","headers":["travel","insurance"],"source":"// A travel agency takes deposits for an insured holiday and pays its supplier after confirmation.\nprogram travel_agency \"Travel agency\"\nuse travel\nuse insurance\nparty hotel: business\n\nobject holiday \"Holiday booking\" {\n  fields { destination: text, leadTraveller: text }\n  columns: [destination, leadTraveller]\n  attach trip = travel.package {\n    price: 5000 SAR, supplier_cost: 3500 SAR, departure: 2027-07-01\n    expose publish as publish_trip\n  }\n  // Bind travel_insurer to an ADL adapter before activating cover.\n  attach protection = insurance.cover {\n    holder: actor, adapter: \"travel_insurer\", covers: reservation\n    expose activate as activate_cover\n  }\n  attach reservation = travel.booking {\n    package: trip, buyer: actor, supplier: hotel, cover: protection\n    expose deposit as pay_deposit\n    expose balance as pay_balance\n    expose confirm as confirm_completion\n    expose cancel_early as cancel_booking\n  }\n}\n"},
+  {"id":"travel","title":"Travel agency","summary":"A travel agency takes deposits for an insured holiday and pays its supplier after confirmation.","headers":["travel","insurance"],"source":"// A travel agency takes deposits for an insured holiday and pays its supplier after confirmation.\nprogram travel_agency \"Travel agency\"\nuse travel\nuse insurance\nparty hotel: business\n\nobject holiday \"Holiday booking\" {\n  fields { destination: text, leadTraveller: text }\n  columns: [destination, leadTraveller]\n  attach trip = travel.package {\n    price: 5000 SAR, supplier_cost: 3500 SAR, departure: 2027-07-01\n    expose publish as publish_trip\n  }\n  // Bind travel_insurer to an ADL adapter before creating cover. Premiums net of commission go to its account.\n  attach protection = insurance.cover {\n    holder: actor, adapter: \"travel_insurer\", commission: 10%, covers: reservation\n    expose activate as activate_cover\n  }\n  attach reservation = travel.booking {\n    package: trip, buyer: actor, supplier: hotel, cover: protection\n    expose deposit as pay_deposit\n    expose balance as pay_balance\n    expose confirm as confirm_completion\n    expose cancel_early as cancel_booking\n  }\n}\n"},
   {"id":"wallet","title":"Workshop credits","summary":"Members prepay for workshop visits and the studio reserves each spend before charging it.","headers":["wallet"],"source":"// Members prepay for workshop visits and the studio reserves each spend before charging it.\nprogram workshop_credits \"Workshop credits\"\nuse wallet\n\nobject membership \"Membership\" {\n  fields { memberName: text, membershipNumber: text }\n  columns: [memberName, membershipNumber]\n  attach balance = wallet.balance {\n    holder: owner\n    expose activate as open_balance\n    expose topup as add_credit\n    expose withdraw as withdraw_credit\n    expose close as close_balance\n  }\n  attach visit = wallet.spend {\n    wallet: balance, payee: operator\n    expose reserve as reserve_visit\n    expose pay as charge_visit\n    expose cancel as cancel_visit\n  }\n}\n"},
 ];