@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/IR/IRNodes/IRVar.js

@@ -1,49 +1,43 @@
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { hashVarSym } from "./utils/hashVarSym.js";
+import { UPLCVar } from "@harmoniclabs/uplc";
 export class IRVar {
+    _creationStack;
+    meta;
+    name;
+    constructor(name, _unsafeHash) {
+        if (!(typeof name === "symbol"
+            && typeof name.description === "string"
+            && name.description.length > 0))
+            throw new BasePlutsError("invalid name for IRVar");
+        this.name = name;
+        this._parent = undefined;
+        this.meta = {};
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+        this._creationStack = (new Error()).stack ?? "unknown";
+    }
+    toUPLC(ctx) {
+        return new UPLCVar(ctx.getVarAccessDbn(this.name));
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = getVarHashAtDbn(this.dbn);
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRVar.tag, hashVarSym(this.name)));
         return this._hash;
     }
-    /**
-     * called inside the dbn setter
-     */
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return true; }
-    _dbn;
-    /**
-     * the IR DeBruijn index is not necessarly the same of the UPLC
-     * ( more ofthen than not it won't be the same )
-     *
-     * this is because in the IR things like `IRLetted` and `IRHoisted`
-     * are skipping some DeBruijin levels that are instead present
-     * in the final UPLC
-    **/
-    get dbn() { return this._dbn; }
-    set dbn(newDbn) {
-        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0)) {
-            // console.log( e.stack );
-            throw new BasePlutsError("invalid index for an `IRVar` instance; new DeBruijn was: " + newDbn);
-        }
-        if (newDbn === this._dbn)
-            return; // everything ok
-        this.markHashAsInvalid();
-        this._dbn = newDbn;
-    }
     static get kind() { return IRNodeKind.Var; }
     get kind() { return IRVar.kind; }
     static get tag() { return new Uint8Array([IRVar.kind]); }
-    meta;
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -57,37 +51,15 @@ export class IRVar {
         // change parent
         this._parent = newParent;
     }
