@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/compiler/tir/types/TirNativeType/native/value.js

@@ -0,0 +1,17 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirValueT {
+    clone() { return new TirValueT(); }
+    isConcrete() { return true; }
+    toString() { return "Value"; }
+    toAstName() { return "Value"; }
+    static toTirTypeKey() { return "Value"; }
+    toTirTypeKey() { return TirValueT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    /**
+     * Native `Value` is bidirectionally reachable from `data` via
+     * `unValueData` / `valueData`, so it qualifies as data-encoded for
+     * the purposes of `data struct` field types.
+     */
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.value; }
+}

package/dist/compiler/tir/types/TirStructType.js

@@ -27,7 +27,12 @@ export class TirDataStructType {
         this.constructors = constructors;
         this.methodNamesPtr = methodNamesPtr;
         this.untagged = untagged;
-        this.untagged = false; // always false for now
+        // `untagged === true` requires a single constructor — its runtime
+        // form is `listData(fields)` instead of `constrData(idx, fields)`.
+        if (untagged && constructors.length !== 1) {
+            throw new Error("untagged data struct must have exactly one constructor; got "
+                + constructors.length);
+        }
         this.narrowedFromParentCtorIdxs = narrowedFromParentCtorIdxs;
     }
     hasDataEncoding() { return true; }

package/dist/compiler/tir/types/TirType.d.ts

@@ -1,5 +1,6 @@
 import { TirAliasType } from "./TirAliasType.js";
 import { TirStructType } from "./TirStructType.js";
+import { TirEnumType } from "./TirEnumType.js";
 import { TirNamedDestructableNativeType, TirNativeType } from "./TirNativeType/TirNativeType.js";
 import { TirTypeParam } from "./TirTypeParam.js";
 import { ConstType } from "@harmoniclabs/uplc";
@@ -28,7 +29,7 @@ export interface ITirType {
 }
 export type TirType = TirNativeType | TirCustomType | TirTypeParam;
 export declare function isTirType(thing: any): thing is TirType;
-export type TirCustomType = TirAliasType | TirStructType;
+export type TirCustomType = TirAliasType | TirStructType | TirEnumType;
 export declare function isTirCustomType(thing: any): thing is TirCustomType;
-export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType;
+export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType | TirEnumType;
 export declare function isTirNamedDestructableType(thing: any): thing is TirNamedDestructableType;

package/dist/compiler/tir/types/TirType.js

@@ -1,16 +1,21 @@
 import { isObject } from "@harmoniclabs/obj-utils";
 import { TirAliasType } from "./TirAliasType.js";
 import { isTirStructType } from "./TirStructType.js";
+import { isTirEnumType } from "./TirEnumType.js";
 import { isTirNamedDestructableNativeType, isTirNativeType } from "./TirNativeType/TirNativeType.js";
+import { TirTypeParam } from "./TirTypeParam.js";
 export function isTirType(thing) {
     return isObject(thing) && (isTirNativeType(thing)
-        || isTirCustomType(thing));
+        || isTirCustomType(thing)
+        || thing instanceof TirTypeParam);
 }
 export function isTirCustomType(thing) {
     return isObject(thing) && (thing instanceof TirAliasType
-        || isTirStructType(thing));
+        || isTirStructType(thing)
+        || isTirEnumType(thing));
 }
 export function isTirNamedDestructableType(thing) {
     return isObject(thing) && (isTirStructType(thing)
+        || isTirEnumType(thing)
         || isTirNamedDestructableNativeType(thing));
 }

package/dist/compiler/tir/types/utils/canAssignTo.js

@@ -1,10 +1,12 @@
 import { TirAliasType } from "../TirAliasType.js";
-import { TirUnConstrDataResultT, TirPairDataT } from "../TirNativeType/index.js";
+import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirUnConstrDataResultT, TirPairDataT } from "../TirNativeType/index.js";
 import { TirBoolT } from "../TirNativeType/native/bool.js";
 import { TirBytesT } from "../TirNativeType/native/bytes.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirIntT } from "../TirNativeType/native/int.js";
