edict-lang 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sowiedu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# Edict
+
+[![CI](https://github.com/Sowiedu/Edict/actions/workflows/ci.yml/badge.svg)](https://github.com/Sowiedu/Edict/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/Node.js-%E2%89%A520-339933?logo=node.js)](https://nodejs.org)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-8A2BE2)](https://modelcontextprotocol.io/)
+
+**A programming language designed for AI agents.** No parser. No syntax. Agents produce AST directly as JSON.
+
+Edict is a statically-typed, effect-tracked programming language where the canonical program format is a JSON AST. It's purpose-built so AI agents can write, verify, and execute programs through a structured pipeline — no text parsing, no human-readable syntax, no ambiguity.
+
+```
+Agent (LLM)
+  │  produces JSON AST via MCP tool call
+  ↓
+Schema Validator ─── invalid? → StructuredError → Agent retries
+  ↓
+Name Resolver ────── undefined? → StructuredError + candidates → Agent retries
+  ↓
+Type Checker ─────── mismatch? → StructuredError + expected type → Agent retries
+  ↓
+Effect Checker ───── violation? → StructuredError + propagation chain → Agent retries
+  ↓
+Contract Verifier ── unproven? → StructuredError + counterexample → Agent retries
+  (Z3/SMT)            ↓
+                  Code Generator (binaryen) → WASM → Execute
+```
+
+## Features
+
+- **JSON AST** — Programs are JSON objects, not text files. No lexer, no parser.
+- **Structured errors** — Every error is a typed JSON object with enough context for an agent to self-repair.
+- **Type system** — `Int`, `Float`, `String`, `Bool`, `Array<T>`, `Option<T>`, `Result<T,E>`, records, enums, refinement types.
+- **Effect tracking** — Functions declare `pure`, `reads`, `writes`, `io`, `fails`. The compiler verifies consistency.
+- **Contract verification** — Pre/post conditions verified at compile time by Z3 (via SMT). Failing contracts return concrete counterexamples.
+- **WASM compilation** — Verified programs compile to WebAssembly via binaryen and run in Node.js.
+- **MCP interface** — All tools exposed via [Model Context Protocol](https://modelcontextprotocol.io/) for direct agent integration.
+
+## Quick Start
+
+```bash
+npm install
+npm test          # 488 tests, ~1.5s
+npm run mcp       # start MCP server (stdio transport)
+```
+
+## MCP Tools
+
+| Tool | Description |
+|---|---|
+| `edict_schema` | Returns the full AST JSON Schema — the spec for how to write programs |
+| `edict_examples` | Returns 10 example programs as JSON ASTs |
+| `edict_validate` | Validates AST structure (field names, types, node kinds) |
+| `edict_check` | Full pipeline: validate → resolve names → type check → effect check → verify contracts |
+| `edict_compile` | Compiles a checked AST to WASM (returns base64-encoded binary) |
+| `edict_run` | Executes a compiled WASM binary, returns output and exit code |
+
+### MCP Resources
+
+| URI | Description |
+|---|---|
+| `edict://schema` | The AST JSON Schema |
+| `edict://examples` | All example programs |
+
+## Example Program
+
+A "Hello, World!" in Edict's JSON AST:
+
+```json
+{
+  "kind": "module",
+  "id": "mod-hello-001",
+  "name": "hello",
+  "imports": [],
+  "definitions": [
+    {
+      "kind": "fn",
+      "id": "fn-main-001",
+      "name": "main",
+      "params": [],
+      "effects": ["io"],
+      "returnType": { "kind": "basic", "name": "Int" },
+      "contracts": [],
+      "body": [
+        {
+          "kind": "call",
+          "id": "call-print-001",
+          "fn": { "kind": "ident", "id": "ident-print-001", "name": "print" },
+          "args": [
+            { "kind": "literal", "id": "lit-msg-001", "value": "Hello, World!" }
+          ]
+        },
+        { "kind": "literal", "id": "lit-ret-001", "value": 0 }
+      ]
+    }
+  ]
+}
+```
+
+## The Agent Loop
+
+The core design: an agent submits an AST → the compiler validates it → if wrong, returns a `StructuredError` with enough context for the agent to self-repair → the agent fixes it → resubmits.
+
+```typescript
+// 1. Agent reads the schema to learn the AST format
+const schema = edict_schema();
+
+// 2. Agent writes a program (may contain errors)
+const program = agentWritesProgram(schema);
+
+// 3. Compile — returns structured errors or WASM
+const result = edict_compile(program);
+
+if (!result.ok) {
+  // 4. Agent reads errors and fixes the program
+  //    Errors include: nodeId, expected type, candidates, counterexamples
+  const fixed = agentFixesProgram(program, result.errors);
+  // 5. Resubmit
+  return edict_compile(fixed);
+}
+
+// 6. Run the WASM
+const output = edict_run(result.wasm);
+```
+
+## Architecture
+
+```
+src/
+├── ast/           # TypeScript interfaces for every AST node
+├── validator/     # Schema validation (structural correctness)
+├── resolver/      # Name resolution (scope-aware, with Levenshtein suggestions)
+├── checker/       # Type checking (bidirectional, with unit types)
+├── effects/       # Effect checking (call-graph propagation)
+├── contracts/     # Contract verification (Z3/SMT integration)
+├── codegen/       # WASM code generation (binaryen)
+│   ├── codegen.ts    # AST → WASM compilation
+│   ├── runner.ts     # WASM execution (Node.js WebAssembly API)
+│   ├── builtins.ts   # Built-in functions (print)
+│   └── string-table.ts  # String interning for WASM memory
+├── mcp/           # MCP server (tools + resources)
+└── errors/        # Structured error types
+
+tests/             # 488 tests across 21 files
+examples/          # 10 example programs as JSON ASTs
+schema/            # Auto-generated JSON Schema
+```
+
+## Type System
+
+| Type | Example |
+|---|---|
+| Basic | `Int`, `Float`, `String`, `Bool` |
+| Array | `Array<Int>` |
+| Option | `Option<String>` |
+| Result | `Result<String, String>` |
+| Record | `Point { x: Float, y: Float }` |
+| Enum | `Shape = Circle { radius: Float } \| Rectangle { w: Float, h: Float }` |
+| Refinement | `{ i: Int \| i > 0 }` — predicates verified by Z3 |
+| Function | `(Int, Int) -> Int` |
+
+## Effect System
+
+Functions declare their effects. The compiler enforces:
+
+- A `pure` function cannot call an `io` function
+- Effects propagate through the call graph
+- Missing effects are detected and reported
+
+Effects: `pure`, `reads`, `writes`, `io`, `fails`
+
+## Contract Verification
+
+Pre/post conditions are verified at compile time using Z3:
+
+```json
+{
+  "kind": "post",
+  "id": "post-001",
+  "condition": {
+    "kind": "binop", "op": ">",
+    "left": { "kind": "ident", "name": "result" },
+    "right": { "kind": "ident", "name": "x" }
+  }
+}
+```
+
+Z3 either proves `unsat` (contract holds ✅) or returns `sat` with a concrete counterexample the agent can reason about.
+
+## Contributing
+
+We welcome contributions from agents and humans alike. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions, coding standards, and the PR workflow.
+
+**Looking for a place to start?** Check issues labeled [`good first issue`](https://github.com/Sowiedu/Edict/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) for the full development plan and [FEATURE_SPEC.md](FEATURE_SPEC.md) for the language specification.
+
+## License
+
+[MIT](LICENSE)

package/dist/ast/nodes.d.ts

@@ -0,0 +1,248 @@
+import type { TypeExpr } from "./types.js";
+export type { TypeExpr } from "./types.js";
+/**
+ * The 5 canonical effect categories.
+ * A function's signature includes which effects it may perform.
+ */
+export type Effect = "pure" | "reads" | "writes" | "io" | "fails";
+export declare const VALID_EFFECTS: readonly Effect[];
+/**
+ * A complete Edict program / module.
+ */
+export interface EdictModule {
+    kind: "module";
+    id: string;
+    name: string;
+    imports: Import[];
+    definitions: Definition[];
+}
+/**
+ * Import names from another module.
+ */
+export interface Import {
+    kind: "import";
+    id: string;
+    module: string;
+    names: string[];
+}
+export type Definition = FunctionDef | TypeDef | RecordDef | EnumDef | ConstDef;
+/**
+ * Function definition with effects, contracts, and body.
+ */
+export interface FunctionDef {
+    kind: "fn";
+    id: string;
+    name: string;
+    params: Param[];
+    effects: Effect[];
+    returnType: TypeExpr;
+    contracts: Contract[];
+    body: Expression[];
+}
+/**
+ * Type alias definition.
+ */
+export interface TypeDef {
+    kind: "type";
+    id: string;
+    name: string;
+    definition: TypeExpr;
+}
+/**
+ * Record (struct) definition.
+ */
+export interface RecordDef {
+    kind: "record";
+    id: string;
+    name: string;
+    fields: RecordField[];
+}
+/**
+ * A field in a record definition.
+ */
+export interface RecordField {
+    kind: "field";
+    id: string;
+    name: string;
+    type: TypeExpr;
+    defaultValue?: Expression;
+}
+/**
+ * Enum (tagged union / sum type) definition.
+ */
+export interface EnumDef {
+    kind: "enum";
+    id: string;
+    name: string;
+    variants: EnumVariant[];
+}
+/**
+ * A variant of an enum. Fields are empty for unit variants (e.g., None).
+ */
+export interface EnumVariant {
+    kind: "variant";
+    id: string;
+    name: string;
+    fields: RecordField[];
+}
+/**
+ * Constant definition.
+ */
+export interface ConstDef {
+    kind: "const";
+    id: string;
+    name: string;
+    type: TypeExpr;
+    value: Expression;
+}
+/**
+ * Function parameter.
+ */
+export interface Param {
+    kind: "param";
+    id: string;
+    name: string;
+    type: TypeExpr;
+}
+/**
+ * Pre/post contract on a function.
+ */
+export interface Contract {
+    kind: "pre" | "post";
+    id: string;
+    condition: Expression;
+}
+export type Expression = Literal | Identifier | BinaryOp | UnaryOp | Call | IfExpr | LetExpr | MatchExpr | ArrayExpr | TupleExpr | RecordExpr | EnumConstructor | FieldAccess | LambdaExpr | BlockExpr;
+export interface Literal {
+    kind: "literal";
+    id: string;
+    value: number | string | boolean;
+    type?: TypeExpr;
+}
+export interface Identifier {
+    kind: "ident";
+    id: string;
+    name: string;
+}
+export type BinaryOperator = "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | ">" | "<=" | ">=" | "and" | "or" | "implies";
+export declare const VALID_BINARY_OPS: readonly BinaryOperator[];
+export interface BinaryOp {
+    kind: "binop";
+    id: string;
+    op: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+export type UnaryOperator = "not" | "-";
+export declare const VALID_UNARY_OPS: readonly UnaryOperator[];
+export interface UnaryOp {
+    kind: "unop";
+    id: string;
+    op: UnaryOperator;
+    operand: Expression;
+}
+export interface Call {
+    kind: "call";
+    id: string;
+    fn: Expression;
+    args: Expression[];
+}
+export interface IfExpr {
+    kind: "if";
+    id: string;
+    condition: Expression;
+    then: Expression[];
+    else?: Expression[];
+}
+export interface LetExpr {
+    kind: "let";
+    id: string;
+    name: string;
+    type?: TypeExpr;
+    value: Expression;
+}
+export interface MatchExpr {
+    kind: "match";
+    id: string;
+    target: Expression;
+    arms: MatchArm[];
+}
+export interface MatchArm {
+    kind: "arm";
+    id: string;
+    pattern: Pattern;
+    body: Expression[];
+}
+export type Pattern = LiteralPattern | WildcardPattern | BindingPattern | ConstructorPattern;
+export interface LiteralPattern {
+    kind: "literal_pattern";
+    value: number | string | boolean;
+}
+export interface WildcardPattern {
+    kind: "wildcard";
+}
+export interface BindingPattern {
+    kind: "binding";
+    name: string;
+}
+export interface ConstructorPattern {
+    kind: "constructor";
+    name: string;
+    fields: Pattern[];
+}
+export interface ArrayExpr {
+    kind: "array";
+    id: string;
+    elements: Expression[];
+}
+export interface TupleExpr {
+    kind: "tuple_expr";
+    id: string;
+    elements: Expression[];
+}
+export interface RecordExpr {
+    kind: "record_expr";
+    id: string;
+    name: string;
+    fields: FieldInit[];
+}
+export interface EnumConstructor {
+    kind: "enum_constructor";
+    id: string;
+    enumName: string;
+    variant: string;
+    fields: FieldInit[];
+}
+/**
+ * Field initialization in record expressions and enum constructors.
+ * Gives these inline objects a proper `kind` discriminator like every other AST node.
+ */
+export interface FieldInit {
+    kind: "field_init";
+    name: string;
+    value: Expression;
+}
+export interface FieldAccess {
+    kind: "access";
+    id: string;
+    target: Expression;
+    field: string;
+}
+export interface LambdaExpr {
+    kind: "lambda";
+    id: string;
+    params: Param[];
+    body: Expression[];
+}
+export interface BlockExpr {
+    kind: "block";
+    id: string;
+    body: Expression[];
+}
+export declare const VALID_DEFINITION_KINDS: readonly ["fn", "type", "record", "enum", "const"];
+export declare const VALID_EXPRESSION_KINDS: readonly ["literal", "ident", "binop", "unop", "call", "if", "let", "match", "array", "tuple_expr", "record_expr", "enum_constructor", "access", "lambda", "block"];
+export declare const VALID_TYPE_KINDS: readonly ["basic", "array", "option", "result", "unit_type", "refined", "fn_type", "named", "tuple"];
+export declare const VALID_PATTERN_KINDS: readonly ["literal_pattern", "wildcard", "binding", "constructor"];
+export declare const VALID_BASIC_TYPE_NAMES: readonly ["Int", "Float", "String", "Bool"];
+export declare const ALL_VALID_KINDS: readonly ["module", "import", "fn", "type", "record", "enum", "const", "param", "field", "variant", "pre", "post", "arm", "field_init", "literal", "ident", "binop", "unop", "call", "if", "let", "match", "array", "tuple_expr", "record_expr", "enum_constructor", "access", "lambda", "block", "basic", "array", "option", "result", "unit_type", "refined", "fn_type", "named", "tuple", "literal_pattern", "wildcard", "binding", "constructor"];
+//# sourceMappingURL=nodes.d.ts.map

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

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

package/dist/ast/nodes.js

@@ -0,0 +1,95 @@
+// =============================================================================
+// Edict AST Node Definitions
+// =============================================================================
+// Every valid Edict program is a tree of these nodes, serialized as JSON.
+// No lexer, no parser — agents produce these directly.
+export const VALID_EFFECTS = [
+    "pure",
+    "reads",
+    "writes",
+    "io",
+    "fails",
+];
+export const VALID_BINARY_OPS = [
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "==",
+    "!=",
+    "<",
+    ">",
+    "<=",
+    ">=",
+    "and",
+    "or",
+    "implies",
+];
+export const VALID_UNARY_OPS = ["not", "-"];
+// =============================================================================
+// Valid kind values — used by the validator
+// =============================================================================
+export const VALID_DEFINITION_KINDS = [
+    "fn",
+    "type",
+    "record",
+    "enum",
+    "const",
+];
+export const VALID_EXPRESSION_KINDS = [
+    "literal",
+    "ident",
+    "binop",
+    "unop",
+    "call",
+    "if",
+    "let",
+    "match",
+    "array",
+    "tuple_expr",
+    "record_expr",
+    "enum_constructor",
+    "access",
+    "lambda",
+    "block",
+];
+export const VALID_TYPE_KINDS = [
+    "basic",
+    "array",
+    "option",
+    "result",
+    "unit_type",
+    "refined",
+    "fn_type",
+    "named",
+    "tuple",
+];
+export const VALID_PATTERN_KINDS = [
+    "literal_pattern",
+    "wildcard",
+    "binding",
+    "constructor",
+];
+export const VALID_BASIC_TYPE_NAMES = [
+    "Int",
+    "Float",
+    "String",
+    "Bool",
+];
+export const ALL_VALID_KINDS = [
+    "module",
+    "import",
+    ...VALID_DEFINITION_KINDS,
+    "param",
+    "field",
+    "variant",
+    "pre",
+    "post",
+    "arm",
+    "field_init",
+    ...VALID_EXPRESSION_KINDS,
+    ...VALID_TYPE_KINDS,
+    ...VALID_PATTERN_KINDS,
+];
+//# sourceMappingURL=nodes.js.map

package/dist/ast/nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../src/ast/nodes.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAChF,0EAA0E;AAC1E,uDAAuD;AAiBvD,MAAM,CAAC,MAAM,aAAa,GAAsB;IAC5C,MAAM;IACN,OAAO;IACP,QAAQ;IACR,IAAI;IACJ,OAAO;CACD,CAAC;AA2LX,MAAM,CAAC,MAAM,gBAAgB,GAA8B;IACvD,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,IAAI;IACJ,IAAI;IACJ,GAAG;IACH,GAAG;IACH,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,IAAI;IACJ,SAAS;CACH,CAAC;AAYX,MAAM,CAAC,MAAM,eAAe,GAA6B,CAAC,KAAK,EAAE,GAAG,CAAU,CAAC;AAiI/E,gFAAgF;AAChF,4CAA4C;AAC5C,gFAAgF;AAEhF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IAClC,IAAI;IACJ,MAAM;IACN,QAAQ;IACR,MAAM;IACN,OAAO;CACD,CAAC;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAAG;IAClC,SAAS;IACT,OAAO;IACP,OAAO;IACP,MAAM;IACN,MAAM;IACN,IAAI;IACJ,KAAK;IACL,OAAO;IACP,OAAO;IACP,YAAY;IACZ,aAAa;IACb,kBAAkB;IAClB,QAAQ;IACR,QAAQ;IACR,OAAO;CACD,CAAC;AAEX,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,OAAO;IACP,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,WAAW;IACX,SAAS;IACT,SAAS;IACT,OAAO;IACP,OAAO;CACD,CAAC;AAEX,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,iBAAiB;IACjB,UAAU;IACV,SAAS;IACT,aAAa;CACP,CAAC;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAAG;IAClC,KAAK;IACL,OAAO;IACP,QAAQ;IACR,MAAM;CACA,CAAC;AAEX,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,QAAQ;IACR,QAAQ;IACR,GAAG,sBAAsB;IACzB,OAAO;IACP,OAAO;IACP,SAAS;IACT,KAAK;IACL,MAAM;IACN,KAAK;IACL,YAAY;IACZ,GAAG,sBAAsB;IACzB,GAAG,gBAAgB;IACnB,GAAG,mBAAmB;CAChB,CAAC"}

package/dist/ast/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Union of all type expressions in Edict.
+ */
+export type TypeExpr = BasicType | ArrayType | OptionType | ResultType | UnitType | RefinedType | FunctionType | NamedType | TupleType;
+/**
+ * Primitive types.
+ */
+export interface BasicType {
+    kind: "basic";
+    name: "Int" | "Float" | "String" | "Bool";
+}
+/**
+ * Homogeneous array type.
+ */
+export interface ArrayType {
+    kind: "array";
+    element: TypeExpr;
+}
+/**
+ * Optional value — None or Some(T).
+ */
+export interface OptionType {
+    kind: "option";
+    inner: TypeExpr;
+}
+/**
+ * Result type for error handling. Interacts with the "fails" effect.
+ */
+export interface ResultType {
+    kind: "result";
+    ok: TypeExpr;
+    err: TypeExpr;
+}
+/**
+ * Semantic unit type — compile-time enforcement, zero runtime cost.
+ * Prevents mixing incompatible units (e.g., currency<usd> + temp<celsius>).
+ */
+export interface UnitType {
+    kind: "unit_type";
+    base: "Int" | "Float";
+    unit: string;
+}
+/**
+ * Refinement type — base type + logical predicate verified by Z3 (Phase 4).
+ * Example: { v: Int | v > 0 } is a positive integer.
+ */
+export interface RefinedType {
+    kind: "refined";
+    id: string;
+    base: TypeExpr;
+    variable: string;
+    predicate: Expression;
+}
+/**
+ * Function type — for higher-order functions and lambdas.
+ */
+export interface FunctionType {
+    kind: "fn_type";
+    params: TypeExpr[];
+    effects: Effect[];
+    returnType: TypeExpr;
+}
+/**
+ * Reference to a user-defined type (RecordDef or EnumDef) by name.
+ */
+export interface NamedType {
+    kind: "named";
+    name: string;
+}
+/**
+ * Fixed-size heterogeneous tuple.
+ */
+export interface TupleType {
+    kind: "tuple";
+    elements: TypeExpr[];
+}
+import type { Expression, Effect } from "./nodes.js";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ast/types.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,MAAM,QAAQ,GACd,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,SAAS,GACT,SAAS,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,QAAQ,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,UAAU,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,QAAQ,EAAE,CAAC;CACxB;AAID,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC"}

package/dist/ast/types.js

@@ -0,0 +1,7 @@
+// =============================================================================
+// Edict AST Type Expressions
+// =============================================================================
+// Every possible type in the Edict type system.
+// Types are compile-time only — unit types are erased after type checking.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/ast/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/ast/types.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAChF,gDAAgD;AAChD,2EAA2E"}