@algorandfoundation/puya-ts 1.0.0-beta.13 → 1.0.0-beta.15

package/compile-options.d.ts

@@ -4,20 +4,21 @@ export interface AlgoFile {
     sourceFile: string;
     outDir: string;
 }
-export interface CompileOptions {
+export interface PuyaTsCompileOptions {
     filePaths: AlgoFile[];
     logLevel: LogLevel;
     outputAwst: boolean;
     outputAwstJson: boolean;
+    skipVersionCheck: boolean;
     dryRun: boolean;
-    getFileFromSource(sourceFile: string): AlgoFile | undefined;
 }
 export declare const buildCompileOptions: ({ paths, workingDirectory, outDir, ...rest }: {
     paths: string[];
     outputAwst: boolean;
     outDir: string;
     outputAwstJson: boolean;
+    skipVersionCheck: boolean;
     workingDirectory?: string;
     dryRun: boolean;
     logLevel: LogLevel;
-}) => CompileOptions;
+}) => PuyaTsCompileOptions;

package/compile.d.ts

@@ -0,0 +1,42 @@
+import type ts from 'typescript';
+import type { AWST } from './awst/nodes';
+import type { CompilationSet } from './awst_build/models/contract-class-model';
+import { type LogLevel } from './logger';
+import type { CreateProgramResult } from './parser';
+import type { PuyaPassThroughOptions } from './puya/options';
+export type CompileResult = {
+    programDirectory: string;
+    awst?: AWST[];
+    ast?: Record<string, ts.SourceFile>;
+    compilationSet?: CompilationSet;
+};
+export type CompileArgs = {
+    paths: string[];
+    outputAwst: boolean;
+    outDir: string;
+    outputAwstJson: boolean;
+    skipVersionCheck?: boolean;
+    workingDirectory?: string;
+    dryRun?: boolean;
+    logLevel: LogLevel;
+    hooks?: Partial<Hooks>;
+} & PuyaPassThroughOptions;
+type Hooks = {
+    /**
+     * Called after TypeScript parsing, but before AWST build. Use this hook to add or remove TS AST nodes before AWST build
+     *
+     * If implemented, this method should return true to continue compilation or false to stop
+     * @param createProgramResult The result of TypeScript compilation
+     */
+    onProgramCreated(createProgramResult: CreateProgramResult): boolean;
+    /**
+     * Called after AWST build, but before invocation of puya. Use this hook to add or remove AWST nodes before puya build
+     *
+     * If implemented, this method should return true to continue compilation or false to stop
+     * @param moduleAwst All AWST nodes of the build
+     * @param compilationSet An array of references to AWST nodes which should result in compilation output.
+     */
+    onAwstBuilt(moduleAwst: AWST[], compilationSet: CompilationSet): boolean;
+};
+export declare function compile({ paths, outputAwst, outDir, outputAwstJson, skipVersionCheck, workingDirectory, dryRun, logLevel, hooks, ...passThroughOptions }: CompileArgs): Promise<CompileResult>;
+export {};

package/constants.d.ts

