@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/compiler/tir/expressions/TirExpr.d.ts

@@ -21,5 +21,6 @@ import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
 import { TirIsExpr } from "./TirIsExpr.js";
-export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirIsExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR);
+import { TirShowExpr } from "./TirShowExpr.js";
+export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirIsExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirShowExpr | TirInlineClosedIR);
 export declare function isTirExpr(thing: any): thing is TirExpr;

package/dist/compiler/tir/expressions/TirExpr.js

@@ -22,6 +22,7 @@ import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
 import { TirIsExpr } from "./TirIsExpr.js";
+import { TirShowExpr } from "./TirShowExpr.js";
 export function isTirExpr(thing) {
     return isObject(thing) && (isTirUnaryPrefixExpr(thing)
         || isTirLitteralExpr(thing)
@@ -45,5 +46,6 @@ export function isTirExpr(thing) {
         || thing instanceof TirAssertAndContinueExpr
         || thing instanceof TirTraceIfFalseExpr
         || thing instanceof TirTraceExpr
+        || thing instanceof TirShowExpr
         || thing instanceof TirInlineClosedIR);
 }

package/dist/compiler/tir/expressions/TirFromDataExpr.js

@@ -1,13 +1,11 @@
-import { _ir_apps, IRApp } from "../../../IR/IRNodes/IRApp.js";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRConstr } from "../../../IR/IRNodes/IRConstr.js";
-import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { _ir_let } from "../../../IR/tree_utils/_ir_let.js";
 import { TirBoolT } from "../types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../types/TirNativeType/native/data.js";
@@ -19,7 +17,10 @@ import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../types/TirNativeType/native/string.js";
 import { TirVoidT } from "../types/TirNativeType/native/void.js";
+import { TirValueT } from "../types/TirNativeType/native/value.js";
+import { TirArrayT } from "../types/TirNativeType/native/array.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { isTirType } from "../types/TirType.js";
 import { getListTypeArg } from "../types/utils/getListTypeArg.js";
 import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
@@ -68,6 +69,20 @@ export function _inlineFromData(target_t, dataExprIR) {
     // LinearMapEntry is Pair<Data,Data> at runtime — no conversion needed
     if (to_t instanceof TirLinearMapEntryT)
         return dataExprIR;
+    // Native Value: data -> Value via `unValueData`
+    if (to_t instanceof TirValueT)
+        return _ir_apps(IRNative.unValueData, dataExprIR);
+    // Native Array<T>: data -> [data] (unListData) -> Array<T>
+    // for non-data element types we map elements through their fromData first.
+    if (to_t instanceof TirArrayT) {
+        const elems_t = getUnaliased(to_t.typeArg);
+        const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataOptT
+            || elems_t instanceof TirDataT)
+            return _ir_apps(IRNative.listToArray, listOfDataExpr);
+        return _ir_apps(IRNative.listToArray, _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), listOfDataExpr));
+    }
     if (to_t instanceof TirListT) {
         const elems_t = getUnaliased(getListTypeArg(to_t));
         const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);
