@algorandfoundation/puya-ts 1.2.0-beta.32 → 1.2.0-beta.34

package/{options-DgrJjFC_.js → options-BCW57sPn.js}

@@ -1,4 +1,4 @@
-import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, cq as invariant, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cr as throwError, cs as StringConstant, ct as BytesConstant, cu as IntegerConstant, cv as BoolConstant, cw as AddressConstant, cx as MethodConstant, cy as DecimalConstant, cz as TemplateVar, cg as LogSource, L as LogLevel, cA as instanceOfAny, cB as SingleEvaluation, cC as VarExpression, cD as nodeFactory, cE as NotSupported, l as logger, cF as TupleItemExpression, cG as FieldExpression, cH as IndexExpression, cI as TupleExpression, cJ as AppStateExpression, cK as AppAccountStateExpression, cL as BoxValueExpression, cM as ReinterpretCast, cN as StateGetEx, cO as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cP as hasFlags, cQ as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cR as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cS as intersectsFlags, cT as extractModuleName, cU as toSubScript, A as AbsolutePath, cV as CompilationSet, cW as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cX as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cY as ARC4CreateOption, cZ as NewArray, O as OnCompletionAction, c_ as BytesEncoding, ce as bigIntToUint8Array, c$ as FixableCodeError, d0 as UInt64BinaryOperator, d1 as tryConvertEnum, d2 as NumericComparison, d3 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d4 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d5 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d6 as TransactionKind, bt as compileFunctionType, bv as compiledLogicSigType, d7 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d8 as getInnerTransactionType, d9 as getItxnParamsType, da as CompiledContract, db as ARC4BareMethodConfig, dc as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dd as BigUIntBinaryOperator, K as BigUintFunction, de as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, df as BytesBinaryOperator, dg as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dh as enumKeyFromValue, di as BytesUnaryOperator, bs as cloneFunctionPType, bw as contractOptionsDecorator, bz as ensureBudgetFunction, dj as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dk as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dl as AppStorageKind, a$ as UnsupportedType, dm as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dn as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunctionPType, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, t as ApplicationFunctionType, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, u as ApplicationTxnFunction, aS as TransactionFunction, bX as paymentItxnFn, bI as keyRegistrationItxnFn, bc as assetConfigItxnFn, bi as assetTransferItxnFn, bf as assetFreezeItxnFn, b3 as applicationCallItxnFn, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dp as Contract, dq as InstanceSuperMethodTarget, dr as ExpressionStatement, ds as AssertExpression, dt as VoidConstant, du as ArrayConcat, dv as ArrayPop, dw as ArrayReplace, dx as ArrayLength, dy as SizeOf, dz as UpdateInnerTransaction, dA as CheckedMaybe, dB as StageInnerTransactions, dC as SubmitInnerTransaction, dD as AssignmentExpression, dE as CommaExpression, dF as NumericComparisonExpression, dG as BytesComparisonExpression, dH as PuyaLibCall, dI as UInt64UnaryOperation, dJ as UInt64PostfixUnaryOperation, dK as BigUIntPostfixUnaryOperation, dL as BytesUnaryOperation, dM as UInt64BinaryOperation, dN as BigUIntBinaryOperation, dO as BooleanBinaryOperation, dP as Not, dQ as Emit, dR as Range, dS as Enumeration, dT as Reversed, dU as StateExists, dV as ARC4Router, dW as MethodSignatureString, dX as SubroutineID, dY as ContractMethodTarget, dZ as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, d_ as patchErrorLocation, d$ as Goto, e0 as ReturnStatement, e1 as ContractMethod, e2 as sameSets, b as ContractClassModel, e3 as Subroutine, e4 as LogicSigClassModel, e5 as ptypeIn, e6 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-BUOeMEKh.js';
+import { ao as LibClassType, d as Constants, bp as boolPType, co as wtypes, b$ as stringPType, a4 as GenericPType, cp as codeInvariant, aL as ReadonlyTuplePType, ax as MutableTuplePType, aD as PType, aA as NumericLiteralPType, c2 as uint64PType, bo as biguintPType, z as ArrayPType, aJ as ReadonlyArrayPType, e as accountPType, bq as bytesPType, ap as LibFunctionType, cq as invariant, _ as ContractClassPType, bu as compiledContractType, aa as ImmutableObjectPType, b5 as applicationItxnType, v as voidPType, aw as MutableObjectPType, I as InternalError, c as CodeError, cr as throwError, cs as StringConstant, ct as BytesConstant, cu as IntegerConstant, cv as BoolConstant, cw as AddressConstant, cx as MethodConstant, cy as DecimalConstant, cz as TemplateVar, cg as LogSource, L as LogLevel, cA as instanceOfAny, cB as SingleEvaluation, cC as VarExpression, cD as nodeFactory, cE as NotSupported, l as logger, cF as TupleItemExpression, cG as FieldExpression, cH as IndexExpression, cI as TupleExpression, cJ as AppStateExpression, cK as AppAccountStateExpression, cL as BoxValueExpression, cM as ReinterpretCast, cN as StateGetEx, cO as StateGet, aU as TransientType, bU as numberPType, bn as bigIntPType, b6 as arc28EmitFunction, y as ArrayLiteralPType, H as BigIntLiteralPType, cP as hasFlags, cQ as BinaryBooleanOperator, ay as NamespacePType, bm as baseContractType, b9 as arc4BaseContractType, cR as SymbolName, a_ as UnionPType, a9 as GroupTransactionPType, h as anyGtxnType, aX as Uint64EnumMemberType, aV as TypeParameterType, bB as esSymbol, c4 as unknownPType, bS as neverPType, b2 as anyPType, bT as nullPType, c3 as undefinedPType, Z as ClusteredPrototype, ae as IntersectionPType, bO as logicSigBaseType, av as LogicSigPType, aY as Uint64EnumType, a1 as FunctionPType, w as ApprovalProgram, X as ClearStateProgram, cn as isIn, R as BoxMapPType, S as BoxPType, as as LocalMapType, au as LocalStateType, a6 as GlobalMapType, a8 as GlobalStateType, aP as SuperPrototypeSelector, Y as ClusteredContractClassType, ch as SourceLocation, cS as intersectsFlags, cT as extractModuleName, cU as toSubScript, A as AbsolutePath, cV as CompilationSet, cW as ARC4ABIMethodConfig, C as ContractReference, V as BytesPType, cX as EqualityComparison, aB as ObjectLiteralPType, bE as isObjectType$1, b_ as readonlyDecorator, b7 as arc4AbiMethodDecorator, b8 as arc4BareMethodDecorator, cY as ARC4CreateOption, cZ as NewArray, O as OnCompletionAction, c_ as BytesEncoding, ce as bigIntToUint8Array, c$ as FixableCodeError, d0 as UInt64BinaryOperator, d1 as tryConvertEnum, d2 as NumericComparison, d3 as UInt64UnaryOperator, bG as itoaMethod, aZ as Uint64Function, d4 as UInt64PostfixUnaryOperator, a0 as FixedArrayPType, al as IterableIteratorType, ak as IterableIteratorGeneric, f as applicationPType, g as assetPType, bV as onCompleteActionType, d5 as wrapInCodeError, cd as base32ToUint8Array, c1 as transactionTypeType, d6 as TransactionKind, bt as compileFunctionType, bv as compiledLogicSigType, d7 as LogicSigReference, ab as InnerTransactionPType, aT as TransactionFunctionType, c0 as submitGroupItxnFunction, am as ItxnParamsPType, d8 as getInnerTransactionType, d9 as getItxnParamsType, da as CompiledContract, db as ARC4BareMethodConfig, dc as MethodSignature, cj as enumFromValue, x as ArrayGeneric, $ as FixedArrayGeneric, cm as zipStrict, bD as isArrayType, bF as isTupleLike, bQ as matchFunction, bb as assertMatchFunction, dd as BigUIntBinaryOperator, K as BigUintFunction, de as BigUIntPostfixUnaryOperator, cf as utf8ToUint8Array, df as BytesBinaryOperator, dg as IntrinsicCall, cb as uint8ArrayToUtf8, T as BytesFunction, U as BytesGeneric, cc as base64ToUint8Array, dh as enumKeyFromValue, di as BytesUnaryOperator, bs as cloneFunctionPType, bw as contractOptionsDecorator, bz as ensureBudgetFunction, dj as PuyaLibFunction, bW as opUpFeeSourceType, af as IntrinsicEnumType, bP as logicSigOptionsDecorator, ac as InstanceType, aC as ObjectWithOptionalFieldsType, c7 as vrfVerifyPType, bR as mimcConfigurationsPType, by as ecdsaPType, bx as ecPType, bl as base64PType, ag as IntrinsicFunctionGroupType, dk as Expression, ai as IntrinsicFunctionType, aM as ReferenceArrayGeneric, aN as ReferenceArrayType, dl as AppStorageKind, a$ as UnsupportedType, dm as transientTypeErrors, a7 as GlobalStateGeneric, aR as TemplateVarFunction, dn as getGroupTransactionType, bH as itxnComposePType, aW as Uint64EnumMemberLiteralType, b0 as anyItxnParamsType, c6 as validateEncodingFunctionPType, M as BooleanFunction, aO as StringFunction, aI as ReadonlyArrayGeneric, aK as ReadonlyGeneric, a2 as GeneratorGeneric, a3 as GeneratorType, aG as PromiseGeneric, aH as PromiseType, W as ClassMethodDecoratorContext, aQ as SuperPrototypeSelectorGeneric, aF as PolytypeClassMethodHelper, bL as logFunction, ba as assertFunction, bA as errFunction, bM as loggedAssertFunction, bN as loggedErrFunction, c5 as urangeFunction, br as bzeroFunction, aj as IntrinsicFunctionTypeType, q as ALL_OP_ENUMS, ah as IntrinsicFunctionGroupTypeType, a5 as GlobalMapGeneric, at as LocalStateGeneric, ar as LocalMapGeneric, N as BoxGeneric, Q as BoxMapGeneric, t as ApplicationFunctionType, r as AccountFunction, E as AssetFunction, p as paymentGtxnType, aE as PaymentTxnFunction, k as keyRegistrationGtxnType, an as KeyRegistrationTxnFunction, i as assetConfigGtxnType, B as AssetConfigTxnFunction, j as assetTransferGtxnType, F as AssetTransferTxnFunction, m as assetFreezeGtxnType, D as AssetFreezeTxnFunction, n as applicationCallGtxnType, u as ApplicationTxnFunction, aS as TransactionFunction, bX as paymentItxnFn, bI as keyRegistrationItxnFn, bc as assetConfigItxnFn, bi as assetTransferItxnFn, bf as assetFreezeItxnFn, b3 as applicationCallItxnFn, bZ as paymentItxnType, bK as keyRegistrationItxnType, be as assetConfigItxnType, bk as assetTransferItxnType, bh as assetFreezeItxnType, bY as paymentItxnParamsType, bJ as keyRegistrationItxnParamsType, bd as assetConfigItxnParamsType, bj as assetTransferItxnParamsType, bg as assetFreezeItxnParamsType, b4 as applicationCallItxnParamsType, bC as inputOnlyObjects, dp as Contract, dq as InstanceSuperMethodTarget, dr as ExpressionStatement, ds as AssertExpression, dt as VoidConstant, du as ArrayConcat, dv as ArrayPop, dw as ArrayReplace, dx as ArrayLength, dy as SizeOf, dz as UpdateInnerTransaction, dA as CheckedMaybe, dB as StageInnerTransactions, dC as SubmitInnerTransaction, dD as AssignmentExpression, dE as CommaExpression, dF as NumericComparisonExpression, dG as BytesComparisonExpression, dH as PuyaLibCall, dI as UInt64UnaryOperation, dJ as UInt64PostfixUnaryOperation, dK as BigUIntPostfixUnaryOperation, dL as BytesUnaryOperation, dM as UInt64BinaryOperation, dN as BigUIntBinaryOperation, dO as BooleanBinaryOperation, dP as Not, dQ as Emit, dR as Range, dS as Enumeration, dT as Reversed, dU as StateExists, dV as ARC4Router, dW as MethodSignatureString, dX as SubroutineID, dY as ContractMethodTarget, dZ as InstanceMethodTarget, ca as uint8ArrayToBase32, ck as mkDirIfNotExists, d_ as patchErrorLocation, d$ as Goto, e0 as ReturnStatement, e1 as ContractMethod, e2 as sameSets, b as ContractClassModel, e3 as Subroutine, e4 as LogicSigClassModel, e5 as ptypeIn, e6 as expandMaybeArray, a as LoggingContext, P as PuyaError } from './contract-class-model-Dpn9A-pJ.js';
 import * as fs from 'node:fs';
 import 'node:util';
 import pathe__default, { normalize } from 'pathe';