@@ -6,7 +6,6 @@ export declare const Constants: {
     readonly opModuleName: "@algorandfoundation/algorand-typescript/op.d.ts";
     readonly templateVarModuleName: "@algorandfoundation/algorand-typescript/template-var.d.ts";
     readonly logicSigModuleName: "@algorandfoundation/algorand-typescript/logic-sig.d.ts";
-    readonly opTypesModuleName: "@algorandfoundation/algorand-typescript/op-types.d.ts";
     readonly baseContractModuleName: "@algorandfoundation/algorand-typescript/base-contract.d.ts";
     readonly utilModuleName: "@algorandfoundation/algorand-typescript/util.d.ts";
     readonly referenceModuleName: "@algorandfoundation/algorand-typescript/reference.d.ts";
@@ -31,6 +30,6 @@ export declare const Constants: {
     readonly encodedAddressLength: 58;
     readonly zeroAddressEncoded: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ";
     readonly supportedAvmVersions: readonly [10n, 11n];
-    readonly targetedPuyaVersion: "4.2.0";
+    readonly targetedPuyaVersion: "4.2.1";
 };
 export type SupportedAvmVersion = (typeof Constants.supportedAvmVersions)[number];

package/index.d.ts

@@ -1,14 +1,10 @@
-import type ts from 'typescript';
-import type { AWST } from './awst/nodes';
-import type { CompilationSet } from './awst_build/models/contract-class-model';
-import type { CompileOptions } from './compile-options';
-import type { CreateProgramResult } from './parser';
-import type { PuyaPassThroughOptions } from './puya/options';
 export { SourceLocation } from './awst/source-location';
 export * as ptypes from './awst_build/ptypes/for-export';
 export { registerPTypes } from './awst_build/ptypes/register';
 export { typeRegistry } from './awst_build/type-registry';
 export { TypeResolver } from './awst_build/type-resolver';
+export { compile } from './compile';
+export { LoggingContext } from './logger';
 export declare const encodingUtil: {
     utf8ToUint8Array: (value: string) => Uint8Array;
     bigIntToUint8Array: (val: bigint, fixedSize?: number | "dynamic") => Uint8Array;
@@ -21,27 +17,3 @@ export declare const encodingUtil: {
     uint8ArrayToBase64: (value: Uint8Array) => string;
     uint8ArrayToBigInt: (v: Uint8Array) => bigint;
 };
-export type CompileResult = {
-    programDirectory: string;
-    awst?: AWST[];
-    ast?: Record<string, ts.SourceFile>;
-    compilationSet?: CompilationSet;
-};
-type Hooks = {
-    /**
-     * Called after TypeScript parsing, but before AWST build. Use this hook to add or remove TS AST nodes before AWST build
-     *
-     * If implemented, this method should return true to continue compilation or false to stop
-     * @param createProgramResult The result of TypeScript compilation
-     */
-    onProgramCreated(createProgramResult: CreateProgramResult): boolean;
-    /**
-     * Called after AWST build, but before invocation of puya. Use this hook to add or remove AWST nodes before puya build
-     *
-     * If implemented, this method should return true to continue compilation or false to stop
-     * @param moduleAwst All AWST nodes of the build
-     * @param compilationSet An array of references to AWST nodes which should result in compilation output.
-     */
-    onAwstBuilt(moduleAwst: AWST[], compilationSet: CompilationSet): boolean;
-};
-export declare function compile(options: CompileOptions, passThroughOptions: PuyaPassThroughOptions, hooks?: Partial<Hooks>): CompileResult;

package/index.mjs

@@ -1,19 +1,236 @@
-export { S as SourceLocation, T as TypeResolver, c as compile, e as encodingUtil, f as ptypes, r as registerPTypes, t as typeRegistry } from './index-B46QirKR.js';
-import 'change-case';
-import 'node:path';
+import { A as ALL_OP_ENUMS, a as ARC4BoolClass, b as ARC4EncodedType, c as ARC4InstanceType, d as ARC4StrClass, e as ARC4StructClass, f as ARC4StructType, g as ARC4TupleType, h as AccountFunction, i as AddressClass, j as AnyPType, k as ApplicationFunctionType, l as ApplicationTxnFunction, m as ApprovalProgram, n as Arc4TupleClass, o as Arc4TupleGeneric, p as ArrayLiteralPType, q as ArrayPType, r as AssetConfigTxnFunction, s as AssetFreezeTxnFunction, t as AssetFunction, u as AssetTransferTxnFunction, B as BaseContractClassType, v as BigIntLiteralPType, w as BigUintFunction, x as BooleanFunction, y as BoxFunction, z as BoxGeneric, C as BoxMapFunction, D as BoxMapGeneric, E as BoxMapPType, F as BoxPType, G as BoxRefFunction, H as BoxRefPType, I as ByteClass, J as BytesFunction, K as ClassMethodDecoratorContext, L as ClearStateProgram, M as ClusteredContractClassType, N as ClusteredPrototype, O as ContractClassPType, P as DynamicArrayConstructor, Q as DynamicArrayGeneric, R as DynamicArrayType, S as DynamicBytesConstructor, T as DynamicBytesType, U as FunctionPType, V as GeneratorGeneric, W as GeneratorType, X as GenericPType, Y as GlobalStateFunction, Z as GlobalStateGeneric, _ as GlobalStateType, $ as GroupTransactionPType, a0 as InnerTransactionPType, a1 as InstanceType, a2 as InternalType, a3 as IntersectionPType, a4 as IntrinsicEnumType, a5 as IntrinsicFunctionGroupType, a6 as IntrinsicFunctionGroupTypeType, a7 as IntrinsicFunctionType, a8 as IntrinsicFunctionTypeType, a9 as IterableIteratorGeneric, aa as IterableIteratorType, ab as ItxnParamsPType, ac as KeyRegistrationTxnFunction, ad as LibClassType, ae as LibFunctionType, af as LocalStateFunction, ag as LocalStateGeneric, ah as LocalStateType, ai as LogicSigPType, aj as NamespacePType, ak as NativeNumericType, al as NumericLiteralPType, am as ObjectPType, an as PType, ao as PaymentTxnFunction, ap as PolytypeClassMethodHelper, aq as PromiseGeneric, ar as PromiseType, as as StaticArrayConstructor, at as StaticArrayGeneric, au as StaticArrayType, av as StaticBytesConstructor, aw as StaticBytesGeneric, ax as StaticBytesType, ay as StorageProxyPType, az as StringFunction, aA as SuperPrototypeSelector, aB as SuperPrototypeSelectorGeneric, aC as TemplateVarFunction, aD as TransactionFunction, aE as TransactionFunctionType, aF as TransientType, aG as TuplePType, aH as TypeParameterType, aI as UFixedNxMClass, aJ as UFixedNxMGeneric, aK as UFixedNxMType, aL as Uint64EnumMemberType, aM as Uint64EnumType, aN as Uint64Function, aO as UintN128Class, aP as UintN16Class, aQ as UintN256Class, aR as UintN32Class, aS as UintN64Class, aT as UintN8Class, aU as UintNClass, aV as UintNGeneric, aW as UintNType, aX as UnionPType, aY as UnsupportedType, aZ as accountPType, a_ as anyGtxnType, a$ as anyPType, b0 as applicationCallGtxnType, b1 as applicationCallItxnFn, b2 as applicationCallItxnParamsType, b3 as applicationItxnType, b4 as applicationPType, b5 as arc28EmitFunction, b6 as arc4AbiMethodDecorator, b7 as arc4AddressAlias, b8 as arc4BareMethodDecorator, b9 as arc4BaseContractType, ba as arc4BooleanType, bb as arc4ByteAlias, bc as arc4StringType, bd as arc4StructBaseType, be as assertFunction, bf as assertMatchFunction, bg as assetConfigGtxnType, bh as assetConfigItxnFn, bi as assetConfigItxnParamsType, bj as assetConfigItxnType, bk as assetFreezeGtxnType, bl as assetFreezeItxnFn, bm as assetFreezeItxnParamsType, bn as assetFreezeItxnType, bo as assetPType, bp as assetTransferGtxnType, bq as assetTransferItxnFn, br as assetTransferItxnParamsType, bs as assetTransferItxnType, bt as base64PType, bu as baseContractType, bv as bigIntPType, bw as biguintPType, bx as boolPType, by as boxRefType, bz as bytesPType, bA as compileFunctionType, bB as compiledContractType, bC as compiledLogicSigType, bD as contractOptionsDecorator, bE as decodeArc4Function, bF as ecPType, bG as ecdsaPType, bH as encodeArc4Function, bI as ensureBudgetFunction, bJ as errFunction, bK as interpretAsArc4Function, bL as isAppStorageType, bM as keyRegistrationGtxnType, bN as keyRegistrationItxnFn, bO as keyRegistrationItxnParamsType, bP as keyRegistrationItxnType, bQ as logFunction, bR as logicSigBaseType, bS as logicSigOptionsDecorator, bT as methodSelectorFunction, bU as mimcConfigurationsPType, bV as neverPType, bW as nullPType, bX as numberPType, bY as onCompleteActionType, bZ as opUpFeeSourceType, b_ as paymentGtxnType, b$ as paymentItxnFn, c0 as paymentItxnParamsType, c1 as paymentItxnType, c2 as ptypeToArc4EncodedType, c3 as stringPType, c4 as submitGroupItxnFunction, c5 as transactionTypeType, c6 as uint64PType, c7 as undefinedPType, c8 as unknownPType, c9 as urangeFunction, ca as voidPType, cb as vrfVerifyPType, cc as utf8ToUint8Array, cd as bigIntToUint8Array, ce as hexToUint8Array, cf as base32ToUint8Array, cg as base64ToUint8Array, ch as uint8ArrayToUtf8, ci as uint8ArrayToHex, cj as uint8ArrayToBase32, ck as uint8ArrayToBase64, cl as uint8ArrayToBigInt } from './compile-BcG41O6Z.js';
+export { cr as LoggingContext, cm as SourceLocation, cp as TypeResolver, cq as compile, cn as registerPTypes, co as typeRegistry } from './compile-BcG41O6Z.js';
+import 'node:async_hooks';
 import 'typescript';
 import 'node:buffer';
 import 'node:fs';
 import 'node:util';
 import 'upath';
 import 'polytype';
+import 'change-case';
+import 'node:path';
 import 'tslib';
 import 'arcsecond';
+import 'glob';
 import 'crypto';
 import 'fs';
-import 'glob';
 import 'os';
 import 'cross-spawn';
 import 'which';
 import 'zod';
+
+/* This file aggregates all ptypes into a single export for external consumption of the compiler api */
+
+var forExport = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ALL_OP_ENUMS: ALL_OP_ENUMS,
+    ARC4BoolClass: ARC4BoolClass,
+    ARC4EncodedType: ARC4EncodedType,
+    ARC4InstanceType: ARC4InstanceType,
+    ARC4StrClass: ARC4StrClass,
+    ARC4StructClass: ARC4StructClass,
+    ARC4StructType: ARC4StructType,
+    ARC4TupleType: ARC4TupleType,
+    AccountFunction: AccountFunction,
+    AddressClass: AddressClass,
+    AnyPType: AnyPType,
+    ApplicationFunctionType: ApplicationFunctionType,
+    ApplicationTxnFunction: ApplicationTxnFunction,
+    ApprovalProgram: ApprovalProgram,
+    Arc4TupleClass: Arc4TupleClass,
+    Arc4TupleGeneric: Arc4TupleGeneric,
+    ArrayLiteralPType: ArrayLiteralPType,
+    ArrayPType: ArrayPType,
+    AssetConfigTxnFunction: AssetConfigTxnFunction,
+    AssetFreezeTxnFunction: AssetFreezeTxnFunction,
+    AssetFunction: AssetFunction,
+    AssetTransferTxnFunction: AssetTransferTxnFunction,
+    BaseContractClassType: BaseContractClassType,
+    BigIntLiteralPType: BigIntLiteralPType,
+    BigUintFunction: BigUintFunction,
+    BooleanFunction: BooleanFunction,
+    BoxFunction: BoxFunction,
+    BoxGeneric: BoxGeneric,
+    BoxMapFunction: BoxMapFunction,
+    BoxMapGeneric: BoxMapGeneric,
+    BoxMapPType: BoxMapPType,
+    BoxPType: BoxPType,
+    BoxRefFunction: BoxRefFunction,
+    BoxRefPType: BoxRefPType,
+    ByteClass: ByteClass,
+    BytesFunction: BytesFunction,
+    ClassMethodDecoratorContext: ClassMethodDecoratorContext,
+    ClearStateProgram: ClearStateProgram,
+    ClusteredContractClassType: ClusteredContractClassType,
+    ClusteredPrototype: ClusteredPrototype,
+    ContractClassPType: ContractClassPType,
+    DynamicArrayConstructor: DynamicArrayConstructor,
+    DynamicArrayGeneric: DynamicArrayGeneric,
+    DynamicArrayType: DynamicArrayType,
+    DynamicBytesConstructor: DynamicBytesConstructor,
+    DynamicBytesType: DynamicBytesType,
+    FunctionPType: FunctionPType,
+    GeneratorGeneric: GeneratorGeneric,
+    GeneratorType: GeneratorType,
+    GenericPType: GenericPType,
+    GlobalStateFunction: GlobalStateFunction,
+    GlobalStateGeneric: GlobalStateGeneric,
+    GlobalStateType: GlobalStateType,
+    GroupTransactionPType: GroupTransactionPType,
+    InnerTransactionPType: InnerTransactionPType,
+    InstanceType: InstanceType,
+    InternalType: InternalType,
+    IntersectionPType: IntersectionPType,
+    IntrinsicEnumType: IntrinsicEnumType,
+    IntrinsicFunctionGroupType: IntrinsicFunctionGroupType,
+    IntrinsicFunctionGroupTypeType: IntrinsicFunctionGroupTypeType,
+    IntrinsicFunctionType: IntrinsicFunctionType,
+    IntrinsicFunctionTypeType: IntrinsicFunctionTypeType,
+    IterableIteratorGeneric: IterableIteratorGeneric,
+    IterableIteratorType: IterableIteratorType,
+    ItxnParamsPType: ItxnParamsPType,
+    KeyRegistrationTxnFunction: KeyRegistrationTxnFunction,
+    LibClassType: LibClassType,
+    LibFunctionType: LibFunctionType,
+    LocalStateFunction: LocalStateFunction,
+    LocalStateGeneric: LocalStateGeneric,
+    LocalStateType: LocalStateType,
+    LogicSigPType: LogicSigPType,
+    NamespacePType: NamespacePType,
+    NativeNumericType: NativeNumericType,
+    NumericLiteralPType: NumericLiteralPType,
+    ObjectPType: ObjectPType,
+    PType: PType,
+    PaymentTxnFunction: PaymentTxnFunction,
+    PolytypeClassMethodHelper: PolytypeClassMethodHelper,
+    PromiseGeneric: PromiseGeneric,
+    PromiseType: PromiseType,
+    StaticArrayConstructor: StaticArrayConstructor,
+    StaticArrayGeneric: StaticArrayGeneric,
+    StaticArrayType: StaticArrayType,
+    StaticBytesConstructor: StaticBytesConstructor,
+    StaticBytesGeneric: StaticBytesGeneric,
+    StaticBytesType: StaticBytesType,
+    StorageProxyPType: StorageProxyPType,
+    StringFunction: StringFunction,
+    SuperPrototypeSelector: SuperPrototypeSelector,
+    SuperPrototypeSelectorGeneric: SuperPrototypeSelectorGeneric,
+    TemplateVarFunction: TemplateVarFunction,
+    TransactionFunction: TransactionFunction,
+    TransactionFunctionType: TransactionFunctionType,
+    TransientType: TransientType,
+    TuplePType: TuplePType,
+    TypeParameterType: TypeParameterType,
+    UFixedNxMClass: UFixedNxMClass,
+    UFixedNxMGeneric: UFixedNxMGeneric,
+    UFixedNxMType: UFixedNxMType,
+    Uint64EnumMemberType: Uint64EnumMemberType,
+    Uint64EnumType: Uint64EnumType,
+    Uint64Function: Uint64Function,
+    UintN128Class: UintN128Class,
+    UintN16Class: UintN16Class,
+    UintN256Class: UintN256Class,
+    UintN32Class: UintN32Class,
+    UintN64Class: UintN64Class,
+    UintN8Class: UintN8Class,
+    UintNClass: UintNClass,
+    UintNGeneric: UintNGeneric,
+    UintNType: UintNType,
+    UnionPType: UnionPType,
+    UnsupportedType: UnsupportedType,
+    accountPType: accountPType,
+    anyGtxnType: anyGtxnType,
+    anyPType: anyPType,
+    applicationCallGtxnType: applicationCallGtxnType,
+    applicationCallItxnFn: applicationCallItxnFn,
+    applicationCallItxnParamsType: applicationCallItxnParamsType,
+    applicationItxnType: applicationItxnType,
+    applicationPType: applicationPType,
+    arc28EmitFunction: arc28EmitFunction,
+    arc4AbiMethodDecorator: arc4AbiMethodDecorator,
+    arc4AddressAlias: arc4AddressAlias,
+    arc4BareMethodDecorator: arc4BareMethodDecorator,
+    arc4BaseContractType: arc4BaseContractType,
+    arc4BooleanType: arc4BooleanType,
+    arc4ByteAlias: arc4ByteAlias,
+    arc4StringType: arc4StringType,
+    arc4StructBaseType: arc4StructBaseType,
+    assertFunction: assertFunction,
+    assertMatchFunction: assertMatchFunction,
+    assetConfigGtxnType: assetConfigGtxnType,
+    assetConfigItxnFn: assetConfigItxnFn,
+    assetConfigItxnParamsType: assetConfigItxnParamsType,
+    assetConfigItxnType: assetConfigItxnType,
+    assetFreezeGtxnType: assetFreezeGtxnType,
+    assetFreezeItxnFn: assetFreezeItxnFn,
+    assetFreezeItxnParamsType: assetFreezeItxnParamsType,
+    assetFreezeItxnType: assetFreezeItxnType,
+    assetPType: assetPType,
+    assetTransferGtxnType: assetTransferGtxnType,
+    assetTransferItxnFn: assetTransferItxnFn,
+    assetTransferItxnParamsType: assetTransferItxnParamsType,
+    assetTransferItxnType: assetTransferItxnType,
+    base64PType: base64PType,
+    baseContractType: baseContractType,
+    bigIntPType: bigIntPType,
+    biguintPType: biguintPType,
+    boolPType: boolPType,
+    boxRefType: boxRefType,
+    bytesPType: bytesPType,
+    compileFunctionType: compileFunctionType,
+    compiledContractType: compiledContractType,
+    compiledLogicSigType: compiledLogicSigType,
+    contractOptionsDecorator: contractOptionsDecorator,
+    decodeArc4Function: decodeArc4Function,
+    ecPType: ecPType,
+    ecdsaPType: ecdsaPType,
+    encodeArc4Function: encodeArc4Function,
+    ensureBudgetFunction: ensureBudgetFunction,
+    errFunction: errFunction,
+    interpretAsArc4Function: interpretAsArc4Function,
+    isAppStorageType: isAppStorageType,
+    keyRegistrationGtxnType: keyRegistrationGtxnType,
+    keyRegistrationItxnFn: keyRegistrationItxnFn,
+    keyRegistrationItxnParamsType: keyRegistrationItxnParamsType,
+    keyRegistrationItxnType: keyRegistrationItxnType,
+    logFunction: logFunction,
+    logicSigBaseType: logicSigBaseType,
+    logicSigOptionsDecorator: logicSigOptionsDecorator,
+    methodSelectorFunction: methodSelectorFunction,
+    mimcConfigurationsPType: mimcConfigurationsPType,
+    neverPType: neverPType,
+    nullPType: nullPType,
+    numberPType: numberPType,
+    onCompleteActionType: onCompleteActionType,
+    opUpFeeSourceType: opUpFeeSourceType,
+    paymentGtxnType: paymentGtxnType,
+    paymentItxnFn: paymentItxnFn,
+    paymentItxnParamsType: paymentItxnParamsType,
+    paymentItxnType: paymentItxnType,
+    ptypeToArc4EncodedType: ptypeToArc4EncodedType,
+    stringPType: stringPType,
+    submitGroupItxnFunction: submitGroupItxnFunction,
+    transactionTypeType: transactionTypeType,
+    uint64PType: uint64PType,
+    undefinedPType: undefinedPType,
+    unknownPType: unknownPType,
+    urangeFunction: urangeFunction,
+    voidPType: voidPType,
+    vrfVerifyPType: vrfVerifyPType
+});
+
+const encodingUtil = {
+    utf8ToUint8Array,
+    bigIntToUint8Array,
+    hexToUint8Array,
+    base32ToUint8Array,
+    base64ToUint8Array,
+    uint8ArrayToUtf8,
+    uint8ArrayToHex,
+    uint8ArrayToBase32,
+    uint8ArrayToBase64,
+    uint8ArrayToBigInt,
+};
+
+export { encodingUtil, forExport as ptypes };
 //# sourceMappingURL=index.mjs.map

