@harmoniclabs/pebble 0.1.10 → 0.2.0

package/dist/compiler/tir/statements/TirTestStmt.d.ts

@@ -0,0 +1,46 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirStmt } from "./TirStmt.js";
+/**
+ * Per-parameter fuzzer descriptor.
+ *
+ * - `kind: "primitive"`: the runner generates values directly in TS for a
+ *   supported primitive type (`int`, `bool`, etc.). No Pebble-side fuzzer call.
+ * - `kind: "unsupported"`: the parameter type has no default generator and
+ *   no `via` was supplied; the runner emits a SKIP `TestResult` carrying
+ *   `reason`.
+ * - `kind: "via_not_implemented"`: the user wrote `via <expr>` and the
+ *   compiler successfully type-checked it, but executing user-defined
+ *   fuzzers is not wired up yet (Phase 2). Surfaced as SKIP.
+ */
+export type FuzzerInfo = {
+    kind: "primitive";
+    primitive: "int" | "bool";
+} | {
+    kind: "unsupported";
+    reason: string;
+} | {
+    kind: "via_not_implemented";
+};
+/**
+ * A `test name( params? ) { body }` block.
+ *
+ * The compiled body lives in `program.functions` keyed by `tirFuncName`
+ * (synthesised as `__pebble_test_<name>_<srcUid>`). The executor
+ * (`runTests`) looks up that function, compiles it to UPLC, and evaluates it.
+ *
+ * `fuzzerInfos` is parallel to the function's params; for unit tests it is
+ * empty. For property tests, each entry tells the runner how to source
+ * values for that parameter.
+ */
+export declare class TirTestStmt implements ITirStmt {
+    readonly name: string;
+    readonly tirFuncName: string;
+    readonly sourceFile: string;
+    readonly range: SourceRange;
+    readonly fuzzerInfos: FuzzerInfo[];
+    constructor(name: string, tirFuncName: string, sourceFile: string, range: SourceRange, fuzzerInfos?: FuzzerInfo[]);
+    toString(): string;
+    pretty(): string;
+    definitelyTerminates(): boolean;
+    deps(): string[];
+}

package/dist/compiler/tir/statements/TirTestStmt.js

@@ -0,0 +1,35 @@
+/**
+ * A `test name( params? ) { body }` block.
+ *
+ * The compiled body lives in `program.functions` keyed by `tirFuncName`
+ * (synthesised as `__pebble_test_<name>_<srcUid>`). The executor
+ * (`runTests`) looks up that function, compiles it to UPLC, and evaluates it.
+ *
+ * `fuzzerInfos` is parallel to the function's params; for unit tests it is
+ * empty. For property tests, each entry tells the runner how to source
+ * values for that parameter.
+ */
+export class TirTestStmt {
+    name;
+    tirFuncName;
+    sourceFile;
+    range;
+    fuzzerInfos;
+    constructor(name, tirFuncName, sourceFile, range, fuzzerInfos = []) {
+        this.name = name;
+        this.tirFuncName = tirFuncName;
+        this.sourceFile = sourceFile;
+        this.range = range;
+        this.fuzzerInfos = fuzzerInfos;
+    }
+    toString() {
+        return `test ${this.name} -> ${this.tirFuncName}`;
+    }
+    pretty() {
+        return this.toString();
+    }
+    definitelyTerminates() { return false; }
+    deps() {
+        return [this.tirFuncName];
+    }
+}

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

@@ -14,7 +14,7 @@ import { TirStringT } from "./native/string.js";
 import { TirVoidT } from "./native/void.js";
 export type TirNamedDestructableNativeType = TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType>;
 export declare function isTirNamedDestructableNativeType(t: any): t is TirNamedDestructableNativeType;
