@harmoniclabs/pebble 0.2.0 → 0.3.1

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 }

package/dist/compiler/tir/program/stdScope/stdScope.d.ts

@@ -11,8 +11,15 @@ export declare const string_t: TirStringT;
 export declare const bytes_t: TirBytesT;
 export declare const bool_t: TirBoolT;
 export declare const data_t: TirDataT;
+export declare const valueMapLovelacesName: string;
+export declare const valueMapAmountOfName: string;
 export declare const valueLovelacesName: string;
 export declare const valueAmountOfName: string;
+export declare const valueInsertCoinName: string;
+export declare const valueUnionName: string;
+export declare const valueContainsName: string;
+export declare const valueScaleName: string;
+export declare const valueToDataName: string;
 export declare const getCredentialHashFuncName: string;
 export declare function populateStdScope(program: TypedProgram): void;
 export declare function populatePreludeScope(program: TypedProgram): void;

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

@@ -6,6 +6,8 @@ import { TirDataT } from "../../types/TirNativeType/native/data.js";
 import { TirIntT } from "../../types/TirNativeType/native/int.js";
 import { TirLinearMapT } from "../../types/TirNativeType/native/linearMap.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 { 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";
@@ -18,14 +20,23 @@ import { IRNative } from "../../../../IR/IRNodes/IRNative/index.js";
 import { IRFunc } from "../../../../IR/IRNodes/IRFunc.js";
 import { IRVar } from "../../../../IR/IRNodes/IRVar.js";
 import { _ir_apps } from "../../../../IR/IRNodes/IRApp.js";
+import { IRConst } from "../../../../IR/IRNodes/IRConst.js";
 export const void_t = new TirVoidT();
 export const int_t = new TirIntT();
 export const string_t = new TirStringT();
 export const bytes_t = new TirBytesT();
 export const bool_t = new TirBoolT();
 export const data_t = new TirDataT();
-export const valueLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "sortedValueLovelaces";
-export const valueAmountOfName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "amountOfValue";
+export const valueMapLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "sortedValueLovelaces";
+export const valueMapAmountOfName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "amountOfValue";
+// Native Value (ConstTyTag.value); methods route to the value builtins.
+export const valueLovelacesName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueLovelaces";
+export const valueAmountOfName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueAmountOf";
+export const valueInsertCoinName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueInsertCoin";
+export const valueUnionName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueUnion";
+export const valueContainsName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueContains";
+export const valueScaleName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueScale";
+export const valueToDataName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "valueToData";
 export const getCredentialHashFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + "getCredentialHash";
 export function populateStdScope(program) {
     const stdScope = program.stdScope;
@@ -40,6 +51,24 @@ export function populateStdScope(program) {
     _defineStdUnambigous(bytes_t);
     _defineStdUnambigous(string_t);
     _defineStdUnambigous(data_t);
+    // Register native Value (ConstTyTag.value) in program.types so the prelude
+    // alias can wrap it. The user-facing `Value` name is defined in the
+    // prelude scope (with methods routed to the value builtins).
+    {
+        const value_native_t = new TirValueT();
+        program.types.set(value_native_t.toTirTypeKey(), value_native_t);
+    }
+    const array_name = TirArrayT.toTirTypeKey();
+    program.defineGenericType(array_name, 1, ([arg]) => new TirArrayT(arg));
+    stdScope.defineType(array_name, {
+        sopTirName: array_name,
+        dataTirName: array_name,
+        allTirNames: new Set([
+            array_name
+        ]),
+        methodsNames: new Map(),
+        isGeneric: true
+    });
     const opt_data_name = TirDataOptT.toTirTypeKey();
     program.defineGenericType(opt_data_name, 1, ([arg]) => new TirDataOptT(arg));
     const opt_sop_name = TirSopOptT.toTirTypeKey();
@@ -542,29 +571,29 @@ export function populatePreludeScope(program) {
         payment: credential_t,
         stake: opt_stakeCredential_t
     }, onlyData);
-    // type Value = LinearMap<PolicyId, LinearMap<TokenName, int>>
+    // type ValueMap = LinearMap<PolicyId, LinearMap<TokenName, int>>
     const map_tokenName_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [tokenName_t, int_t]);
     if (!map_tokenName_int_t)
         throw new Error("expected map_tokenName_int_t");
     const map_policyId_map_tokenName_int_t = program.getAppliedGeneric(TirLinearMapT.toTirTypeKey(), [policyId_t, map_tokenName_int_t]);
     if (!map_policyId_map_tokenName_int_t)
         throw new Error("expected map_policyId_map_tokenName_int_t");
