@hyperscale0/hsx 5.7.0 → 6.0.0

package/src/compile.ts

@@ -1,4 +1,9 @@
-import { CompileFailure, fail, failWithCode } from "./diagnostics.ts";
+import {
+  CompileFailure,
+  didYouMean,
+  fail,
+  failWithCode,
+} from "./diagnostics.ts";
 import { hash as sha256 } from "fast-sha256";
 import { buildUdlCostManifest, type UdlCostManifest } from "./cost.ts";
 import {
@@ -21,6 +26,7 @@ import {
   type UdlField,
   type UdlInstrument,
   type UdlObjectField,
+  type UdlSelection,
   type UdlSubjectRequirement,
   type UdlValue,
 } from "@hyperscale0/udl";
@@ -398,6 +404,18 @@ export function compile(
     severity: "error",
     stage,
   });
+  // A program instrument lowers once standalone and once per attachment, so
+  // one authored mistake can fail each copy at the same place.
+  const distinct = (list: Diagnostic[]) =>
+    list.filter(
+      (d, index) =>
+        list.findIndex(
+          (other) =>
+            other.source === d.source &&
+            other.span.start === d.span.start &&
+            other.message === d.message,
+        ) === index,
+    );
   if (parsed.diagnostics.length)
     return {
       verdict: "invalid",
@@ -531,8 +549,6 @@ export function compile(
       parties: Object.assign(Object.create(null) as UdlDocument["parties"], {
         programOperator: { kind: "business", role: "program_operator" },
         programTax: { kind: "business", role: "tax_payable" },
-        programFines: { kind: "business", role: "fine_payable" },
-        programCosts: { kind: "business", role: "cost_recovery" },
       }),
       objects: [],
       instruments: [],
@@ -589,6 +605,10 @@ export function compile(
       }
     }
     const origins: CompileOriginMapEntry[] = [];
+    // Lowered objects lose their spans, so each keeps the expression that
+    // produced it for the name check after lowering.
+    const authored = new WeakMap<object, Expr>();
+    const declarations = new WeakMap<UdlInstrument, InstrumentDecl>();
     const exposures: { instrument: string; action: string; entry: Entry }[] =
       [];
     const refundBindings = new Map<
@@ -1179,14 +1199,11 @@ export function compile(
             param.value.kind === "default" ? param.value.type : param.value;
           const type =
             t.kind === "type" || t.kind === "call" ? t.name : text(t);
-          let v =
-            (supplied.has(param.key) && !attachmentInfo) || type === "enum"
-              ? actual
-              : resolve(
-                  actual,
-                  new Set(),
-                  !!attachmentInfo && type === "party",
-                );
+          const asWritten =
+            (supplied.has(param.key) && !attachmentInfo) || type === "enum";
+          let v = asWritten
+            ? actual
+            : resolve(actual, new Set(), !!attachmentInfo && type === "party");
           if (
             type === "duration" &&
             (v.kind === "text" || v.kind === "name") &&
@@ -1237,7 +1254,16 @@ export function compile(
                 ? { role: v.value as SubjectPartyRole }
                 : { party: v.value };
           } else if (type === "ref") {
-            const values = v.kind === "list" ? v.items : [v];
+            // Listed objects resolve like a single binding, so `on: [plan]`
+            // names the sibling attachment that `on: plan` names.
+            const values =
+              v.kind !== "list"
+                ? [v]
+                : asWritten
+                  ? v.items
+                  : v.items.map((item) => resolve(item));
+            if (v.kind === "list")
+              environment.set(param.key, { ...v, items: values });
             if (v.kind === "list" && (t.kind !== "type" || !t.many))
               fail(
                 v,
@@ -1587,9 +1613,11 @@ export function compile(
       };
       const val = (expr: Expr): UdlValue => {
         const v = resolve(expr);
-        return v.kind === "name" && !["true", "false"].includes(v.value)
-          ? { field: path(v) }
-          : { literal: literal(v) };
+        if (v.kind !== "name" || ["true", "false"].includes(v.value))
+          return { literal: literal(v) };
+        const value = { field: path(v) };
+        authored.set(value, expr);
+        return value;
       };
       const data = (expr: Expr): unknown => {
         if (
@@ -1646,6 +1674,7 @@ export function compile(
               if (k === "family" || k === "instrument") continue;
               result[k] = data(v);
             }
+            authored.set(result, value);
             return result;
           }
 
@@ -1674,10 +1703,14 @@ export function compile(
               };
             return null;
           }
+          authored.set(result, value);
           return result;
         }
-        if (value.kind === "list")
-          return value.items.map(data).filter((item) => item !== null);
+        if (value.kind === "list") {
+          const items = value.items.map(data).filter((item) => item !== null);
+          authored.set(items, value);
+          return items;
+        }
         if (
           value.kind === "call" &&
           value.name === "child" &&
@@ -1811,12 +1844,6 @@ export function compile(
               f.book = t.args[1] ? text(t.args[1]) : "cash";
               if (t.args[2]) {
                 const mode = text(t.args[2]);
-                if (mode === "external")
-                  fail(
-                    t,
-                    "external account mode was removed",
-                    "use a reservation and instruction-bound evidence",
-                  );
                 if (mode === "contra") f.contra = true;
                 else f.key = mode;
               }
@@ -1921,6 +1948,7 @@ export function compile(
                   `unknown calculation ${constant.name}`,
                   "use rate, sum, minimum, subtract, multiply, divide, before or after",
                 );
+              authored.set(calculations.at(-1)!, constant);
             } else if (type === "enum" && constant.kind === "name")
               f.value = constant.value;
             else if (type === "money" && constant.kind === "name")
@@ -1931,14 +1959,26 @@ export function compile(
               });
             else f.value = literal(constant, String(type));
           }
+          authored.set(f, row.value);
           result.push(f as UdlField);
         }
         return result;
       };
       fields.push(...lowerFields(asBlock(body.get("fields"))));
-      const lifecycle = data(
-        asBlock(body.get("lifecycle")),
-      ) as UdlInstrument["lifecycle"];
+      const lifecycleBlock = asBlock(body.get("lifecycle"));
+      const lifecycle = data(lifecycleBlock) as UdlInstrument["lifecycle"];
+      const states = Array.isArray(lifecycle.states) ? lifecycle.states : [];
+      const checkState = (expr: Expr, state: unknown) => {
+        if (typeof state !== "string" || !states.length) return;
+        if (states.includes(state)) return;
+        fail(
+          expr,
+          `\`${state}\` is not a state of \`${decl.name}\`.${didYouMean(state, states)}`,
+          `Use one of ${states.join(", ")}, or add \`${state}\` to \`lifecycle.states\`.`,
+        );
+      };
+      const initialExpr = entries(lifecycleBlock).get("initial");
+      if (initialExpr) checkState(initialExpr, lifecycle.initial);
       lifecycle.transitions = Object.create(
         null,
       ) as UdlInstrument["lifecycle"]["transitions"];
@@ -2288,6 +2328,7 @@ export function compile(
           moves: [],
           ...(actionSubject ? { subject: actionSubject } : {}),
         };
+        authored.set(a, row.value);
         for (const binding of boundaryBindings)
           if (
             !a.subject?.adapters.find((entry) => entry.binding === binding)
@@ -2309,12 +2350,12 @@ export function compile(
               `action ${name} needs from and to`,
               "declare its source and destination states",
             );
-          lifecycle.transitions[name] = {
-            from: (from!.kind === "list" ? from!.items : [from!]).map((e) =>
-              String(data(e)),
-            ),
-            to: String(data(to!)),
-          };
+          const sources = from!.kind === "list" ? from!.items : [from!];
+          const fromStates = sources.map((e) => String(data(e)));
+          const toState = String(data(to!));
+          sources.forEach((e, index) => checkState(e, fromStates[index]));
+          if (toState !== "preserve") checkState(to!, toState);
+          lifecycle.transitions[name] = { from: fromStates, to: toState };
         }
         for (const [key, expr] of slots) {
           if (["from", "to", "input", "summary", "subject"].includes(key))
@@ -2322,6 +2363,7 @@ export function compile(
           if (key === "moves") {
             const moves = expr.kind === "list" ? expr.items : [expr];
             for (const [index, move] of moves.entries()) {
+              const lowered = a.moves.length;
               const parts = entries(asBlock(move));
               const op = parts.has("operation")
                 ? String(data(parts.get("operation")!))
@@ -2571,6 +2613,8 @@ export function compile(
                       "split percentages must sum to 100%",
                       "give the recipients exactly 100% together",
                     );
+                  for (const item of a.moves.slice(lowered))
+                    authored.set(item, move);
                   continue;
                 }
                 if (!amount || !from || !to)
@@ -2767,6 +2811,8 @@ export function compile(
                   `unknown transfer instruction ${op}`,
                   "choose create, reserve, post, or void from internal_transfer",
                 );
+              for (const item of a.moves.slice(lowered))
+                authored.set(item, move);
             }
           } else (a as unknown as Record<string, unknown>)[key] = data(expr);
         }
@@ -2911,6 +2957,7 @@ export function compile(
         };
       }
       document.instruments.push(inst);