-    constructor(DeBruijn) {
-        Object.defineProperty(this, "meta", {
-            value: {},
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        this._hash = undefined;
-        DeBruijn = typeof DeBruijn === "number" ? DeBruijn : Number(DeBruijn);
-        this._dbn = DeBruijn;
-        // call setter to check for validity
-        this.dbn = DeBruijn;
-        this._parent = undefined;
-    }
+    children() { return []; }
     clone() {
-        return new IRVar(this.dbn);
+        return new IRVar(this.name, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
         return {
             type: "IRVar",
-            dbn: this.dbn
+            name: this.name
         };
     }
 }
-const _bdnVarHashCache = new Map();
-function getVarHashAtDbn(dbn) {
-    const cached = _bdnVarHashCache.get(dbn)?.deref();
-    if (isIRHash(cached))
-        return cached;
-    const hash = hashIrData(concatUint8Arr(IRVar.tag, positiveIntAsBytes(dbn)));
-    _bdnVarHashCache.set(dbn, new WeakRef(hash));
-    return hash;
-}

package/dist/IR/IRNodes/utils/dependsByDbns.d.ts

@@ -2,4 +2,4 @@ import { IRTerm } from "../../IRTerm.js";
 /**
  * returns true if the term depends on *ANY* of the deBrujin indices specified
  */
-export declare function dependsByDbns(term: IRTerm, depsDbns: readonly number[]): boolean;
+export declare function dependsByVars(term: IRTerm, depsVars: readonly symbol[]): boolean;

package/dist/IR/IRNodes/utils/dependsByDbns.js

@@ -4,20 +4,14 @@ import { IRVar } from "../IRVar.js";
 /**
  * returns true if the term depends on *ANY* of the deBrujin indices specified
  */
-export function dependsByDbns(term, depsDbns) {
-    if (depsDbns.length === 0)
+export function dependsByVars(term, depsVars) {
+    if (depsVars.length === 0)
         return false;
     let doesDepend = false;
     iterTree(term, (node, diff) => {
-        if (node instanceof IRVar ||
-            node instanceof IRSelfCall) {
-            doesDepend = doesDepend || depsDbns.some(dbn => {
-                const realDbn = dbn + diff;
-                // realDbn === 0 implies no variables are in scope
-                // so if node.dbn === 0 and realDbn === 1 then the 
-                // variable is pointing to that definition
-                return node.dbn === realDbn;
-            });
+        if (node instanceof IRVar
+            || node instanceof IRSelfCall) {
+            doesDepend = doesDepend || depsVars.some(sym => node.name === sym);
         }
     }, 
     // shouldSkipNode

package/dist/IR/IRNodes/utils/hashVarSym.d.ts

@@ -0,0 +1 @@
+export declare function hashVarSym(s: symbol): Uint8Array;

package/dist/IR/IRNodes/utils/hashVarSym.js

@@ -0,0 +1,37 @@
+// HASH GENERATOR
+import { fromHex } from "@harmoniclabs/uint8array-utils";
+const MAX_SAFE_INTEGER = Number(globalThis.Number?.MAX_SAFE_INTEGER ?? ((2 ** 53) - 1));
+const MIN_SAFE_INTEGER = Number(globalThis.Number?.MIN_SAFE_INTEGER ?? -MAX_SAFE_INTEGER);
+/// @ts-ignore Type 'symbol' does not satisfy the constraint 'object'.
+const _sym_to_hash = new WeakMap();
+// we cannot store the symbol itself as it would prevent garbage collection
+/// @ts-ignore Type 'symbol' does not satisfy the constraint 'object'.
+const _hash_to_sym = new Map();
+let _next_hash = MIN_SAFE_INTEGER;
+const unusedHashes = [];
+function _collectUnusedHashes() {
+    for (const [h, s] of _hash_to_sym) {
+        const newSymbol = s.deref();
+        if (!newSymbol
+            || !_sym_to_hash.has(newSymbol)) {
+            _hash_to_sym.delete(h);
+            unusedHashes.push(h);
+        }
+    }
+}
+export function hashVarSym(s) {
+    const limitReached = _next_hash >= MAX_SAFE_INTEGER;
+    if (_next_hash % 0xffff === 0
+        || limitReached)
+        _collectUnusedHashes();
+    if (limitReached
+        && unusedHashes.length <= 0)
+        throw new Error("ran out of IR hashes");
+    const result_hash = unusedHashes.shift() ?? _next_hash++;
+    _sym_to_hash.set(s, result_hash);
+    /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<symbol>'
+    _hash_to_sym.set(result_hash, new WeakRef(s));
+    return fromHex((BigInt(result_hash) + BigInt(MAX_SAFE_INTEGER))
+        .toString(16)
+        .padStart(16, "0"));
+}

package/dist/IR/IRNodes/utils/makeArrayLikeProxy.d.ts

@@ -1 +1,2 @@
-export declare function makeArrayLikeProxy<T>(arr: ArrayLike<T>, isValidElem: (elem: T) => boolean, initModifyElem: (elem: T) => T, modifyElem: (elem: T, oldElem: T) => T): ArrayLike<T>;
+import { MutArrayLike } from "../../utils/MutArrayLike.js";
+export declare function makeArrayLikeProxy<T>(arr: ArrayLike<T>, isValidElem: (elem: T) => boolean, initModifyElem: (elem: T) => T, modifyElem: (elem: T, oldElem: T) => T): MutArrayLike<T>;

package/dist/IR/IRTerm.d.ts

@@ -12,4 +12,11 @@ import { IRConstr } from "./IRNodes/IRConstr.js";
 import { IRCase } from "./IRNodes/IRCase.js";
 import { IRRecursive } from "./IRNodes/IRRecursive.js";
 import { IRSelfCall } from "./IRNodes/IRSelfCall.js";
+import { IHash } from "./interfaces/index.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "./toUPLC/ctx/ToUplcCtx.js";
 export type IRTerm = IRVar | IRFunc | IRApp | IRConst | IRNative | IRLetted | IRHoisted | IRError | IRForced | IRDelayed | IRConstr | IRCase | IRRecursive | IRSelfCall;
+export interface IIRTerm extends IHash {
+    children(): IRTerm[];
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
+}

package/dist/IR/toUPLC/_internal/_modifyChildFromTo.js

@@ -138,4 +138,7 @@ export function _modifyChildFromTo(parent, currentChild, newChild) {
         parent.value = newChild;
         return;
     }
+    const tsEnsureExhaustiveCheck = parent;
+    throw new Error("unknown parent type in '_modifyChildFromTo': " +
+        parent.constructor?.name);
 }

package/dist/IR/toUPLC/_internal/findAll.js

@@ -1,11 +1,4 @@
-import { IRCase, IRConstr } from "../../IRNodes/index.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
-import { IRFunc } from "../../IRNodes/IRFunc.js";
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { IRRecursive } from "../../IRNodes/IRRecursive.js";
 export function findAll(term, predicate) {
     const stack = [term];
     const result = [];
@@ -13,37 +6,7 @@ export function findAll(term, predicate) {
         const t = stack.pop();
         if (predicate(t))
             result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRHoisted) {
-            stack.push(t.hoisted);
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            // same stuff as the hoisted terms
-            // the only difference is that depth is then incremented
-            // once the letted term reaches its final position
-            stack.push(t.value);
-            continue;
-        }
+        stack.push(...t.children());
     }
     return result;
 }
@@ -54,46 +17,12 @@ export function findAllNoHoisted(term, predicate) {
         const t = stack.pop();
         if (predicate(t))
             result.push(t);
-        if (t instanceof IRApp) {
-            stack.push(t.fn, t.arg);
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push(t.constrTerm, ...t.continuations);
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...t.fields);
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push(t.delayed);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push(t.forced);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push(t.body);
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push(t.body);
-            continue;
-        }
         if (t instanceof IRHoisted) {
             // this is `findAllNoHoisted` remember?
             // stack.push( t.hoisted );
             continue;
         }
-        if (t instanceof IRLetted) {
-            // same stuff as the hoisted terms
-            // the only difference is that depth is then incremented
-            // once the letted term reaches its final position
-            stack.push(t.value);
-            continue;
-        }
+        stack.push(...t.children());
     }
     return result;
 }

package/dist/IR/toUPLC/_internal/getDebruijnInTerm.js

@@ -1,12 +1,7 @@
 import { equalIrHash } from "../../IRHash.js";
-import { IRCase, IRConstr } from "../../IRNodes/index.js";
-import { IRApp } from "../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../IRNodes/IRForced.js";
+import { IRHoisted } from "../../IRNodes/index.js";
 import { IRFunc } from "../../IRNodes/IRFunc.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../IRNodes/IRRecursive.js";
-import { mapArrayLike } from "../../IRNodes/utils/mapArrayLike.js";
 export function getDebruijnInTerm(root, termToFind) {
     const termTofindHash = termToFind.hash;
     const stack = [{ term: root, dbn: 0 }];
@@ -14,38 +9,16 @@ export function getDebruijnInTerm(root, termToFind) {
         const { term, dbn } = stack.pop();
         if (term === termToFind || equalIrHash(term.hash, termTofindHash))
             return dbn;
-        if (term instanceof IRApp) {
-            stack.push({ term: term.fn, dbn }, { term: term.arg, dbn });
-            continue;
-        }
-        if (term instanceof IRCase) {
-            stack.push({ term: term.constrTerm, dbn }, ...mapArrayLike(term.continuations, (continuation) => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (term instanceof IRConstr) {
-            stack.push(...mapArrayLike(term.fields, (field) => ({ term: field, dbn })));
-            continue;
-        }
-        if (term instanceof IRDelayed) {
-            stack.push({ term: term.delayed, dbn });
-            continue;
-        }
-        if (term instanceof IRForced) {
-            stack.push({ term: term.forced, dbn });
-            continue;
-        }
-        if (term instanceof IRFunc) {
+        if (term instanceof IRFunc
+            || term instanceof IRRecursive) {
+            // new variable in scope
             stack.push({ term: term.body, dbn: dbn + term.arity });
             continue;
         }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
+        if (term instanceof IRHoisted) {
             continue;
-        }
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
-            continue;
-        }
+        } // skip hoisted since closed
+        stack.push(...term.children().map(t => ({ term: t, dbn })));
     }
     return -1;
 }

package/dist/IR/toUPLC/_internal/iterTree.js

@@ -7,6 +7,7 @@ import { IRFunc } from "../../IRNodes/IRFunc.js";
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { sanifyTree } from "../subRoutines/sanifyTree.js";
 export function iterTree(_term, fn, 
 // necessary for letted hash calculation (exclude hoisted)
 shouldSkipNode, shouldExit) {
@@ -32,31 +33,14 @@ shouldSkipNode, shouldExit) {
             continue;
         }
         if (t instanceof IRApp) {
-            // sanifyTree as we go
-            if (t.fn.parent !== t)
-                t.fn = t.fn.clone();
-            if (t.arg.parent !== t)
-                t.arg = t.arg.clone();
             stack.push({ term: t.fn, dbn }, { term: t.arg, dbn, shouldPopIfParentIsModified: true });
             continue;
         }
         if (t instanceof IRCase) {
-            // sanifyTree as we go
-            if (t.constrTerm.parent !== t)
-                t.constrTerm = t.constrTerm.clone();
-            for (let i = 0; i < t.continuations.length; i++) {
-                if (t.continuations[i].parent !== t)
-                    t.continuations[i] = t.continuations[i].clone();
-            }
             stack.push({ term: t.constrTerm, dbn }, ...Array.from(t.continuations).map(cont => ({ term: cont, dbn, shouldPopIfParentIsModified: true })));
             continue;
         }
         if (t instanceof IRConstr) {
-            // sanifyTree as we go
-            for (let i = 0; i < t.fields.length; i++) {
-                if (t.fields[i].parent !== t)
-                    t.fields[i] = t.fields[i].clone();
-            }
             stack.push(...Array.from(t.fields).map((f, i) => ({ term: f, dbn, shouldPopIfParentIsModified: i !== 0 })));
             continue;
         }
@@ -89,5 +73,7 @@ shouldSkipNode, shouldExit) {
             stack.push({ term: t.value, dbn });
             continue;
         }
+        stack.push(...t.children().map(c => ({ term: c, dbn })));
     }
+    sanifyTree(_term);
 }

package/dist/IR/toUPLC/common_hoisted.d.ts

@@ -0,0 +1,2 @@
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+export declare const hoisted_constr1_empty: IRHoisted;

package/dist/IR/toUPLC/common_hoisted.js

@@ -0,0 +1,4 @@
+import { DataConstr } from "@harmoniclabs/plutus-data";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+export const hoisted_constr1_empty = new IRHoisted(IRConst.data(new DataConstr(1, [])));

package/dist/IR/toUPLC/compileIRToUPLC.d.ts

@@ -1,4 +1,4 @@
-import type { UPLCTerm } from "@harmoniclabs/uplc";
+import { type UPLCTerm } from "@harmoniclabs/uplc";
 import type { IRTerm } from "../IRTerm.js";
 import { CompilerOptions } from "./CompilerOptions.js";
 export declare function compileIRToUPLC(term: IRTerm, paritalOptions?: Partial<CompilerOptions>): UPLCTerm;

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -1,7 +1,8 @@
+import { isClosedTerm, prettyUPLC } from "@harmoniclabs/uplc";
 import { IRLetted } from "../IRNodes/IRLetted.js";
 import { IRHoisted } from "../IRNodes/IRHoisted.js";
 import { IRConst } from "../IRNodes/IRConst.js";
-import { _irToUplc } from "./_internal/_irToUplc.js";
+import { _makeAllNegativeNativesHoisted } from "./_internal/_makeAllNegativeNativesHoisted.js";
 import { includesNode } from "./_internal/includesNode.js";
 import { handleLettedAndReturnRoot } from "./subRoutines/handleLetted/index.js";
 import { handleHoistedAndReturnRoot } from "./subRoutines/handleHoistedAndReturnRoot/index.js";
@@ -11,20 +12,26 @@ import { hoistForcedNatives } from "./subRoutines/hoistForcedNatives.js";
 import { handleRootRecursiveTerm } from "./subRoutines/handleRecursiveTerms.js";
 import { completeCompilerOptions, defaultOptions } from "./CompilerOptions.js";
 import { replaceHoistedWithLetted } from "./subRoutines/replaceHoistedWithLetted.js";
-import { IRCase, IRConstr, IRNative } from "../IRNodes/index.js";
+import { IRCase, IRConstr, IRFunc, IRNative } from "../IRNodes/index.js";
 import { replaceForcedNativesWithHoisted } from "./subRoutines/replaceForcedNativesWithHoisted.js";
-import { performUplcOptimizationsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/index.js";
+import { performUplcOptimizationsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/performUplcOptimizationsAndReturnRoot.js";
+import { rewriteNativesAppliedToConstantsAndReturnRoot } from "./subRoutines/rewriteNativesAppliedToConstantsAndReturnRoot.js";
+import { _debug_assertClosedIR } from "../utils/index.js";
+import { ToUplcCtx } from "./ctx/ToUplcCtx.js";
+import { removeUnusedVarsAndReturnRoot } from "./subRoutines/removeUnusuedVarsAndReturnRoot/removeUnusuedVarsAndReturnRoot.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
 export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // most of the time we are just compiling small
     // pre-execuded terms (hence constants)
     if (term instanceof IRConst)
-        return _irToUplc(term).term;
+        return term.toUPLC();
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------------- init  --------------------------------- //
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     const options = completeCompilerOptions(paritalOptions);
+    const debugAsserts = options.debugAsserts ?? false;
     // unwrap top level letted and hoisted;
     while (term instanceof IRLetted || term instanceof IRHoisted) {
         // replace with value
@@ -32,14 +39,20 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         // forget the parent; this is the new root
         term.parent = undefined;
     }
-    // _makeAllNegativeNativesHoisted( term );
+    debugAsserts && _debug_assertions(term);
+    // term = preEvaluateDefinedTermsAndReturnRoot( term );
+    term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
+    // removing unused variables BEFORE going into the rest of the compilation
+    // helps letted terms to find a better spot (and possibly be inlined instead of hoisted)
+    term = removeUnusedVarsAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
+    _makeAllNegativeNativesHoisted(term);
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // ----------------------------- optimizations ----------------------------- //
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
-    // --------------------------- optimize natives  --------------------------- //
-    // at constant -> head and tails
     // --------------------- optimize recursive functions  --------------------- //
     // avoid passing whole structs
     // take letted terms outside
@@ -52,6 +65,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     term = replaceNativesAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // unwrap top level letted and hoisted;
     // some natives may be converted to hoisted;
     // this is really just an edge case
@@ -64,23 +78,32 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     if (term instanceof IRNative ||
         term instanceof IRConst // while we are at it
     )
-        return _irToUplc(term).term;
-    if (options.delayHoists)
-        replaceForcedNativesWithHoisted(term);
+        return term.toUPLC();
+    replaceForcedNativesWithHoisted(term);
+    debugAsserts && _debug_assertions(term);
     if (options.delayHoists)
         replaceHoistedWithLetted(term);
     else
         replaceClosedLettedWithHoisted(term);
+    debugAsserts && _debug_assertions(term);
+    if (debugAsserts
+        && options.delayHoists
+        && includesNode(term, node => node instanceof IRHoisted)) {
+        throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
+    }
     // handle letted before hoisted because the tree is smaller
     // and we also have less letted dependecies to handle
     term = handleLettedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     term = handleHoistedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // replaced hoisted terms might include new letted terms
-    while (includesNode(term, node => node instanceof IRLetted ||
-        node instanceof IRHoisted)) {
+    while (includesNode(term, node => node instanceof IRLetted
+        || node instanceof IRHoisted)) {
         term = handleLettedAndReturnRoot(term);
         term = handleHoistedAndReturnRoot(term);
     }
+    debugAsserts && _debug_assertions(term);
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------- translate to UPLC --------------------------- //
@@ -94,12 +117,33 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // if( options.delayHoists ) replaceHoistedWithLetted( term );
     // handle new hoisted terms
     term = handleHoistedAndReturnRoot(term);
+    debugAsserts && _debug_assertions(term);
     // strictly necessary to check the options
     // otherwise forced natives where already hoisted
     // will be re-hosited; causeing uselsess evaluations
     if (!options.delayHoists)
         term = hoistForcedNatives(term);
+    debugAsserts && _debug_assertions(term);
     // at this point we expect the IR to be translable 1:1 to UPLC
+    // The loop is needed because after inlining some params, 
+    // new params in outer (or sibling) functions can become 
+    // single‑use; a single bottom‑up pass doesn’t 
+    // “see” those future states.
+    //
+    // ALWAYS AT LEAST 1 ITERATION
+    // const maxInlineIterations = Math.max( 3, 1 );
+    // for(
+    //     let somethingWasInlined = true,
+    //         inlineIterations = 0;
+    //     somethingWasInlined
+    //     && inlineIterations < maxInlineIterations;
+    //     inlineIterations++
+    // ) {
+    //     const inlineResult = inlineSingleUseAndReturnRoot( term );
+    //     term = inlineResult.term;
+    //     somethingWasInlined = inlineResult.somethingWasInlined;
+    // }
+    term = removeUnusedVarsAndReturnRoot(term);
     term = performUplcOptimizationsAndReturnRoot(term, options);
     if (options.addMarker &&
         options.targetUplcVersion.major >= 1 &&
@@ -111,8 +155,41 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
             IRConst.int(42)
         ]);
     }
-    const srcmap = {};
-    const uplc = _irToUplc(term, srcmap).term;
+    // let irJson = prettyIR( term );
+    // console.log(
+    //     "final IR before UPLC translation:\n",
+    //     irJson.text,
+    //     JSON.stringify( onlyHoistedAndLetted( irJson ) )
+    // );
+    debugAsserts && _debug_assertions(term);
+    // const srcmap = {};
+    const uplc = term.toUPLC(ToUplcCtx.root());
+    if (!isClosedTerm(uplc)) {
+        console.log(prettyUPLC(uplc));
+        throw new Error("compileIRToUPLC: final UPLC term is not closed:\n" +
+            "This is a compiler internal error; please open an issue on github so we can fix this.");
+    }
     // console.log( "srcmap", srcmap );
     return uplc;
 }
+function _debug_assertions(term) {
+    _debug_assertClosedIR(term);
+    _debug_assertNoDoubleVars(term);
+}
+function _debug_assertNoDoubleVars(term) {
+    const seen = new Set();
+    const stack = [term];
+    let current = term;
+    while (current = stack.pop()) {
+        if (current instanceof IRFunc
+            || current instanceof IRRecursive) {
+            for (const p of current.params) {
+                if (seen.has(p)) {
+                    throw new Error("debug assertion failed: double variable detected");
+                }
+                seen.add(p);
+            }
+        }
+        stack.push(...current.children());
+    }
+}

package/dist/IR/toUPLC/ctx/ToUplcCtx.d.ts

@@ -0,0 +1,16 @@
+export declare class ToUplcCtx {
+    readonly parent: ToUplcCtx | undefined;
+    readonly ctxMap: Map<symbol, ToUplcCtx>;
+    private readonly _variables;
+    private get _parentDbn();
+    get dbn(): number;
+    private _frozen;
+    constructor(parent: ToUplcCtx | undefined, variables: symbol[]);
+    static root(): ToUplcCtx;
+    newChild(variables: symbol[]): ToUplcCtx;
+    getVarDeclDbn(sym: symbol): number;
+    getVarAccessDbn(sym: symbol): number;
+    toJson(): any;
+    allVars(): symbol[];
+    expectedDbn(sym: symbol): number;
+}