@harmoniclabs/pebble 0.2.0 → 0.3.0

package/dist/compiler/tir/expressions/TirNativeFunc.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([
@@ -577,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/TirToDataExpr.js

@@ -7,6 +7,7 @@ import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
 import { data_t } from "../program/stdScope/stdScope.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";
@@ -99,6 +100,8 @@ export function _toDataUplcFunc(origin_t) {
         return IRNative._id;
     if (from_t instanceof TirIntT)
         return IRNative.iData;
+    if (from_t instanceof TirEnumType)
+        return IRNative.iData;
     if (from_t instanceof TirBytesT)
         return IRNative.bData;
     if (from_t instanceof TirVoidT)

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

@@ -7,6 +7,7 @@ import { TirIntT } from "../types/TirNativeType/native/int.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirStringT } from "../types/TirNativeType/native/string.js";
 import { TirDataStructType } from "../types/TirStructType.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 import { _inlineFromData } from "./TirFromDataExpr.js";
 import { _inlineToData } from "./TirToDataExpr.js";
@@ -49,12 +50,21 @@ export class TirTypeConversionExpr {
         if (to_t instanceof TirIntT) {
             if (from_t instanceof TirIntT)
                 return exprIR;
+            // enum is already an int at runtime; identity conversion.
+            if (from_t instanceof TirEnumType)
+                return exprIR;
             if (from_t instanceof TirBytesT)
                 return _ir_apps(IRNative._bytesToIntBE, exprIR);
             if (from_t instanceof TirBoolT)
                 return _ir_apps(IRNative._boolToInt, exprIR);
             throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
         }
+        if (to_t instanceof TirEnumType) {
+            // identity at runtime — same enum type.
+            if (from_t instanceof TirEnumType)
+                return exprIR;
+            throw new Error(`Cannot convert from ${from_t.toString()} to ${to_t.toString()}`);
+        }
         if (to_t instanceof TirBytesT) {
             if (from_t instanceof TirBytesT)
                 return exprIR;

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

@@ -1,6 +1,5 @@
 import { SourceRange } from "../../../ast/Source/SourceRange.js";
-import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
-import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
 import { ResolveValueResult } from "../../AstCompiler/scope/AstScope.js";
 import { TirType } from "../types/TirType.js";
 import type { ITirExpr } from "./ITirExpr.js";
@@ -17,5 +16,5 @@ export declare class TirVariableAccessExpr implements ITirExpr {
     get isConstant(): boolean;
     get varName(): string;
     deps(): string[];
-    toIR(ctx: ToIRTermCtx): IRVar | IRSelfCall;
+    toIR(ctx: ToIRTermCtx): IRTerm;
 }

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

@@ -1,5 +1,3 @@
-import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
-import { IRVar } from "../../../IR/IRNodes/IRVar.js";
 export class TirVariableAccessExpr {
     range;
     resolvedValue;
@@ -35,8 +33,7 @@ export class TirVariableAccessExpr {
     deps() { return [this.varName]; }
     toIR(ctx) {
         const ir = ctx.getVarAccessIR(this.varName);
-        if (!(ir instanceof IRVar
-            || ir instanceof IRSelfCall)) {
+        if (!ir) {
             throw new Error(`variable '${this.varName}' is missing in [${ctx.allVariables().join(", ")}]`);
         }
         return ir;

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

@@ -1,9 +1,17 @@
-import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
 export declare class ToIRTermCtx {
     readonly parent: ToIRTermCtx | undefined;
     readonly _creationStack?: string | undefined;
     private readonly localVars;
+    /**
+     * Per-name overrides whose lookup synthesizes a fresh IR term at each
+     * access (rather than resolving to a pre-allocated IRVar). Used to
+     * implement lazy field extraction in case-arms — the body's references
+     * to pattern-bound fields each emit an `IRLetted` over the extraction
+     * IR, so the letted-handling pass can dedup, hoist or eliminate as
+     * appropriate.
+     */
+    private readonly deferredAccess;
     private _firstVariableIsRecursive;
     _children: ToIRTermCtx[];
     constructor(parent: ToIRTermCtx | undefined);
@@ -13,7 +21,16 @@ export declare class ToIRTermCtx {
     newChild(): ToIRTermCtx;
     private localVarSym;
     getVarAccessSym(name: string): symbol | undefined;
-    getVarAccessIR(name: string): IRVar | IRSelfCall | undefined;
+    private getDeferredAccessFactory;
+    getVarAccessIR(name: string): IRTerm | undefined;
+    /**
+     * Register a per-name lookup override. Subsequent `getVarAccessIR(name)`
+     * calls in this context (or its descendants) return the IR term produced
+     * by `factory()`. The factory is invoked once per access — wrap the
+     * result in `IRLetted` if you want the IR-level let-handling pass to
+     * dedup / hoist / eliminate as appropriate.
+     */
+    defineDeferredAccess(name: string, factory: () => IRTerm): void;
     /**
      * @returns the symbol of the defined variable (for eventual `new IRFunc( ... )`)
     **/

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

@@ -5,6 +5,15 @@ export class ToIRTermCtx {
     parent;
     _creationStack;
     localVars = new Map();
+    /**
+     * Per-name overrides whose lookup synthesizes a fresh IR term at each
+     * access (rather than resolving to a pre-allocated IRVar). Used to
+     * implement lazy field extraction in case-arms — the body's references
+     * to pattern-bound fields each emit an `IRLetted` over the extraction
+     * IR, so the letted-handling pass can dedup, hoist or eliminate as
+     * appropriate.
+     */
+    deferredAccess = new Map();
     _firstVariableIsRecursive = false;
     _children = [];
     constructor(parent) {
@@ -37,15 +46,51 @@ export class ToIRTermCtx {
         return (this.localVarSym(name)
             ?? this.parent?.getVarAccessSym(name));
     }
+    getDeferredAccessFactory(name) {
+        return (this.deferredAccess.get(name)
+            ?? this.parent?.getDeferredAccessFactory(name));
+    }
     getVarAccessIR(name) {
+        // deferred accesses (lazy field extraction in case-arms etc.)
+        // shadow symbol-based lookups when present.
+        const deferred = this.getDeferredAccessFactory(name);
+        if (deferred)
+            return deferred();
         const accessSym = this.getVarAccessSym(name);
         if (typeof accessSym !== "symbol")
             return undefined;
-        if (this._firstVariableIsRecursive
-            && name === this.localVars.keys().next().value)
-            return new IRSelfCall(accessSym);
+        // Recursive accesses must use IRSelfCall (the recursive symbol is
+        // bound by an IRRecursive, not an IRFunc — IRVar references would
+        // not find a binder during the unused-var pass). Walk the parent
+        // chain to find the ctx that owns `name`; that ctx may not be the
+        // current one when we're deep inside the recursive function's body
+        // (e.g. inside a `case` continuation that newChild'd from it).
+        let cur = this;
+        while (cur) {
+            const localSym = cur.localVars.get(name);
+            if (localSym !== undefined) {
+                if (cur._firstVariableIsRecursive
+                    && name === cur.localVars.keys().next().value)
+                    return new IRSelfCall(accessSym);
+                break;
+            }
+            cur = cur.parent;
+        }
         return new IRVar(accessSym);
     }
+    /**
+     * Register a per-name lookup override. Subsequent `getVarAccessIR(name)`
+     * calls in this context (or its descendants) return the IR term produced
+     * by `factory()`. The factory is invoked once per access — wrap the
+     * result in `IRLetted` if you want the IR-level let-handling pass to
+     * dedup / hoist / eliminate as appropriate.
+     */
+    defineDeferredAccess(name, factory) {
+        if (this.localVars.has(name) || this.deferredAccess.has(name)) {
+            throw new Error(`variable '${name}' already defined in the current scope`);
+        }
+        this.deferredAccess.set(name, factory);
+    }
     /**
      * @returns the symbol of the defined variable (for eventual `new IRFunc( ... )`)
     **/

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.d.ts

@@ -119,7 +119,7 @@ export declare class TirSubExpr implements ITirBinaryExpr {
     left: TirExpr;
     right: TirExpr;
     readonly range: SourceRange;
-    readonly type: TirType;
+    get type(): TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
     toString(): string;
     pretty(indent: number): string;
@@ -132,7 +132,7 @@ export declare class TirMultExpr implements ITirBinaryExpr {
     left: TirExpr;
     right: TirExpr;
     readonly range: SourceRange;
-    readonly type: TirType;
+    get type(): TirType;
     constructor(left: TirExpr, right: TirExpr, range: SourceRange);
     toString(): string;
     pretty(indent: number): string;

package/dist/compiler/tir/expressions/binary/TirBinaryExpr.js

@@ -5,6 +5,8 @@ import { getUnaliased } from "../../types/utils/getUnaliased.js";
 import { CEKConst, Machine } from "@harmoniclabs/plutus-machine";
 import { TirBytesT } from "../../types/TirNativeType/native/bytes.js";
 import { TirIntT } from "../../types/TirNativeType/native/int.js";
+import { TirEnumType } from "../../types/TirEnumType.js";
+import { TirValueT } from "../../types/TirNativeType/native/value.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 import { IRConst } from "../../../../IR/IRNodes/IRConst.js";
 import { compileIRToUPLC } from "../../../../IR/toUPLC/compileIRToUPLC.js";
@@ -87,7 +89,7 @@ export class TirLessThanExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanInteger :
+        const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanInteger :
             type instanceof TirBytesT ? IRNative.lessThanByteString :
                 undefined);
         if (!irFunc)
@@ -124,7 +126,7 @@ export class TirGreaterThanExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanInteger :
+        const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanInteger :
             type instanceof TirBytesT ? IRNative.lessThanByteString :
                 undefined);
         if (!irFunc)
@@ -163,7 +165,7 @@ export class TirLessThanEqualExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanEqualInteger :
+        const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanEqualInteger :
             type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
                 undefined);
         if (!irFunc)
@@ -200,7 +202,7 @@ export class TirGreaterThanEqualExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.lessThanEqualInteger :
+        const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.lessThanEqualInteger :
             type instanceof TirBytesT ? IRNative.lessThanEqualsByteString :
                 undefined);
         if (!irFunc)
@@ -285,9 +287,14 @@ export class TirAddExpr {
     _creationStack;
     get type() {
         const leftType = getUnaliased(this.left.type);
+        if (leftType instanceof TirValueT)
+            return this.left.type;
         if (leftType instanceof TirIntT
             || leftType instanceof TirBytesT)
             return leftType;
+        // enum + int yields an int (enums lower to ints at runtime)
+        if (leftType instanceof TirEnumType)
+            return int_t;
         throw new Error("invalid type for addition");
     }
     constructor(left, right, range) {
@@ -312,9 +319,10 @@ export class TirAddExpr {
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
         const type = getUnaliased(this.left.type);
-        const irFunc = (type instanceof TirIntT ? IRNative.addInteger :
+        const irFunc = ((type instanceof TirIntT || type instanceof TirEnumType) ? IRNative.addInteger :
             type instanceof TirBytesT ? IRNative.appendByteString :
-                undefined);
+                type instanceof TirValueT ? IRNative.unionValue :
+                    undefined);
         if (!irFunc)
             throw new Error("invalid left type for TirAddExpr");
         return _ir_apps(irFunc, this.left.toIR(ctx), this.right.toIR(ctx));
@@ -329,7 +337,12 @@ export class TirSubExpr {
     left;
     right;
     range;
-    type = int_t;
+    get type() {
+        const leftType = getUnaliased(this.left.type);
+        if (leftType instanceof TirValueT)
+            return this.left.type;
+        return int_t;
+    }
     constructor(left, right, range) {
         this.left = left;
         this.right = right;
@@ -348,6 +361,11 @@ export class TirSubExpr {
     }
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
+        const type = getUnaliased(this.left.type);
+        if (type instanceof TirValueT) {
+            // a - b  →  unionValue a (negateValue b)
+            return _ir_apps(IRNative.unionValue, this.left.toIR(ctx), _ir_apps(IRNative._negateValue, this.right.toIR(ctx)));
+        }
         return _ir_apps(IRNative.subtractInteger, this.left.toIR(ctx), this.right.toIR(ctx));
     }
     deps() {
@@ -360,7 +378,15 @@ export class TirMultExpr {
     left;
     right;
     range;
-    type = int_t;
+    get type() {
+        const leftTy = getUnaliased(this.left.type);
+        const rightTy = getUnaliased(this.right.type);
+        if (leftTy instanceof TirValueT)
+            return this.left.type;
+        if (rightTy instanceof TirValueT)
+            return this.right.type;
+        return int_t;
+    }
     constructor(left, right, range) {
         this.left = left;
         this.right = right;
@@ -379,6 +405,17 @@ export class TirMultExpr {
     }
     get isConstant() { return this.left.isConstant && this.right.isConstant; }
     toIR(ctx) {
+        const leftTy = getUnaliased(this.left.type);
+        const rightTy = getUnaliased(this.right.type);
+        // scaleValue :: int -> Value -> Value
+        if (leftTy instanceof TirValueT) {
+            // Value * int  →  scaleValue int Value
+            return _ir_apps(IRNative.scaleValue, this.right.toIR(ctx), this.left.toIR(ctx));
+        }
+        if (rightTy instanceof TirValueT) {
+            // int * Value  →  scaleValue int Value
+            return _ir_apps(IRNative.scaleValue, this.left.toIR(ctx), this.right.toIR(ctx));
+        }
         return _ir_apps(IRNative.multiplyInteger, this.left.toIR(ctx), this.right.toIR(ctx));
     }
     deps() {

package/dist/compiler/tir/expressions/litteral/TirLitEnumMemberExpr.d.ts

@@ -0,0 +1,19 @@
+import { ITirExpr } from "../ITirExpr.js";
+import { SourceRange } from "../../../../ast/Source/SourceRange.js";
+import { TirEnumType } from "../../types/TirEnumType.js";
+import { ToIRTermCtx } from "../ToIRTermCtx.js";
+import { IRTerm } from "../../../../IR/index.js";
+import type { TirExpr } from "../TirExpr.js";
+export declare class TirLitEnumMemberExpr implements ITirExpr {
+    readonly type: TirEnumType;
+    readonly memberIdx: number;
+    readonly range: SourceRange;
+    readonly isConstant: boolean;
+    constructor(type: TirEnumType, memberIdx: number, range: SourceRange);
+    get memberName(): string;
+    pretty(): string;
+    toString(): string;
+    clone(): TirExpr;
+    deps(): string[];
+    toIR(_ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/litteral/TirLitEnumMemberExpr.js

@@ -0,0 +1,24 @@
+import { IRConst } from "../../../../IR/index.js";
+export class TirLitEnumMemberExpr {
+    type;
+    memberIdx;
+    range;
+    isConstant = true;
+    constructor(type, memberIdx, range) {
+        this.type = type;
+        this.memberIdx = memberIdx;
+        this.range = range;
+    }
+    get memberName() { return this.type.members[this.memberIdx]; }
+    pretty() { return this.toString(); }
+    toString() {
+        return `${this.type.name}.${this.memberName}`;
+    }
+    clone() {
+        return new TirLitEnumMemberExpr(this.type.clone(), this.memberIdx, this.range.clone());
+    }
+    deps() { return []; }
+    toIR(_ctx) {
+        return IRConst.int(BigInt(this.memberIdx));
+    }
+}

package/dist/compiler/tir/expressions/litteral/TirLitteralExpr.d.ts

@@ -1,4 +1,5 @@
 import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirLitEnumMemberExpr } from "./TirLitEnumMemberExpr.js";
 import { TirLitFailExpr } from "./TirLitFailExpr.js";
 import { TirLitFalseExpr } from "./TirLitFalseExpr.js";
 import { TirLitHexBytesExpr } from "./TirLitHexBytesExpr.js";
@@ -10,5 +11,5 @@ import { TirLitThisExpr } from "./TirLitThisExpr.js";
 import { TirLitTrueExpr } from "./TirLitTrueExpr.js";
 import { TirLitUndefExpr } from "./TirLitUndefExpr.js";
 import { TirLitVoidExpr } from "./TirLitVoidExpr.js";
-export type TirLitteralExpr = TirLitVoidExpr | TirLitUndefExpr | TirLitTrueExpr | TirLitFalseExpr | TirLitStrExpr | TirLitIntExpr | TirLitHexBytesExpr | TirLitThisExpr | TirLitArrExpr | TirLitObjExpr | TirLitNamedObjExpr | TirLitFailExpr;
+export type TirLitteralExpr = TirLitVoidExpr | TirLitUndefExpr | TirLitTrueExpr | TirLitFalseExpr | TirLitStrExpr | TirLitIntExpr | TirLitHexBytesExpr | TirLitThisExpr | TirLitArrExpr | TirLitObjExpr | TirLitNamedObjExpr | TirLitEnumMemberExpr | TirLitFailExpr;
 export declare function isTirLitteralExpr(thing: any): thing is TirLitteralExpr;

package/dist/compiler/tir/expressions/litteral/TirLitteralExpr.js

@@ -1,4 +1,5 @@
 import { TirLitArrExpr } from "./TirLitArrExpr.js";
+import { TirLitEnumMemberExpr } from "./TirLitEnumMemberExpr.js";
 import { TirLitFailExpr } from "./TirLitFailExpr.js";
 import { TirLitFalseExpr } from "./TirLitFalseExpr.js";
 import { TirLitHexBytesExpr } from "./TirLitHexBytesExpr.js";
@@ -19,6 +20,7 @@ export function isTirLitteralExpr(thing) {
         || thing instanceof TirLitArrExpr
         || thing instanceof TirLitObjExpr
         || thing instanceof TirLitNamedObjExpr
+        || thing instanceof TirLitEnumMemberExpr
         || thing instanceof TirLitStrExpr
         || thing instanceof TirLitIntExpr
         || thing instanceof TirLitHexBytesExpr

package/dist/compiler/tir/expressions/unary/TirUnaryMinus.js

@@ -1,3 +1,5 @@
+import { TirValueT } from "../../types/TirNativeType/native/value.js";
+import { getUnaliased } from "../../types/utils/getUnaliased.js";
 import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 export class TirUnaryMinus {
@@ -23,6 +25,7 @@ export class TirUnaryMinus {
     }
     get isConstant() { return this.operand.isConstant; }
     toIR(ctx) {
-        return _ir_apps(IRNative._negateInt, this.operand.toIR(ctx));
+        const operandTy = getUnaliased(this.operand.type);
+        return _ir_apps(operandTy instanceof TirValueT ? IRNative._negateValue : IRNative._negateInt, this.operand.toIR(ctx));
     }
 }

package/dist/compiler/tir/program/stdScope/populateStdNamespace.js

@@ -1,5 +1,6 @@
 import { SourceRange } from "../../../../ast/Source/SourceRange.js";
 import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
+import { IRCase } from "../../../../IR/IRNodes/IRCase.js";
 import { IRFunc } from "../../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 import { IRNativeTag } from "../../../../IR/IRNodes/IRNative/IRNativeTag.js";
@@ -10,9 +11,11 @@ import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirUnConstrDataResultT, TirFuncT, }
 import { TirLinearMapT } from "../../types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../types/TirNativeType/native/list.js";
+import { TirArrayT } from "../../types/TirNativeType/native/array.js";
+import { TirValueT } from "../../types/TirNativeType/native/value.js";
 import { TirSopOptT } from "../../types/TirNativeType/native/Optional/sop.js";
 import { TirTypeParam } from "../../types/TirTypeParam.js";
-import { bool_t, bytes_t, data_t, int_t, string_t, void_t, valueLovelacesName, valueAmountOfName, getCredentialHashFuncName, } from "./stdScope.js";
+import { bool_t, bytes_t, data_t, int_t, string_t, void_t, valueLovelacesName, valueAmountOfName, valueMapLovelacesName, valueMapAmountOfName, valueInsertCoinName, valueUnionName, valueContainsName, valueScaleName, valueToDataName, getCredentialHashFuncName, } from "./stdScope.js";
 /**
  * Populate the top-level `std` namespace and its sub-namespaces:
  *
@@ -264,6 +267,16 @@ export function populateStdNamespace(program) {
     // data misc
     defineBuiltin(builtinsNsScope, "equalsData", IRNativeTag.equalsData, new TirFuncT([data_t, data_t], bool_t), blt);
     defineBuiltin(builtinsNsScope, "serialiseData", IRNativeTag.serialiseData, new TirFuncT([data_t], bytes_t), blt);
+    // Chang2 / value & array builtins
+    const value_native_t = new TirValueT();
+    defineBuiltin(builtinsNsScope, "expModInteger", IRNativeTag.expModInteger, new TirFuncT([int_t, int_t, int_t], int_t), blt);
+    defineBuiltin(builtinsNsScope, "insertCoin", IRNativeTag.insertCoin, new TirFuncT([bytes_t, bytes_t, int_t, value_native_t], value_native_t), blt);
+    defineBuiltin(builtinsNsScope, "lookupCoin", IRNativeTag.lookupCoin, new TirFuncT([bytes_t, bytes_t, value_native_t], int_t), blt);
+    defineBuiltin(builtinsNsScope, "unionValue", IRNativeTag.unionValue, new TirFuncT([value_native_t, value_native_t], value_native_t), blt);
+    defineBuiltin(builtinsNsScope, "valueContains", IRNativeTag.valueContains, new TirFuncT([value_native_t, value_native_t], bool_t), blt);
+    defineBuiltin(builtinsNsScope, "valueData", IRNativeTag.valueData, new TirFuncT([value_native_t], data_t), blt);
+    defineBuiltin(builtinsNsScope, "unValueData", IRNativeTag.unValueData, new TirFuncT([data_t], value_native_t), blt);
+    defineBuiltin(builtinsNsScope, "scaleValue", IRNativeTag.scaleValue, new TirFuncT([int_t, value_native_t], value_native_t), blt);
     // ------------------------------------------------------------------
     // 5b. std.builtins -- polymorphic intrinsics via native generic templates
     // ------------------------------------------------------------------
@@ -395,8 +408,20 @@ export function populateStdNamespace(program) {
     defineGenericBuiltin(builtinsNsScope, "tailList", 1, ([T]) => new TirFuncT([new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag.tailList));
     // nullList<T>( xs: List<T> ): bool
     defineGenericBuiltin(builtinsNsScope, "nullList", 1, ([T]) => new TirFuncT([new TirListT(T)], bool_t), () => new IRNative(IRNativeTag.nullList));
-    // chooseList<A,B>( xs: List<A>, caseNil: B, caseCons: B ): B  -- strict
-    defineGenericBuiltin(builtinsNsScope, "chooseList", 2, ([A, B]) => new TirFuncT([new TirListT(A), B, B], B), () => new IRNative(IRNativeTag.strictChooseList));
+    // chooseList<A,B>( xs: List<A>, caseNil: B, caseCons: B ): B
+    // Lowered to a UPLC `Case` on the list: the cons branch ignores h/t
+    // (matching the `chooseList` builtin contract — head/tail aren't bound).
+    defineGenericBuiltin(builtinsNsScope, "chooseList", 2, ([A, B]) => new TirFuncT([new TirListT(A), B, B], B), () => {
+        const xs = Symbol("xs");
+        const caseNil = Symbol("caseNil");
+        const caseCons = Symbol("caseCons");
+        const h = Symbol("_h");
+        const t = Symbol("_t");
+        return new IRFunc([xs, caseNil, caseCons], new IRCase(new IRVar(xs), [
+            new IRFunc([h, t], new IRVar(caseCons)),
+            new IRVar(caseNil)
+        ]));
+    });
     // chooseData<T>( d: data, caseConstr: T, caseMap: T, caseList: T,
     //                caseIData: T, caseBData: T ): T
     defineGenericBuiltin(builtinsNsScope, "chooseData", 1, ([T]) => new TirFuncT([data_t, T, T, T, T, T], T), () => new IRNative(IRNativeTag.chooseData));
@@ -414,12 +439,14 @@ export function populateStdNamespace(program) {
     //    Method-call surface (e.g. `xs.map(f)`) is unchanged.
     // ------------------------------------------------------------------
     const listNsScope = new AstScope(stdNsScope, program, {});
+    const arrayNsScope = new AstScope(stdNsScope, program, {});
     const linearMapNsScope = new AstScope(stdNsScope, program, {});
     const bytesNsScope = new AstScope(stdNsScope, program, {});
     const intNsScope = new AstScope(stdNsScope, program, {});
     const boolNsScope = new AstScope(stdNsScope, program, {});
     const dataNsScope = new AstScope(stdNsScope, program, {});
     const valueNsScope = new AstScope(stdNsScope, program, {});
+    const valueMapNsScope = new AstScope(stdNsScope, program, {});
     const credentialNsScope = new AstScope(stdNsScope, program, {});
     // ---------- std.list (polymorphic) ----------
     const listNs = "list";
@@ -428,7 +455,7 @@ export function populateStdNamespace(program) {
     defineGenericBuiltin(listNsScope, "head", 1, ([T]) => new TirFuncT([new TirListT(T)], T), () => new IRNative(IRNativeTag.headList), listNs);
     defineGenericBuiltin(listNsScope, "tail", 1, ([T]) => new TirFuncT([new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag.tailList), listNs);
     defineGenericBuiltin(listNsScope, "prepend", 1, ([T]) => new TirFuncT([T, new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag.mkCons), listNs);
-    defineGenericBuiltin(listNsScope, "drop", 1, ([T]) => new TirFuncT([int_t, new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag._dropList), listNs);
+    defineGenericBuiltin(listNsScope, "drop", 1, ([T]) => new TirFuncT([int_t, new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag.dropList), listNs);
     defineGenericBuiltin(listNsScope, "foldr", 2, ([T, A]) => new TirFuncT([new TirFuncT([T, A], A), A, new TirListT(T)], A), () => new IRNative(IRNativeTag._foldr), listNs);
     defineGenericBuiltin(listNsScope, "foldl", 2, ([T, A]) => new TirFuncT([new TirFuncT([A, T], A), A, new TirListT(T)], A), () => new IRNative(IRNativeTag._foldl), listNs);
     defineGenericBuiltin(listNsScope, "filter", 1, ([T]) => new TirFuncT([new TirFuncT([T], bool_t), new TirListT(T)], new TirListT(T)), () => new IRNative(IRNativeTag._filter), listNs);
@@ -521,9 +548,23 @@ export function populateStdNamespace(program) {
         }
         scope.functions.set(astName, existingTirFuncName);
     }
+    // std.value.* — methods on the native Value
     defineAliasFromProgram(valueNsScope, "amountOf", valueAmountOfName);
     defineAliasFromProgram(valueNsScope, "lovelaces", valueLovelacesName);
+    defineAliasFromProgram(valueNsScope, "insert", valueInsertCoinName);
+    defineAliasFromProgram(valueNsScope, "union", valueUnionName);
+    defineAliasFromProgram(valueNsScope, "contains", valueContainsName);
+    defineAliasFromProgram(valueNsScope, "scale", valueScaleName);
+    defineAliasFromProgram(valueNsScope, "toData", valueToDataName);
+    // std.valueMap.* — methods on the legacy AssocMap-of-AssocMap representation
+    defineAliasFromProgram(valueMapNsScope, "amountOf", valueMapAmountOfName);
+    defineAliasFromProgram(valueMapNsScope, "lovelaces", valueMapLovelacesName);
     defineAliasFromProgram(credentialNsScope, "hash", getCredentialHashFuncName);
+    // ---------- std.array (polymorphic; native array) ----------
+    const arrayNs = "array";
+    defineGenericBuiltin(arrayNsScope, "length", 1, ([T]) => new TirFuncT([new TirArrayT(T)], int_t), () => new IRNative(IRNativeTag.lengthOfArray), arrayNs);
+    defineGenericBuiltin(arrayNsScope, "at", 1, ([T]) => new TirFuncT([new TirArrayT(T), int_t], T), () => new IRNative(IRNativeTag.indexArray), arrayNs);
+    defineGenericBuiltin(arrayNsScope, "fromList", 1, ([T]) => new TirFuncT([new TirListT(T)], new TirArrayT(T)), () => new IRNative(IRNativeTag.listToArray), arrayNs);
     // ---------- top-level std.id<T> / std.equals<T> ----------
     // id<T>(x: T): T  -- the polymorphic identity. Useful as a default
     // argument or "do-nothing" callback to higher-order code.
@@ -552,22 +593,26 @@ export function populateStdNamespace(program) {
     cryptoNsScope.readonly();
     builtinsNsScope.readonly();
     listNsScope.readonly();
+    arrayNsScope.readonly();
     linearMapNsScope.readonly();
     bytesNsScope.readonly();
     intNsScope.readonly();
     boolNsScope.readonly();
     dataNsScope.readonly();
     valueNsScope.readonly();
+    valueMapNsScope.readonly();
     credentialNsScope.readonly();
     stdNsScope.defineNamespace({ name: "crypto", publicScope: cryptoNsScope });
     stdNsScope.defineNamespace({ name: "builtins", publicScope: builtinsNsScope });
     stdNsScope.defineNamespace({ name: "list", publicScope: listNsScope });
+    stdNsScope.defineNamespace({ name: "array", publicScope: arrayNsScope });
     stdNsScope.defineNamespace({ name: "linearMap", publicScope: linearMapNsScope });
     stdNsScope.defineNamespace({ name: "bytes", publicScope: bytesNsScope });
     stdNsScope.defineNamespace({ name: "int", publicScope: intNsScope });
     stdNsScope.defineNamespace({ name: "boolean", publicScope: boolNsScope });
     stdNsScope.defineNamespace({ name: "data", publicScope: dataNsScope });
     stdNsScope.defineNamespace({ name: "value", publicScope: valueNsScope });
+    stdNsScope.defineNamespace({ name: "valueMap", publicScope: valueMapNsScope });
     stdNsScope.defineNamespace({ name: "credential", publicScope: credentialNsScope });
     stdNsScope.readonly();
     program.preludeScope.defineNamespace({ name: "std", publicScope: stdNsScope });

package/dist/compiler/tir/program/stdScope/prelude/preludeTypesSrc.js

@@ -152,9 +152,9 @@ export struct Address {
     stake: Optional<Credential>
 }
 
-export type Value = LinearMap<PolicyId, LinearMap<TokenName, int>>
+export type ValueMap = LinearMap<PolicyId, LinearMap<TokenName, int>>
 
-type Value implements {
+type ValueMap implements {
     amountOf( policy: PolicyId, name: bytes ): int
     {
         // todo
@@ -166,6 +166,39 @@ type Value implements {
     }
 }
 
+// `Value` is a native built-in value (ConstTyTag.value).
+// It is reached from `data` via `unValueData`; the ledger always passes data.
+type Value implements {
+    amountOf( policy: PolicyId, name: bytes ): int
+    {
+        return native.lookupCoin( policy, name, this );
+    }
+    lovelaces(): int
+    {
+        return this.amountOf( #, # );
+    }
+    insert( policy: PolicyId, name: bytes, amount: int ): Value
+    {
+        return native.insertCoin( policy, name, amount, this );
+    }
+    union( other: Value ): Value
+    {
+        return native.unionValue( this, other );
+    }
+    contains( other: Value ): bool
+    {
+        return native.valueContains( this, other );
+    }
+    scale( factor: int ): Value
+    {
+        return native.scaleValue( factor, this );
+    }
+    toData(): data
+    {
+        return native.valueData( this );
+    }
+}
+
 export struct OutputDatum {
     NoDatum {}
     DatumHash { hash: Hash32 }