@hyperscale0/hsx 1.0.0-alpha.1

package/LICENSING.md

@@ -0,0 +1,52 @@
+# Licensing
+
+The code in this repository is Copyright 2026 Hyperscale LLC and is licensed
+under the GNU Affero General Public License version 3 only
+(`AGPL-3.0-only`). The full text is in [`LICENSE`](./LICENSE).
+
+## What the AGPL asks of you
+
+Two obligations matter in practice.
+
+**If you distribute a copy in object form**, modified or not, you make its
+Corresponding Source available under the same license.
+
+**If you run a modified copy as a network service**, section 13 applies: the
+users interacting with it over the network get an offer of the source of the
+version you are running. Compiling HSX with an unmodified copy behind your own
+service does not trigger this. Changing the lexer, the parser, the lowering, or
+the emitted IR and then serving that change does.
+
+Using `@hyperscale0/hsx` as a library inside your own program is a combined
+work under the AGPL. If that does not fit how you ship, take the commercial
+license instead.
+
+## Commercial license
+
+Hyperscale LLC sells a commercial license to organisations that cannot accept
+the AGPL, for the usual reasons: a proprietary product that links the compiler,
+a hosted service you will not open, a procurement policy that refuses copyleft.
+It grants the same code under ordinary commercial terms with no source
+obligation.
+
+Ask through <https://hyperscale0.ai>.
+
+## The license covers code, not marks
+
+"Hyperscale" and "HSX" are trademarks of Hyperscale LLC. A copyright license
+says nothing about trademarks in either direction, so
+[`TRADEMARKS.md`](./TRADEMARKS.md) draws that boundary.
+
+## The language is not the compiler
+
+HSX the language and the HSX-JSON IR are separate from this compiler. The IR
+schema in [`spec/`](./spec) and the fixtures under [`examples/`](./examples)
+are data describing a language, and anyone may write their own compiler,
+formatter, or runtime against them, in any language, under any license, without
+touching this code.
+
+What you may then say about it is a trademark question, not a copyright one.
+[`TRADEMARKS.md`](./TRADEMARKS.md) has the rule: claim compatibility with an
+HSX IR version only when your implementation emits IR that validates against
+that version's published schema, from the published example programs,
+unmodified.

package/README.md

