@hyperscale0/hsx 1.0.0-beta.1 → 1.0.0

package/src/index.ts

@@ -1,11 +1,41 @@
-export { checkProgram } from "./check.ts";
-export { compile } from "./compile.ts";
+export {
+  compile,
+  type CompileDiagnostic,
+  type CompileOptions,
+  type CompileOriginMapEntry,
+  type CompileResult,
+} from "./compile.ts";
+export {
+  buildUdlCostManifest,
+  computeUdlFixedCost,
+  evaluateUdlCostManifest,
+  type HsxEffectKind,
+  type UdlCostManifest,
+  type UdlCostTable,
+} from "./cost.ts";
+export {
+  hsxDiagnostics,
+  type HsxDiagnosticCatalogEntry,
+} from "./diagnostics.ts";
+export type { HsxCompilerHost, ModuleSource } from "./modules.ts";
+export { format, type FormatResult } from "./format.ts";
+export { KEYWORDS } from "./lex.ts";
 export {
   overrideProgramEntries,
   type ProgramEntryOverride,
   type ProgramEntryOverrideIssue,
   type ProgramEntryOverrideValue,
 } from "./entry-overrides.ts";
-export { lowerProgram, MONEY_EVENT_BUDGET } from "./lower.ts";
+export { type OriginMapEntry } from "./emit.ts";
+export { lowerGeneralProgram } from "./emit.ts";
 export { parseProgram } from "./parse.ts";
-export type { Program } from "./ast.ts";
+export { checkGeneralProgram, type GeneralCheckOptions } from "./typecheck.ts";
+export {
+  byteOffsetToCodeUnit,
+  type BlockExpr,
+  type ExposeDecl,
+  type Program,
+  type ProgramDecl,
+  type UseDecl,
+} from "./ast.ts";
+export { bundledStandardLibrary, type StandardLibrary } from "./std-library.ts";

package/src/ir.ts

@@ -0,0 +1,99 @@
+import type { Span } from "./ast.ts";
+import type { UdlEffectKind } from "@hyperscale0/udl";
+
+export type JsonValue =
+  | boolean
+  | number
+  | string
+  | null
+  | readonly JsonValue[]
+  | { readonly [key: string]: JsonValue };
+
+export const HSX_TYPE_KINDS = [
+  "account",
+  "boolean",
+  "bps",
+  "condition",
+  "date",
+  "integer",
+  "money",
+  "party",
+  "percent",
+  "ref",
+  "text",
+  "unknown",
+] as const;
+
+export interface HsxType {
+  readonly currency?: string;
+  /** Positive safe integer minor units fixed by money(CUR, amount). */
+  readonly fixedAmount?: string;
+  readonly kind: (typeof HSX_TYPE_KINDS)[number];
+  readonly target?: string;
+}
+
+export interface TypedField {
+  readonly name: string;
+  readonly origin: Span;
+  readonly required: boolean;
+  readonly schema: Readonly<Record<string, JsonValue>>;
+  readonly type: HsxType;
+}
+
+export interface TypedAction {
+  readonly effects: Readonly<
+    Partial<
+      Record<
+        UdlEffectKind,
+        readonly {
+          readonly signature: string;
+          readonly source: string;
+          readonly channel?: string;
+          readonly role?: string;
+        }[]
+      >
+    >
+  >;
+  readonly name: string;
+  readonly origin: Span;
+  readonly slots: Readonly<Record<string, JsonValue>>;
+}
+
+export interface TypedInstrument {
+  readonly actions: readonly TypedAction[];
+  readonly fields: readonly TypedField[];
+  readonly id: string;
+  readonly origin: Span;
+  readonly slots: Readonly<Record<string, JsonValue>>;
+}
+
+export interface TypedSubject {
+  readonly declaredValue: "none" | "optional" | "required";
+  readonly kind: string;
+  readonly origin: Span;
+  readonly schema: Readonly<Record<string, JsonValue>>;
+  readonly title: string;
+  readonly version: number;
+}
+
+export interface TypedProgram {
+  readonly instruments: readonly TypedInstrument[];
+  readonly kind: "typed_program";
+  readonly name: string;
+  readonly origin: Span;
+  readonly subjects: readonly TypedSubject[];
+  readonly title: string;
+}
+
+export interface GeneralDiagnostic {
+  readonly code: string;
+  readonly fix: string;
+  readonly message: string;
+  readonly severity: "error" | "warning";
+  readonly span: Span;
+}
+
+export interface GeneralCheckResult {
+  readonly diagnostics: readonly GeneralDiagnostic[];
+  readonly program?: TypedProgram;
+}