+      declarations.set(inst, decl);
       for (const [key, definition] of records) {
         const childAttachment = attachmentInfo
           ? {
@@ -3267,7 +3314,7 @@ export function compile(
     if (bindingDiagnostics.length)
       return {
         verdict: "invalid",
-        diagnostics: bindingDiagnostics
+        diagnostics: distinct(bindingDiagnostics)
           .sort((a, b) => a.span.start - b.span.start)
           .map((d) => diagnostic(d, "check")),
       };
@@ -3517,6 +3564,287 @@ export function compile(
           );
       }
     }
+    // Names resolve here, once tunables, attachments and derived fields are
+    // final, and each failure points at the expression that wrote the name.
+    type Located = { span: Span; source?: string };
+    type Scope = { inst: UdlInstrument; label: string; action?: UdlAction };
+    const byId = new Map(document.instruments.map((inst) => [inst.id, inst]));
+    const site = (owner: object, key: string | number, fallback: Located) => {
+      const expr = authored.get(owner);
+      if (expr?.kind === "block")
+        return expr.entries.find((entry) => entry.key === key)?.value ?? expr;
+      if (expr?.kind === "list" && Array.isArray(owner))
+        return expr.items.length === owner.length
+          ? expr.items[Number(key)]!
+          : expr;
+      return expr ?? fallback;
+    };
+    const keySite = (owner: object, key: string, fallback: Located) => {
+      const expr = authored.get(owner);
+      const entry =
+        expr?.kind === "block"
+          ? expr.entries.find((item) => item.key === key)
+          : undefined;
+      if (!entry) return fallback;
+      return {
+        ...entry,
+        span: { start: entry.span.start, end: entry.span.start + key.length },
+      };
+    };
+    const builtins = (inst: UdlInstrument) => [
+      "id",
+      "now",
+      "createdAt",
+      "productRevision",
+      "status",
+      ...(inst.subject ? ["subject"] : []),
+    ];
+    const parties = (inst: UdlInstrument) => [
+      ...Object.keys(document.parties),
+      ...(inst.subject ? subjectPartyRoles : []),
+    ];
+    const members = (field: UdlField): string[] => {
+      if (field.type === "account") return ["balance", "reserved"];
+      if (field.type !== "ref") return [];
+      const [id] = [field.target].flat();
+      const target =
+        field.targetKind === "object"
+          ? document.objects.find((object) => object.id === id)
+          : byId.get(id!);
+      if (!target) return [];
+      return [
+        ...target.fields.map((item) => item.name),
+        ...("lifecycle" in target ? builtins(target) : []),
+      ];
+    };
+    const checkParty = (name: string, at: Located, inst: UdlInstrument) => {
+      const names = parties(inst);
+      if (!names.includes(name))
+        fail(
+          at,
+          `\`${name}\` is not a declared party.${didYouMean(name, names)}`,
+          `Declare it with \`party ${name}: business\`, or name a declared party (${names.join(", ")}).`,
+        );
+    };
+    const checkInput = (
+      name: string,
+      at: Located,
+      label: string,
+      input: readonly UdlField[],
+    ) => {
+      const names = input.map((field) => field.name);
+      if (!names.includes(name))
+        fail(
+          at,
+          `\`${name}\` is not an input of \`${label}\`.${didYouMean(name, names)}`,
+          `Declare \`${name}\` in the input of \`${label}\`${names.length ? `, or use one of ${names.join(", ")}` : ""}.`,
+        );
+    };
+    const checkTarget = (id: string, at: Located, objects = false) => {
+      const ids = [
+        ...byId.keys(),
+        ...(objects ? document.objects.map((object) => object.id) : []),
+      ];
+      const noun = objects ? "instrument or object" : "instrument";
+      if (!ids.includes(id))
+        fail(
+          at,
+          `\`${id}\` is not a declared ${noun}.${didYouMean(id, ids)}`,
+          `Name a declared ${noun}.`,
+        );
+    };
+    const checkPath = (path: string, at: Located, scope: Scope): void => {
+      const { inst, action } = scope;
+      const parts = path.split(".");
+      const found = (count: number) =>
+        resolveField(
+          document,
+          inst,
+          parts.slice(0, count).join("."),
+          action?.input,
+          action,
+        );
+      // Subject paths keep their own check against the action's requirements.
+      if (found(parts.length) || parts[0] === "subject") return;
+      if (parts[0] === "party" && parts[1]) {
+        checkParty(parts[1], at, inst);
+        if (!found(2)) return;
+      }
+      if (!["self", "input", "party"].includes(parts[0]!))
+        parts.unshift("self");
+      let count = 2;
+      while (count <= parts.length && found(count)) count++;
+      if (count > parts.length) return;
+      const name = parts[count - 1]!;
+      if (count > 2) {
+        const prefix = parts.slice(0, count - 1).join(".");
+        const names = members(found(count - 1)!);
+        fail(
+          at,
+          `\`${name}\` is not a field of \`${prefix}\`.${didYouMean(name, names)}`,
+          names.length
+            ? `Use one of ${names.join(", ")}.`
+            : `\`${prefix}\` has no fields.`,
+        );
+      }
+      if (parts[0] === "input")
+        return checkInput(name, at, scope.label, action?.input ?? []);
+      const declared = declarations.get(inst)!.name;
+      const fields = inst.fields.map((field) => field.name);
+      fail(
+        at,
+        `\`${name}\` is not a field or party of \`${declared}\`.${didYouMean(name, [...fields, ...builtins(inst), ...parties(inst)])}`,
+        `Use a field declared in \`${declared}\` (${fields.join(", ")}) or a declared party (${parties(inst).join(", ")}).`,
+      );
+    };
+    const scopeOf = (inst: UdlInstrument): Scope => ({
+      inst,
+      label: declarations.get(inst)!.name,
+    });
+    const checkSelection = (
+      selection: UdlSelection,
+      at: Located,
+      scope: Scope,
+    ) => {
+      walk(selection.anchor, "anchor", site(selection, "anchor", at), scope);
+      walk(selection.where, "where", site(selection, "where", at), scope);
+      for (const id of [selection.instrument].flat()) {
+        checkTarget(id, site(selection, "instrument", at));
+        const target = scopeOf(byId.get(id)!);
+        const member = (key: string, where: Located) =>
+          checkPath(
+            key.startsWith("self.") ? key : `self.${key}`,
+            where,
+            target,
+          );
+        for (const key of Object.keys(selection.where ?? {}))
+          member(key, keySite(selection.where!, key, at));
+        member(selection.reference, site(selection, "reference", at));
+        selection.order?.forEach((key, index) =>
+          member(key, site(selection.order!, index, at)),
+        );
+        if (selection.window)
+          member(selection.window.field, site(selection.window, "field", at));
+      }
+    };
+    const checkCall = (
+      call: NonNullable<UdlAction["invoke"]>[number],
+      at: Located,
+      scope: Scope,
+    ) => {
+      const bind = "range" in call ? call.range?.bind : undefined;
+      for (const [key, value] of Object.entries(call))
+        if (key !== "input") walk(value, key, site(call, key, at), scope);
+      for (const [key, value] of Object.entries(call.input))
+        if (!("field" in value) || value.field !== bind)
+          walk(value, key, site(call.input, key, at), scope);
+      if ("instrument" in call)
+        checkTarget(call.instrument, site(call, "instrument", at));
+      const reference =
+        "reference" in call
+          ? resolveField(
+              document,
+              scope.inst,
+              call.reference,
+              scope.action?.input,
+              scope.action,
+            )
+          : undefined;
+      const ids =
+        "instrument" in call
+          ? [call.instrument]
+          : "selection" in call
+            ? [call.selection.instrument].flat()
+            : reference?.type === "ref" && reference.targetKind === "instrument"
+              ? [reference.target].flat()
+              : [];
+      for (const id of ids) {
+        const target = byId.get(id);
+        if (!target) continue;
+        const action = target.actions[call.action];
+        if (!action)
+          fail(
+            site(call, "action", at),
+            `\`${call.action}\` is not an action of \`${id}\`.${didYouMean(call.action, target.actionOrder)}`,
+            `Use one of ${target.actionOrder.join(", ")}.`,
+          );
+        for (const key of Object.keys(call.input))
+          checkInput(
+            key,
+            keySite(call.input, key, at),
+            `${id}.${call.action}`,
+            action.input,
+          );
+      }
+    };
+    const pathKeys = [
+      "field",
+      "reference",
+      "anchor",
+      "at",
+      "list",
+      "from",
+      "to",
+      "transfer",
+      "subject",
+      "instruction",
+      "installment",
+      "recipient",
+      "dueAt",
+      "fields",
+    ];
+    const walk = (
+      value: unknown,
+      key: string,
+      at: Located,
+      scope: Scope,
+    ): void => {
+      if (typeof value === "string") {
+        if (key === "party") checkParty(value, at, scope.inst);
+        if (key === "target") checkPath(`self.${value}`, at, scope);
+        if (pathKeys.includes(key)) checkPath(value, at, scope);
+        return;
+      }
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value))
+        return value.forEach((item, index) =>
+          walk(item, key, site(value, index, at), scope),
+        );
+      if (key === "selection")
+        return checkSelection(value as UdlSelection, at, scope);
+      if (key === "invoke")
+        return checkCall(
+          value as NonNullable<UdlAction["invoke"]>[number],
+          at,
+          scope,
+        );
+      if (key === "set")
+        for (const name of Object.keys(value))
+          checkPath(`self.${name}`, keySite(value, name, at), scope);
+      for (const [child, item] of Object.entries(value))
+        walk(item, child, site(value, child, at), scope);
+    };
+    for (const inst of document.instruments) {
+      const decl = declarations.get(inst)!;
+      const scope = scopeOf(inst);
+      for (const field of [
+        ...inst.fields,
+        ...Object.values(inst.actions).flatMap((action) => action.input),
+      ])
+        if ("target" in field && field.target !== undefined)
+          for (const id of [field.target].flat())
+            checkTarget(id, site(field, "target", decl), true);
+      walk(inst.calculate, "calculate", decl, scope);
+      walk(inst.invariants, "invariants", decl, scope);
+      for (const [name, action] of Object.entries(inst.actions))
+        for (const [key, value] of Object.entries(action))
+          if (key !== "input" && key !== "subject")
+            walk(value, key, site(action, key, decl), {
+              inst,
+              label: `${decl.name}.${name}`,
+              action,
+            });
+    }
     const eliminatedStates = new Map<string, Set<string>>();
     // Remove branches excluded by immutable tunables before checking reference states.
     for (const inst of document.instruments) {
@@ -3669,19 +3997,6 @@ export function compile(
           );
       }
     }