@@ -320,7 +320,6 @@ class UintNType extends ARC4EncodedType {
         return visitor.visitUintNType(this);
     }
 }
-const arc4Uint64 = new UintNType({ n: 64n });
 const UFixedNxMGeneric = new GenericPType({
     name: 'UFixed',
     module: Constants.moduleNames.algoTs.arc4.encodedTypes,
@@ -1617,12 +1616,12 @@ function requireStringConstant(builder) {
 }
 function requireIntegerConstant(builder) {
     const constant = requestConstantOfType(builder, uint64PType) ?? requestConstantOfType(builder, biguintPType);
-    codeInvariant(constant instanceof IntegerConstant, 'Expected integer literal');
+    codeInvariant(constant instanceof IntegerConstant, 'Expected integer literal', builder.sourceLocation);
     return constant;
 }
 function requireBooleanConstant(builder) {
     const constant = requireConstantOfType(builder, boolPType);
-    codeInvariant(constant instanceof BoolConstant, 'Expected boolean literal');
+    codeInvariant(constant instanceof BoolConstant, 'Expected boolean literal', builder.sourceLocation);
     return constant;
 }
 function requestConstantOfType(builder, ptype) {
@@ -2809,7 +2808,7 @@ let TypeResolver = (() => {
                 }
                 else if (t instanceof SuperPrototypeSelector) ;
                 else {
-                    throw new CodeError(`Unexpected type: ${t}. Polytype can only be used to support multiple inheritance in contracts for now. All base types must extend the Contract or BaseContract class.}`);
+                    throw new CodeError(`Unexpected type: ${t}. Polytype can only be used to support multiple inheritance in contracts for now. All base types must extend the Contract or BaseContract class.`, { sourceLocation });
                 }
             }
             return new ClusteredContractClassType({
@@ -3420,7 +3419,7 @@ class ConvertBytesFunctionBuilder extends FunctionBuilder {
             ],
             callLocation: sourceLocation,
         });
-        codeInvariant(ptype instanceof ARC4EncodedType, 'Generic type must be an ARC4 encoded type');
+        codeInvariant(ptype instanceof ARC4EncodedType, 'Generic type must be an ARC4 encoded type', sourceLocation);
         const prefixBytes = getPrefixValue(prefix);
         const validate = requireStringConstant(strategy).value === 'validate';
         return instanceEb(nodeFactory.aRC4FromBytes({
@@ -3794,70 +3793,78 @@ class ResolvedObjectLiteralExpressionBuilder extends InstanceExpressionBuilder {
 class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
     ptype;
     propertyToItemMap;
-    items;
+    bindings;
     isSingleEval;
     isConstant = false;
     static fromParts(sourceLocation, parts) {
+        // `bindings` preserves every contributing entry in source order, so that destructuring with
+        // duplicate keys (e.g. `({ a: p, a: q } = obj)`) keeps both targets. `propertyToItemMap` maps
+        // each source property name to its latest binding for object-literal "last write wins" semantics
+        // (spread overrides, duplicate keys).
         const propertyToItemMap = {};
-        const items = [];
+        const bindings = [];
         for (const part of parts) {
             if (part.type === 'properties') {
-                for (const [name, propBuilder] of Object.entries(part.properties)) {
-                    propertyToItemMap[name] = items.length;
-                    items.push(propBuilder);
-                }
+                const { name, target } = part.property;
+                propertyToItemMap[name] = bindings.length;
+                bindings.push({ name, target });
             }
             else {
                 const obj = part.obj.singleEvaluation();
                 for (const [name] of spreadableProperties(part.obj.ptype, part.spreadLocation)) {
-                    propertyToItemMap[name] = items.length;
-                    items.push(requireInstanceBuilder(obj.memberAccess(name, part.spreadLocation)));
+                    propertyToItemMap[name] = bindings.length;
+                    bindings.push({ name, target: requireInstanceBuilder(obj.memberAccess(name, part.spreadLocation)) });
                 }
             }
         }
-        const types = [];
-        for (const [name, idx] of Object.entries(propertyToItemMap)) {
-            const builder = items[idx];
-            types.push({ name, ptype: builder.ptype, description: null });
-        }
-        return new ObjectLiteralExpressionBuilder(sourceLocation, new ObjectLiteralPType({ properties: types }), propertyToItemMap, items);
+        const types = Object.entries(propertyToItemMap).map(([name, idx]) => ({
+            name,
+            ptype: bindings[idx].target.ptype,
+            description: null,
+        }));
+        return new ObjectLiteralExpressionBuilder(sourceLocation, new ObjectLiteralPType({ properties: types }), propertyToItemMap, bindings);
     }
-    constructor(sourceLocation, ptype, propertyToItemMap, items, isSingleEval = false) {
+    constructor(sourceLocation, ptype, propertyToItemMap, bindings, isSingleEval = false) {
         super(sourceLocation);
         this.ptype = ptype;
         this.propertyToItemMap = propertyToItemMap;
-        this.items = items;
+        this.bindings = bindings;
         this.isSingleEval = isSingleEval;
     }
     singleEvaluation() {
         if (this.isSingleEval)
             return this;
+        invariant(this.bindings.length === Object.keys(this.propertyToItemMap).length, 'singleEvaluation called with duplicate or spread-overridden bindings; route through resolveToPType first');
         const tuple = nodeFactory.singleEvaluation({
             source: nodeFactory.tupleExpression({
-                items: this.items.map((item) => item.resolve()),
+                items: this.bindings.map((item) => item.target.resolve()),
                 sourceLocation: this.sourceLocation,
                 wtype: this.ptype.wtype,
             }),
         });
-        return new ObjectLiteralExpressionBuilder(this.sourceLocation, this.ptype, this.propertyToItemMap, this.items.map((item, index) => instanceEb(nodeFactory.tupleItemExpression({
-            base: tuple,
-            index: BigInt(index),
-            sourceLocation: item.sourceLocation,
-        }), item.ptype)), true);
+        return new ObjectLiteralExpressionBuilder(this.sourceLocation, this.ptype, this.propertyToItemMap, this.bindings.map((item, index) => ({
+            name: item.name,
+            target: instanceEb(nodeFactory.tupleItemExpression({
+                base: tuple,
+                index: BigInt(index),
+                sourceLocation: item.target.sourceLocation,
+            }), item.target.ptype),
+        })), true);
     }
     resolve() {
         throw new InternalError('Cannot resolve object literal', { sourceLocation: this.sourceLocation });
     }
     resolveLValue() {
+        invariant(this.bindings.length === Object.keys(this.propertyToItemMap).length, 'resolveLValue called with duplicate bindings; destructuring assignment must iterate bindings via buildAssignmentValues');
         return nodeFactory.tupleExpression({
-            items: this.ptype.properties.map(({ name }) => requireInstanceBuilder(this.memberAccess(name, this.sourceLocation)).resolveLValue()),
+            items: this.bindings.map(({ target }) => target.resolveLValue()),
             sourceLocation: this.sourceLocation,
             wtype: this.ptype.getImmutable().wtype,
         });
     }
     memberAccess(name, sourceLocation) {
         if (name in this.propertyToItemMap) {
-            return this.items[this.propertyToItemMap[name]];
+            return this.bindings[this.propertyToItemMap[name]].target;
         }
         throw new CodeError(`${name} does not exist on ${this.typeDescription}`, { sourceLocation });
     }
@@ -3866,7 +3873,7 @@ class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
     }
     toObjectType(ptype) {
         let base;
-        if (this.isSingleEval || (this.ptype.hasSameStructure(ptype) && this.items.length === Object.keys(ptype.properties).length)) {
+        if (this.isSingleEval || (this.ptype.hasSameStructure(ptype) && this.bindings.length === Object.keys(ptype.properties).length)) {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             base = this;
         }
@@ -3876,7 +3883,7 @@ class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
             const itemToPropertyType = Object.fromEntries(Object.entries(this.propertyToItemMap).map(([propName, index]) => [index, getIndexType(ptype, propName, this.sourceLocation)]));
             const tuple = nodeFactory.singleEvaluation({
                 source: nodeFactory.tupleExpression({
-                    items: this.items.map((item, index) => requireExpressionOfType(item, itemToPropertyType[index] ?? item.ptype)),
+                    items: this.bindings.map((item, index) => requireExpressionOfType(item.target, itemToPropertyType[index] ?? item.target.ptype)),
                     sourceLocation: this.sourceLocation,
                 }),
             });
@@ -3886,7 +3893,11 @@ class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
             base = new ResolvedObjectLiteralExpressionBuilder(nodeFactory.tupleExpression({
                 items: ptype.properties.map(({ name }) => {
                     const index = this.propertyToItemMap[name];
-                    return nodeFactory.tupleItemExpression({ base: tuple, index: BigInt(index), sourceLocation: this.items[index].sourceLocation });
+                    return nodeFactory.tupleItemExpression({
+                        base: tuple,
+                        index: BigInt(index),
+                        sourceLocation: this.bindings[index].target.sourceLocation,
+                    });
                 }),
                 sourceLocation: this.sourceLocation,
                 wtype: tempType.wtype,
@@ -3916,10 +3927,10 @@ class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
     checkForUnclonedMutables(scenario) {
         const usedIndexes = new Set(Object.values(this.propertyToItemMap));
         let contains = false;
-        for (const [idx, item] of this.items.entries()) {
+        for (const [idx, item] of this.bindings.entries()) {
             if (!usedIndexes.has(idx))
                 continue;
-            contains ||= item.checkForUnclonedMutables('being used in an object literal');
+            contains ||= item.target.checkForUnclonedMutables('being used in an object literal');
         }
         return contains;
     }
@@ -3986,7 +3997,7 @@ class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
             typeArgs,
             genericTypeArgs: 1,
             callLocation: sourceLocation,
-            funcName: 'arc4.abimethod',
+            funcName: Constants.symbolNames.arc4AbiDecoratorName,
             argSpec: (a) => [
                 a.obj({
                     allowActions: a.optional(stringPType, new ReadonlyArrayPType({ elementType: stringPType })),
@@ -4041,10 +4052,10 @@ function resolveDefaultArguments(defaultArguments, sourceLocation) {
     const result = {};
     if (!defaultArguments)
         return result;
-    codeInvariant(defaultArguments instanceof ObjectLiteralExpressionBuilder, `Default argument specification should be an object literal`);
+    codeInvariant(defaultArguments instanceof ObjectLiteralExpressionBuilder, `Default argument specification should be an object literal`, sourceLocation);
     for (const { name } of defaultArguments.ptype.properties) {
         const paramConfig = defaultArguments.memberAccess(name, sourceLocation);
-        codeInvariant(paramConfig instanceof ObjectLiteralExpressionBuilder, 'Default argument specification should be an object literal');
+        codeInvariant(paramConfig instanceof ObjectLiteralExpressionBuilder, 'Default argument specification should be an object literal', sourceLocation);
         if (paramConfig.hasProperty('constant')) {
             result[name] = {
                 type: 'constant',
@@ -5914,7 +5925,7 @@ class ItxnParamsFactoryFunctionBuilder extends FunctionBuilder {
     }
 }
 function mapTransactionFields(mappedFields, fields, kind, sourceLocation, ignoreProps) {
-    codeInvariant(isObjectType$1(fields.ptype), 'fields argument must be an object type');
+    codeInvariant(isObjectType$1(fields.ptype), 'fields argument must be an object type', sourceLocation);
     for (const { name } of fields.ptype.properties) {
         if (ignoreProps?.has(name))
             continue;
@@ -6330,7 +6341,7 @@ function getOca(ocaField, allowedCompletionTypes, sourceLocation) {
     if (ocaField) {
         codeInvariant(ocaField instanceof IntegerConstant, `${txnFieldName.onCompletion} should be a compile time constant`, ocaField.sourceLocation);
         const oca = enumFromValue(Number(ocaField.value), OnCompletionAction);
-        codeInvariant(allowedCompletionTypes.includes(oca), `${txnFieldName.onCompletion} should be one of ${allowedCompletionTypes}`);
+        codeInvariant(allowedCompletionTypes.includes(oca), `${txnFieldName.onCompletion} should be one of ${allowedCompletionTypes}`, ocaField.sourceLocation);
         return oca;
     }
     else {
@@ -6675,7 +6686,7 @@ function newUintN(initialValueBuilder, ptype, sourceLocation) {
     if (initialValueBuilder.resolvableToPType(uint64PType)) {
         const initialValue = initialValueBuilder.resolveToPType(uint64PType).resolve();
         if (initialValue instanceof IntegerConstant) {
-            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`);
+            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`, sourceLocation);
             return new UintNExpressionBuilder(nodeFactory.integerConstant({
                 value: initialValue.value,
                 wtype: ptype.wtype,
@@ -6694,7 +6705,7 @@ function newUintN(initialValueBuilder, ptype, sourceLocation) {
     if (initialValueBuilder.resolvableToPType(biguintPType)) {
         const initialValue = initialValueBuilder.resolveToPType(biguintPType).resolve();
         if (initialValue instanceof IntegerConstant) {
-            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`);
+            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`, sourceLocation);
             return new UintNExpressionBuilder(nodeFactory.integerConstant({
                 value: initialValue.value,
                 wtype: ptype.wtypeOrThrow,
@@ -6720,12 +6731,12 @@ function newUintN(initialValueBuilder, ptype, sourceLocation) {
         let sourceLength;
         if (initialValue instanceof BytesConstant) {
             // Constant bytes: compile-time length check via value
-            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`);
+            codeInvariant(isValidLiteralForPType(initialValue.value, ptype), `${initialValue.value} cannot be converted to ${ptype}`, sourceLocation);
             sourceLength = BigInt(initialValue.value.byteLength);
         }
         else if (originalType instanceof BytesPType && originalType.length !== null) {
             // Fixed-size bytes type: compile-time length check via type
-            codeInvariant(originalType.length <= expectedLength, `${originalType} cannot be converted to ${ptype}`);
+            codeInvariant(originalType.length <= expectedLength, `${originalType} cannot be converted to ${ptype}`, sourceLocation);
             sourceLength = originalType.length;
         }
         if (sourceLength !== undefined) {
@@ -6898,7 +6909,7 @@ class PushFunctionBuilder extends FunctionBuilder {
             funcName: 'Array.push',
         });
         const target = this.arrayBuilder.resolve();
-        codeInvariant(isReferableExpression(target), 'target of Array.push method must be a variable or state expression');
+        codeInvariant(isReferableExpression(target), 'target of Array.push method must be a variable or state expression', sourceLocation);
         return instanceEb(nodeFactory.commaExpression({
             expressions: [
                 nodeFactory.arrayExtend({
@@ -7222,7 +7233,7 @@ class VoidExpressionBuilder extends InstanceExpressionBuilder {
         super(expr, voidPType);
     }
     resolveLValue() {
-        throw new CodeError(`${this.typeDescription} is not a valid assignment target`);
+        throw new CodeError(`${this.typeDescription} is not a valid assignment target`, { sourceLocation: this.sourceLocation });
     }
 }
 
@@ -8431,7 +8442,7 @@ class PolytypeClassSuperMethodBuilder extends FunctionBuilder {
             argSpec: (a) => [a.required(ContractClassPType)],
         });
         const matchedBaseType = this.ptype.baseTypes.find((b) => b.equals(contract.ptype));
-        codeInvariant(matchedBaseType, `${contract.ptype} must be a direct base type of this class`);
+        codeInvariant(matchedBaseType, `${contract.ptype} must be a direct base type of this class`, sourceLocation);
         return new PolytypeExplicitClassAccessExpressionBuilder(matchedBaseType, sourceLocation);
     }
 }
@@ -8442,10 +8453,10 @@ class PolytypeExplicitClassAccessExpressionBuilder extends InstanceBuilder {
     ptype;
     isConstant = false;
     resolve() {
-        throw new CodeError('Contract class cannot be used as a value');
+        throw new CodeError('Contract class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     resolveLValue() {
-        throw new CodeError('Contract class cannot be used as a value');
+        throw new CodeError('Contract class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     constructor(ptype, sourceLocation) {
         super(sourceLocation);
@@ -8467,10 +8478,10 @@ class PolytypeExplicitClassAccessExpressionBuilder extends InstanceBuilder {
 class ContractClassBuilder extends InstanceBuilder {
     isConstant = false;
     resolve() {
-        throw new CodeError('Contract class cannot be used as a value');
+        throw new CodeError('Contract class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     resolveLValue() {
-        throw new CodeError('Contract class cannot be used as a value');
+        throw new CodeError('Contract class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     ptype;
     constructor(sourceLocation, ptype) {
@@ -8479,10 +8490,10 @@ class ContractClassBuilder extends InstanceBuilder {
         this.ptype = ptype;
     }
     newCall(args, typeArgs, sourceLocation) {
-        throw new CodeError('Contract class cannot be constructed manually');
+        throw new CodeError('Contract class cannot be constructed manually', { sourceLocation });
     }
     call(args, typeArgs, sourceLocation) {
-        throw new CodeError('Contract class cannot be called manually');
+        throw new CodeError('Contract class cannot be called manually', { sourceLocation });
     }
     memberAccess(name, sourceLocation) {
         switch (name) {
@@ -8712,10 +8723,10 @@ class LogFunctionBuilder extends FunctionBuilder {
 class LogicSigClassBuilder extends InstanceBuilder {
     isConstant = false;
     resolve() {
-        throw new CodeError('LogicSig class cannot be used as a value');
+        throw new CodeError('LogicSig class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     resolveLValue() {
-        throw new CodeError('LogicSig class cannot be used as a value');
+        throw new CodeError('LogicSig class cannot be used as a value', { sourceLocation: this.sourceLocation });
     }
     ptype;
     constructor(sourceLocation, ptype) {
@@ -8724,10 +8735,10 @@ class LogicSigClassBuilder extends InstanceBuilder {
         this.ptype = ptype;
     }
     newCall(args, typeArgs, sourceLocation) {
-        throw new CodeError('LogicSig class cannot be constructed manually');
+        throw new CodeError('LogicSig class cannot be constructed manually', { sourceLocation });
     }
     call(args, typeArgs, sourceLocation) {
-        throw new CodeError('LogicSig class cannot be called manually');
+        throw new CodeError('LogicSig class cannot be called manually', { sourceLocation });
     }
 }
 class LogicSigOptionsDecoratorBuilder extends FunctionBuilder {
@@ -15343,7 +15354,7 @@ class LocalStateFunctionResultBuilder extends InstanceBuilder {
     ptype;
     buildStorageDeclaration(memberName, memberLocation, memberDescription, contractType) {
         if (this._expr)
-            codeInvariant(this._expr instanceof BytesConstant, `key is must be a compile time constant value if ${this.typeDescription} is assigned to a contract member`);
+            codeInvariant(this._expr instanceof BytesConstant, `key is must be a compile time constant value if ${this.typeDescription} is assigned to a contract member`, memberLocation);
         return new AppStorageDeclaration({
             sourceLocation: memberLocation,
             ptype: this.ptype,
@@ -15831,13 +15842,13 @@ class ValidateEncodingFunctionBuilder extends FunctionBuilder {
             argSpec: (a) => [a.required()],
             callLocation: sourceLocation,
         });
-        codeInvariant(!(ptype instanceof BytesPType) || ptype.length !== null, 'Cannot validate unbounded bytes');
+        codeInvariant(!(ptype instanceof BytesPType) || ptype.length !== null, 'Cannot validate unbounded bytes', sourceLocation);
         const validateType = ptype.equals(accountPType)
             ? arc4AddressAlias
             : ptype instanceof BytesPType && ptype.length !== null
                 ? new StaticBytesType({ length: ptype.length })
                 : ptype;
-        codeInvariant(validateType.wtype instanceof wtypes.ARC4Type, 'Can only validate ARC4-encoded types');
+        codeInvariant(validateType.wtype instanceof wtypes.ARC4Type, 'Can only validate ARC4-encoded types', sourceLocation);
         const expr = nodeFactory.aRC4FromBytes({
             value: theValue.resolve(),
             validate: true,
@@ -16024,11 +16035,11 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: arc4BareMethodDecorator, singletonEb: Arc4BareMethodDecoratorBuilder });
     typeRegistry.register({ ptype: ByteClass, singletonEb: classBuilderForUintNAlias(ByteClass, arc4ByteAlias) });
     typeRegistry.register({ ptype: UintN8Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 8n })) });
-    typeRegistry.register({ ptype: UintN16Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 16n })) });
-    typeRegistry.register({ ptype: UintN32Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 32n })) });
-    typeRegistry.register({ ptype: UintN64Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 64n })) });
-    typeRegistry.register({ ptype: UintN128Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 128n })) });
-    typeRegistry.register({ ptype: UintN256Class, singletonEb: classBuilderForUintNAlias(UintN8Class, new UintNType({ n: 256n })) });
+    typeRegistry.register({ ptype: UintN16Class, singletonEb: classBuilderForUintNAlias(UintN16Class, new UintNType({ n: 16n })) });
+    typeRegistry.register({ ptype: UintN32Class, singletonEb: classBuilderForUintNAlias(UintN32Class, new UintNType({ n: 32n })) });
+    typeRegistry.register({ ptype: UintN64Class, singletonEb: classBuilderForUintNAlias(UintN64Class, new UintNType({ n: 64n })) });
+    typeRegistry.register({ ptype: UintN128Class, singletonEb: classBuilderForUintNAlias(UintN128Class, new UintNType({ n: 128n })) });
+    typeRegistry.register({ ptype: UintN256Class, singletonEb: classBuilderForUintNAlias(UintN256Class, new UintNType({ n: 256n })) });
     typeRegistry.registerGeneric({
         generic: UintNGeneric,
         ptype: UintNType,
@@ -17229,6 +17240,26 @@ const accept = (visitor, node) => {
     }
 };
 
+class LooseEqualityOperator extends CodeFix {
+    constructor({ sourceLocation, errorMessage, operatorRequired, }) {
+        super({
+            sourceLocation,
+            errorMessage,
+            fixMessage: `Replace with ${operatorRequired}`,
+            logLevel: LogLevel.Error,
+            edits: LooseEqualityOperator.buildEdits(sourceLocation.node, operatorRequired),
+        });
+    }
+    static buildEdits(node, operatorRequired) {
+        return [
+            {
+                range: getNodeRange(node),
+                newText: operatorRequired,
+            },
+        ];
+    }
+}
+
 class NoOpNonNullAssertion extends CodeFix {
     constructor({ sourceLocation }) {
         super({
@@ -17252,26 +17283,6 @@ class NoOpNonNullAssertion extends CodeFix {
     }
 }
 
-class LooseEqualityOperator extends CodeFix {
-    constructor({ sourceLocation, errorMessage, operatorRequired, }) {
-        super({
-            sourceLocation,
-            errorMessage,
-            fixMessage: `Replace with ${operatorRequired}`,
-            logLevel: LogLevel.Error,
-            edits: LooseEqualityOperator.buildEdits(sourceLocation.node, operatorRequired),
-        });
-    }
-    static buildEdits(node, operatorRequired) {
-        return [
-            {
-                range: getNodeRange(node),
-                newText: operatorRequired,
-            },
-        ];
-    }
-}
-
 class ConditionalExpressionBuilder extends LiteralExpressionBuilder {
     isConstant = false;
     _ptype;
@@ -17353,9 +17364,9 @@ function handleAssignmentStatement(context, target, source, sourceLocation) {
     return nodeFactory.expressionStatement({ expr: handleAssignment(context, target, source, sourceLocation, true).resolve() });
 }
 function handleAssignment(context, target, source, sourceLocation, isStatement) {
-    checkForUnclonedMutables(target, source, sourceLocation);
+    checkForUnclonedMutables(target, source);
     if (isSpecialItxnType(source)) {
-        codeInvariant(isStatement, 'inner transaction results can not be used in assignment expressions');
+        codeInvariant(isStatement, 'inner transaction results can not be used in assignment expressions', sourceLocation);
         return handleItxnAssignment(context, target, source, sourceLocation);
     }
     const narrowedSourceType = narrowSourceType(target.ptype, source.ptype, sourceLocation);
@@ -17389,7 +17400,7 @@ function buildAssignmentValues(target, source, sourceLocation) {
         for (const [index, item] of target[StaticIterator]().entries()) {
             if (item instanceof OmittedExpressionBuilder)
                 continue;
-            const values = buildAssignmentValues(item, requireInstanceBuilder(source.indexAccess(BigInt(index), source.sourceLocation)), sourceLocation);
+            const values = buildAssignmentValues(item, requireInstanceBuilder(source.indexAccess(BigInt(index), source.sourceLocation)));
             targets.push(values.target);
             sources.push(values.source);
         }
@@ -17399,11 +17410,11 @@ function buildAssignmentValues(target, source, sourceLocation) {
         };
     }
     else if (target instanceof ObjectLiteralExpressionBuilder) {
-        // // Destructured object
+        // Destructured object
         const targets = [];
         const sources = [];
-        for (const { name } of target.ptype.properties) {
-            const values = buildAssignmentValues(requireInstanceBuilder(target.memberAccess(name, sourceLocation)), requireInstanceBuilder(source.memberAccess(name, source.sourceLocation)), sourceLocation);
+        for (const { name, target: targetBuilder } of target.bindings) {
+            const values = buildAssignmentValues(targetBuilder, requireInstanceBuilder(source.memberAccess(name, source.sourceLocation)));
             targets.push(values.target);
             sources.push(values.source);
         }
@@ -17423,7 +17434,7 @@ function buildAssignmentExpression(target, source, sourceLocation, isStatement)
     const expressionType = getAssignmentExpressionType(target.ptype, source.ptype);
     //  Skip single eval for non-destructuring assignments
     const sourceSingle = isDestructuringAssignment(target) || (!target.ptype.equals(expressionType) && !isStatement) ? source.singleEvaluation() : source;
-    const assignmentValues = buildAssignmentValues(target, sourceSingle, sourceLocation);
+    const assignmentValues = buildAssignmentValues(target, sourceSingle);
     const assignment = nodeFactory.assignmentExpression({
         target: assignmentValues.target,
         value: assignmentValues.source,
@@ -17532,12 +17543,12 @@ function handleItxnAssignment(context, target, source, sourceLocation) {
 function checkForUnclonedMutables(target, source, sourceLocation) {
     if (target instanceof ArrayLiteralExpressionBuilder) {
         for (const [index, item] of target[StaticIterator]().entries()) {
-            checkForUnclonedMutables(item, requireInstanceBuilder(source.indexAccess(BigInt(index), source.sourceLocation)), sourceLocation);
+            checkForUnclonedMutables(item, requireInstanceBuilder(source.indexAccess(BigInt(index), source.sourceLocation)));
         }
     }
     else if (target instanceof ObjectLiteralExpressionBuilder) {
-        for (const { name } of target.ptype.properties) {
-            checkForUnclonedMutables(requireInstanceBuilder(target.memberAccess(name, sourceLocation)), requireInstanceBuilder(source.memberAccess(name, source.sourceLocation)), sourceLocation);
+        for (const { name, target: targetBuilder } of target.bindings) {
+            checkForUnclonedMutables(targetBuilder, requireInstanceBuilder(source.memberAccess(name, source.sourceLocation)));
         }
     }
     else {
@@ -17670,8 +17681,9 @@ class BaseVisitor {
                     return [
                         {
                             type: 'properties',
-                            properties: {
-                                [this.textVisitor.accept(p.name)]: requireInstanceBuilder(this.baseAccept(p.initializer)),
+                            property: {
+                                name: this.textVisitor.accept(p.name),
+                                target: requireInstanceBuilder(this.baseAccept(p.initializer)),
                             },
                         },
                     ];
@@ -17681,7 +17693,7 @@ class BaseVisitor {
                     return [
                         {
                             type: 'properties',
-                            properties: { [this.textVisitor.accept(p.name)]: requireInstanceBuilder(this.baseAccept(p.name)) },
+                            property: { name: this.textVisitor.accept(p.name), target: requireInstanceBuilder(this.baseAccept(p.name)) },
                         },
                     ];
                 case ts.SyntaxKind.SpreadAssignment:
@@ -17984,7 +17996,7 @@ class BaseVisitor {
                 sourceLocation,
             }), right.ptype);
         }
-        throw new NotSupported(`Binary expression with op ${getSyntaxName(binaryOpKind)}`);
+        this.throwNotSupported(node, `Binary expression with op ${getSyntaxName(binaryOpKind)}`);
     }
     visitConditionalExpression(node) {
         const sourceLocation = this.sourceLocation(node);
@@ -18211,7 +18223,7 @@ class DecoratorVisitor extends BaseVisitor {
         let readonlyDecorator = undefined;
         for (const data of DecoratorVisitor.buildDecoratorData(target)) {
             switch (data.type) {
-                case 'arc4.abimethod':
+                case Constants.symbolNames.arc4AbiDecoratorName:
                     if (abiDecorator) {
                         logger.error(data.sourceLocation, 'Only one abimethod decorator is allowed per method. Multiple on complete actions can be provided in a single decorator');
                     }
@@ -18222,7 +18234,7 @@ class DecoratorVisitor extends BaseVisitor {
                         abiDecorator = data;
                     }
                     break;
-                case 'arc4.baremethod':
+                case Constants.symbolNames.arc4BareDecoratorName:
                     if (bareDecorator) {
                         logger.error(data.sourceLocation, 'Only one baremethod decorator is allowed per method. Multiple on complete actions can be provided in a single decorator');
                     }
@@ -18233,7 +18245,7 @@ class DecoratorVisitor extends BaseVisitor {
                         bareDecorator = data;
                     }
                     break;
-                case 'arc4.readonly':
+                case Constants.symbolNames.readonlyDecoratorName:
                     if (readonlyDecorator) {
                         logger.error(data.sourceLocation, 'Only one readonly decorator is allowed per method');
                     }
@@ -18313,7 +18325,7 @@ class FunctionVisitor extends BaseVisitor {
         const sourceLocation = this.sourceLocation(node);
         const args = node.parameters.map((p) => this.accept(p));
         const assignDestructuredParams = this.evaluateParameterBindingExpressions(node.parameters, sourceLocation);
-        codeInvariant(node.body, 'Functions must have a body');
+        codeInvariant(node.body, 'Functions must have a body', sourceLocation);
         const body = assignDestructuredParams.length
             ? nodeFactory.block({ sourceLocation }, assignDestructuredParams, this.accept(node.body))
             : this.accept(node.body);
@@ -18326,17 +18338,23 @@ class FunctionVisitor extends BaseVisitor {
     visitBindingName(bindingName, sourceLocation) {
         switch (bindingName.kind) {
             case ts.SyntaxKind.ObjectBindingPattern: {
-                const props = Array();
+                const parts = [];
                 for (const element of bindingName.elements) {
                     const sourceLocation = this.sourceLocation(element);
-                    const propertyNameIdentifier = element.propertyName ?? element.name;
-                    invariant(ts.isIdentifier(propertyNameIdentifier), 'propertyName must be an identifier');
-                    const propertyName = this.textVisitor.accept(propertyNameIdentifier);
+                    const sourcePropertyNameIdentifier = element.propertyName ?? element.name;
+                    codeInvariant(ts.isIdentifier(sourcePropertyNameIdentifier), 'propertyName must be an identifier', sourceLocation);
                     codeInvariant(!element.dotDotDotToken, 'Spread operator is not supported here', sourceLocation);
                     codeInvariant(!element.initializer, 'Initializer on object binding pattern is not supported', sourceLocation);
-                    props.push([propertyName, this.visitBindingName(element.name, sourceLocation)]);
+                    const sourcePropertyName = this.textVisitor.accept(sourcePropertyNameIdentifier);
+                    parts.push({
+                        type: 'properties',
+                        property: {
+                            name: sourcePropertyName,
+                            target: this.visitBindingName(element.name, sourceLocation),
+                        },
+                    });
                 }
-                return ObjectLiteralExpressionBuilder.fromParts(sourceLocation, [{ type: 'properties', properties: Object.fromEntries(props) }]);
+                return ObjectLiteralExpressionBuilder.fromParts(sourceLocation, parts);
             }
             case ts.SyntaxKind.ArrayBindingPattern: {
                 const items = [];
@@ -18389,9 +18407,7 @@ class FunctionVisitor extends BaseVisitor {
         return [];
     }
     visitClassDeclaration(node) {
-        throw new NotSupported('Nested classes', {
-            sourceLocation: this.sourceLocation(node),
-        });
+        this.throwNotSupported(node, 'Nested classes');
     }
     visitVariableDeclarationList(node) {
         const isConstDeclaration = hasFlags(node.flags, ts.NodeFlags.Const);
@@ -18401,7 +18417,7 @@ class FunctionVisitor extends BaseVisitor {
                 // Typescript will already error if a destructuring expression is used without an initializer
                 if (ts.isIdentifier(d.name)) {
                     const ptype = this.context.getPTypeForNode(d.name);
-                    codeInvariant(ptype.wtype, `${ptype.fullName} is not a valid variable type`);
+                    codeInvariant(ptype.wtype, `${ptype.fullName} is not a valid variable type`, sourceLocation);
                 }
                 return [];
             }
@@ -18521,14 +18537,10 @@ class FunctionVisitor extends BaseVisitor {
         }
     }
     visitForInStatement(node) {
-        throw new NotSupported('For in statements', {
-            sourceLocation: this.sourceLocation(node),
-        });
+        this.throwNotSupported(node, 'For in statements');
     }
     visitTryStatement(node) {
-        throw new NotSupported('Try statements', {
-            sourceLocation: this.sourceLocation(node),
-        });
+        this.throwNotSupported(node, 'Try statements');
     }
     visitEmptyStatement(node) {
         return nodeFactory.block({ sourceLocation: this.sourceLocation(node), comment: 'Empty statement' });
@@ -18624,7 +18636,7 @@ class FunctionVisitor extends BaseVisitor {
         });
     }
     visitWithStatement(node) {
-        throw new NotSupported('with statements', { sourceLocation: this.sourceLocation(node) });
+        this.throwNotSupported(node, 'with statements');
     }
     visitSwitchStatement(node) {
         const env_5 = { stack: [], error: void 0, hasError: false };
@@ -18673,16 +18685,14 @@ class FunctionVisitor extends BaseVisitor {
         return this.accept(node.statement);
     }
     visitThrowStatement(node) {
-        throw new NotSupported('Throw statements', {
-            sourceLocation: this.sourceLocation(node),
-        });
+        this.throwNotSupported(node, 'Throw statements');
     }
     visitDebuggerStatement(node) {
         logger.warn(this.sourceLocation(node), 'Ignoring debugger statement');
         return [];
     }
     visitImportDeclaration(node) {
-        throw new NotSupported('Non-top-level import declarations');
+        this.throwNotSupported(node, 'Non-top-level import declarations');
     }
     visitBlock(node) {
         return nodeFactory.block({
@@ -18818,7 +18828,7 @@ class ContractMethodVisitor extends ContractMethodBaseVisitor {
             allowedCompletionTypes: [OnCompletionAction.NoOp],
             create: ARC4CreateOption.disallow,
         };
-        if (decorator?.type === 'arc4.baremethod') {
+        if (decorator?.type === Constants.symbolNames.arc4BareDecoratorName) {
             this.checkBareMethodTypes(functionType, methodLocation);
             return new ARC4BareMethodConfig({
                 sourceLocation: decorator.sourceLocation,
@@ -18826,7 +18836,7 @@ class ContractMethodVisitor extends ContractMethodBaseVisitor {
                 create: decorator.create ?? conventionalDefaults?.create ?? unspecifiedDefaults.create,
             });
         }
-        if (decorator?.type === 'arc4.abimethod') {
+        if (decorator?.type === Constants.symbolNames.arc4AbiDecoratorName) {
             return new ARC4ABIMethodConfig({
                 readonly: decorator.readonly ?? false,
                 sourceLocation: decorator.sourceLocation,
@@ -18861,7 +18871,7 @@ class ContractMethodVisitor extends ContractMethodBaseVisitor {
         return null;
     }
     validateDecoratorRoutingData(functionType, decorator, impliedByConvention) {
-        if (!decorator || !impliedByConvention || decorator.type === 'arc4.readonly')
+        if (!decorator || !impliedByConvention || decorator.type === Constants.symbolNames.readonlyDecoratorName)
             return;
         if (decorator.allowedCompletionTypes !== undefined &&
             impliedByConvention.allowedCompletionTypes !== undefined &&
@@ -18971,7 +18981,7 @@ class ConstructorVisitor extends ContractMethodBaseVisitor {
                 const statement = this.accept(s);
                 if (isSuperCall(s)) {
                     // Property initializer statements should be injected immediately after the super() call
-                    codeInvariant(!this._foundSuperCall, 'A constructor can only contain one call to super()');
+                    codeInvariant(!this._foundSuperCall, 'A constructor can only contain one call to super()', this.sourceLocation(s));
                     this._foundSuperCall = true;
                     return nodeFactory.block({
                         sourceLocation: this.sourceLocation(s),
@@ -19114,7 +19124,7 @@ class ContractVisitor extends ClassDefinitionVisitor {
         const sourceLocation = this.sourceLocation(node);
         codeInvariant(!node.questionToken, 'Optional properties are not supported', sourceLocation);
         codeInvariant(!node.exclamationToken, 'Non-null assertion operators on properties are not supported', sourceLocation);
-        codeInvariant(!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword), 'Static properties are not supported');
+        codeInvariant(!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword), 'Static properties are not supported', sourceLocation);
         const propertyName = this.textVisitor.accept(node.name);
         codeInvariant(node.initializer, 'Properties must have an initializer', sourceLocation);
         if (node.type) {
@@ -19348,7 +19358,7 @@ class SourceFileVisitor extends BaseVisitor {
                 return [];
             }
             const maybeConst = requireInstanceBuilder(initializerBuilder);
-            codeInvariant(maybeConst.isConstant || maybeConst.isConstantOp, 'Module level assignments must be compile time constants');
+            codeInvariant(maybeConst.isConstant || maybeConst.isConstantOp, 'Module level assignments must be compile time constants', sourceLocation);
             this.context.addConstant(dec.name, maybeConst);
             return [];
         });
@@ -23520,5 +23530,5 @@ class PuyaOptions {
     }
 }
 
-export { defaultPuyaOptions as $, ARC4ArrayType as A, ByteClass as B, ContractProxyGeneric as C, DynamicArrayGeneric as D, abiCallFunction as E, arc4AddressAlias as F, arc4BooleanType as G, arc4ByteAlias as H, arc4StringType as I, arc4StructBaseType as J, arc4Uint64 as K, compileArc4Function as L, convertBytesFunction as M, decodeArc4Function as N, encodeArc4Function as O, methodSelectorFunction as P, sizeOfFunction as Q, uint8ArrayToHex as R, StaticArrayGeneric as S, TypedApplicationCallResponseGeneric as T, UFixedNxMGeneric as U, hexToUint8Array as V, CompileOptions as W, TypeResolver as X, processInputPaths as Y, registerPTypes as Z, typeRegistry as _, ARC4BoolClass as a, parseCliTemplateVar as a0, LocalsCoalescingStrategy as a1, PuyaService as a2, deserializeAndLog as a3, createTsProgram as a4, buildAwst as a5, validateAwst as a6, sleep as a7, DefaultMap as a8, relinquishThread as a9, ARC4EncodedType as b, ARC4InstanceType as c, ARC4StrClass as d, ARC4StructClass as e, ARC4StructType as f, ARC4TupleType as g, AddressClass as h, Arc4TupleGeneric as i, ContractProxyType as j, DynamicArrayType as k, DynamicBytesConstructor as l, DynamicBytesType as m, StaticArrayType as n, StaticBytesGeneric as o, StaticBytesType as p, TypedApplicationCallResponseType as q, UFixedNxMType as r, UintN128Class as s, UintN16Class as t, UintN256Class as u, UintN32Class as v, UintN64Class as w, UintN8Class as x, UintNGeneric as y, UintNType as z };
-//# sourceMappingURL=options-DgrJjFC_.js.map
+export { parseCliTemplateVar as $, ARC4ArrayType as A, ByteClass as B, ContractProxyGeneric as C, DynamicArrayGeneric as D, abiCallFunction as E, arc4AddressAlias as F, arc4BooleanType as G, arc4ByteAlias as H, arc4StringType as I, arc4StructBaseType as J, compileArc4Function as K, convertBytesFunction as L, decodeArc4Function as M, encodeArc4Function as N, methodSelectorFunction as O, sizeOfFunction as P, uint8ArrayToHex as Q, hexToUint8Array as R, StaticArrayGeneric as S, TypedApplicationCallResponseGeneric as T, UFixedNxMGeneric as U, CompileOptions as V, TypeResolver as W, processInputPaths as X, registerPTypes as Y, typeRegistry as Z, defaultPuyaOptions as _, ARC4BoolClass as a, LocalsCoalescingStrategy as a0, PuyaService as a1, deserializeAndLog as a2, createTsProgram as a3, buildAwst as a4, validateAwst as a5, sleep as a6, DefaultMap as a7, relinquishThread as a8, ARC4EncodedType as b, ARC4InstanceType as c, ARC4StrClass as d, ARC4StructClass as e, ARC4StructType as f, ARC4TupleType as g, AddressClass as h, Arc4TupleGeneric as i, ContractProxyType as j, DynamicArrayType as k, DynamicBytesConstructor as l, DynamicBytesType as m, StaticArrayType as n, StaticBytesGeneric as o, StaticBytesType as p, TypedApplicationCallResponseType as q, UFixedNxMType as r, UintN128Class as s, UintN16Class as t, UintN256Class as u, UintN32Class as v, UintN64Class as w, UintN8Class as x, UintNGeneric as y, UintNType as z };
+//# sourceMappingURL=options-BCW57sPn.js.map