@hyperscale0/hsx 3.2.0 → 4.0.0

package/src/cost.ts

@@ -1,4 +1,4 @@
-import type { UdlDocument } from "@hyperscale0/udl";
+import { resolveField, type UdlDocument } from "@hyperscale0/udl";
 export interface UdlCostManifest {
   actions: Record<
     string,
@@ -12,21 +12,65 @@ export interface UdlCostManifest {
 /** Counts sealed instructions after lowering. Prices belong to the executor's tariff. */
 export function buildUdlCostManifest(document: UdlDocument): UdlCostManifest {
   const actions: UdlCostManifest["actions"] = {};
-  for (const instrument of document.instruments)
-    for (const [name, action] of Object.entries(instrument.actions)) {
-      actions[`${instrument.id}.${name}`] = {
-        transfers: action.moves.length,
-        accounts:
-          name === "create"
-            ? instrument.fields.filter(
-                (f) => f.type === "account" && f.owner === "self",
-              ).length
-            : 0,
-        invocations: (action.invoke ?? []).reduce(
-          (sum, call) => sum + ("selection" in call ? call.selection.limit : 1),
-          0,
-        ),
-      };
+  const active = new Set<string>();
+  const visit = (
+    id: string,
+    name: string,
+  ): UdlCostManifest["actions"][string] => {
+    const key = `${id}.${name}`;
+    if (actions[key]) return actions[key];
+    if (active.has(key)) throw new Error(`Invocation cycle at ${key}`);
+    const instrument = document.instruments.find((item) => item.id === id);
+    const action = instrument?.actions[name];
+    if (!instrument || !action) throw new Error(`Unknown invocation ${key}`);
+    active.add(key);
+    const cost = {
+      transfers: action.moves.length,
+      accounts:
+        name === "create"
+          ? instrument.fields.filter(
+              (field) => field.type === "account" && field.owner === "self",
+            ).length
+          : 0,
+      invocations: 0,
+    };
+    for (const call of action.invoke ?? []) {
+      const ref =
+        "reference" in call
+          ? resolveField(document, instrument, call.reference, action.input)
+          : undefined;
+      const targets =
+        "instrument" in call
+          ? call.instrument
+          : "selection" in call
+            ? call.selection.instrument
+            : ref?.type === "ref"
+              ? ref.target
+              : [];
+      const children = (typeof targets === "string" ? [targets] : targets).map(
+        (target) => visit(target, call.action),
+      );
+      const count =
+        "selection" in call
+          ? call.selection.limit
+          : "instrument" in call
+            ? (call.range?.maximum ?? 1)
+            : 1;
+      // A union selects one target per row. Each meter takes its worst case.
+      cost.transfers +=
+        count * Math.max(0, ...children.map((child) => child.transfers));
+      cost.accounts +=
+        count * Math.max(0, ...children.map((child) => child.accounts));
+      cost.invocations +=
+        count *
+        (1 + Math.max(0, ...children.map((child) => child.invocations)));
     }
+    active.delete(key);
+    actions[key] = cost;
+    return cost;
+  };
+  for (const instrument of document.instruments)
+    for (const name of Object.keys(instrument.actions))
+      visit(instrument.id, name);
   return { actions };
 }

package/src/headers.ts

@@ -16,6 +16,7 @@ export const HEADER_NAMES = [
   "travel",
   "cards",
   "savings",
+  "reporting",
 ] as const;
 
 /** The compiler frontend owns header metadata used by docs and catalogue consumers. */
@@ -23,7 +24,7 @@ export function headerManifest(
   library: StandardLibrary = bundledStandardLibrary,
 ) {
   return {
-    version: 3,
+    version: 4,
     headers: HEADER_NAMES.map((name) => {
       const source = library.source(name);
       if (!source) throw new Error(`Missing standard header ${name}`);
@@ -110,7 +111,7 @@ export function headerManifest(
                 requiredImport: `use ${name}`,
                 instancePlaceholder: "${instance}",
                 source:
-                  "${instance} = " +
+                  "attach ${instance} = " +
                   `${name}.${decl.name} { ` +
                   bindings
                     .map((t) => t.name + ": ${" + t.name + "}")

package/src/index.ts

@@ -4,12 +4,23 @@ export {
   type CompileOptions,
   type CompileResult,
   type CompileOriginMapEntry,
+  type AdapterBindingTarget,
 } from "./compile.ts";
+export type { ProviderAdapter } from "@hyperscale0/adl";
 export { parseProgram } from "./parse.ts";
 export { lex, KEYWORDS } from "./lex.ts";
 export { format } from "./format.ts";
 export { bundledStandardLibrary, type StandardLibrary } from "./std-library.ts";
 export { buildUdlCostManifest, type UdlCostManifest } from "./cost.ts";
-export type { Program, Decl, Expr, Span, Diagnostic } from "./ast.ts";
+export type {
+  Program,
+  Decl,
+  AssignmentDecl,
+  ObjectDecl,
+  InstrumentDecl,
+  Expr,
+  Span,
+  Diagnostic,
+} from "./ast.ts";
 
 export { headerManifest, HEADER_NAMES } from "./headers.ts";

package/src/lex.ts

@@ -42,6 +42,11 @@ export const KEYWORDS = [
   "capture",
   "fee",
   "shares",
+  "object",
+  "attach",
+  "subject",
+  "rename",
+  "columns",
 ] as const;
 export interface Token {
   kind: "name" | "number" | "string" | "date" | "punct" | "eof";

package/src/parse.ts

@@ -172,14 +172,30 @@ class Parser {
         });
         continue;
       }
+      if (this.eat("object")) {
+        const name = this.identifier();
+        const title =
+          this.peek().kind === "string"
+            ? (JSON.parse(this.take().text) as string)
+            : name;
+        const body = this.block();
+        program.decls.push({
+          kind: "object",
+          name,
+          title,
+          body,
+          span: this.span(start),
+        });
+        continue;
+      }
       const name = this.identifier();
       this.expect("=");
       const object = this.path();
       const body = this.block();
       program.decls.push({
-        kind: "object",
+        kind: "assignment",
         name,
-        object,
+        target: object,
         body,
         span: this.span(start),
       });
@@ -194,14 +210,74 @@ class Parser {
       if (this.peek().kind === "eof")
         this.fail(`unclosed block, expected ${end}`, `add ${end}`);
       const start = this.peek().span.start;
+      if (this.eat("attach")) {
+        const name = this.identifier();
+        this.expect("=");
+        const target = this.path();
+        const body = this.block();
+        entries.push({
+          key: `attach ${name} = ${target}`,
+          value: body,
+          span: this.span(start),
+        });
+        this.separators();
+        continue;
+      }
+      if (this.eat("rename")) {
+        const body = this.block();
+        entries.push({
+          key: "rename",
+          value: body,
+          span: this.span(start),
+        });
+        this.separators();
+        continue;
+      }
+      if (this.eat("expose")) {
+        const action = this.identifier();
+        let publicName = action;
+        if (this.eat("as")) {
+          publicName = this.identifier();
+        }
+        entries.push({
+          key: "expose",
+          value: {
+            kind: "call",
+            name: action,
+            args: [{ kind: "name", value: publicName, span: this.span(start) }],
+            span: this.span(start),
+          },
+          span: this.span(start),
+        });
+        this.separators();
+        continue;
+      }
       let key = this.path();
+      if (key === "columns" && !this.at(":")) {
+        let value: Expr;
+        if (this.at("[")) {
+          value = this.atom();
+        } else if (this.at("{")) {
+          value = this.block();
+        } else {
+          value = { kind: "list", items: [], span: this.span(start) };
+        }
+        entries.push({
+          key: "columns",
+          value,
+          span: this.span(start),
+        });
+        this.separators();
+        continue;
+      }
       if (key === "action" && !this.at(":")) key += " " + this.identifier();
       if (key === "when") {
         const tunable = this.identifier();
-        this.expect("is");
+        const relation = this.eat("has") ? "has" : "is";
+        if (relation === "is") this.expect("is");
         const choice = this.identifier();
         entries.push({
-          key: `when ${tunable} is ${choice}`,
+          key: `when ${tunable} ${relation} ${choice}`,
           value: this.block(),
           span: this.span(start),
         });
@@ -241,7 +317,8 @@ class Parser {
   private operand(): BlockExpr {
     const value = this.atom();
     return this.record({
-      [value.kind === "name" && /^(self|input|party)\./.test(value.value)
+      [value.kind === "name" &&
+      /^(self|input|party|subject)\./.test(value.value)
         ? "field"
         : "literal"]: value,
     });
@@ -263,6 +340,8 @@ class Parser {
       };
       if (this.eat("for")) values.action = this.atom();
       if (this.eat("is")) values.decision = this.atom();
+      for (const key of ["protectedRequest", "differentFromInitiator"])
+        if (this.eat(key)) values[key] = this.atom();
       return this.record(values);
     }
     if (this.eat("unique")) {
@@ -315,6 +394,7 @@ class Parser {
         this.expect(key);
         values[key] = this.atom();
       }
+      if (this.eat("instruction")) values.instruction = this.atom();
       return this.record(values);
     }
     const left = this.operand();
@@ -360,6 +440,8 @@ class Parser {
     }
     for (const key of ["fee", "capture", "key"])
       if (this.eat(key)) values[key] = this.atom();
+    if (this.eat("boundary"))
+      values.boundary = this.record({ adapter: this.atom() });
     return this.record(values);
   }
   private block(): BlockExpr {