-    const value_t = _defineUnambigousAlias("Value", map_policyId_map_tokenName_int_t, new Map([
+    const valueMap_t = _defineUnambigousAlias("ValueMap", map_policyId_map_tokenName_int_t, new Map([
         [
             "lovelaces",
-            valueLovelacesName
+            valueMapLovelacesName
         ],
         [
             "amountOf",
-            valueAmountOfName
+            valueMapAmountOfName
         ],
     ]));
-    preludeScope.program.functions.set(valueLovelacesName, new TirInlineClosedIR(new TirFuncT([value_t], int_t), (ctx) => IRNative._sortedValueLovelaces, SourceRange.unknown));
-    // Value.amountOf( policy: PolicyId, name: bytes ): int
+    preludeScope.program.functions.set(valueMapLovelacesName, new TirInlineClosedIR(new TirFuncT([valueMap_t], int_t), (ctx) => IRNative._sortedValueLovelaces, SourceRange.unknown));
+    // ValueMap.amountOf( policy: PolicyId, name: bytes ): int
     // The IR native _amountOfValue is curried as: (isPolicy)(value)(isTokenName) => int
     // where isPolicy and isTokenName are equality-check predicates.
     // This wrapper adapts (self, policy, tokenName) => _amountOfValue(p => equalsByteString(p, policy))(self)(tn => equalsByteString(tn, tokenName))
-    preludeScope.program.functions.set(valueAmountOfName, new TirInlineClosedIR(new TirFuncT([value_t, policyId_t, bytes_t], int_t), (ctx) => {
+    preludeScope.program.functions.set(valueMapAmountOfName, new TirInlineClosedIR(new TirFuncT([valueMap_t, policyId_t, bytes_t], int_t), (ctx) => {
         const self = Symbol("amtOf_self");
         const policy = Symbol("amtOf_policy");
         const tokenName = Symbol("amtOf_tokenName");
@@ -578,37 +607,51 @@ export function populatePreludeScope(program) {
         // isTokenName predicate: \tn -> equalsByteString(tn, tokenName)
         _ir_apps(IRNative.equalsByteString, new IRVar(tokenName))));
     }, SourceRange.unknown));
-    /* // TODO
-    untagged struct FlatValueEntry {
-        policy: PolicyId,
-        name: bytes,
-        amount: int
-    }
-
-    type FlatValue = List<FlatValueEntry>;
-
-    type Value implements {
-        amountOf( policy: PolicyId, name: bytes ): int
-        {
-            return native.valueAmountOf( this, policy, name );
-        }
-        lovelaces(): int
-        {
-            return this.amountOf( #, # );
-        }
-        flatten(): FlatValue
-        {
-            return native.flattenValue( this );
-        }
-    }
-
-    type FlatValue implements {
-        unflatten(): Value
-        {
-            return native.unflattenValue( this );
-        }
-    }
-    */
+    // Native `Value` (ConstTyTag.value). Methods route to the value builtins.
+    const value_native_t = program.types.get(TirValueT.toTirTypeKey());
+    if (!value_native_t)
+        throw new Error("expected native Value type registered");
+    const value_t = _defineUnambigousAlias("Value", value_native_t, new Map([
+        ["lovelaces", valueLovelacesName],
+        ["amountOf", valueAmountOfName],
+        ["insert", valueInsertCoinName],
+        ["union", valueUnionName],
+        ["contains", valueContainsName],
+        ["scale", valueScaleName],
+        ["toData", valueToDataName],
+    ]));
+    // Value.lovelaces(): int  -- lookupCoin "" "" self
+    preludeScope.program.functions.set(valueLovelacesName, new TirInlineClosedIR(new TirFuncT([value_t], int_t), (ctx) => {
+        const self = Symbol("value_lovelaces_self");
+        return new IRFunc([self], _ir_apps(IRNative.lookupCoin, IRConst.bytes(new Uint8Array(0)), IRConst.bytes(new Uint8Array(0)), new IRVar(self)));
+    }, SourceRange.unknown));
+    // Value.amountOf( policy, name ): int  -- lookupCoin policy name self
+    preludeScope.program.functions.set(valueAmountOfName, new TirInlineClosedIR(new TirFuncT([value_t, policyId_t, bytes_t], int_t), (ctx) => {
+        const self = Symbol("value_amountOf_self");
+        const policy = Symbol("value_amountOf_policy");
+        const tokenName = Symbol("value_amountOf_tokenName");
+        return new IRFunc([self, policy, tokenName], _ir_apps(IRNative.lookupCoin, new IRVar(policy), new IRVar(tokenName), new IRVar(self)));
+    }, SourceRange.unknown));
+    // Value.insert( policy, name, amount ): Value -- insertCoin policy name amount self
+    preludeScope.program.functions.set(valueInsertCoinName, new TirInlineClosedIR(new TirFuncT([value_t, policyId_t, bytes_t, int_t], value_t), (ctx) => {
+        const self = Symbol("value_insert_self");
+        const policy = Symbol("value_insert_policy");
+        const tokenName = Symbol("value_insert_tokenName");
+        const amount = Symbol("value_insert_amount");
+        return new IRFunc([self, policy, tokenName, amount], _ir_apps(IRNative.insertCoin, new IRVar(policy), new IRVar(tokenName), new IRVar(amount), new IRVar(self)));
+    }, SourceRange.unknown));
+    // Value.union( other ): Value -- unionValue self other
+    preludeScope.program.functions.set(valueUnionName, new TirInlineClosedIR(new TirFuncT([value_t, value_t], value_t), (ctx) => IRNative.unionValue, SourceRange.unknown));
+    // Value.contains( other ): bool -- valueContains self other
+    preludeScope.program.functions.set(valueContainsName, new TirInlineClosedIR(new TirFuncT([value_t, value_t], bool_t), (ctx) => IRNative.valueContains, SourceRange.unknown));
+    // Value.scale( factor ): Value -- scaleValue factor self
+    preludeScope.program.functions.set(valueScaleName, new TirInlineClosedIR(new TirFuncT([value_t, int_t], value_t), (ctx) => {
+        const self = Symbol("value_scale_self");
+        const factor = Symbol("value_scale_factor");
+        return new IRFunc([self, factor], _ir_apps(IRNative.scaleValue, new IRVar(factor), new IRVar(self)));
+    }, SourceRange.unknown));
+    // Value.toData(): data -- valueData self
+    preludeScope.program.functions.set(valueToDataName, new TirInlineClosedIR(new TirFuncT([value_t], data_t), (ctx) => IRNative.valueData, SourceRange.unknown));
     // struct OutputDatum {
     //     NoDatum {}
     //     DatumHash { hash: Hash32 }

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

@@ -0,0 +1,21 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { AstFuncName, TirFuncName } from "../../AstCompiler/scope/AstScope.js";
+import { ITirType, TirType } from "./TirType.js";
+export declare class TirEnumType implements ITirType {
+    readonly name: string;
+    readonly fileUid: string;
+    readonly members: readonly string[];
+    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
+    constructor(name: string, fileUid: string, members: readonly string[], methodNamesPtr: Map<AstFuncName, TirFuncName>);
+    indexOf(member: string): number;
+    isConcrete(): boolean;
+    hasDataEncoding(): boolean;
+    toString(): string;
+    toAstName(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toUplcConstType(): ConstType;
+    clone(): TirEnumType;
+}
+export declare function isTirEnumType(thing: any): thing is TirEnumType;
+export declare function getEnumType(type: TirType | undefined): TirEnumType | undefined;

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

@@ -0,0 +1,36 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { constT } from "@harmoniclabs/uplc";
+import { TirAliasType } from "./TirAliasType.js";
+export class TirEnumType {
+    name;
+    fileUid;
+    members;
+    methodNamesPtr;
+    constructor(name, fileUid, members, methodNamesPtr) {
+        this.name = name;
+        this.fileUid = fileUid;
+        this.members = members;
+        this.methodNamesPtr = methodNamesPtr;
+    }
+    indexOf(member) {
+        return this.members.indexOf(member);
+    }
+    isConcrete() { return true; }
+    hasDataEncoding() { return true; }
+    toString() { return this.name; }
+    toAstName() { return this.name; }
+    toTirTypeKey() { return "enum_" + this.name + "_" + this.fileUid; }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    toUplcConstType() { return constT.int; }
+    clone() {
+        return new TirEnumType(this.name, this.fileUid, this.members.slice(), this.methodNamesPtr);
+    }
+}
+export function isTirEnumType(thing) {
+    return isObject(thing) && thing instanceof TirEnumType;
+}
+export function getEnumType(type) {
+    while (type instanceof TirAliasType)
+        type = type.aliased;
+    return type instanceof TirEnumType ? type : undefined;
+}

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

@@ -12,9 +12,11 @@ import { TirDataOptT } from "./native/Optional/data.js";
 import { TirSopOptT } from "./native/Optional/sop.js";
 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>;
+import { TirArrayT } from "./native/array.js";
+import { TirValueT } from "./native/value.js";
+export type TirNamedDestructableNativeType = TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirArrayT<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 | TirBlsG1T | TirBlsG2T | TirMlResultT;
+export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirArrayT<TirType> | TirValueT | 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();

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

@@ -11,11 +11,14 @@ import { TirDataOptT } from "./native/Optional/data.js";
 import { TirSopOptT } from "./native/Optional/sop.js";
 import { TirStringT } from "./native/string.js";
 import { TirVoidT } from "./native/void.js";
+import { TirArrayT } from "./native/array.js";
+import { TirValueT } from "./native/value.js";
 export function isTirNamedDestructableNativeType(t) {
     return (t instanceof TirDataT
         || t instanceof TirDataOptT
         || t instanceof TirSopOptT
         || t instanceof TirListT
+        || t instanceof TirArrayT
         || t instanceof TirLinearMapT);
 }
 export function isTirNativeType(t) {
@@ -28,6 +31,8 @@ export function isTirNativeType(t) {
         || t instanceof TirDataOptT
         || t instanceof TirSopOptT
         || t instanceof TirListT
+        || t instanceof TirArrayT
+        || t instanceof TirValueT
         || t instanceof TirLinearMapT
         || t instanceof TirLinearMapEntryT
         || t instanceof TirFuncT // =>

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

@@ -0,0 +1,16 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirType, ITirType } from "../../TirType.js";
+export declare class TirArrayT<T extends TirType = TirType> implements ITirType {
+    readonly typeArg: T;
+    constructor(typeArg: T);
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirArrayT<T>;
+    toUplcConstType(): ConstType;
+}

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

@@ -0,0 +1,38 @@
+import { constT } from "@harmoniclabs/uplc";
+import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
+export class TirArrayT {
+    typeArg;
+    constructor(typeArg) {
+        this.typeArg = typeArg;
+    }
+    hasDataEncoding() { return this.typeArg.hasDataEncoding(); }
+    static toTirTypeKey() {
+        return "Array";
+    }
+    toTirTypeKey() {
+        return TirArrayT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
+    }
+    toString() {
+        return `${this.toTirTypeKey()}<${this.typeArg.toString()}>`;
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.typeArg.isConcrete();
+        return this._isConcrete ?? false;
+    }
+    clone() {
+        const result = new TirArrayT(this.typeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        return constT.arrayOf(this.typeArg.toUplcConstType());
+    }
+}

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

@@ -1,4 +1,5 @@
 export * from "./Optional/index.js";
+export * from "./array.js";
 export * from "./bool.js";
 export * from "./bytes.js";
 export * from "./data.js";
@@ -8,4 +9,5 @@ export * from "./linearMap.js";
 export * from "./linearMapEntry.js";
 export * from "./list.js";
 export * from "./string.js";
+export * from "./value.js";
 export * from "./void.js";