package/src/lex.ts

@@ -17,13 +17,29 @@ type TokenKind =
   | "string";
 
 export const KEYWORDS = [
+  "action",
+  "as",
   "asset",
+  "commit",
+  "const",
+  "expect",
+  "expose",
+  "expires",
+  "export",
   "from",
   "import",
+  "instrument",
+  "module",
   "party",
   "port",
   "program",
+  "quote",
+  "rate",
+  "reconcile",
   "settlement",
+  "subject",
+  "type",
+  "use",
 ] as const;
 
 export interface Token {
@@ -35,7 +51,31 @@ export interface Token {
   readonly value: string;
 }
 
-const PUNCT = new Set(["{", "}", "(", ")", "[", "]", ":", ",", "=", "|", "."]);
+/** Source trivia retained for tools that must reproduce author comments. */
+export interface CommentTrivia {
+  readonly kind: "line_comment";
+  readonly span: Span;
+  readonly text: string;
+}
+
+export const PUNCT = [
+  "{",
+  "}",
+  "(",
+  ")",
+  "[",
+  "]",
+  ":",
+  ",",
+  ";",
+  "=",
+  "|",
+  ".",
+  "<",
+  ">",
+  "?",
+] as const;
+const PUNCT_SET: ReadonlySet<string> = new Set(PUNCT);
 const KEYWORD_SET: ReadonlySet<string> = new Set(KEYWORDS);
 
 // Case conventions (snake_case declarations, uppercase currency codes) are
@@ -45,12 +85,14 @@ const isIdentPart = (ch: string): boolean => /[A-Za-z0-9_]/.test(ch);
 const isDigit = (ch: string): boolean => ch >= "0" && ch <= "9";
 
 export interface LexResult {
+  readonly comments: readonly CommentTrivia[];
   readonly diagnostics: readonly Diagnostic[];
   readonly tokens: readonly Token[];
 }
 
 export function lex(source: string): LexResult {
   const tokens: Token[] = [];
+  const comments: CommentTrivia[] = [];
   const diagnostics: Diagnostic[] = [];
   let index = 0;
 
@@ -67,17 +109,30 @@ export function lex(source: string): LexResult {
     }
 
     if (ch === "/" && source[index + 1] === "/") {
+      const start = index;
       while (index < source.length && source[index] !== "\n") index += 1;
+      comments.push({
+        kind: "line_comment",
+        span: { end: index, start },
+        text: source.slice(start, index),
+      });
       continue;
     }
 
-    if (PUNCT.has(ch)) {
+    if (PUNCT_SET.has(ch)) {
       const start = index;
       index += 1;
       push("punct", start, ch);
       continue;
     }
 
+    if (ch === "-" && source[index + 1] === ">") {
+      const start = index;
+      index += 2;
+      push("punct", start, "->");
+      continue;
+    }
+
     if (ch === '"') {
       const start = index;
       index += 1;
@@ -139,7 +194,7 @@ export function lex(source: string): LexResult {
     while (
       index < source.length &&
       !/[\sA-Za-z0-9_"]/.test(source[index] as string) &&
-      !PUNCT.has(source[index] as string) &&
+      !PUNCT_SET.has(source[index] as string) &&
       !(source[index] === "/" && source[index + 1] === "/")
     ) {
       index += 1;
@@ -157,5 +212,5 @@ export function lex(source: string): LexResult {
     text: "",
     value: "",
   });
-  return { diagnostics, tokens };
+  return { comments, diagnostics, tokens };
 }

package/src/limits.ts

@@ -1,7 +1,6 @@
 /**
  * What the compiler refuses to read, as opposed to what it refuses to emit.
- * `MONEY_EVENT_BUDGET` in lower.ts bounds the OUTPUT; these bound the INPUT,
- * which is the side an attacker controls.
+ * These bounds cap the input side an attacker controls.
  *
  * Both numbers are set against the 34 real programs this compiler is tested
  * on. The deepest nests 5 levels; the largest is 13,934 bytes.
@@ -16,6 +15,6 @@ export const HSX_LIMITS = Object.freeze({
    * 12x the deepest real program and 144x below that measured crash.
    */
   maxNestingDepth: 64,
-  /** Matches `UDL_LIMITS.maxSourceBytes`. 18x the largest real program. */
+  /** 18x the largest real HSX program. */
   maxSourceBytes: 256 * 1_024,
 });