@@ -0,0 +1,170 @@
+# HSX
+
+HSX is a language for describing how money moves through a financial product.
+You write the product's parties, the things they trade, and the settlements
+between them; the compiler turns that into an intermediate representation the
+Hyperscale engine executes.
+
+Seventeen lines of HSX ([`car-escrow.hsx`](./test/fixtures/car-escrow.hsx)) are
+a used-car escrow: the buyer's money is held, the buyer's own backend confirms
+the handover, the platform takes asymmetric fees, and a cancellation splits the
+held amount to the basis point. There is no account provisioning in it, no
+lifecycle table, no transfer plumbing. That is the point: those are consequences
+of the settlement you named, so the compiler derives them instead of asking you
+to hand-write them and get them right.
+
+The line here is the one HCL draws with Terraform. **The language is open.**
+The lexer, the parser, the typechecker, the lowering, the diagnostics, the IR
+schema, and this compiler are AGPL-3.0-only and live in this repository. **The
+runtime that executes the IR is the product**, and it is not open. HSX targets
+it the way HCL targets a provider: you can read every rule the compiler
+enforces, compile any program, and inspect the exact document that gets
+executed.
+
+## Install
+
+```bash
+npm install @hyperscale0/hsx@alpha
+```
+
+The `@alpha` tag is not optional. There is no `latest` tag before 1.0.0, so a
+bare `npm install @hyperscale0/hsx` fails loudly rather than quietly installing
+something you did not choose.
+
+## A program
+
+[`photo-booth.hsx`](./examples/02-imports-and-archetypes/photo-booth.hsx), a
+booth rental company, whole apart from its comments:
+
+```hsx
+program photo_booth "Photo booth rentals"
+
+import { held_payment } from "settlement"
+
+party renter:  person
+party company: business
+
+asset booth: good { title_transfer: off_platform }
+
+settlement booking = held_payment {
+  payer:   renter
+  payee:   company
+  amount:  bookingFee: money(SAR)
+  fees { renter: 1%, company: 3% }
+  release: port confirm_delivery
+  on_cancel(funded) { renter: 90%, company: 10% }
+}
+
+port confirm_delivery {
+  allowed: [company]
+  shape {
+    boothId:     id(booth)
+    deliveredOn: date
+  }
+}
+```
+
+```ts
+import { compile } from "@hyperscale0/hsx";
+
+const result = compile(await Bun.file("photo-booth.hsx").text());
+
+result.verdict; // "valid" | "warning" | "invalid"
+result.diagnostics; // [{ line, column, severity, stage, message }]
+result.artifacts; // present unless the verdict is "invalid"
+```
+
+`result.artifacts.document` is the HSX-JSON IR. Those 20 lines compile to one
+escrow noun, `booking`, carrying:
+
+- **five money fields**: `bookingFee`, the three pieces it partitions into
+  (90%, 7%, 3%: the finest split that every exit agrees on, since release pays
+  97/3 to company and platform while cancellation pays 90/10 to renter and
+  company), and `serviceFeeAmount` for the renter's 1% charged on top;
+- **a `partitions` clause** proving those pieces sum to `bookingFee` exactly,
+  checked at create admission before any money moves;
+- **fifteen verbs**: the funding chain, the fee collection, the port itself,
+  the release payout, the cancellation unwind, and the abandonment refunds,
+  each with its `from` states, its `to` state, and its ledger moves.
+
+`result.artifacts.frame` is the congruent Business Frame: the same product as
+actors, money events, rules, and fees, for the surfaces people read rather
+than the runtime that executes.
+
+Both shapes are specified in
+[`spec/hsx-ir.schema.json`](./spec/hsx-ir.schema.json) (JSON Schema 2020-12),
+and every file under `examples/` and `test/fixtures/` is validated against it
+in CI.
+
+## The command
+
+```bash
+hsx check photo-booth.hsx              # diagnostics, nothing else
+hsx check photo-booth.hsx --strict     # warnings fail too
+hsx build photo-booth.hsx              # artifacts to stdout
+hsx build photo-booth.hsx --out ir.json
+```
+
+Exit codes: `0` the program compiled, `1` it was refused, `2` the command line
+or the input file could not be used. A refused program and a mistyped command
+are different failures, so they get different codes.
+
+There is no `hsx fmt`. This package ships no formatter, and shipping a bad one
+is worse than shipping none.
+
+## Learn it
+
+- [`examples/`](./examples/) has four programs, in order: the smallest one that
+  moves money, archetypes and ports, a walk through the diagnostics, and a
+  complete small product. Each has its own README, and each is compiled by the
+  test suite so they cannot rot.
+- [`docs/reference.md`](./docs/reference.md) is the language reference: lexical
+  grammar, EBNF, what each stage does, the diagnostic model, and every
+  archetype in the `settlement` standard library with its parameters and
+  constraints.
+- [`editors/vscode/`](./editors/vscode/) carries the syntax highlighting.
+
+## Versioning
+
+Two numbers move independently.
+
+**IR version** is the literal `"hsx": 1` stamped into every compiled document,
+exported as `HSX_IR_VERSION`. A consumer reads that one integer to decide
+whether it understands the document. It moves only when the emitted IR shape
+changes in a way a consumer must notice.
+
+**Package version** is this package's semver, currently `1.0.0-alpha.1`,
+published only under the `alpha` dist-tag. It moves whenever the compiler
+changes, including changes that only affect a diagnostic's wording.
+
+IR version 1 is unstable until the package reaches 1.0.0. Until then an alpha
+release may change what the compiler emits, and every such change is listed in
+[`CHANGELOG.md`](./CHANGELOG.md). After 1.0.0, an incompatible IR change bumps
+the literal to `2`.
+
+## Status
+
+Alpha. Nine settlement archetypes ship and all nine lower. The compiler is in
+production use; the surface is settled enough to build on and the version
+number is honest about the rest. What is most likely to move: diagnostic
+wording (there are no stable diagnostic codes yet), and the archetype
+parameter surfaces as more products land.
+
+## Contributing
+
+Issues only. Hyperscale makes the changes to the language and the compiler; you
+propose them in an issue carrying the program you were trying to write and the
+fixture the change would add. [`CONTRIBUTING.md`](./CONTRIBUTING.md) has that
+model in full, plus the setup, the test commands, and the one hard rule: a
+grammar change without a fixture is not a grammar change. Conduct:
+[`CODE_OF_CONDUCT.md`](./CODE_OF_CONDUCT.md). Vulnerabilities:
+[`SECURITY.md`](./SECURITY.md).
+
+## License
+
+AGPL-3.0-only, with a commercial license available from Hyperscale LLC for
+organisations that cannot accept the AGPL. See [`LICENSE`](./LICENSE) for the
+text and [`LICENSING.md`](./LICENSING.md) for which one you want and how to ask
+for the commercial one. The marks are not covered by either; see
+[`TRADEMARKS.md`](./TRADEMARKS.md), which also carries the rule for claiming
+HSX compatibility.