-export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirLinearMapEntryT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT;
+export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirLinearMapEntryT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT | TirBlsG1T | TirBlsG2T | TirMlResultT;
 export declare function isTirNativeType(t: any): t is TirNativeType;
 export declare class TirUnConstrDataResultT implements ITirType {
     constructor();
@@ -40,3 +40,52 @@ export declare class TirPairDataT implements ITirType {
     clone(): TirPairDataT;
     toUplcConstType(): ConstType;
 }
+/**
+ * BLS12-381 G1 element. Opaque native scalar; cannot be constructed from
+ * Pebble source directly — values are produced by `std.crypto.bls12_381.*`
+ * builtins (typically `g1Uncompress` or `g1HashToGroup`).
+ */
+export declare class TirBlsG1T implements ITirType {
+    constructor();
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    isConcrete(): boolean;
+    clone(): TirBlsG1T;
+    toUplcConstType(): ConstType;
+}
+/**
+ * BLS12-381 G2 element. Opaque native scalar.
+ */
+export declare class TirBlsG2T implements ITirType {
+    constructor();
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    isConcrete(): boolean;
+    clone(): TirBlsG2T;
+    toUplcConstType(): ConstType;
+}
+/**
+ * BLS12-381 Miller-loop result. Opaque native scalar produced by
+ * `bls12_381_millerLoop` and consumed by `bls12_381_finalVerify` /
+ * `bls12_381_mulMlResult`.
+ */
+export declare class TirMlResultT implements ITirType {
+    constructor();
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    isConcrete(): boolean;
+    clone(): TirMlResultT;
+    toUplcConstType(): ConstType;
+}

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

@@ -32,7 +32,10 @@ export function isTirNativeType(t) {
         || t instanceof TirLinearMapEntryT
         || t instanceof TirFuncT // =>
         || t instanceof TirUnConstrDataResultT
-        || t instanceof TirPairDataT);
+        || t instanceof TirPairDataT
+        || t instanceof TirBlsG1T
+        || t instanceof TirBlsG2T
+        || t instanceof TirMlResultT);
 }
 export class TirUnConstrDataResultT {
     constructor() { }
@@ -86,3 +89,52 @@ export class TirPairDataT {
         return constT.pairOf(constT.data, constT.data);
     }
 }
+/**
+ * BLS12-381 G1 element. Opaque native scalar; cannot be constructed from
+ * Pebble source directly — values are produced by `std.crypto.bls12_381.*`
+ * builtins (typically `g1Uncompress` or `g1HashToGroup`).
+ */
+export class TirBlsG1T {
+    constructor() { }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() { return "#bls12_381_g1#"; }
+    toTirTypeKey() { return TirBlsG1T.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    toString() { return "G1"; }
+    toAstName() { return "G1"; }
+    isConcrete() { return true; }
+    clone() { return new TirBlsG1T(); }
+    toUplcConstType() { return constT.bls12_381_G1_element; }
+}
+/**
+ * BLS12-381 G2 element. Opaque native scalar.
+ */
+export class TirBlsG2T {
+    constructor() { }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() { return "#bls12_381_g2#"; }
+    toTirTypeKey() { return TirBlsG2T.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    toString() { return "G2"; }
+    toAstName() { return "G2"; }
+    isConcrete() { return true; }
+    clone() { return new TirBlsG2T(); }
+    toUplcConstType() { return constT.bls12_381_G2_element; }
+}
+/**
+ * BLS12-381 Miller-loop result. Opaque native scalar produced by
+ * `bls12_381_millerLoop` and consumed by `bls12_381_finalVerify` /
+ * `bls12_381_mulMlResult`.
+ */
+export class TirMlResultT {
+    constructor() { }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() { return "#bls12_381_ml_result#"; }
+    toTirTypeKey() { return TirMlResultT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    toString() { return "MlResult"; }
+    toAstName() { return "MlResult"; }
+    isConcrete() { return true; }
+    clone() { return new TirMlResultT(); }
+    toUplcConstType() { return constT.bls12_381_MlResult; }
+}

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

@@ -2,9 +2,11 @@ import { isObject } from "@harmoniclabs/obj-utils";
 import { TirAliasType } from "./TirAliasType.js";
 import { isTirStructType } from "./TirStructType.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

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

@@ -1,5 +1,5 @@
 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";
@@ -232,6 +232,13 @@ 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;
     const tsEnsureExhautstiveCheck = b;
     return CanAssign.No;
 }

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,79 @@
+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 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/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,62 @@
+import { TirAliasType } from "../TirAliasType.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 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,11 @@ 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,
     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,11 @@ 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["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 +568,11 @@ 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 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;
     /**