package/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":["../src/awst_build/ptypes/for-export.ts","../src/index.ts"],"sourcesContent":["/* This file aggregates all ptypes into a single export for external consumption of the compiler api */\nexport { ptypeToArc4EncodedType } from '../arc4-util'\nexport * from './arc4-types'\nexport * from './index'\n","import {\n  base32ToUint8Array,\n  base64ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n  uint8ArrayToHex,\n  uint8ArrayToUtf8,\n  utf8ToUint8Array,\n} from './util'\n\nexport { SourceLocation } from './awst/source-location'\nexport * as ptypes from './awst_build/ptypes/for-export'\nexport { registerPTypes } from './awst_build/ptypes/register'\nexport { typeRegistry } from './awst_build/type-registry'\nexport { TypeResolver } from './awst_build/type-resolver'\nexport { compile } from './compile'\nexport { LoggingContext } from './logger'\n\nexport const encodingUtil = {\n  utf8ToUint8Array,\n  bigIntToUint8Array,\n  hexToUint8Array,\n  base32ToUint8Array,\n  base64ToUint8Array,\n  uint8ArrayToUtf8,\n  uint8ArrayToHex,\n  uint8ArrayToBase32,\n  uint8ArrayToBase64,\n  uint8ArrayToBigInt,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqBa,MAAA,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}