package/SECURITY.md

@@ -0,0 +1,47 @@
+# Security
+
+## Reporting a vulnerability
+
+Report privately through GitHub, using this repository's
+[private vulnerability reporting form](https://github.com/hyperscale0/hyperscale-hsx/security/advisories/new).
+That is the only intake. There is no security email address, and nothing
+security-sensitive belongs in an issue, a pull request, a discussion, or a
+commit message.
+
+A report we can act on names the affected version and gives us something to
+run: the `.hsx` source, and what you expected the compiler to do with it. If
+you can shape it as a fixture under `test/fixtures/`, do that; it goes straight
+into the fix.
+
+## What counts
+
+This compiler reads untrusted source and emits a document a runtime then
+executes, so the interesting failures are the ones a source file can cause:
+
+- **A program that compiles but should not**, especially one whose emitted
+  pieces do not partition their total, whose exits do not drain custody, or
+  whose fees move money the source did not authorise. A `valid` verdict on an
+  unsound program is the worst bug this package can have.
+- **A program that makes the lexer, parser, checker, or lowering burn
+  unbounded time or memory.** Every stage is meant to be linear or near it in
+  the size of the input, and the schedule, split, and money-event limits exist
+  to bound the output.
+- **A crash.** Parsing and checking are total by design: they return
+  diagnostics, they never throw. A source file that throws out of `compile()`
+  is a bug even when the program is nonsense.
+- **A diagnostic that reports the wrong source coordinates**, which sends an
+  author to fix the wrong line.
+
+Out of scope: the `hsx` command reading a file you told it to read, and
+anything that requires already controlling the machine running it.
+
+## Supported versions
+
+Alpha releases are supported at the newest published `alpha` version only.
+Fixes land there; there is no backport branch before 1.0.0.
+
+## Disclosure
+
+We will confirm receipt, tell you what we found, and agree a disclosure date
+with you before publishing an advisory. If a fix is not straightforward we will
+say so rather than go quiet.

package/TRADEMARKS.md

@@ -0,0 +1,35 @@
+# Trademarks
+
+"Hyperscale" and "HSX" are trademarks of Hyperscale LLC.
+
+The AGPL covers the code in this repository and nothing else. It grants no
+rights to the marks, and it never mentions them: a copyright license says
+nothing about trademarks either way. This file draws that boundary so nobody
+has to guess where it sits.
+
+What that means in practice:
+
+- **Yes.** Say your project uses HSX, compiles HSX, or reads the HSX-JSON IR.
+  Say it in your README, your docs, your talk, and your package description.
+  Fork this repository and keep the notices intact.
+- **Yes.** Publish an HSX implementation or tool in another language, and name
+  it in a way that describes what it does: `hsx-rs`, `hsx-lsp`, `tree-sitter-hsx`.
+- **No.** Name your project, company, or product in a way that suggests
+  Hyperscale LLC published it or endorses it. `@hyperscale0/*` on npm and the
+  `hyperscale0` GitHub organisation are ours.
+- **No.** Use the marks or our logo in a way that implies affiliation,
+  sponsorship, or certification we have not given.
+
+## Claiming compatibility
+
+An independent implementation may say it "implements HSX IR version X" only
+while it emits IR that validates against the published schema for that version,
+from the published example programs, unmodified. The schema in
+[`spec/`](./spec) and the programs in [`examples/`](./examples) are the whole
+test: no edited fixture, no local relaxation of the schema.
+
+That claim is a statement about your implementation, so keep the marks out of
+its name and off its logo, and do not present it as endorsement or
+certification by Hyperscale LLC. We certify nothing; the schema does.
+
+If you are unsure, open an issue and ask. Nobody has ever regretted asking.

package/bin/hsx.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * The `hsx` executable. Everything it does lives in `runCli`; this file only
+ * binds that function to the real filesystem and the real streams.
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import { runCli } from "../src/cli.ts";
+
+process.exitCode = await runCli(process.argv.slice(2), {
+  err: (line) => process.stderr.write(`${line}\n`),
+  out: (line) => process.stdout.write(`${line}\n`),
+  readFile: (path) => readFile(path, "utf8"),
+  writeFile: (path, contents) => writeFile(path, contents, "utf8"),
+});

package/dist/bin/hsx.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * The `hsx` executable. Everything it does lives in `runCli`; this file only
+ * binds that function to the real filesystem and the real streams.
+ */
+export {};
+//# sourceMappingURL=hsx.d.ts.map

package/dist/bin/hsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hsx.d.ts","sourceRoot":"","sources":["../../bin/hsx.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/bin/hsx.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * The `hsx` executable. Everything it does lives in `runCli`; this file only
+ * binds that function to the real filesystem and the real streams.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { runCli } from "../src/cli.js";
+process.exitCode = await runCli(process.argv.slice(2), {
+    err: (line) => process.stderr.write(`${line}\n`),
+    out: (line) => process.stdout.write(`${line}\n`),
+    readFile: (path) => readFile(path, "utf8"),
+    writeFile: (path, contents) => writeFile(path, contents, "utf8"),
+});
+//# sourceMappingURL=hsx.js.map

package/dist/bin/hsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hsx.js","sourceRoot":"","sources":["../../bin/hsx.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,CAAC,QAAQ,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IACrD,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC;IAChD,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC;IAChD,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC1C,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC;CACjE,CAAC,CAAC"}

package/dist/src/ast.d.ts

@@ -0,0 +1,172 @@
+/**
+ * The HSX abstract syntax tree.
+ *
+ * Every node carries a byte-offset span into the original source. Spans are
+ * the compiler's source-mapping currency: diagnostics at every later stage
+ * (typecheck, lowering, verdicts) point at source coordinates, never at
+ * lowered IR paths. Offsets convert to line/column via `lineColAt`.
+ */
+export interface Span {
+    /** Inclusive start byte offset into the source text. */
+    readonly start: number;
+    /** Exclusive end byte offset into the source text. */
+    readonly end: number;
+}
+export interface LineCol {
+    /** 1-indexed line. */
+    readonly line: number;
+    /** 1-indexed column, counted in UTF-16 code units. */
+    readonly column: number;
+}
+/** Convert a byte offset to a 1-indexed line/column position. */
+export declare function lineColAt(source: string, offset: number): LineCol;
+export interface IdentExpr {
+    readonly kind: "ident";
+    readonly name: string;
+    readonly span: Span;
+}
+export interface StringExpr {
+    readonly kind: "string";
+    readonly span: Span;
+    readonly value: string;
+}
+interface NumberExpr {
+    readonly kind: "number";
+    /** The literal exactly as written, e.g. "99.5". Interpretation is typed later. */
+    readonly raw: string;
+    readonly span: Span;
+}
+export interface PercentExpr {
+    /** Exact basis points: 99.5% is 9950. Percents never round. */
+    readonly bps: number;
+    readonly kind: "percent";
+    readonly raw: string;
+    readonly span: Span;
+}
+/** A type or constructor application: `money(SAR)`, `id(vehicle)`. */
+export interface CallExpr {
+    readonly args: readonly Expr[];
+    readonly callee: IdentExpr;
+    readonly kind: "call";
+    readonly span: Span;
+}
+/**
+ * A reference to a decision port, optionally bounded (`port dispute within
+ * P14D`) or carrying the date that decides when the port has not
+ * (`port approve_release | at(releaseDueAt)`).
+ */
+export interface PortRefExpr {
+    /** `| at(<field>)`, the stored date field that resolves an undecided hold. */
+    readonly deadline?: IdentExpr;
+    readonly kind: "port_ref";
+    readonly name: IdentExpr;
+    readonly span: Span;
+    readonly within?: IdentExpr;
+}
+/**
+ * `retention.release`, one settlement naming another settlement's exit. The
+ * only cross-settlement reference the language has: it is resolved wholly at
+ * check time, never by a caller at runtime.
+ */
+export interface SettlementRefExpr {
+    readonly kind: "settlement_ref";
+    /** The exit named on the owner, e.g. `release`. */
+    readonly member: IdentExpr;
+    /** The settlement being referenced. */
+    readonly owner: IdentExpr;
+    readonly span: Span;
+}
+export interface ListExpr {
+    readonly items: readonly Expr[];
+    readonly kind: "list";
+    readonly span: Span;
+}
+/** A brace block of entries: `{ buyer: 1%, seller: 2% }`. */
+export interface BlockExpr {
+    readonly entries: readonly Entry[];
+    readonly kind: "block";
+    readonly span: Span;
+}
+/**
+ * A named typed binding inside an expression position:
+ * `amount: price: money(SAR)` binds the field name `price` to type
+ * `money(SAR)`: the entry key is `amount`, the value is this binding.
+ */
+interface BindingExpr {
+    readonly kind: "binding";
+    readonly name: IdentExpr;
+    readonly span: Span;
+    readonly type: Expr;
+}
+export type Expr = BindingExpr | BlockExpr | CallExpr | IdentExpr | ListExpr | NumberExpr | PercentExpr | PortRefExpr | SettlementRefExpr | StringExpr;
+/**
+ * One keyed entry inside a declaration body. Three surface shapes normalize
+ * here: `payer: buyer` (key + value), `fees { ... }` (key + block value),
+ * and `on_cancel(funded) { ... }` (key + qualifiers + block value).
+ */
+export interface Entry {
+    readonly key: IdentExpr;
+    readonly qualifiers: readonly IdentExpr[];
+    readonly span: Span;
+    readonly value: Expr;
+}
+/** `program used_car_escrow "Used-car escrow"` names the company program. */
+export interface ProgramDecl {
+    readonly kind: "program";
+    readonly name: IdentExpr;
+    readonly span: Span;
+    readonly title?: StringExpr;
+}
+/** `import { held_payment } from "settlement"`. */
+export interface ImportDecl {
+    readonly from: StringExpr;
+    readonly kind: "import";
+    readonly names: readonly IdentExpr[];
+    readonly span: Span;
+}
+/** `party buyer: person` with an optional attribute block. */
+export interface PartyDecl {
+    readonly attrs?: BlockExpr;
+    readonly kind: "party";
+    readonly name: IdentExpr;
+    readonly partyKind: IdentExpr;
+    readonly span: Span;
+}
+/** `asset vehicle: good { title_transfer: off_platform }`. */
+export interface AssetDecl {
+    readonly assetKind: IdentExpr;
+    readonly attrs?: BlockExpr;
+    readonly kind: "asset";
+    readonly name: IdentExpr;
+    readonly span: Span;
+}
+/** `settlement sale = held_payment { ... }`, an archetype instantiation. */
+export interface SettlementDecl {
+    readonly archetype: IdentExpr;
+    readonly body: BlockExpr;
+    readonly kind: "settlement";
+    readonly name: IdentExpr;
+    readonly span: Span;
+}
+/** `port confirm_handover { allowed: [buyer], ... }`. */
+export interface PortDecl {
+    readonly body: BlockExpr;
+    readonly kind: "port";
+    readonly name: IdentExpr;
+    readonly span: Span;
+}
+export type Decl = AssetDecl | ImportDecl | PartyDecl | PortDecl | ProgramDecl | SettlementDecl;
+export interface Program {
+    readonly decls: readonly Decl[];
+    readonly span: Span;
+}
+/**
+ * A parse-stage problem, worded for the program's author. Parsing is total:
+ * it never throws, it returns the best-effort tree plus these.
+ */
+export interface Diagnostic {
+    readonly message: string;
+    readonly span: Span;
+}
+export {};
+//# sourceMappingURL=ast.d.ts.map

package/dist/src/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/ast.ts"],"names":[],"mappings":"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"}

package/dist/src/ast.js

@@ -0,0 +1,22 @@
+/**
+ * The HSX abstract syntax tree.
+ *
+ * Every node carries a byte-offset span into the original source. Spans are
+ * the compiler's source-mapping currency: diagnostics at every later stage
+ * (typecheck, lowering, verdicts) point at source coordinates, never at
+ * lowered IR paths. Offsets convert to line/column via `lineColAt`.
+ */
+/** Convert a byte offset to a 1-indexed line/column position. */
+export function lineColAt(source, offset) {
+    let line = 1;
+    let lineStart = 0;
+    const clamped = Math.max(0, Math.min(offset, source.length));
+    for (let index = 0; index < clamped; index += 1) {
+        if (source.charCodeAt(index) === 10) {
+            line += 1;
+            lineStart = index + 1;
+        }
+    }
+    return { column: clamped - lineStart + 1, line };
+}
+//# sourceMappingURL=ast.js.map

package/dist/src/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../src/ast.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,iEAAiE;AACjE,MAAM,UAAU,SAAS,CAAC,MAAc,EAAE,MAAc;IACtD,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7D,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAChD,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;YACpC,IAAI,IAAI,CAAC,CAAC;YACV,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC;AACnD,CAAC"}

package/dist/src/check.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The HSX typechecker. Takes the parsed AST, resolves every name, validates
+ * each archetype's parameter surface, and produces the checked program model
+ * the lowering consumes. Total: always returns diagnostics; returns the model
+ * exactly when nothing error-severity was found. Warnings are the compiler's
+ * lint voice and never block.
+ */
+import type { Program } from "./ast.ts";
+import { type CheckResult } from "./model.ts";
+export declare function checkProgram(program: Program): CheckResult;
+//# sourceMappingURL=check.d.ts.map

package/dist/src/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/check.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAKV,OAAO,EAER,MAAM,UAAU,CAAC;AAClB,OAAO,EAOL,KAAK,WAAW,EAcjB,MAAM,YAAY,CAAC;AAiFpB,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAshD1D"}