@@ -81,16 +96,24 @@ export function _inlineFromData(target_t, dataExprIR) {
         const value_t = getOptTypeArg(to_t);
         if (!isTirType(value_t))
             throw new Error("TirFromDataExpr: unreachable");
-        return _ir_let(// introuduce a var
-        _ir_apps(IRNative.unConstrData, dataExprIR), unConstrDataResultSym => _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrDataResultSym) // unConstrData result
-        ), IRConst.int(0)), 
-        // then (Just value)
-        new IRConstr(0, [
-            _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, new IRVar(unConstrDataResultSym) // unConstrData result
-            )))
-        ]), 
-        // else (Nothing)
-        new IRHoisted(new IRConstr(1, []))));
+        // Case(unConstrData(data), [\idxSym fieldsSym ->
+        //     Case(idxSym, [
+        //         IRConstr(0, [fromData(headList(fieldsSym))]),  -- Some
+        //         IRConstr(1, [])                                -- None
+        //     ])
+        // ])
+        const idxSym = Symbol("optIdx");
+        const fieldsListSym = Symbol("optFields");
+        return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+            new IRFunc([idxSym, fieldsListSym], new IRCase(new IRVar(idxSym), [
+                // ctor 0: Some
+                new IRConstr(0, [
+                    _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
+                ]),
+                // ctor 1: None
+                new IRHoisted(new IRConstr(1, []))
+            ]))
+        ]);
     }
     if (to_t instanceof TirSoPStructType) {
         return _inlineMultiSopConstrFromData(to_t, dataExprIR);
@@ -106,6 +129,8 @@ export function _fromDataUplcFunc(_target_t) {
         return IRNative._id;
     if (target_t instanceof TirIntT)
         return IRNative.unIData;
+    if (target_t instanceof TirEnumType)
+        return IRNative.unIData;
     if (target_t instanceof TirBytesT)
         return IRNative.unBData;
     if (target_t instanceof TirVoidT)
@@ -114,6 +139,9 @@ export function _fromDataUplcFunc(_target_t) {
         return _boolFromData.clone();
     if (target_t instanceof TirStringT)
         return _strFromData.clone();
+    // Native Value: data -> Value via `unValueData`
+    if (target_t instanceof TirValueT)
+        return IRNative.unValueData;
     if (target_t instanceof TirLinearMapT)
         // linear maps only have pairs as elements
         // and we only support pairs of data (bc we only have `mkPairData`)
@@ -136,8 +164,21 @@ export function _fromDataUplcFunc(_target_t) {
 const _unitFromDataSym = Symbol("unit");
 const _mkUnit = new IRHoisted(new IRFunc([_unitFromDataSym], IRConst.unit));
 const _boolFromDataDataSym = Symbol("boolData");
+// Case(unConstrData(data), [\idxSym _fieldsSym ->
+//     Case(idxSym, [
+//         IRConst.bool(true),   -- ctor 0 → true   (preserves equalsInteger(_, 0) semantics)
+//         IRConst.bool(false)   -- ctor 1 → false
+//     ])
+// ])
+const _boolFromDataIdxSym = Symbol("boolIdx");
+const _boolFromDataFieldsSym = Symbol("boolFields_unused");
 const _boolFromData = new IRHoisted(new IRFunc([_boolFromDataDataSym], // data
-_ir_apps(IRNative.equalsInteger, new IRApp(IRNative.fstPair, new IRApp(IRNative.unConstrData, new IRVar(_boolFromDataDataSym))), IRConst.int(0))));
+new IRCase(_ir_apps(IRNative.unConstrData, new IRVar(_boolFromDataDataSym)), [
+    new IRFunc([_boolFromDataIdxSym, _boolFromDataFieldsSym], new IRCase(new IRVar(_boolFromDataIdxSym), [
+        IRConst.bool(true),
+        IRConst.bool(false)
+    ]))
+])));
 const _strFromDataDataSym = Symbol("strData");
 const _strFromData = new IRHoisted(new IRFunc([_strFromDataDataSym], // data
 _ir_apps(IRNative.decodeUtf8, _ir_apps(IRNative.unBData, new IRVar(_strFromDataDataSym)))));
@@ -147,63 +188,57 @@ export function _inilneSingeSopConstrFromData(sop_t, dataExprIR) {
     const constr = sop_t.constructors[0];
     if (constr.fields.length === 0)
         return new IRHoisted(new IRConstr(0, []));
-    if (constr.fields.length === 1) {
-        const value_t = getUnaliased(constr.fields[0].type);
-        if (!isTirType(value_t))
-            throw new Error("TirFromDataExpr: unreachable");
-        return new IRConstr(0, [
-            _inlineFromData(value_t, 
-            // get head of fields list
-            _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR))))
-        ]);
-    }
-    return _ir_let(_ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR)), // introduce fields list
-    // introduce fields list
-    fieldsListSym => new IRConstr(0, constr.fields.map((field, i) => {
-        const field_t = getUnaliased(field.type);
-        if (!isTirType(field_t))
-            throw new Error("TirFromDataExpr: unreachable");
-        return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
-            ? new IRVar(fieldsListSym)
-            : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(fieldsListSym))));
-    })));
+    // Case(unConstrData(data), [\_idxSym fieldsListSym -> IRConstr(0, [...fields])])
+    // Single ctor, so the index is ignored — the outer Case destructures
+    // the pair via a 2-arg branch and we only consume the fields list.
+    const idxSym = Symbol("singleCtorIdx_unused");
+    const fieldsListSym = Symbol("fieldsList");
+    return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+        new IRFunc([idxSym, fieldsListSym], new IRConstr(0, constr.fields.map((field, i) => {
+            const field_t = getUnaliased(field.type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
+                ? new IRVar(fieldsListSym)
+                : _ir_apps(IRNative.dropList, IRConst.int(i), new IRVar(fieldsListSym))));
+        })))
+    ]);
 }
 export function _inlineMultiSopConstrFromData(sop_t, dataExprIR) {
     if (sop_t.constructors.length <= 1)
         return _inilneSingeSopConstrFromData(sop_t, dataExprIR);
-    return _ir_let(_ir_apps(IRNative.unConstrData, dataExprIR), // introduce unConstrData result
-    // introduce unConstrData result
-    unConstrDataSym => _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrDataSym))), // introduce isConstrIdx predicate (a function expecting an int)
-    // introduce isConstrIdx predicate (a function expecting an int)
-    isConstrIdxSym => _ir_let(_ir_apps(IRNative.sndPair, new IRVar(unConstrDataSym)), // introduce fields list
-    // introduce fields list
-    fieldsListSym => {
-        const continuations = sop_t.constructors.map((constr, constrIdx) => {
-            if (constr.fields.length === 0)
-                return new IRHoisted(new IRConstr(constrIdx, []));
-            if (constr.fields.length === 1) {
-                const value_t = getUnaliased(constr.fields[0].type);
-                if (!isTirType(value_t))
-                    throw new Error("TirFromDataExpr: unreachable");
-                return new IRConstr(constrIdx, [
-                    _inlineFromData(value_t, _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
-                ]);
-            }
-            return new IRConstr(constrIdx, constr.fields.map((field, i) => {
-                const field_t = getUnaliased(field.type);
-                if (!isTirType(field_t))
-                    throw new Error("TirFromDataExpr: unreachable");
-                return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
-                    ? new IRVar(fieldsListSym)
-                    : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(fieldsListSym))));
-            }));
-        });
-        let finalIfThenElseChain = continuations[continuations.length - 1];
-        for (let i = continuations.length - 2; i >= 0; i--) {
-            finalIfThenElseChain = new IRForced(_ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(isConstrIdxSym), IRConst.int(i)), new IRDelayed(continuations[i]), new IRDelayed(finalIfThenElseChain)));
+    // Case(unConstrData(data), [\idxSym fieldsListSym ->
+    //     Case(idxSym, [
+    //         IRConstr(0, [...fields_of_ctor_0]),
+    //         IRConstr(1, [...fields_of_ctor_1]),
+    //         ...
+    //     ])
+    // ])
+    const idxSym = Symbol("ctorIdx");
+    const fieldsListSym = Symbol("fieldsList");
+    const continuations = sop_t.constructors.map((constr, constrIdx) => {
+        if (constr.fields.length === 0)
+            return new IRHoisted(new IRConstr(constrIdx, []));
+        if (constr.fields.length === 1) {
+            const value_t = getUnaliased(constr.fields[0].type);
+            if (!isTirType(value_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return new IRConstr(constrIdx, [
+                _inlineFromData(value_t, _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
+            ]);
         }
-        return finalIfThenElseChain;
-    })));
+        return new IRConstr(constrIdx, constr.fields.map((field, i) => {
+            const field_t = getUnaliased(field.type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
+                ? new IRVar(fieldsListSym)
+                : _ir_apps(IRNative.dropList, IRConst.int(i), new IRVar(fieldsListSym))));
+        }));
+    });
+    return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+        new IRFunc([idxSym, fieldsListSym], new IRCase(new IRVar(idxSym), continuations))
+    ]);
 }
 // new cached hoisted helpers (mirroring TirToDataExpr pattern)
 const _mapListFromDataOfType = {};