+import { TirArrayT } from "../TirNativeType/native/array.js";
+import { TirValueT } from "../TirNativeType/native/value.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -13,6 +15,7 @@ import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../TirNativeType/native/string.js";
 import { TirVoidT } from "../TirNativeType/native/void.js";
 import { isTirStructType, TirDataStructType, TirSoPStructType } from "../TirStructType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { isTirNamedDestructableType } from "../TirType.js";
 import { TirTypeParam } from "../TirTypeParam.js";
 import { canCastToData } from "./canCastTo.js";
@@ -108,6 +111,10 @@ function uncheckedGetCanAssign(a, b, symbols) {
     if (b instanceof TirIntT) {
         if (a instanceof TirIntT)
             return CanAssign.Yes;
+        // enum runtime representation is a plain int, so an enum value can
+        // flow directly into any int operation.
+        if (a instanceof TirEnumType)
+            return CanAssign.Yes;
         if (a instanceof TirDataT)
             return CanAssign.RequiresExplicitCast;
         return CanAssign.No;
@@ -218,6 +225,19 @@ function uncheckedGetCanAssign(a, b, symbols) {
     }
     if (isTirStructType(a))
         return CanAssign.No;
+    if (b instanceof TirEnumType) {
+        if (a instanceof TirEnumType
+            && a.toTirTypeKey() === b.toTirTypeKey())
+            return CanAssign.Yes;
+        // `data` (e.g. datum/redeemer) can be decoded to an enum with an
+        // explicit cast; plain `int` cannot — there is no way to statically
+        // verify it is a valid tag.
+        if (a instanceof TirDataT)
+            return CanAssign.RequiresExplicitCast;
+        return CanAssign.No;
+    }
+    if (a instanceof TirEnumType)
+        return CanAssign.No;
     if (b instanceof TirFuncT) {
         if (!(a instanceof TirFuncT
             && a.argTypes.length === b.argTypes.length))
@@ -232,6 +252,21 @@ function uncheckedGetCanAssign(a, b, symbols) {
         }
         return currentDecision;
     }
+    // BLS / ML-result are opaque atomic types: assignable only to themselves
+    if (b instanceof TirBlsG1T)
+        return a instanceof TirBlsG1T ? CanAssign.Yes : CanAssign.No;
+    if (b instanceof TirBlsG2T)
+        return a instanceof TirBlsG2T ? CanAssign.Yes : CanAssign.No;
+    if (b instanceof TirMlResultT)
+        return a instanceof TirMlResultT ? CanAssign.Yes : CanAssign.No;
+    // Native Value / Array<T>
+    if (b instanceof TirValueT)
+        return a instanceof TirValueT ? CanAssign.Yes : CanAssign.No;
+    if (b instanceof TirArrayT) {
+        if (!(a instanceof TirArrayT))
+            return CanAssign.No;
+        return uncheckedGetCanAssign(a.typeArg, b.typeArg, symbols);
+    }
     const tsEnsureExhautstiveCheck = b;
     return CanAssign.No;
 }

package/dist/compiler/tir/types/utils/canCastTo.js

@@ -12,6 +12,7 @@ import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../TirNativeType/native/string.js";
 import { TirVoidT } from "../TirNativeType/native/void.js";
 import { isTirStructType, TirDataStructType } from "../TirStructType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { CanAssign, getCanAssign } from "./canAssignTo.js";
 export function canCastTo(a, b) {
     if (!(a.isConcrete()
@@ -52,6 +53,8 @@ export function canCastTo(a, b) {
     if (b instanceof TirIntT) {
         if (a instanceof TirIntT)
             return true;
+        if (a instanceof TirEnumType)
+            return true; // enum is an int at runtime
         if (a instanceof TirDataT)
             return true;
         if (a instanceof TirBoolT)
@@ -113,6 +116,15 @@ export function canCastTo(a, b) {
         }
         return false;
     }
+    if (b instanceof TirEnumType) {
+        if (a instanceof TirEnumType)
+            return a.toTirTypeKey() === b.toTirTypeKey();
+        // only `data` (e.g. datum/redeemer decoding) can be cast to enum;
+        // plain `int` cannot — there is no way to verify it is a valid tag.
+        if (a instanceof TirDataT)
+            return true;
+        return false;
+    }
     if (b instanceof TirFuncT) {
         if (!(a instanceof TirFuncT))
             return false;
@@ -148,7 +160,8 @@ export function canCastToData(a) {
         || a instanceof TirStringT
         || a instanceof TirBoolT
         || a instanceof TirDataOptT
-        || a instanceof TirDataStructType)
+        || a instanceof TirDataStructType
+        || a instanceof TirEnumType)
         return true;
     if (a instanceof TirLinearMapT) {
         const key = canCastToData(a.keyTypeArg);

package/dist/compiler/tir/types/utils/getDeconstructableType.d.ts

@@ -1,3 +1,4 @@
+import { TirEnumType } from "../TirEnumType.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -5,5 +6,5 @@ import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
 import { TirStructType } from "../TirStructType.js";
 import { TirType } from "../TirType.js";
-export type DeconstructableTirType = TirStructType | TirSopOptT | TirDataOptT | TirListT | TirLinearMapT | TirDataT;
+export type DeconstructableTirType = TirStructType | TirEnumType | TirSopOptT | TirDataOptT | TirListT | TirLinearMapT | TirDataT;
 export declare function getDeconstructableType(type: TirType): DeconstructableTirType | undefined;

package/dist/compiler/tir/types/utils/getDeconstructableType.js

@@ -1,4 +1,5 @@
 import { TirAliasType } from "../TirAliasType.js";
+import { TirEnumType } from "../TirEnumType.js";
 import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
 import { TirListT } from "../TirNativeType/native/list.js";
@@ -9,6 +10,7 @@ export function getDeconstructableType(type) {
     while (type instanceof TirAliasType)
         type = type.aliased;
     if (isTirStructType(type)
+        || type instanceof TirEnumType
         || type instanceof TirSopOptT
         || type instanceof TirDataOptT
         || type instanceof TirListT

package/dist/compiler/tir/types/utils/inferTypeArgs.d.ts

@@ -0,0 +1,19 @@
+import { TirType } from "../TirType.js";
+/**
+ * Attempt to bind free `TirTypeParam`s in `formal` so that the result matches
+ * `actual`. Bindings are accumulated into `env`. Returns `true` on success.
+ *
+ * - Inconsistent bindings (`T = int` then `T = bytes`) cause failure.
+ * - Shape mismatches between concrete containers cause failure.
+ * - Unknown type-params in `formal` not yet in `env` are bound to `actual`'s
+ *   matching position.
+ *
+ * This is intentionally syntactic — no subtyping, no widening. The caller
+ * passes already-unaliased argument types.
+ */
+export declare function inferTypeArgs(formal: TirType, actual: TirType, env: Map<symbol, TirType>): boolean;
+/**
+ * Cheap structural equality for unaliased TirTypes — compares concrete TIR
+ * names. Sufficient for our inference consistency checks.
+ */
+export declare function tirTypeStructurallyEqual(a: TirType, b: TirType): boolean;

package/dist/compiler/tir/types/utils/inferTypeArgs.js

@@ -0,0 +1,83 @@
+import { TirArrayT } from "../TirNativeType/native/array.js";
+import { TirFuncT } from "../TirNativeType/native/function.js";
+import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
+import { TirListT } from "../TirNativeType/native/list.js";
+import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
+import { TirTypeParam } from "../TirTypeParam.js";
+import { getUnaliased } from "./getUnaliased.js";
+/**
+ * Attempt to bind free `TirTypeParam`s in `formal` so that the result matches
+ * `actual`. Bindings are accumulated into `env`. Returns `true` on success.
+ *
+ * - Inconsistent bindings (`T = int` then `T = bytes`) cause failure.
+ * - Shape mismatches between concrete containers cause failure.
+ * - Unknown type-params in `formal` not yet in `env` are bound to `actual`'s
+ *   matching position.
+ *
+ * This is intentionally syntactic — no subtyping, no widening. The caller
+ * passes already-unaliased argument types.
+ */
+export function inferTypeArgs(formal, actual, env) {
+    formal = getUnaliased(formal);
+    actual = getUnaliased(actual);
+    if (formal instanceof TirTypeParam) {
+        const existing = env.get(formal.symbol);
+        if (existing === undefined) {
+            env.set(formal.symbol, actual);
+            return true;
+        }
+        // consistency: existing binding must equal actual
+        return tirTypeStructurallyEqual(existing, actual);
+    }
+    // both must be the same shape and equal in arg-positions
+    if (formal instanceof TirListT && actual instanceof TirListT) {
+        return inferTypeArgs(formal.typeArg, actual.typeArg, env);
+    }
+    if (formal instanceof TirArrayT && actual instanceof TirArrayT) {
+        return inferTypeArgs(formal.typeArg, actual.typeArg, env);
+    }
+    if (formal instanceof TirFuncT && actual instanceof TirFuncT) {
+        if (formal.argTypes.length !== actual.argTypes.length)
+            return false;
+        for (let i = 0; i < formal.argTypes.length; i++) {
+            if (!inferTypeArgs(formal.argTypes[i], actual.argTypes[i], env))
+                return false;
+        }
+        return inferTypeArgs(formal.returnType, actual.returnType, env);
+    }
+    if (formal instanceof TirLinearMapT && actual instanceof TirLinearMapT) {
+        return (inferTypeArgs(formal.keyTypeArg, actual.keyTypeArg, env)
+            && inferTypeArgs(formal.valTypeArg, actual.valTypeArg, env));
+    }
+    if (formal instanceof TirLinearMapEntryT && actual instanceof TirLinearMapEntryT) {
+        return (inferTypeArgs(formal.keyTypeArg, actual.keyTypeArg, env)
+            && inferTypeArgs(formal.valTypeArg, actual.valTypeArg, env));
+    }
+    if (formal instanceof TirDataOptT && actual instanceof TirDataOptT) {
+        return inferTypeArgs(formal.typeArg, actual.typeArg, env);
+    }
+    if (formal instanceof TirSopOptT && actual instanceof TirSopOptT) {
+        return inferTypeArgs(formal.typeArg, actual.typeArg, env);
+    }
+    // base case: both concrete with no type-vars — must be the same type
+    return tirTypeStructurallyEqual(formal, actual);
+}
+/**
+ * Cheap structural equality for unaliased TirTypes — compares concrete TIR
+ * names. Sufficient for our inference consistency checks.
+ */
+export function tirTypeStructurallyEqual(a, b) {
+    a = getUnaliased(a);
+    b = getUnaliased(b);
+    if (a instanceof TirTypeParam && b instanceof TirTypeParam) {
+        return a.symbol === b.symbol;
+    }
+    try {
+        return a.toConcreteTirTypeName() === b.toConcreteTirTypeName();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/compiler/tir/types/utils/normalizeEnumToInt.d.ts

@@ -0,0 +1,10 @@
+import { TirIntT } from "../TirNativeType/native/int.js";
+import { TirType } from "../TirType.js";
+/**
+ * If `t` is an enum type (or alias of one), returns the shared `int` type
+ * (since enums lower to plain ints at runtime). Otherwise returns `t`.
+ *
+ * Use this to relax type checks for binary operators that treat enums as
+ * integers (arithmetic, comparison, equality).
+ */
+export declare function normalizeEnumToInt(t: TirType, int_t: TirIntT): TirType;

package/dist/compiler/tir/types/utils/normalizeEnumToInt.js

@@ -0,0 +1,17 @@
+import { TirAliasType } from "../TirAliasType.js";
+import { TirEnumType } from "../TirEnumType.js";
+/**
+ * If `t` is an enum type (or alias of one), returns the shared `int` type
+ * (since enums lower to plain ints at runtime). Otherwise returns `t`.
+ *
+ * Use this to relax type checks for binary operators that treat enums as
+ * integers (arithmetic, comparison, equality).
+ */
+export function normalizeEnumToInt(t, int_t) {
+    let probe = t;
+    while (probe instanceof TirAliasType)
+        probe = probe.aliased;
+    if (probe instanceof TirEnumType)
+        return int_t;
+    return t;
+}

package/dist/compiler/tir/types/utils/substituteTypeParams.d.ts

@@ -0,0 +1,9 @@
+import { TirType } from "../TirType.js";
+/**
+ * Walk a TirType tree and replace each `TirTypeParam` whose `symbol` is a key
+ * in `subst` with the corresponding concrete type. Containers (`List`, `Func`,
+ * `LinearMap`, optionals, aliases) are rebuilt with their substituted children.
+ *
+ * Returns the input unchanged when no substitution applies.
+ */
+export declare function substituteTypeParams(t: TirType, subst: Map<symbol, TirType>): TirType;

package/dist/compiler/tir/types/utils/substituteTypeParams.js

@@ -0,0 +1,67 @@
+import { TirAliasType } from "../TirAliasType.js";
+import { TirArrayT } from "../TirNativeType/native/array.js";
+import { TirFuncT } from "../TirNativeType/native/function.js";
+import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
+import { TirListT } from "../TirNativeType/native/list.js";
+import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
+import { TirTypeParam } from "../TirTypeParam.js";
+/**
+ * Walk a TirType tree and replace each `TirTypeParam` whose `symbol` is a key
+ * in `subst` with the corresponding concrete type. Containers (`List`, `Func`,
+ * `LinearMap`, optionals, aliases) are rebuilt with their substituted children.
+ *
+ * Returns the input unchanged when no substitution applies.
+ */
+export function substituteTypeParams(t, subst) {
+    if (subst.size === 0)
+        return t;
+    if (t instanceof TirTypeParam) {
+        return subst.get(t.symbol) ?? t;
+    }
+    if (t instanceof TirListT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirListT(sub);
+    }
+    if (t instanceof TirArrayT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirArrayT(sub);
+    }
+    if (t instanceof TirFuncT) {
+        let changed = false;
+        const newArgs = t.argTypes.map(a => {
+            const s = substituteTypeParams(a, subst);
+            if (s !== a)
+                changed = true;
+            return s;
+        });
+        const newRet = substituteTypeParams(t.returnType, subst);
+        if (newRet !== t.returnType)
+            changed = true;
+        return changed ? new TirFuncT(newArgs, newRet) : t;
+    }
+    if (t instanceof TirLinearMapT) {
+        const k = substituteTypeParams(t.keyTypeArg, subst);
+        const v = substituteTypeParams(t.valTypeArg, subst);
+        return (k === t.keyTypeArg && v === t.valTypeArg) ? t : new TirLinearMapT(k, v);
+    }
+    if (t instanceof TirLinearMapEntryT) {
+        const k = substituteTypeParams(t.keyTypeArg, subst);
+        const v = substituteTypeParams(t.valTypeArg, subst);
+        return (k === t.keyTypeArg && v === t.valTypeArg) ? t : new TirLinearMapEntryT(k, v);
+    }
+    if (t instanceof TirDataOptT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirDataOptT(sub);
+    }
+    if (t instanceof TirSopOptT) {
+        const sub = substituteTypeParams(t.typeArg, subst);
+        return sub === t.typeArg ? t : new TirSopOptT(sub);
+    }
+    if (t instanceof TirAliasType) {
+        const sub = substituteTypeParams(t.aliased, subst);
+        return sub === t.aliased ? t : sub;
+    }
+    return t;
+}

package/dist/diagnostics/diagnosticMessages.generated.d.ts

@@ -278,6 +278,16 @@ export declare enum DiagnosticCode {
     _super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class = 17009,
     _super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class = 17011,
     Unkonwn_AST_node = 20000,
+    Namespace_0_has_no_exported_member_1 = 30001,
+    Namespace_path_is_incomplete_expected_a_value_type_function_or_interface = 30002,
+    _private_modifier_is_only_allowed_on_declarations_inside_a_namespace = 30003,
+    Namespaces_cannot_be_declared_here = 30004,
+    _0_is_not_a_namespace = 30005,
+    Enum_members_cannot_have_explicit_values = 30100,
+    Duplicate_enum_member_0 = 30101,
+    Enum_must_have_at_least_one_member = 30102,
+    Property_0_is_not_a_member_of_enum_1 = 30103,
+    Enum_member_pattern_cannot_have_fields = 30104,
     Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong = 42069
 }
 /** Translates a diagnostic code to its respective string. */

package/dist/diagnostics/diagnosticMessages.generated.js

@@ -280,6 +280,16 @@ export var DiagnosticCode;
     DiagnosticCode[DiagnosticCode["_super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class"] = 17009] = "_super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class";
     DiagnosticCode[DiagnosticCode["_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class"] = 17011] = "_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class";
     DiagnosticCode[DiagnosticCode["Unkonwn_AST_node"] = 20000] = "Unkonwn_AST_node";
+    DiagnosticCode[DiagnosticCode["Namespace_0_has_no_exported_member_1"] = 30001] = "Namespace_0_has_no_exported_member_1";
+    DiagnosticCode[DiagnosticCode["Namespace_path_is_incomplete_expected_a_value_type_function_or_interface"] = 30002] = "Namespace_path_is_incomplete_expected_a_value_type_function_or_interface";
+    DiagnosticCode[DiagnosticCode["_private_modifier_is_only_allowed_on_declarations_inside_a_namespace"] = 30003] = "_private_modifier_is_only_allowed_on_declarations_inside_a_namespace";
+    DiagnosticCode[DiagnosticCode["Namespaces_cannot_be_declared_here"] = 30004] = "Namespaces_cannot_be_declared_here";
+    DiagnosticCode[DiagnosticCode["_0_is_not_a_namespace"] = 30005] = "_0_is_not_a_namespace";
+    DiagnosticCode[DiagnosticCode["Enum_members_cannot_have_explicit_values"] = 30100] = "Enum_members_cannot_have_explicit_values";
+    DiagnosticCode[DiagnosticCode["Duplicate_enum_member_0"] = 30101] = "Duplicate_enum_member_0";
+    DiagnosticCode[DiagnosticCode["Enum_must_have_at_least_one_member"] = 30102] = "Enum_must_have_at_least_one_member";
+    DiagnosticCode[DiagnosticCode["Property_0_is_not_a_member_of_enum_1"] = 30103] = "Property_0_is_not_a_member_of_enum_1";
+    DiagnosticCode[DiagnosticCode["Enum_member_pattern_cannot_have_fields"] = 30104] = "Enum_member_pattern_cannot_have_fields";
     DiagnosticCode[DiagnosticCode["Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong"] = 42069] = "Dev_was_too_lazy_to_add_a_prooper_error_message_Something_went_wrong";
 })(DiagnosticCode || (DiagnosticCode = {}));
 /** Translates a diagnostic code to its respective string. */
@@ -563,6 +573,16 @@ export function diagnosticCodeToString(code) {
         case 17009: return "'super' must be called before accessing 'this' in the constructor of a derived class.";
         case 17011: return "'super' must be called before accessing a property of 'super' in the constructor of a derived class.";
         case 20000: return "Unkonwn AST node.";
+        case 30001: return "Namespace '{0}' has no exported member '{1}'.";
+        case 30002: return "Namespace path is incomplete; expected a value, type, function, or interface.";
+        case 30003: return "'private' modifier is only allowed on declarations inside a namespace.";
+        case 30004: return "Namespaces cannot be declared here.";
+        case 30005: return "'{0}' is not a namespace.";
+        case 30100: return "Enum members cannot have explicit values.";
+        case 30101: return "Duplicate enum member '{0}'.";
+        case 30102: return "Enum must have at least one member.";
+        case 30103: return "Property '{0}' is not a member of enum '{1}'.";
+        case 30104: return "Enum member pattern cannot have fields.";
         case 42069: return "Dev was too lazy to add a prooper error message. Something went wrong";
         default: return "";
     }

package/dist/index.d.ts

@@ -8,3 +8,5 @@ export * from "./IR/index.js";
 export * from "./tokenizer/index.js";
 export * from "./parser/index.js";
 export * from "./compiler/index.js";
+export * from "./version.generated.js";
+export * from "./utils/semverSatisfies.js";

package/dist/index.js

@@ -8,4 +8,6 @@ export * from "./IR/index.js";
 export * from "./tokenizer/index.js";
 export * from "./parser/index.js";
 export * from "./compiler/index.js";
+export * from "./version.generated.js";
+export * from "./utils/semverSatisfies.js";
 // export * from "./ast";

package/dist/parser/Parser.d.ts

@@ -12,7 +12,8 @@ import { SourceRange } from "../ast/Source/SourceRange.js";
 import { SimpleVarDecl } from "../ast/nodes/statements/declarations/VarDecl/SimpleVarDecl.js";
 import { ArrayLikeDeconstr } from "../ast/nodes/statements/declarations/VarDecl/ArrayLikeDeconstr.js";
 import { ParentesizedExpr } from "../ast/nodes/expr/ParentesizedExpr.js";
-import { FuncExpr } from "../ast/nodes/expr/functions/FuncExpr.js";
+import { FuncExpr, TypeParamDecl } from "../ast/nodes/expr/functions/FuncExpr.js";
+import { TemplateStrExpr } from "../ast/nodes/expr/litteral/TemplateStrExpr.js";
 import { BlockStmt } from "../ast/nodes/statements/BlockStmt.js";
 import { BreakStmt } from "../ast/nodes/statements/BreakStmt.js";
 import { ContinueStmt } from "../ast/nodes/statements/ContinueStmt.js";
@@ -25,6 +26,7 @@ import { FailStmt } from "../ast/nodes/statements/FailStmt.js";
 import { TraceStmt } from "../ast/nodes/statements/TraceStmt.js";
 import { AssertStmt } from "../ast/nodes/statements/AssertStmt.js";
 import { TestStmt } from "../ast/nodes/statements/TestStmt.js";
+import { TestParam } from "../ast/nodes/statements/TestParam.js";
 import { MatchStmt } from "../ast/nodes/statements/MatchStmt.js";
 import { WhileStmt } from "../ast/nodes/statements/WhileStmt.js";
 import { CaseExpr } from "../ast/nodes/expr/CaseExpr.js";
@@ -39,7 +41,8 @@ import { TypeAliasDecl } from "../ast/nodes/statements/declarations/TypeAliasDec
 import { EnumDecl, EnumValueDecl } from "../ast/nodes/statements/declarations/EnumDecl.js";
 import { AssignmentStmt } from "../ast/nodes/statements/AssignmentStmt.js";
 import { AstTypeExpr } from "../ast/nodes/types/AstTypeExpr.js";
-import { UsingStmt } from "../ast/nodes/statements/UsingStmt.js";
+import { UsingAliasStmt, UsingPath, UsingRhs, UsingStmt } from "../ast/nodes/statements/UsingStmt.js";
+import { NamespaceDecl, NamespaceMemberStmt } from "../ast/nodes/statements/declarations/NamespaceDecl.js";
 import { BodyStmt, TopLevelStmt } from "../ast/nodes/statements/PebbleStmt.js";
 import { Precedence } from "./Precedence.js";
 import { ContractDecl } from "../ast/nodes/statements/declarations/ContractDecl.js";
@@ -57,8 +60,50 @@ export declare class Parser extends DiagnosticEmitter {
     parseTopLevelStatement(): TopLevelStmt | undefined;
     parseContractDecl(startPos: number): ContractDecl | undefined;
     parseStateDecl(startPos: number): StateDecl | undefined;
-    parseUsingDecl(): UsingStmt | undefined;
+    parseUsingDecl(): UsingStmt | UsingAliasStmt | undefined;
+    /**
+     * parse a dotted chain of identifiers: `A`, `A.B`, `A.B.C`, ...
+     * used for namespace paths on the RHS of `using` statements.
+     */
+    parseUsingPath(): UsingPath | undefined;
+    /**
+     * parse the RHS of `using { ... } = <rhs>;`:
+     *  - if it begins with a native type keyword (or a generic struct
+     *    with type args), it's parsed as `AstTypeExpr` (legacy
+     *    struct-destructure behavior)
+     *  - if it's a single identifier followed by `<`, it's also parsed as
+     *    a generic type expression
+     *  - otherwise, it's parsed as a dotted `UsingPath`
+     *    (a namespace path; the compiler decides whether it's a struct
+     *    type or a namespace based on what the head identifier resolves to)
+     */
+    parseUsingRhs(): UsingRhs | undefined;
+    /**
+     * parse a namespace body: `{ (private? <member-decl>)* }`
+     *
+     * called with `namespace` already consumed; `startPos` is the position
+     * of the `namespace` keyword.
+     */
+    parseNamespaceDecl(startPos: number): NamespaceDecl | undefined;
+    /**
+     * parse a single namespace body member. delegates to the relevant
+     * top-level-style parser based on the next token, but rejects
+     * declarations that aren't allowed inside a namespace body
+     * (no `export`, no `import`, no `using`, no `contract`, no `test`).
+     */
+    parseNamespaceMember(): NamespaceMemberStmt | undefined;
     parseTypeParameters(): Identifier[] | undefined;
+    /**
+     * Parses a function's type-parameter list with optional `implements`
+     * interface constraints:
+     *   `<T, U implements ToData, V implements Foo>`
+     *
+     * Returns `TypeParamDecl[]` so the compiler can read each param's
+     * optional constraint at template-registration time. Struct/interface
+     * decls keep using the simpler {@link parseTypeParameters} which
+     * returns bare `Identifier[]`.
+     */
+    parseFuncTypeParameters(): TypeParamDecl[] | undefined;
     parseTypeArguments(): AstTypeExpr[] | undefined;
     parseExport(startPos?: number): ExportImportStmt | ExportStarStmt | undefined;
     parseTypeStmt(flags?: CommonFlags, startPos?: number): TypeAliasDecl | TypeImplementsStmt | undefined;
@@ -132,9 +177,34 @@ export declare class Parser extends DiagnosticEmitter {
     parseIfStatement(): IfStmt | undefined;
     parseReturn(): ReturnStmt | undefined;
     parseTestStatement(): TestStmt | undefined;
+    /**
+     * Parses the parameter list of a `test` declaration:
+     * `( <id>: <type> ('via' <expr>)? (, <id>: <type> ('via' <expr>)? )* )?`
+     *
+     * Assumes the opening `(` has already been consumed by the caller.
+     * Consumes the closing `)` on success.
+     *
+     * `via` is recognised here ONLY — function/method/contract parameter
+     * parsing uses `parseParameters()` which never looks for `Token.Via`.
+     */
+    parseTestParameters(): TestParam[] | undefined;
     parseMatchStatement(): MatchStmt | undefined;
     parseFailStatement(): FailStmt | undefined;
     parseTraceStatement(): TraceStmt | undefined;
+    /**
+     * Parse a backtick-delimited template literal:
+     *
+     *   `text ${expr1} more text ${expr2} ...`
+     *
+     * Tokenizer state: on entry, the current token is
+     * `Token.StringTemplateLiteralQuote`; the tokenizer is positioned at
+     * the opening backtick. `readString()` (called with no arg) consumes
+     * the backtick + the first fragment up to `${` or to the closing
+     * backtick; if it stopped at `${` it sets `readingTemplateString = true`
+     * and the parser must consume an expression + `}` and then call
+     * `readString(CharCode.Backtick)` to read the next fragment.
+     */
+    parseTemplateLiteral(startPos: number): TemplateStrExpr | undefined;
     parseAssertStatement(): AssertStmt | undefined;
     parseWhileStatement(): WhileStmt | undefined;
     /**