@hyperscale0/hsx 1.0.0-rc.1 → 2.0.0

package/src/emit.ts

@@ -1,10 +1,9 @@
 import {
-  serializeUdl,
   validateUdl,
   type UdlDocument,
   type UdlIssueCode,
 } from "@hyperscale0/udl";
-import type { JsonValue, TypedInstrument, TypedProgram } from "./ir.ts";
+import type { TypedInstrument, TypedProgram } from "./ir.ts";
 
 export interface OriginMapEntry {
   readonly path: string;
@@ -25,9 +24,7 @@ export type GeneralLowerResult =
   | {
       readonly ok: true;
       readonly value: {
-        readonly canonicalUdl: string;
         readonly document: UdlDocument;
-        readonly frame: Record<string, JsonValue>;
         readonly originMap: readonly OriginMapEntry[];
       };
     };
@@ -58,11 +55,7 @@ export function lowerGeneralProgram(program: TypedProgram): GeneralLowerResult {
     udl: 1,
     version: 1,
   };
-  const frame = frameFor(program);
-  const unresolved = [
-    ...unresolvedCompilerMarkers(candidate),
-    ...unresolvedCompilerMarkers(frame, "$.frame"),
-  ];
+  const unresolved = unresolvedCompilerMarkers(candidate);
   if (unresolved.length > 0) {
     const origins = originMapFor(program);
     return {
@@ -77,7 +70,9 @@ export function lowerGeneralProgram(program: TypedProgram): GeneralLowerResult {
       ok: false,
     };
   }
-  const validation = validateUdl(candidate);
+  const validation = validateUdl(candidate, {
+    requireDecisionPartyBindings: true,
+  });
   if (!validation.ok) {
     const origins = originMapFor(program);
     return {
@@ -99,9 +94,7 @@ export function lowerGeneralProgram(program: TypedProgram): GeneralLowerResult {
   return {
     ok: true,
     value: {
-      canonicalUdl: serializeUdl(document),
       document,
-      frame,
       originMap: originMapFor(program),
     },
   };
@@ -135,21 +128,36 @@ function unresolvedCompilerMarkers(
   });
 }
 
-function originForUdlPath(
+export function originForUdlPath<T extends { readonly path: string }>(
   path: string,
-  origins: readonly OriginMapEntry[],
-): OriginMapEntry | undefined {
-  return (
-    [...origins]
-      .filter(
-        (entry) =>
-          path === entry.path ||
-          path.startsWith(`${entry.path}.`) ||
-          path.startsWith(`${entry.path}[`),
-      )
-      .sort((left, right) => right.path.length - left.path.length)[0] ??
-    origins.find((entry) => entry.path === "$")
-  );
+  origins: readonly T[],
+): T | undefined {
+  let longestMatch: T | undefined;
+  let longestLength = -1;
+  let rootFallback: T | undefined;
+
+  for (let i = 0; i < origins.length; i += 1) {
+    const entry = origins[i]!;
+    const entryPath = entry.path;
+    if (rootFallback === undefined && entryPath === "$") {
+      rootFallback = entry;
+    }
+    const entryLen = entryPath.length;
+    if (
+      path === entryPath ||
+      (path.length > entryLen &&
+        (path.charCodeAt(entryLen) === 46 ||
+          path.charCodeAt(entryLen) === 91) &&
+        path.startsWith(entryPath))
+    ) {
+      if (entryLen > longestLength) {
+        longestMatch = entry;
+        longestLength = entryLen;
+      }
+    }
+  }
+
+  return longestMatch ?? rootFallback;
 }
 
 export function requiredFields(instrument: TypedInstrument): string[] {
@@ -182,240 +190,6 @@ export function requiredFields(instrument: TypedInstrument): string[] {
   ];
 }
 
-function frameFor(program: TypedProgram): Record<string, JsonValue> {
-  const actors = new Map<string, Record<string, JsonValue>>();
-  const moneyEvents: Record<string, JsonValue>[] = [];
-  const design: string[] = [];
-  const fees: Record<string, JsonValue>[] = [];
-  const mechanics = new Set<string>();
-  const eventKeys = new Set<string>();
-  const ensureActor = (rawKey: string, role: string): string => {
-    const key = frameKey(rawKey);
-    if (!actors.has(key)) {
-      actors.set(key, {
-        key,
-        label: titleize(key),
-        maxCount: 1,
-        minCount: 1,
-        role,
-      });
-    }
-    return key;
-  };
-  const uniqueEventKey = (raw: string): string => {
-    const base = frameKey(raw);
-    let key = base;
-    let ordinal = 2;
-    while (eventKeys.has(key)) {
-      const suffix = `_${ordinal}`;
-      key = `${base.slice(0, 40 - suffix.length)}${suffix}`;
-      ordinal += 1;
-    }
-    eventKeys.add(key);
-    return key;
-  };
-  for (const instrument of program.instruments) {
-    const actorByField = new Map<string, string>();
-    const parties = instrument.slots.parties;
-    if (parties && typeof parties === "object" && !Array.isArray(parties)) {
-      for (const [role, value] of Object.entries(parties)) {
-        if (typeof value !== "string") continue;
-        const actor = ensureActor(role, frameActorRole(role, "source"));
-        actorByField.set(value, actor);
-      }
-    }
-    for (const action of instrument.actions) {
-      if (action.slots.due) mechanics.add("recurring_billing");
-      const moves = action.slots.moves;
-      if (!Array.isArray(moves)) continue;
-      moves.forEach((move, index) => {
-        if (moneyEvents.length >= 20) return;
-        if (!move || typeof move !== "object" || Array.isArray(move)) return;
-        const bind =
-          move.bind &&
-          typeof move.bind === "object" &&
-          !Array.isArray(move.bind)
-            ? move.bind
-            : {};
-        const source = frameActorForBinding(
-          bind.sourceAccountId,
-          actorByField,
-          "source",
-          ensureActor,
-        );
-        const destination = frameActorForBinding(
-          bind.destinationAccountId,
-          actorByField,
-          "destination",
-          ensureActor,
-        );
-        const operation =
-          typeof move.operation === "string" ? move.operation : "transfer";
-        if (source === "escrow" || destination === "escrow") {
-          mechanics.add("escrow");
-        }
-        moneyEvents.push({
-          allocationTotalBps: 0,
-          amount: bindingWords(bind.amount) || "the declared amount",
-          amountDependencies: [],
-          amountMode: "fixed",
-          amountSchedule: [],
-          distribution: "single",
-          fromActor: source,
-          key: uniqueEventKey(
-            typeof move.key === "string"
-              ? move.key
-              : `${instrument.id}_${action.name}_${index + 1}`,
-          ),
-          kind: frameEventKind(operation, source, destination),
-          label: `${titleize(action.name)} movement`,
-          occurrence: action.slots.due ? "repeatable" : "once",
-          timing: action.name === "create" ? "on_create" : "on_lifecycle",
-          toActor: destination,
-          trigger: `when ${action.name.replaceAll("_", " ")} runs`,
-        });
-      });
-    }
-    if (design.length < 10) {
-      design.push(
-        `${instrument.id}: ${instrument.fields.length} fields and ${instrument.actions.length} actions`,
-      );
-    }
-    const feeRules = instrument.slots.feeRules;
-    if (Array.isArray(feeRules)) {
-      feeRules.forEach((fee, index) => {
-        if (fees.length >= 4) return;
-        if (!fee || typeof fee !== "object" || Array.isArray(fee)) return;
-        fees.push({
-          label: `${titleize(instrument.id)} fee ${index + 1}`,
-          on:
-            typeof fee.baseField === "string"
-              ? fee.baseField
-              : `${instrument.id} movement`,
-          structure:
-            typeof fee.position === "string"
-              ? `${fee.position.replaceAll("_", " ")} fee`
-              : "declared fee",
-        });
-      });
-    }
-  }
-  if (actors.size === 0) ensureActor("platform", "platform");
-  if (moneyEvents.length === 0) {
-    const actor = actors.keys().next().value ?? "platform";
-    moneyEvents.push({
-      allocationTotalBps: 0,
-      amount: "the declared settlement amount",
-      amountDependencies: [],
-      amountMode: "fixed",
-      amountSchedule: [],
-      distribution: "single",
-      fromActor: actor,
-      key: uniqueEventKey(`${program.name}_create`),
-      kind: "charge",
-      label: `${program.title} movement`,
-      occurrence: "once",
-      timing: "on_create",
-      toActor: actor,
-      trigger: "when the settlement is created",
-    });
-  }
-  if (mechanics.size === 0) mechanics.add("escrow");
-  return {
-    actors: [...actors.values()],
-    confidence: "high",
-    conservationGroups: [],
-    design,
-    feePolicy: fees.length > 0 ? "defined" : "none",
-    fees,
-    headline: program.title,
-    mechanics: [...mechanics],
-    moneyEvents,
-    offPlatform: [],
-    openQuestions: [],
-    rules: [],
-    subjects: program.subjects.map((subject) => ({
-      kind: subject.kind,
-      title: subject.title,
-    })),
-    summary: `${program.title} compiles ${program.instruments.length} financial instrument${program.instruments.length === 1 ? "" : "s"}.`,
-  };
-}
-
-function frameActorForBinding(
-  value: JsonValue | undefined,
-  actorByField: ReadonlyMap<string, string>,
-  direction: "destination" | "source",
-  ensureActor: (key: string, role: string) => string,
-): string {
-  const path = bindingWords(value);
-  if (path.includes("escrowAccountId")) return "escrow";
-  const field = path.startsWith("fields.")
-    ? path.slice("fields.".length)
-    : path;
-  const declared = actorByField.get(field);
-  if (declared) return declared;
-  if (field.toLowerCase().includes("platform")) {
-    return ensureActor("platform", "platform");
-  }
-  return ensureActor(
-    direction === "source" ? "payer" : "beneficiary",
-    direction === "source" ? "payer" : "beneficiary",
-  );
-}
-
-function frameActorRole(
-  role: string,
-  direction: "destination" | "source",
-): string {
-  return [
-    "payer",
-    "beneficiary",
-    "platform",
-    "provider",
-    "guardian",
-    "holder",
-  ].includes(role)
-    ? role
-    : direction === "source"
-      ? "payer"
-      : "beneficiary";
-}
-
-function frameEventKind(
-  operation: string,
-  source: string,
-  destination: string,
-): string {
-  if (operation.endsWith(".reserve")) return "hold";
-  if (operation.endsWith(".void") || operation.endsWith(".return")) {
-    return "refund";
-  }
-  if (operation.startsWith("payout.")) return "payout";
-  if (source === "escrow" || destination === "escrow") return "release";
-  return "charge";
-}
-
-function frameKey(value: string): string {
-  const snake = value
-    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-    .replace(/[^A-Za-z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "")
-    .toLowerCase();
-  const leading = /^[a-z]/.test(snake) ? snake : `event_${snake}`;
-  return leading.slice(0, 40) || "event";
-}
-
-function bindingWords(value: JsonValue | undefined): string {
-  if (typeof value === "string") return value;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
-  const binding = value as Readonly<Record<string, JsonValue>>;
-  if (binding.from === "const" && typeof binding.value === "string")
-    return binding.value;
-  if (typeof binding.path === "string") return binding.path;
-  return "";
-}
-
 function originMapFor(program: TypedProgram): OriginMapEntry[] {
   const entries: OriginMapEntry[] = [{ path: "$", span: program.origin }];
   program.subjects.forEach((subject, index) => {
@@ -439,9 +213,3 @@ function originMapFor(program: TypedProgram): OriginMapEntry[] {
   });
   return entries;
 }
-
-function titleize(value: string): string {
-  return value
-    .replaceAll("_", " ")
-    .replace(/\b[a-z]/g, (letter) => letter.toUpperCase());
-}

package/src/index.ts

@@ -12,6 +12,7 @@ export {
   type HsxEffectKind,
   type UdlCostManifest,
   type UdlCostTable,
+  type UdlCostTables,
 } from "./cost.ts";
 export {
   hsxDiagnostics,
@@ -27,13 +28,15 @@ export {
   type ProgramEntryOverrideValue,
 } from "./entry-overrides.ts";
 export { type OriginMapEntry } from "./emit.ts";
-export { lowerGeneralProgram } from "./emit.ts";
+export { lowerGeneralProgram, originForUdlPath } from "./emit.ts";
 export { parseProgram } from "./parse.ts";
 export { checkGeneralProgram, type GeneralCheckOptions } from "./typecheck.ts";
-export type {
-  BlockExpr,
-  ExposeDecl,
-  Program,
-  ProgramDecl,
-  UseDecl,
+export {
+  byteOffsetToCodeUnit,
+  type BlockExpr,
+  type ExposeDecl,
+  type Program,
+  type ProgramDecl,
+  type UseDecl,
 } from "./ast.ts";
+export { bundledStandardLibrary, type StandardLibrary } from "./std-library.ts";