package/dist/compiler/tir/expressions/TirIsExpr.js

@@ -4,6 +4,7 @@ import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 export class TirIsExpr {
     instanceExpr;
@@ -34,8 +35,20 @@ export class TirIsExpr {
     }
     get isConstant() { return this.instanceExpr.isConstant; }
     toIR(ctx) {
-        const structType = getUnaliased(this.instanceExpr.type);
+        const unaliased = getUnaliased(this.instanceExpr.type);
+        if (unaliased instanceof TirEnumType) {
+            // enums lower to a plain int; `is Member` is integer equality
+            return _ir_apps(IRNative.equalsInteger, IRConst.int(this.parentCtorIdx), this.instanceExpr.toIR(ctx));
+        }
+        const structType = unaliased;
         if (structType instanceof TirDataStructType) {
+            // untagged data structs have exactly one constructor; the
+            // runtime value carries no tag — `is Ctor` is statically true.
+            // We still evaluate `instanceExpr` to preserve any error it
+            // would produce (the redundancy is also flagged with a warning
+            // at AstCompiler time).
+            if (structType.untagged)
+                return _ir_apps(new IRFunc([Symbol("_unused_is_untagged")], IRConst.bool(true)), this.instanceExpr.toIR(ctx));
             // equalsInteger(parentCtorIdx, fstPair(unConstrData(<instance>)))
             return _ir_apps(IRNative.equalsInteger, IRConst.int(this.parentCtorIdx), _ir_apps(IRNative.fstPair, _ir_apps(IRNative.unConstrData, this.instanceExpr.toIR(ctx))));
         }

package/dist/compiler/tir/expressions/TirNativeFunc.d.ts

@@ -42,7 +42,6 @@ export declare class TirNativeFunc implements ITirExpr {
     static get verifyEd25519Signature(): TirNativeFunc;
     static strictIfThenElse(returnT: TirType): TirNativeFunc;
     static chooseUnit(returnT: TirType): TirNativeFunc;
-    static strictChooseList(elemT: TirType, returnT: TirType): TirNativeFunc;
     static mkCons(elemT: TirType): TirNativeFunc;
     static headList(elemT: TirType): TirNativeFunc;
     static tailList(elemT: TirType): TirNativeFunc;
@@ -65,6 +64,23 @@ export declare class TirNativeFunc implements ITirExpr {
     static get serialiseData(): TirNativeFunc;
     static get verifyEcdsaSecp256k1Signature(): TirNativeFunc;
     static get verifySchnorrSecp256k1Signature(): TirNativeFunc;
+    static get bls12_381_G1_add(): TirNativeFunc;
+    static get bls12_381_G1_neg(): TirNativeFunc;
+    static get bls12_381_G1_scalarMul(): TirNativeFunc;
+    static get bls12_381_G1_equal(): TirNativeFunc;
+    static get bls12_381_G1_hashToGroup(): TirNativeFunc;
+    static get bls12_381_G1_compress(): TirNativeFunc;
+    static get bls12_381_G1_uncompress(): TirNativeFunc;
+    static get bls12_381_G2_add(): TirNativeFunc;
+    static get bls12_381_G2_neg(): TirNativeFunc;
+    static get bls12_381_G2_scalarMul(): TirNativeFunc;
+    static get bls12_381_G2_equal(): TirNativeFunc;
+    static get bls12_381_G2_hashToGroup(): TirNativeFunc;
+    static get bls12_381_G2_compress(): TirNativeFunc;
+    static get bls12_381_G2_uncompress(): TirNativeFunc;
+    static get bls12_381_millerLoop(): TirNativeFunc;
+    static get bls12_381_mulMlResult(): TirNativeFunc;
+    static get bls12_381_finalVerify(): TirNativeFunc;
     static get keccak_256(): TirNativeFunc;
     static get blake2b_224(): TirNativeFunc;
     static get integerToByteString(): TirNativeFunc;
@@ -81,7 +97,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static get countSetBits(): TirNativeFunc;
     static get findFirstSetBit(): TirNativeFunc;
     static get ripemd_160(): TirNativeFunc;
-    static _dropList(elemT: TirType): TirNativeFunc;
+    static dropList(elemT: TirType): TirNativeFunc;
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _findSopOptional(elems_t: TirType): TirNativeFunc;

package/dist/compiler/tir/expressions/TirNativeFunc.js

@@ -2,7 +2,7 @@ import { SourceRange } from "../../../ast/Source/SourceRange.js";
 import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { bool_t, bytes_t, data_t, int_t, void_t } from "../program/stdScope/stdScope.js";
-import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT } from "../types/TirNativeType/index.js";
+import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT, TirBlsG1T, TirBlsG2T, TirMlResultT } from "../types/TirNativeType/index.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../types/TirNativeType/native/linearMapEntry.js";
@@ -229,16 +229,6 @@ export class TirNativeFunc {
             void_t
         ], returnT));
     }