-    const usedParties = new Set<string>();
-    const collectParties = (value: unknown): void => {
-      if (typeof value === "string") {
-        usedParties.add(value);
-        if (value.startsWith("party.")) usedParties.add(value.split(".")[1]!);
-      } else if (Array.isArray(value)) value.forEach(collectParties);
-      else if (value && typeof value === "object")
-        Object.values(value).forEach(collectParties);
-    };
-    collectParties(document.instruments);
-    for (const party of ["programFines", "programCosts"])
-      if (!usedParties.has(party) && !names.has(party))
-        delete document.parties[party];
     const validated = validateUdl(document);
     if (!validated.ok)
       return {
@@ -3754,8 +4069,8 @@ export function compile(
     if (error instanceof CompileFailure)
       return {
         verdict: "invalid",
-        diagnostics: [...bindingDiagnostics, error.diagnostic].map((d) =>
-          diagnostic(d, "check"),
+        diagnostics: distinct([...bindingDiagnostics, error.diagnostic]).map(
+          (d) => diagnostic(d, "check"),
         ),
       };
     throw error;

package/src/diagnostics.ts

@@ -26,3 +26,37 @@ export function failWithCode(
     ...(expr.source ? { source: expr.source } : {}),
   });
 }
+
+// Levenshtein distance where swapping two adjacent letters counts as one edit.
+function editDistance(a: string, b: string): number {
+  const d = Array.from({ length: a.length + 1 }, (_, i) =>
+    Array.from({ length: b.length + 1 }, (_, j) =>
+      i === 0 ? j : j === 0 ? i : 0,
+    ),
+  );
+  for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++) {
+      d[i]![j] = Math.min(
+        d[i - 1]![j]! + 1,
+        d[i]![j - 1]! + 1,
+        d[i - 1]![j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+        d[i]![j] = Math.min(d[i]![j]!, d[i - 2]![j - 2]! + 1);
+    }
+  return d[a.length]![b.length]!;
+}
+/** " Did you mean `x`?" for the closest candidate within a third of the name's length, else "". */
+export function didYouMean(
+  name: string,
+  candidates: readonly string[],
+): string {
+  const limit = Math.max(1, Math.floor(name.length / 3));
+  let best: string | undefined;
+  let bestDistance = limit + 1;
+  for (const candidate of candidates) {
+    const distance = editDistance(name, candidate);
+    if (distance < bestDistance) [best, bestDistance] = [candidate, distance];
+  }
+  return best === undefined ? "" : ` Did you mean \`${best}\`?`;
+}

package/src/examples-bundle.ts

@@ -15,6 +15,5 @@ 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    expose create as create_allowance\n    borrower: owner, per_borrower: 200000 SAR\n    expose approve as approve_business\n  }\n  attach budget = financing.portfolio_limit {\n    expose create as create_budget\n    limit: 5000000 SAR\n    expose approve as approve_budget\n  }\n  attach loan = financing.installments {\n    expose create as create_loan\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 { expose create as create_reports, 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    expose create as create_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    expose create as create_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 { expose create as create_sale, payer: actor, payee: operator, expose fund as purchase }\n attach limits = financing.limits { expose create as create_limits, borrower: actor, per_borrower: 250000 SAR }\n attach ceiling = financing.portfolio_limit { expose create as create_ceiling, 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   expose create as create_late\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 { expose create as create_reminders, 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    expose create as create_trip\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    expose create as create_protection\n    holder: actor, adapter: \"travel_insurer\", commission: 10%, covers: reservation\n    expose activate as activate_cover\n  }\n  attach reservation = travel.booking {\n    expose create as create_reservation\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    expose create as create_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    expose create as create_visit\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"},
 ];

package/src/headers.ts

@@ -16,7 +16,6 @@ export const HEADER_NAMES = [
   "lending",
   "insurance",
   "collections",
-  "travel",
   "cards",
   "savings",
   "reporting",