@harmoniclabs/pebble 0.2.0 → 0.3.1

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileAddExpr.js

@@ -1,20 +1,33 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirAddExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileAddExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    // Probe the left first with no hint; if it turns out to be a Value, we
+    // accept the same on the right and lower to `unionValue` in TirAddExpr.
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, leftProbe.type);
+        if (!right)
+            return undefined;
+        if (!(getUnaliased(right.type) instanceof TirValueT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), "Value");
+        return new TirAddExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
     const right = _compileExpr(ctx, expr.right, int_t);
     if (!right)
         return undefined;
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirAddExpr(left, right, 
+    return new TirAddExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileEqualExpr.js

@@ -1,12 +1,14 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    const leftType = left.type;
+    // enums lower to ints at runtime, so allow comparing against ints
+    const leftType = normalizeEnumToInt(left.type, ctx.program.stdTypes.int);
     const right = _compileExpr(ctx, expr.right, leftType);
     if (!right)
         return undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanEqualExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 // only aviable for ints and bytes
 export function _compileGreaterThanEqualExpr(ctx, expr, typeHint) {
@@ -13,7 +14,7 @@ export function _compileGreaterThanEqualExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileGreaterThanExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirGreaterThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileGreaterThanExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
@@ -12,7 +13,7 @@ export function _compileGreaterThanExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanEqualExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { int_t, bytes_t } from "../../../../tir/program/stdScope/stdScope.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
@@ -11,7 +12,7 @@ export function _compileLessThanEqualExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileLessThanExpr.js

@@ -2,6 +2,7 @@ import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.ge
 import { TirLessThanExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { TirAliasType } from "../../../../tir/types/TirAliasType.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileLessThanExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
@@ -12,7 +13,7 @@ export function _compileLessThanExpr(ctx, expr, typeHint) {
     if (!canAssignTo(left.type, int_t)
         && !canAssignTo(left.type, bytes_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    let leftType = left.type;
+    let leftType = normalizeEnumToInt(left.type, int_t);
     while (leftType instanceof TirAliasType)
         leftType = leftType.aliased;
     const right = _compileExpr(ctx, expr.right, leftType);

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileMultExpr.js

@@ -1,20 +1,38 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirMultExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileMultExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    // Probe both sides without hints so we can disambiguate
+    // (int * Value) / (Value * int) / (int * int).
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
-    const right = _compileExpr(ctx, expr.right, int_t);
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, int_t);
+        if (!right)
+            return undefined;
+        if (!canAssignTo(right.type, int_t))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
+    // left is int — right may be int (regular product) or Value (scaleValue).
+    const right = _compileExpr(ctx, expr.right, undefined);
     if (!right)
         return undefined;
+    const rightTy = getUnaliased(right.type);
+    if (rightTy instanceof TirValueT) {
+        return new TirMultExpr(leftProbe, right, expr.range);
+    }
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirMultExpr(left, right, 
+    return new TirMultExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileNotEqualExpr.js

@@ -1,12 +1,13 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirNotEqualExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { normalizeEnumToInt } from "../../../../tir/types/utils/normalizeEnumToInt.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileNotEqualExpr(ctx, expr, typeHint) {
     const left = _compileExpr(ctx, expr.left, typeHint);
     if (!left)
         return undefined;
-    const leftType = left.type;
+    const leftType = normalizeEnumToInt(left.type, ctx.program.stdTypes.int);
     const right = _compileExpr(ctx, expr.right, leftType);
     if (!right)
         return undefined;

package/dist/compiler/AstCompiler/internal/exprs/binary/_compileSubExpr.js

@@ -1,20 +1,31 @@
 import { DiagnosticCode } from "../../../../../diagnostics/diagnosticMessages.generated.js";
 import { TirSubExpr } from "../../../../tir/expressions/binary/TirBinaryExpr.js";
+import { TirValueT } from "../../../../tir/types/TirNativeType/native/value.js";
 import { canAssignTo } from "../../../../tir/types/utils/canAssignTo.js";
+import { getUnaliased } from "../../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../_compileExpr.js";
 export function _compileSubExpr(ctx, expr, _typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const left = _compileExpr(ctx, expr.left, int_t);
-    if (!left)
+    const leftProbe = _compileExpr(ctx, expr.left, undefined);
+    if (!leftProbe)
         return undefined;
-    if (!canAssignTo(left.type, int_t))
-        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, left.type.toString(), int_t.toString());
+    const leftTy = getUnaliased(leftProbe.type);
+    if (leftTy instanceof TirValueT) {
+        const right = _compileExpr(ctx, expr.right, leftProbe.type);
+        if (!right)
+            return undefined;
+        if (!(getUnaliased(right.type) instanceof TirValueT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), "Value");
+        return new TirSubExpr(leftProbe, right, expr.range);
+    }
+    if (!canAssignTo(leftProbe.type, int_t))
+        return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.left.range, leftProbe.type.toString(), int_t.toString());
     const right = _compileExpr(ctx, expr.right, int_t);
     if (!right)
         return undefined;
     if (!canAssignTo(right.type, int_t))
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.right.range, right.type.toString(), int_t.toString());
-    return new TirSubExpr(left, right, 
+    return new TirSubExpr(leftProbe, right, 
     // implicit int type,
     expr.range);
 }

package/dist/compiler/AstCompiler/internal/statements/_compileMatchStmt.js

@@ -11,6 +11,7 @@ import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
 import { TirDataOptT } from "../../../tir/types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
 import { isTirStructType, TirDataStructType, TirSoPStructType } from "../../../tir/types/TirStructType.js";
+import { TirEnumType } from "../../../tir/types/TirEnumType.js";
 import { getDeconstructableType } from "../../../tir/types/utils/getDeconstructableType.js";
 import { wrapManyStatements } from "../../utils/wrapManyStatementsOrReturnSame.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
@@ -32,11 +33,13 @@ export function _compileMatchStmt(ctx, stmt) {
     if (!deconstructableType)
         return ctx.error(DiagnosticCode.A_value_of_type_0_cannot_be_deconstructed, stmt.matchExpr.range, matchExprType.toString());
     // TODO: add support for all deconstructable types
-    if (!isTirStructType(deconstructableType)) {
-        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs supported for now, sorry!");
+    if (!isTirStructType(deconstructableType) && !(deconstructableType instanceof TirEnumType)) {
+        return ctx.error(DiagnosticCode.Not_implemented_0, stmt.matchExpr.range, "only structs and enums supported for now, sorry!");
     }
-    const ctors = deconstructableType.constructors;
-    const ctorNames = ctors.map(c => c.name);
+    const ctorNames = deconstructableType instanceof TirEnumType
+        ? deconstructableType.members.slice()
+        : deconstructableType.constructors.map(c => c.name);
+    const totalCtors = ctorNames.length;
     const missingCtors = ctorNames.slice();
     if (stmt.cases.length === 0)
         return ctx.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, stmt.range);
@@ -70,7 +73,7 @@ export function _compileMatchStmt(ctx, stmt) {
             return undefined;
         wildcardCase = new TirMatchStmtWildcardCase(branchBody, matchCase.range);
     }
-    if (!wildcardCase && cases.length < ctors.length) {
+    if (!wildcardCase && cases.length < totalCtors) {
         return ctx.error(DiagnosticCode.Match_cases_are_not_exhaustive, stmt.range);
     }
     return [new TirMatchStmt(matchExpr, cases, wildcardCase, stmt.range)];
@@ -82,23 +85,21 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
     //*/
     const pattern = matchCase.pattern;
     if (pattern instanceof SimpleVarDecl) {
-        /*
-        if( pattern.name.text === "_" ) {
+        // bare-name pattern: only valid for enum scrutinees (`when Apple: ...`)
+        if (deconstructableType instanceof TirEnumType) {
+            const memberName = pattern.name.text;
+            const memberIdx = deconstructableType.indexOf(memberName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), memberName);
+            if (constrNamesAlreadySpecified.includes(memberName))
+                return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, pattern.name.range, memberName);
+            constrNamesAlreadySpecified.push(memberName);
             const branchCtx = ctx.newBranchChildScope();
-            const branchBody = wrapManyStatements(
-                _compileStatement(
-                    branchCtx,
-                    matchCase.body
-                ),
-                matchCase.body.range
-            );
-            if( !branchBody ) return undefined;
-            return new TirMatchStmtWildcardCase(
-                branchBody,
-                matchCase.range
-            );
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(memberName, new Map(), undefined, deconstructableType, undefined, true, pattern.name.range, pattern.name.range), branchBody, matchCase.range);
         }
-        //*/
         return ctx.error(DiagnosticCode.The_argument_of_a_match_statement_branch_must_be_deconstructed, matchCase.pattern.range);
     }
     else if (pattern instanceof NamedDeconstructVarDecl) {
@@ -107,6 +108,18 @@ export function _compileTirMatchStmtCase(ctx, matchCase, deconstructableType, co
         if (constrNamesAlreadySpecified.includes(deconstructedCtorName))
             return ctx.error(DiagnosticCode.Constructor_0_was_already_specified, deconstructedCtorIdentifier.range, deconstructedCtorName);
         constrNamesAlreadySpecified.push(deconstructedCtorName);
+        if (deconstructableType instanceof TirEnumType) {
+            const memberIdx = deconstructableType.indexOf(deconstructedCtorName);
+            if (memberIdx < 0)
+                return ctx.error(DiagnosticCode.Unknown_0_constructor_1, pattern.name.range, deconstructableType.toString(), deconstructedCtorName);
+            if (pattern.fields.size > 0 || pattern.rest)
+                return ctx.error(DiagnosticCode.Enum_member_pattern_cannot_have_fields, pattern.range);
+            const branchCtx = ctx.newBranchChildScope();
+            const branchBody = wrapManyStatements(_compileStatement(branchCtx, matchCase.body), matchCase.body.range);
+            if (!branchBody)
+                return undefined;
+            return new TirMatchStmtCase(new TirNamedDeconstructVarDecl(deconstructedCtorName, new Map(), undefined, deconstructableType, undefined, true, pattern.range, pattern.name.range), branchBody, matchCase.range);
+        }
         if (deconstructableType instanceof TirSoPStructType
             || deconstructableType instanceof TirDataStructType) {
             const localIdx = deconstructableType.constructors.findIndex(c => c.name === deconstructedCtorName);

package/dist/compiler/AstCompiler/utils/getPropAccessReturnType.js

@@ -1,5 +1,6 @@
 import { TirAliasType } from "../../tir/types/TirAliasType.js";
 import { isTirStructType } from "../../tir/types/TirStructType.js";
+import { TirEnumType } from "../../tir/types/TirEnumType.js";
 import { TirTypeParam } from "../../tir/types/TirTypeParam.js";
 import { int_t, bytes_t, bool_t, string_t } from "../../tir/program/stdScope/stdScope.js";
 import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirUnConstrDataResultT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
@@ -8,6 +9,8 @@ import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../../tir/types/TirNativeType/native/data.js";
 import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
 import { TirIntT } from "../../tir/types/TirNativeType/native/int.js";
+import { TirArrayT } from "../../tir/types/TirNativeType/native/array.js";
+import { TirValueT } from "../../tir/types/TirNativeType/native/value.js";
 import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../tir/types/TirNativeType/native/list.js";
@@ -84,6 +87,14 @@ export function getPropAccessReturnType(ctx, objType, propId) {
         return undefined;
     if (objType instanceof TirMlResultT)
         return undefined;
+    // Native Value / Array<T> — methods are reached through prelude/std
+    // aliases, not via direct prop-access on the native type.
+    if (objType instanceof TirValueT)
+        return undefined;
+    if (objType instanceof TirArrayT)
+        return undefined;
+    if (objType instanceof TirEnumType)
+        return undefined;
     const tsEnsureExhaustiveCheck = objType;
     console.error(objType);
     throw new Error("unreachable::getPropAccessReturnType");

package/dist/compiler/Compiler.js

@@ -7,12 +7,7 @@ import { semverSatisfies } from "../utils/semverSatisfies.js";
 import { AstCompiler } from "./AstCompiler/AstCompiler.js";
 import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
-import { __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRHash.js";
-import { __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION } from "../IR/IRNodes/utils/hashVarSym.js";
-import { __unsafe_clear_hoisted_hash_to_symbol } from "../IR/IRNodes/IRHoisted.js";
-import { __unsafe_clear_letted_hash_to_symbol } from "../IR/IRNodes/IRLetted.js";
-import { __unsafe_clear_hoisted_cache } from "../IR/toUPLC/subRoutines/replaceHoistedWithLetted.js";
-import { __unsafe_clear_mapToType_cache } from "./TirCompiler/expressify/expressifyVars.js";
+import { CompilationCtx, withCompilationCtx } from "../IR/CompilationCtx.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
 import { TirFuncExpr } from "./tir/expressions/TirFuncExpr.js";
 import { addBudget, zeroBudget, } from "./test/TestResult.js";
@@ -57,7 +52,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.compile();
         if (this.diagnostics.length > 0) {
             let msg;
-            // globalThis.console && console.log( this.diagnostics );
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             for (msg of this.diagnostics) {
@@ -82,7 +76,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.export(cfg.functionName, cfg.entry);
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -103,7 +96,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.run();
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -288,7 +280,6 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.runRepl();
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             while (msg = this.diagnostics.shift()) {
@@ -303,23 +294,25 @@ export class Compiler extends DiagnosticEmitter {
         return Machine.eval(new Force(uplcProgram.body));
     }
     _compileBackend(cfg, program, skipFileOutput = false) {
-        // backend starts here
-        const ir = compileTypedProgram(cfg, program);
-        const uplc = compileIRToUPLC(ir, cfg);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
-        if (!skipFileOutput) {
-            const outDir = cfg.outDir;
-            const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
-            this.io.writeFile(outPath, serialized, cfg.root);
-            this.io.stdout.write(`compiled program written to ${outPath}\n`);
-        }
-        __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        __unsafe_clear_hoisted_hash_to_symbol();
-        __unsafe_clear_letted_hash_to_symbol();
-        __unsafe_clear_hoisted_cache();
-        __unsafe_clear_mapToType_cache();
-        return serialized;
+        // Run the whole backend under a fresh per-compilation context. All
+        // node-level caches (hoisted/letted naming, hoisted->letted lowering,
+        // the mapToType helper cache) live on this context, so they cannot
+        // leak into or be perturbed by any other compilation — and they are
+        // dropped automatically when this scope exits, even on throw. The
+        // content-addressed `IRHash` has no global state at all, so there is
+        // nothing else to reset.
+        return withCompilationCtx(new CompilationCtx(), () => {
+            const ir = compileTypedProgram(cfg, program);
+            const uplc = compileIRToUPLC(ir, cfg);
+            const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
+            if (!skipFileOutput) {
+                const outDir = cfg.outDir;
+                const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
+                this.io.writeFile(outPath, serialized, cfg.root);
+                this.io.stdout.write(`compiled program written to ${outPath}\n`);
+            }
+            return serialized;
+        });
     }
 }
 function _failedTestResult(desc, msg, kind = "unit") {

package/dist/compiler/TirCompiler/expressify/ExpressifyCtx.js

@@ -303,7 +303,7 @@ export class ExpressifyCtx {
         if (stmt.rest) {
             if (isDestructuredField)
                 throw new Error("rest is not implemented in destructured field array-like deconstruct. TODO: map data elems to elem type");
-            const lettedRest = this.introduceLettedConstant(stmt.rest, new TirCallExpr(TirNativeFunc._dropList(elemsType), [
+            const lettedRest = this.introduceLettedConstant(stmt.rest, new TirCallExpr(TirNativeFunc.dropList(elemsType), [
                 new TirLitIntExpr(BigInt(nElems), stmt.range),
                 lettedArrayExpr
             ], new TirListT(elemsType), stmt.range), stmt.range);

package/dist/compiler/TirCompiler/expressify/expressify.js

@@ -200,7 +200,7 @@ loopReplacements, assertions = []) {
             }
             if (stmt.rest) {
                 const uniqueRestName = getUniqueInternalName(stmt.rest);
-                const restLetted = ctx.introduceLettedConstant(uniqueRestName, new TirCallExpr(TirNativeFunc._dropList(elemType), [
+                const restLetted = ctx.introduceLettedConstant(uniqueRestName, new TirCallExpr(TirNativeFunc.dropList(elemType), [
                     new TirLitIntExpr(BigInt(stmt.elements.length % modTails), stmt.range),
                     lettedArr
                 ], listType, stmt.range), stmt.range);
@@ -395,8 +395,36 @@ loopReplacements, assertions = []) {
             const returnTypeAndInvalidInit = getBranchStmtReturnType(reassignedAndFlow, ctx, stmt.range);
             const forStmt = loopToForStmt(stmt);
             const { bodyStateType, initState } = getBodyStateType(returnTypeAndInvalidInit, forStmt);
+            // Optimization: when the loop reassigns exactly one variable
+            // and has no user-written `return` inside, skip the SoP wrap
+            // around the loop's result. The recursive loop function then
+            // returns the bare variable's type, saving one `Reassigns{…}`
+            // constructor build per iteration and one IRCase at the exit.
+            // Requires the loop to be non-terminating (terminating loops
+            // are tail-positioned and their value must match the outer
+            // function's expected return type — we don't try to reconcile
+            // that here).
+            const canBareLower = (reassignedAndFlow.reassigned.length === 1
+                && !reassignedAndFlow.returns
+                && !definitelyTerminates);
             const loopExprCtx = ctx.newChild();
-            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState);
+            const bareReturnType = canBareLower
+                ? bodyStateType.constructors[0].fields[0].type
+                : undefined;
+            const loopExpr = expressifyForStmt(loopExprCtx, forStmt, returnTypeAndInvalidInit.sop, bodyStateType, initState, bareReturnType);
+            if (canBareLower) {
+                // Bind the loop's bare result as the variable's new SSA
+                // name, then evaluate the rest of the body. No outer
+                // case-match needed. Use a fresh internal name so the
+                // existing `letted[varName] = initialValue` binding (from
+                // the original `let varName = ...` statement) isn't
+                // shadowed by a no-op `introduceLettedConstant` call.
+                const [varName] = reassignedAndFlow.reassigned;
+                const loopResultName = getUniqueInternalName(varName);
+                const lettedExpr = ctx.introduceLettedConstant(loopResultName, loopExpr, stmt.range);
+                ctx.setNewVariableName(varName, lettedExpr.varName);
+                return TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, expressifyFuncBody(ctx, bodyStmts, loopReplacements));
+            }
             const result = TirAssertAndContinueExpr.fromStmtsAndContinuation(assertions, definitelyTerminates ? loopExpr : wrapNonTerminatingFinalStmtAsCaseExpr(loopExpr, returnTypeAndInvalidInit.sop, ctx, stmt.range, reassignedAndFlow, bodyStmts, loopReplacements));
             return result;
         }

package/dist/compiler/TirCompiler/expressify/expressifyForStmt.d.ts

@@ -4,6 +4,7 @@ import { TirForOfStmt } from "../../tir/statements/TirForOfStmt.js";
 import { TirForStmt } from "../../tir/statements/TirForStmt.js";
 import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
 import { TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { TirType } from "../../tir/types/TirType.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
 export declare function loopToForStmt(stmt: TirWhileStmt | TirForOfStmt | TirForStmt): TirForStmt;
-export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr): TirCallExpr;
+export declare function expressifyForStmt(ctx: ExpressifyCtx, stmt: TirForStmt, returnType: TirSoPStructType, bodyStateType: TirSoPStructType, initState: TirLitNamedObjExpr, bareReturnType?: TirType): TirCallExpr;

package/dist/compiler/TirCompiler/expressify/expressifyForStmt.js

@@ -68,7 +68,16 @@ export function loopToForStmt(stmt) {
     stmt.body, // loopBody
     stmt.range);
 }
-export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState) {
+export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initState, 
+// Optimization: when the loop has exactly one reassigned variable
+// and no user-written `return` inside its body, the SoP wrap
+// (`Reassigns{var}`) on every iteration is unnecessary. The caller
+// can opt into a bare-value lowering by passing the variable's type
+// here; the loop function then returns that type directly, and the
+// call site is expected to bind the result without a case-match.
+bareReturnType) {
+    const effectiveReturnType = bareReturnType ?? returnType;
+    const isBareMode = bareReturnType !== undefined;
     let loopBody = stmt.body instanceof TirBlockStmt ? stmt.body : new TirBlockStmt([stmt.body], stmt.range);
     loopBody = new TirBlockStmt(loopBody.stmts.slice(), loopBody.range);
     // add final loop updates
@@ -88,9 +97,27 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
         ], loopBody.range);
     }
     const loopFuncName = getUniqueInternalName("loop");
-    const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), returnType);
+    const loopFuncType = new TirFuncT(bodyStateType.constructors[0].fields.map(f => f.type), effectiveReturnType);
     const loopReplacements = {
         compileBreak(ctx, stmt) {
+            if (isBareMode) {
+                // Bare-value mode: the loop's return type IS the single
+                // user variable's type. `break` yields that var's current
+                // value directly, no SoP construction.
+                const userVarField = bodyStateType.constructors[0].fields[0];
+                const resolved = ctx.getVariable(userVarField.name);
+                if (isExpressifyFuncParam(resolved)) {
+                    return new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: resolved.name,
+                            type: resolved.type,
+                            isConstant: false
+                        },
+                        isDefinedOutsideFuncScope: false
+                    }, stmt.range);
+                }
+                return resolved;
+            }
             // return first constructor of the return type
             const ctor = returnType.constructors[0];
             return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), ctor.fields.map(f => new Identifier(f.name, stmt.range)), bodyStateType.constructors[0].fields
@@ -111,10 +138,21 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
             }), returnType, stmt.range);
         },
         replaceReturnValue(ctx, stmt) {
-            // return second constructor of the return type
+            // Synthetic returns inserted by `expressifyIfBranch` (and
+            // analogous callers) carry the inner-if's SoP value as the
+            // continuation of the ternary they participate in — they are
+            // NOT user-written returns escaping the loop. When the loop
+            // has no user-written `return` in its body, `returnType` has
+            // only the "break/continue" constructor: in that case the
+            // value flowing through is already the right type and we
+            // must leave it untouched. (Previously this threw "No return
+            // constructor found in return type" when a for-of body
+            // contained an `if` that mutated a captured `let` — the
+            // synthesized branch-tail returns hit this path even though
+            // the user had no `return` inside the loop.)
             const ctor = returnType.constructors[1];
             if (!ctor) {
-                throw new Error("No return constructor found in return type");
+                return stmt.value;
             }
             return new TirLitNamedObjExpr(new Identifier(ctor.name, stmt.range), [new Identifier(ctor.fields[0].name, stmt.range)], [stmt.value], returnType, stmt.range);
         },
@@ -149,7 +187,7 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
                     }, stmt.range);
                 }
                 return resolved;
-            }), returnType, stmt.range);
+            }), effectiveReturnType, stmt.range);
         },
     };
     const loopCompilationCtx = ctx.newChild();
@@ -165,7 +203,7 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
     false, // is constant
     stmt.range)), 
     // func return type
-    returnType, 
+    effectiveReturnType, 
     // func body
     new TirBlockStmt([
         new TirReturnStmt(expressifyFuncBody(loopCompilationCtx, loopBody.stmts, loopReplacements, [] // assertions
@@ -176,5 +214,5 @@ export function expressifyForStmt(ctx, stmt, returnType, bodyStateType, initStat
     );
     return new TirCallExpr(loopFuncExpr, 
     // loop call init args
-    initState.values.map(v => expressifyVars(ctx, v.clone())), returnType, stmt.range);
+    initState.values.map(v => expressifyVars(ctx, v.clone())), effectiveReturnType, stmt.range);
 }

package/dist/compiler/TirCompiler/expressify/expressifyVars.d.ts

@@ -8,4 +8,3 @@ import { ExpressifyCtx } from "./ExpressifyCtx.js";
  * @returns a the modified expression
 **/
 export declare function expressifyVars(ctx: ExpressifyCtx, expr: TirExpr): TirExpr;
-export declare function __unsafe_clear_mapToType_cache(): void;