-    static strictChooseList(elemT, returnT) {
-        return new TirNativeFunc(IRNativeTag.strictChooseList, new TirFuncT([
-            // list
-            new TirListT(elemT),
-            // caseNil
-            returnT,
-            // caseCons
-            returnT
-        ], returnT));
-    }
     // List operations with type parameters
     static mkCons(elemT) {
         return new TirNativeFunc(IRNativeTag.mkCons, new TirFuncT([
@@ -395,111 +385,58 @@ export class TirNativeFunc {
             bytes_t
         ], bool_t));
     }
-    // BLS12-381 operations
-    /* TODO: add bls supprot
-    get bls12_381_G1_add(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_add,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_neg(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_neg,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_scalarMul(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_scalarMul,
-            new TirFuncT([bytes_t, int_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_equal(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_equal,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    get bls12_381_G1_hashToGroup(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_hashToGroup,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_compress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_compress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_uncompress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_uncompress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_add(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_add,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_neg(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_neg,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_scalarMul(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_scalarMul,
-            new TirFuncT([bytes_t, int_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_equal(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_equal,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    get bls12_381_G2_hashToGroup(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_hashToGroup,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_compress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_compress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_uncompress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_uncompress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_millerLoop(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_millerLoop,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_mulMlResult(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_mulMlResult,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_finalVerify(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_finalVerify,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    //*/
+    // BLS12-381 operations -- now exposed under `std.crypto.bls12_381`
+    static get bls12_381_G1_add() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_add, new TirFuncT([new TirBlsG1T(), new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_neg() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_neg, new TirFuncT([new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_scalarMul() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_scalarMul, new TirFuncT([int_t, new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_equal() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_equal, new TirFuncT([new TirBlsG1T(), new TirBlsG1T()], bool_t));
+    }
+    static get bls12_381_G1_hashToGroup() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_hashToGroup, new TirFuncT([bytes_t, bytes_t], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_compress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_compress, new TirFuncT([new TirBlsG1T()], bytes_t));
+    }
+    static get bls12_381_G1_uncompress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_uncompress, new TirFuncT([bytes_t], new TirBlsG1T()));
+    }
+    static get bls12_381_G2_add() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_add, new TirFuncT([new TirBlsG2T(), new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_neg() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_neg, new TirFuncT([new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_scalarMul() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_scalarMul, new TirFuncT([int_t, new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_equal() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_equal, new TirFuncT([new TirBlsG2T(), new TirBlsG2T()], bool_t));
+    }
+    static get bls12_381_G2_hashToGroup() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_hashToGroup, new TirFuncT([bytes_t, bytes_t], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_compress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_compress, new TirFuncT([new TirBlsG2T()], bytes_t));
+    }
+    static get bls12_381_G2_uncompress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_uncompress, new TirFuncT([bytes_t], new TirBlsG2T()));
+    }
+    static get bls12_381_millerLoop() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_millerLoop, new TirFuncT([new TirBlsG1T(), new TirBlsG2T()], new TirMlResultT()));
+    }
+    static get bls12_381_mulMlResult() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_mulMlResult, new TirFuncT([new TirMlResultT(), new TirMlResultT()], new TirMlResultT()));
+    }
+    static get bls12_381_finalVerify() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_finalVerify, new TirFuncT([new TirMlResultT(), new TirMlResultT()], bool_t));
+    }
     // Additional hashing functions
     static get keccak_256() {
         return new TirNativeFunc(IRNativeTag.keccak_256, new TirFuncT([
@@ -630,8 +567,8 @@ export class TirNativeFunc {
         ], bytes_t));
     }
     // Custom utility functions
-    static _dropList(elemT) {
-        return new TirNativeFunc(IRNativeTag._dropList, new TirFuncT([
+    static dropList(elemT) {
+        return new TirNativeFunc(IRNativeTag.dropList, new TirFuncT([
             // n
             int_t,
             // list

package/dist/compiler/tir/expressions/TirShowExpr.d.ts

@@ -0,0 +1,52 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+/**
+ * `_showIR`-backed compile-time-dispatched show expression.
+ *
+ * Created when the user writes `expr.show()` on a built-in type whose Show
+ * impl the compiler provides (int, bytes, bool, data, void, string,
+ * List<T>, LinearMap<K,V>, data-encoded structs). For user-declared
+ * `type X implements Show { show(self): bytes { ... } }` impls the
+ * regular method-dispatch path in `expressifyVars` keeps applying — this
+ * expr is only emitted when no user impl is registered.
+ */
+export declare class TirShowExpr implements ITirExpr {
+    readonly inner: TirExpr;
+    readonly range: SourceRange;
+    constructor(inner: TirExpr, range: SourceRange);
+    get type(): TirType;
+    get isConstant(): boolean;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}
+/**
+ * Inline an `IRTerm` of type `t` into its UTF-8 textual representation
+ * (also bytes). Returns the IR producing the show-encoded bytes.
+ *
+ * Mirrors `_inlineToData` — fully compile-time-dispatched per source type:
+ *
+ *   int          -> hoisted_intToUtf8Bytes (decimal, sign-aware)
+ *   bytes        -> hoisted_bytesToHex (lowercase hex)
+ *   bool         -> "true" / "false" via lazy ifThenElse
+ *   data         -> serialiseData -> bytesToHex
+ *   void         -> "()"
+ *   string       -> encodeUtf8 (treat as already-readable text)
+ *   List<T>      -> "[" + intercalate(", ", map(_showIR(T), elems)) + "]"
+ *   LinearMap<K,V> -> "{" + intercalate(", ", map((k,v) -> showK(k) ++ ": " ++ showV(v), entries)) + "}"
+ *
+ * For struct-typed receivers (TirDataStructType / TirSoPStructType) this
+ * function does not produce IR — those should reach a user-declared
+ * `type X implements Show { show(self): bytes { ... } }` and dispatch
+ * through the regular method-call path. The caller is expected to detect
+ * that case before invoking `_showIR`.
+ */
+export declare function _showIR(origin_t: TirType, exprIR: IRTerm): IRTerm;
+/** A canonical 1-arg `(T) -> bytes` IR closure for use as a `Show` dictionary entry. */
+export declare function _showUplcFunc(origin_t: TirType): IRTerm;