package/logger/index.d.ts

@@ -30,15 +30,15 @@ declare class PuyaLogger {
 }
 export declare const logger: PuyaLogger;
 export declare const logPuyaExceptions: <T>(action: () => T, sourceLocation: SourceLocation) => T;
-export declare class LoggingContext implements Disposable {
+export declare class LoggingContext {
     logEvents: LogEvent[];
     sourcesByPath: Record<string, string[]>;
     private constructor();
     hasErrors(): boolean;
     exitIfErrors(): void;
-    private static contexts;
-    static create(): Disposable & LoggingContext;
+    run<R>(cb: () => R): R;
+    private static asyncStore;
+    static create(): LoggingContext;
     static get current(): LoggingContext;
-    [Symbol.dispose](): void;
 }
 export {};

package/package.json

@@ -4,23 +4,23 @@
     "**"
   ],
   "name": "@algorandfoundation/puya-ts",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.15",
   "description": "Compiles Algorand TypeScript into byte code which runs on the Algorand Virtual Machine (AVM)",
   "private": false,
   "author": "Algorand foundation",
   "license": "MIT",
   "dependencies": {
     "arcsecond": "^5.0.0",
+    "argparse": "^2.0.1",
     "chalk": "^5.3.0",
     "change-case": "^5.4.4",
-    "commander": "^12.1.0",
     "cross-spawn": "7.0.6",
     "glob": "^11.0.0",
     "polytype": "^0.17.0",
     "typescript": "^5.7.2",
     "upath": "^2.0.1",
     "which": "^5.0.0",
-    "zod": "^3.24.0"
+    "zod": "^3.24.1"
   },
   "overrides": {
     "cross-spawn": "7.0.6",

package/parser/index.d.ts

@@ -1,9 +1,9 @@
 import ts from 'typescript';
-import type { CompileOptions } from '../compile-options';
+import type { PuyaTsCompileOptions } from '../compile-options';
 export type SourceFileMapping = Record<string, ts.SourceFile>;
 export type CreateProgramResult = {
     sourceFiles: SourceFileMapping;
     program: ts.Program;
     programDirectory: string;
 };
-export declare function createTsProgram(options: CompileOptions): CreateProgramResult;
+export declare function createTsProgram(options: PuyaTsCompileOptions): CreateProgramResult;

package/puya/check-puya-version.d.ts

@@ -3,11 +3,12 @@ export declare enum VersionCompareVerdict {
     Inconclusive = "Inconclusive",
     MajorMismatch = "MajorMismatch",
     MinorMismatch = "MinorMismatch",
-    RevisionMismatch = "RevisionMismatch"
+    OlderRevision = "OlderRevision",
+    NewerRevision = "NewerRevision"
 }
-export declare function comparePuyaVersion(): {
+export declare function comparePuyaVersion(): Promise<{
     target: string;
     found?: string;
     verdict: VersionCompareVerdict;
-};
-export declare function checkPuyaVersion(): void;
+}>;
+export declare function checkPuyaVersion(): Promise<void>;

package/puya/index.d.ts

@@ -1,13 +1,13 @@
 import type { AWST } from '../awst/nodes';
 import type { CompilationSet } from '../awst_build/models/contract-class-model';
-import type { CompileOptions } from '../compile-options';
+import type { PuyaTsCompileOptions } from '../compile-options';
 import type { SourceFileMapping } from '../parser';
 import type { PuyaPassThroughOptions } from './options';
 export declare function invokePuya({ moduleAwst, programDirectory, sourceFiles, compileOptions, compilationSet, passThroughOptions, }: {
     moduleAwst: AWST[];
     programDirectory: string;
     sourceFiles: SourceFileMapping;
-    compileOptions: CompileOptions;
+    compileOptions: PuyaTsCompileOptions;
     compilationSet: CompilationSet;
     passThroughOptions: PuyaPassThroughOptions;
-}): void;
+}): Promise<void>;

package/puya/run-puya.d.ts

@@ -3,4 +3,4 @@ export declare function runPuya({ command, args, cwd, onOutput, }: {
     args: string[];
     cwd?: string;
     onOutput: (line: string) => void;
-}): void;
+}): Promise<void>;

package/util/invoke-cli.d.ts

@@ -0,0 +1,13 @@
+type InvokeCliOptions = {
+    command: string;
+    args: string[];
+    cwd?: string;
+    onReceiveLine?(line: string): void;
+    dontThrowOnNonzeroCode?: boolean;
+};
+type InvokeCliResponse = {
+    lines: string[];
+    code: number;
+};
+export declare function invokeCli(options: InvokeCliOptions): Promise<InvokeCliResponse>;
+export {};