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

package/awst/validation/arc4-approval-calls-router.d.ts

@@ -0,0 +1,9 @@
+import type { ARC4Router, AWST, ContractMethod, SubroutineCallExpression } from '../nodes';
+import { FunctionTraverser } from './awst-traverser';
+export declare class Arc4ApprovalCallsRouter extends FunctionTraverser {
+    #private;
+    static validate(awst: AWST[]): void;
+    validate(approvalProgram: ContractMethod): void;
+    visitSubroutineCallExpression(expression: SubroutineCallExpression): void;
+    visitARC4Router(expression: ARC4Router): void;
+}

package/awst/validation/awst-traverser.d.ts

@@ -0,0 +1,87 @@
+import type { AddressConstant, AppAccountStateExpression, AppStateExpression, AppStorageDefinition, ARC4Decode, ARC4Encode, ARC4Router, ArrayConcat, ArrayExtend, ArrayPop, AssertExpression, AssignmentExpression, AssignmentStatement, BigUIntAugmentedAssignment, BigUIntBinaryOperation, BigUIntPostfixUnaryOperation, Block, BoolConstant, BooleanBinaryOperation, BoxValueExpression, BytesAugmentedAssignment, BytesBinaryOperation, BytesComparisonExpression, BytesConstant, BytesUnaryOperation, CheckedMaybe, CompiledContract, CompiledLogicSig, ConditionalExpression, Contract, ContractMemberNodeVisitor, ContractMethod, Copy, CreateInnerTransaction, DecimalConstant, Emit, Enumeration, ExpressionStatement, ExpressionVisitor, FieldExpression, ForInLoop, Goto, GroupTransactionReference, IfElse, IndexExpression, InnerTransactionField, IntegerConstant, IntersectionSliceExpression, IntrinsicCall, LogicSignature, LoopContinue, LoopExit, MethodConstant, NewArray, NewStruct, Not, NumericComparisonExpression, PuyaLibCall, Range, ReinterpretCast, ReturnStatement, Reversed, RootNodeVisitor, SingleEvaluation, SliceExpression, StateDelete, StateExists, StateGet, StateGetEx, StatementVisitor, StringConstant, SubmitInnerTransaction, Subroutine, SubroutineCallExpression, Switch, TemplateVar, TupleExpression, TupleItemExpression, UInt64AugmentedAssignment, UInt64BinaryOperation, UInt64PostfixUnaryOperation, UInt64UnaryOperation, UpdateInnerTransaction, VarExpression, VoidConstant, WhileLoop } from '../nodes';
+export declare class FunctionTraverser implements ExpressionVisitor<void>, StatementVisitor<void> {
+    visitExpressionStatement(statement: ExpressionStatement): void;
+    visitBlock(statement: Block): void;
+    visitGoto(statement: Goto): void;
+    visitIfElse(statement: IfElse): void;
+    visitSwitch(statement: Switch): void;
+    visitWhileLoop(statement: WhileLoop): void;
+    visitLoopExit(statement: LoopExit): void;
+    visitLoopContinue(statement: LoopContinue): void;
+    visitReturnStatement(statement: ReturnStatement): void;
+    visitAssignmentStatement(statement: AssignmentStatement): void;
+    visitUInt64AugmentedAssignment(statement: UInt64AugmentedAssignment): void;
+    visitBigUIntAugmentedAssignment(statement: BigUIntAugmentedAssignment): void;
+    visitBytesAugmentedAssignment(statement: BytesAugmentedAssignment): void;
+    visitForInLoop(statement: ForInLoop): void;
+    visitAssertExpression(expression: AssertExpression): void;
+    visitIntegerConstant(expression: IntegerConstant): void;
+    visitDecimalConstant(expression: DecimalConstant): void;
+    visitBoolConstant(expression: BoolConstant): void;
+    visitBytesConstant(expression: BytesConstant): void;
+    visitStringConstant(expression: StringConstant): void;
+    visitVoidConstant(expression: VoidConstant): void;
+    visitTemplateVar(expression: TemplateVar): void;
+    visitMethodConstant(expression: MethodConstant): void;
+    visitAddressConstant(expression: AddressConstant): void;
+    visitARC4Encode(expression: ARC4Encode): void;
+    visitCopy(expression: Copy): void;
+    visitArrayConcat(expression: ArrayConcat): void;
+    visitArrayPop(expression: ArrayPop): void;
+    visitArrayExtend(expression: ArrayExtend): void;
+    visitARC4Decode(expression: ARC4Decode): void;
+    visitIntrinsicCall(expression: IntrinsicCall): void;
+    visitCreateInnerTransaction(expression: CreateInnerTransaction): void;
+    visitUpdateInnerTransaction(expression: UpdateInnerTransaction): void;
+    visitGroupTransactionReference(expression: GroupTransactionReference): void;
+    visitCheckedMaybe(expression: CheckedMaybe): void;
+    visitTupleExpression(expression: TupleExpression): void;
+    visitTupleItemExpression(expression: TupleItemExpression): void;
+    visitVarExpression(expression: VarExpression): void;
+    visitInnerTransactionField(expression: InnerTransactionField): void;
+    visitSubmitInnerTransaction(expression: SubmitInnerTransaction): void;
+    visitFieldExpression(expression: FieldExpression): void;
+    visitIndexExpression(expression: IndexExpression): void;
+    visitSliceExpression(expression: SliceExpression): void;
+    visitIntersectionSliceExpression(expression: IntersectionSliceExpression): void;
+    visitAppStateExpression(expression: AppStateExpression): void;
+    visitAppAccountStateExpression(expression: AppAccountStateExpression): void;
+    visitBoxValueExpression(expression: BoxValueExpression): void;
+    visitSingleEvaluation(expression: SingleEvaluation): void;
+    visitReinterpretCast(expression: ReinterpretCast): void;
+    visitNewArray(expression: NewArray): void;
+    visitConditionalExpression(expression: ConditionalExpression): void;
+    visitAssignmentExpression(expression: AssignmentExpression): void;
+    visitNumericComparisonExpression(expression: NumericComparisonExpression): void;
+    visitBytesComparisonExpression(expression: BytesComparisonExpression): void;
+    visitSubroutineCallExpression(expression: SubroutineCallExpression): void;
+    visitPuyaLibCall(expression: PuyaLibCall): void;
+    visitUInt64UnaryOperation(expression: UInt64UnaryOperation): void;
+    visitUInt64PostfixUnaryOperation(expression: UInt64PostfixUnaryOperation): void;
+    visitBigUIntPostfixUnaryOperation(expression: BigUIntPostfixUnaryOperation): void;
+    visitBytesUnaryOperation(expression: BytesUnaryOperation): void;
+    visitUInt64BinaryOperation(expression: UInt64BinaryOperation): void;
+    visitBigUIntBinaryOperation(expression: BigUIntBinaryOperation): void;
+    visitBytesBinaryOperation(expression: BytesBinaryOperation): void;
+    visitBooleanBinaryOperation(expression: BooleanBinaryOperation): void;
+    visitNot(expression: Not): void;
+    visitEmit(expression: Emit): void;
+    visitRange(expression: Range): void;
+    visitEnumeration(expression: Enumeration): void;
+    visitReversed(expression: Reversed): void;
+    visitStateGet(expression: StateGet): void;
+    visitStateGetEx(expression: StateGetEx): void;
+    visitStateExists(expression: StateExists): void;
+    visitStateDelete(expression: StateDelete): void;
+    visitNewStruct(expression: NewStruct): void;
+    visitCompiledContract(expression: CompiledContract): void;
+    visitCompiledLogicSig(expression: CompiledLogicSig): void;
+    visitARC4Router(expression: ARC4Router): void;
+}
+export declare class AwstTraverser extends FunctionTraverser implements RootNodeVisitor<void>, ContractMemberNodeVisitor<void> {
+    visitContractMethod(contractMemberNode: ContractMethod): void;
+    visitAppStorageDefinition(contractMemberNode: AppStorageDefinition): void;
+    visitSubroutine(rootNode: Subroutine): void;
+    visitLogicSignature(rootNode: LogicSignature): void;
+    visitContract(rootNode: Contract): void;
+}

package/awst/validation/index.d.ts

@@ -0,0 +1,2 @@
+import type { AWST } from '../nodes';
+export declare function validateAwst(awst: AWST[]): void;

package/awst_build/index.d.ts

@@ -1,5 +1,5 @@
 import type { AWST } from '../awst/nodes';
-import type { CompileOptions } from '../compile-options';
+import type { PuyaTsCompileOptions } from '../compile-options';
 import type { CreateProgramResult } from '../parser';
 import type { CompilationSet } from './models/contract-class-model';
-export declare function buildAwst({ program, sourceFiles }: CreateProgramResult, options: CompileOptions): [AWST[], CompilationSet];
+export declare function buildAwst({ program, sourceFiles }: CreateProgramResult, options: PuyaTsCompileOptions): [AWST[], CompilationSet];

package/bin/run-cli.mjs

@@ -1,23 +1,24 @@
 #!/usr/bin/env node
 import '../cli.mjs';
-import 'tslib';
-import 'commander';
-import 'zod';
-import 'glob';
-import 'node:fs';
-import 'upath';
-import '../index-B46QirKR.js';
-import 'change-case';
-import 'node:path';
+import 'argparse';
+import '../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 'os';
 import 'cross-spawn';
 import 'which';
+import 'zod';
 import 'chalk';
 //# sourceMappingURL=run-cli.mjs.map

package/bin/run-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"run-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"run-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}

package/cli/build-command.d.ts

@@ -0,0 +1,31 @@
+import type { SubParser } from 'argparse';
+import { LogLevel } from '../logger';
+import { LocalsCoalescingStrategy } from '../puya/options';
+export interface BuildCommandArgs {
+    command: 'build';
+    log_level: LogLevel;
+    output_awst: boolean;
+    output_awst_json: boolean;
+    dry_run: boolean;
+    skip_version_check: boolean;
+    output_teal: boolean;
+    output_source_map: boolean;
+    output_arc32: boolean;
+    output_arc56: boolean;
+    output_ssa_ir: boolean;
+    output_optimization_ir: boolean;
+    output_destructured_ir: boolean;
+    output_memory_ir: boolean;
+    output_bytecode: boolean;
+    match_algod_bytecode: boolean;
+    out_dir: string;
+    debug_level: string;
+    optimization_level: string;
+    target_avm_version: string;
+    cli_template_definitions: string[];
+    template_vars_prefix: string;
+    locals_coalescing_strategy: LocalsCoalescingStrategy;
+    paths: string[];
+}
+export declare function addBuildCommand(subparsers: SubParser): void;
+export declare function buildCommand(args: BuildCommandArgs): Promise<void>;

package/cli/parse.d.ts

@@ -0,0 +1 @@
+export declare function parseCliArguments(): Promise<void>;

package/cli/util.d.ts

@@ -0,0 +1,8 @@
+import type { ArgumentParser } from 'argparse';
+export declare function addEnumArg<T>(parser: ArgumentParser, { name, enumType, default: defaultValue, help }: {
+    name: string;
+    enumType: Record<string, string>;
+    default?: T;
+    help: string;
+}): void;
+export declare function convertInt(val: string): number;

package/cli.mjs

@@ -1,79 +1,24 @@
-import { __addDisposableResource, __disposeResources } from 'tslib';
-import { Command, Option } from 'commander';
-import { z } from 'zod';
-import { globSync } from 'glob';
-import * as fs from 'node:fs';
-import upath from 'upath';
-import { n as normalisePath, l as logger, P as PuyaError, L as LoggingContext, a as LogLevel, b as LocalsCoalescingStrategy, d as defaultPuyaOptions, c as compile } from './index-B46QirKR.js';
+import { BooleanOptionalAction, ArgumentParser } from 'argparse';
+import { cr as LoggingContext, cs as enumFromValue, ct as defaultPuyaOptions, cu as logger, cq as compile, cv as LogLevel, cw as LocalsCoalescingStrategy } from './compile-BcG41O6Z.js';
 import chalk from 'chalk';
-import 'change-case';
-import 'node:path';
+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 'os';
 import 'cross-spawn';
 import 'which';
-
-const buildCompileOptions = ({ paths, workingDirectory = process.cwd(), outDir, ...rest }) => {
-    const filePaths = [];
-    for (const p of paths) {
-        if (p.endsWith('.algo.ts')) {
-            if (fs.existsSync(p)) {
-                const actualPath = normalisePath(p, workingDirectory);
-                filePaths.push({
-                    matchedInput: p,
-                    sourceFile: actualPath,
-                    outDir: upath.isAbsolute(outDir) ? upath.normalize(outDir) : upath.join(upath.dirname(actualPath), outDir),
-                });
-            }
-            else {
-                logger.warn(undefined, `File ${p} could not be found`);
-            }
-        }
-        else if (p.endsWith('.ts')) {
-            logger.warn(undefined, `Ignoring path ${p} as it does use the .algo.ts extension`);
-        }
-        else {
-            const matches = globSync(upath.join(p, '**/*.algo.ts'));
-            if (matches.length) {
-                for (const match of matches) {
-                    filePaths.push({
-                        matchedInput: p,
-                        sourceFile: normalisePath(match, workingDirectory),
-                        outDir: upath.join(upath.isAbsolute(outDir) ? outDir : upath.join(p, outDir), upath.relative(p, upath.dirname(match))),
-                    });
-                }
-            }
-            else {
-                logger.warn(undefined, `Path '${p}' did not match any .algo.ts files`);
-            }
-        }
-    }
-    if (filePaths.length === 0) {
-        throw new PuyaError('Input paths did not match any .algo.ts files');
-    }
-    return {
-        filePaths: filePaths.map(replaceOutDirTokens),
-        ...rest,
-        getFileFromSource(sourceFile) {
-            return this.filePaths.find((p) => p.sourceFile === sourceFile);
-        },
-    };
-};
-function replaceOutDirTokens(algoFile) {
-    const replacements = {
-        name: upath.basename(algoFile.sourceFile).replace('.algo.ts', ''),
-    };
-    return {
-        ...algoFile,
-        outDir: algoFile.outDir.replaceAll('[name]', replacements.name),
-    };
-}
+import 'zod';
 
 const levelConfig = {
     /* eslint-disable no-console */
@@ -111,144 +56,212 @@ class ConsoleLogSink {
     }
 }
 
-const cmdInteger = () => z.preprocess((x) => (typeof x === 'string' && x.length > 0 ? Number(x) : x), z.number().int());
-const cliOptionsSchema = z.object({
-    outputAwst: z.boolean(),
-    outputAwstJson: z.boolean(),
-    outDir: z.string(),
-    dryRun: z.boolean(),
-    logLevel: z.nativeEnum(LogLevel),
-    isolatedFiles: z.boolean(),
-    // Puya options
-    outputSourceMap: z.boolean(),
-    outputTeal: z.boolean(),
-    outputArc32: z.boolean(),
-    outputArc56: z.boolean(),
-    outputSsaIr: z.boolean(),
-    outputOptimizationIr: z.boolean(),
-    outputDestructuredIr: z.boolean(),
-    outputMemoryIr: z.boolean(),
-    outputBytecode: z.boolean(),
-    matchAlgodBytecode: z.boolean(),
-    debugLevel: cmdInteger(),
-    optimizationLevel: cmdInteger(),
-    targetAvmVersion: cmdInteger(),
-    cliTemplateDefinitions: z.preprocess((x) => x ?? [], z.array(z.string())),
-    templateVarsPrefix: z.string(),
-    localsCoalescingStrategy: z.nativeEnum(LocalsCoalescingStrategy),
-});
-const cliArgumentsSchema = z.array(z.string());
-function cli() {
-    const commander = new Command().name('puya-ts').description('Algo-TS to Algorand smart contract compiler');
-    commander.helpCommand(true);
-    commander
-        .command('build')
-        .argument('<paths...>', 'The path, or paths to search for compatible .algo.ts files')
-        .addOption(new Option('--log-level [level]', 'The minimum log level to output')
-        .choices([LogLevel.Debug, LogLevel.Info, LogLevel.Warning, LogLevel.Error, LogLevel.Critical])
-        .default(LogLevel.Info))
-        .addOption(new Option('--output-awst', 'Output debugging awst file per parsed file').default(false))
-        .addOption(new Option('--output-awst-json', 'Output debugging awst json file per parsed file').default(false))
-        .addOption(new Option('--out-dir [outDir]').default('out'))
-        .addOption(new Option('--dry-run', "Just parse typescript files, don't invoke puya compiler").default(false))
-        .addOption(new Option('--isolated-files', 'Invoke compilation on each input file individually').default(false))
-        .addOption(new Option('--no-output-teal', 'Do not output TEAL code').default(defaultPuyaOptions.outputTeal))
-        .addOption(new Option('--output-source-map', 'Output debug source maps ').default(defaultPuyaOptions.outputSourceMap))
-        .addOption(new Option('--no-output-arc32', 'Do not output {contract}.arc32.json ARC-32 app spec file. Only applicable to ARC4 contracts').default(defaultPuyaOptions.outputArc32))
-        .addOption(new Option('--output-arc56', 'Output {contract}.arc56.json ARC-56 app spec file. Only applicable to ARC4 contracts').default(defaultPuyaOptions.outputArc56))
-        .addOption(new Option('--output-ssa-ir', 'Output IR (in SSA form) before optimisations').default(defaultPuyaOptions.outputSsaIr))
-        .addOption(new Option('--output-optimization-ir', 'Output IR after each optimization').default(defaultPuyaOptions.outputOptimizationIr))
-        .addOption(new Option('--output-destructured-ir', 'Output IR after SSA destructuring and before MIR').default(defaultPuyaOptions.outputDestructuredIr))
-        .addOption(new Option('--output-memory-ir', 'Output MIR before lowering to TealOps').default(defaultPuyaOptions.outputMemoryIr))
-        .addOption(new Option('--output-bytecode', 'Output AVM bytecode').default(defaultPuyaOptions.outputBytecode))
-        .addOption(new Option('--match-algod-bytecode', 'When outputting bytecode, ensure bytecode matches algod output').default(defaultPuyaOptions.matchAlgodBytecode))
-        .addOption(new Option('--debug-level [level]', 'Output debug information level, 0 = none, 1 = debug, 2 = reserved for future use')
-        .choices(['0', '1', '2'])
-        .default(defaultPuyaOptions.debugLevel))
-        .addOption(new Option('--optimization-level [level]', 'Set optimization level of output TEAL / AVM bytecode')
-        .choices(['0', '1', '2'])
-        .default(defaultPuyaOptions.optimizationLevel))
-        .addOption(new Option('--target-avm-version [version]', '').choices(['10', '11']).default(10))
-        .addOption(new Option('--cli-template-definitions <...definitions>', 'Define template vars for use when assembling via --output-bytecode, should be specified without the prefix (see --template-vars-prefix)'))
-        .addOption(new Option('--template-vars-prefix [prefix]', 'Define the prefix to use with --template-var').default(defaultPuyaOptions.templateVarsPrefix))
-        .addOption(new Option('--locals-coalescing-strategy', '')
-        .default(defaultPuyaOptions.localsCoalescingStrategy)
-        .choices([
-        LocalsCoalescingStrategy.root_operand,
-        LocalsCoalescingStrategy.root_operand_excluding_args,
-        LocalsCoalescingStrategy.aggressive,
-    ]))
-        .action((a, o) => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
+function addEnumArg(parser, { name, enumType, default: defaultValue, help }) {
+    parser.add_argument(name, {
+        type: (v) => enumFromValue(v, enumType),
+        choices: Array.from(Object.values(enumType)),
+        default: defaultValue,
+        help,
+    });
+}
+function convertInt(val) {
+    const res = Number(val);
+    if (isNaN(res) || Math.round(res) !== res) {
+        throw new Error(`'${val}' could not be converted to a number`);
+    }
+    return res;
+}
+
+function addBuildCommand(subparsers) {
+    const buildParser = subparsers.add_parser('build', {
+        description: 'Build a smart contract or logic signature',
+        help: `When provided with a directory or .algo.ts file, parses and compiles all smart contracts and logic signatures found in the directory or file and outputs compilation artifacts.`,
+    });
+    addEnumArg(buildParser, {
+        name: '--log-level',
+        default: LogLevel.Info,
+        enumType: LogLevel,
+        help: 'The minimum log level to output',
+    });
+    buildParser.add_argument('--output-awst', {
+        help: 'Output debugging awst file per parsed file',
+        default: false,
+        action: BooleanOptionalAction,
+    });
+    buildParser.add_argument('--output-awst-json', {
+        action: BooleanOptionalAction,
+        default: false,
+        help: 'Output debugging awst json file per parsed file',
+    });
+    buildParser.add_argument('--dry-run', {
+        action: BooleanOptionalAction,
+        default: false,
+        help: "Just parse typescript files, don't invoke puya compiler",
+    });
+    buildParser.add_argument('--skip-version-check', {
+        action: BooleanOptionalAction,
+        default: false,
+        help: "Don't verify installed puya compiler version matches targeted version",
+    });
+    buildParser.add_argument('--output-teal', {
+        action: BooleanOptionalAction,
+        help: 'Output TEAL code',
+        default: defaultPuyaOptions.outputTeal,
+    });
+    buildParser.add_argument('--output-source-map', {
+        action: BooleanOptionalAction,
+        help: 'Output debug source maps ',
+        default: defaultPuyaOptions.outputSourceMap,
+    });
+    buildParser.add_argument('--output-arc32', {
+        action: BooleanOptionalAction,
+        help: 'Output {contract}.arc32.json ARC-32 app spec file. Only applicable to ARC4 contracts ',
+        default: defaultPuyaOptions.outputArc32,
+    });
+    buildParser.add_argument('--output-arc56', {
+        action: BooleanOptionalAction,
+        help: 'Output {contract}.arc56.json ARC-56 app spec file. Only applicable to ARC4 contracts ',
+        default: defaultPuyaOptions.outputArc56,
+    });
+    buildParser.add_argument('--output-ssa-ir', {
+        action: BooleanOptionalAction,
+        help: 'Output IR (in SSA form) before optimisations',
+        default: defaultPuyaOptions.outputSsaIr,
+    });
+    buildParser.add_argument('--output-optimization-ir', {
+        action: BooleanOptionalAction,
+        help: 'Output IR after each optimization',
+        default: defaultPuyaOptions.outputOptimizationIr,
+    });
+    buildParser.add_argument('--output-destructured-ir', {
+        action: BooleanOptionalAction,
+        help: 'Output IR after SSA destructuring and before MIR',
+        default: defaultPuyaOptions.outputDestructuredIr,
+    });
+    buildParser.add_argument('--output-memory-ir', {
+        action: BooleanOptionalAction,
+        help: 'Output MIR before lowering to TealOps',
+        default: defaultPuyaOptions.outputMemoryIr,
+    });
+    buildParser.add_argument('--output-bytecode', {
+        action: BooleanOptionalAction,
+        help: 'Output AVM bytecode',
+        default: defaultPuyaOptions.outputBytecode,
+    });
+    buildParser.add_argument('--match-algod-bytecode', {
+        action: BooleanOptionalAction,
+        help: 'When outputting bytecode, ensure bytecode matches algod output',
+        default: defaultPuyaOptions.matchAlgodBytecode,
+    });
+    buildParser.add_argument('--out-dir', {
+        action: 'store',
+        help: 'Where to output builder artifacts. Can use [name] placeholder to include contract name in path',
+        default: 'out',
+    });
+    buildParser.add_argument('--debug-level', {
+        default: defaultPuyaOptions.debugLevel.toString(),
+        choices: ['0', '1', '2'],
+        help: 'Output debug information level, 0 = none, 1 = debug, 2 = reserved for future use',
+    });
+    buildParser.add_argument('--optimization-level', {
+        default: defaultPuyaOptions.optimizationLevel.toString(),
+        choices: ['0', '1', '2'],
+        help: 'Set optimization level of output TEAL / AVM bytecode, 0 = none, 1 = normal, 2 = intensive',
+    });
+    buildParser.add_argument('--target-avm-version', {
+        default: defaultPuyaOptions.targetAvmVersion.toString(),
+        choices: ['10', '11'],
+        help: 'Select the targeted AVM version for compilation output',
+    });
+    buildParser.add_argument('--cli-template-definitions', {
+        metavar: 'VAR=VALUE',
+        nargs: '+',
+        help: 'Define template vars for use when assembling via --output-bytecode, should be specified without the prefix (see --template-vars-prefix)',
+    });
+    buildParser.add_argument('--template-vars-prefix', {
+        help: 'Define the prefix to use with --template-var',
+        default: defaultPuyaOptions.templateVarsPrefix,
+    });
+    addEnumArg(buildParser, {
+        name: '--locals-coalescing-strategy',
+        enumType: LocalsCoalescingStrategy,
+        help: 'Strategy choice for out-of-ssa local variable coalescing. The best choice for your app is best determined through experimentation',
+        default: defaultPuyaOptions.localsCoalescingStrategy,
+    });
+    buildParser.add_argument('paths', {
+        metavar: 'PATHS',
+        nargs: '+',
+        help: 'The path, or paths to search for compatible .algo.ts files',
+    });
+    buildParser.set_defaults({
+        command: 'build',
+    });
+}
+async function buildCommand(args) {
+    const logCtx = LoggingContext.create();
+    return logCtx.run(async () => {
+        logger.configure([new ConsoleLogSink(args.log_level)]);
         try {
-            const logCtx = __addDisposableResource(env_1, LoggingContext.create(), false);
-            logger.configure([new ConsoleLogSink(LogLevel.Warning)]);
-            try {
-                const paths = cliArgumentsSchema.parse(a);
-                const cliOptions = cliOptionsSchema.parse(o);
-                logger.configure([new ConsoleLogSink(cliOptions.logLevel)]);
-                const compileOptions = buildCompileOptions({
-                    paths,
-                    ...cliOptions,
-                });
-                const passThroughOptions = cliOptions;
-                if (cliOptions.isolatedFiles) {
-                    let anyHasErrors = false;
-                    for (const file of compileOptions.filePaths) {
-                        const env_2 = { stack: [], error: void 0, hasError: false };
-                        try {
-                            const logCtx = __addDisposableResource(env_2, LoggingContext.create(), false);
-                            try {
-                                compile({
-                                    ...compileOptions,
-                                    filePaths: [file],
-                                }, passThroughOptions);
-                            }
-                            catch (e) {
-                                logger.critical(undefined, `Compilation failure: ${e}`);
-                            }
-                            anyHasErrors ||= logCtx.hasErrors();
-                        }
-                        catch (e_1) {
-                            env_2.error = e_1;
-                            env_2.hasError = true;
-                        }
-                        finally {
-                            __disposeResources(env_2);
-                        }
-                    }
-                    if (anyHasErrors) {
-                        process.exit(-1);
-                    }
-                }
-                else {
-                    compile(compileOptions, passThroughOptions);
-                    logCtx.exitIfErrors();
-                }
+            await compile({
+                paths: args.paths,
+                outputAwst: args.output_awst,
+                outputAwstJson: args.output_awst_json,
+                outDir: args.out_dir,
+                skipVersionCheck: args.skip_version_check,
+                dryRun: args.dry_run,
+                logLevel: args.log_level,
+                outputTeal: args.output_teal,
+                outputArc32: args.output_arc32,
+                outputArc56: args.output_arc56,
+                outputSsaIr: args.output_ssa_ir,
+                outputOptimizationIr: args.output_optimization_ir,
+                outputDestructuredIr: args.output_destructured_ir,
+                outputMemoryIr: args.output_memory_ir,
+                outputBytecode: args.output_bytecode,
+                outputSourceMap: args.output_source_map,
+                matchAlgodBytecode: args.match_algod_bytecode,
+                debugLevel: convertInt(args.debug_level),
+                optimizationLevel: convertInt(args.optimization_level),
+                targetAvmVersion: convertInt(args.target_avm_version),
+                cliTemplateDefinitions: args.cli_template_definitions,
+                templateVarsPrefix: args.template_vars_prefix,
+                localsCoalescingStrategy: args.locals_coalescing_strategy,
+            });
+            logCtx.exitIfErrors();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                logger.error(e);
             }
-            catch (e) {
-                if (e instanceof Error) {
-                    logger.error(e);
-                }
-                else {
-                    throw e;
-                }
+            else {
+                throw e;
             }
         }
-        catch (e_2) {
-            env_1.error = e_2;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
     });
-    if (process.argv.length < 3) {
-        commander.help();
-    }
-    else {
-        commander.parse(process.argv);
+}
+
+async function parseCliArguments() {
+    const parser = new ArgumentParser({
+        prog: 'puya-ts',
+    });
+    parser.add_argument('--version', {
+        action: 'version',
+        version: 'puya-ts TODO',
+    });
+    parser.set_defaults({
+        command: 'none',
+    });
+    addBuildCommand(parser.add_subparsers());
+    const result = parser.parse_args();
+    switch (result.command) {
+        case 'build':
+            await buildCommand(result);
+            break;
+        default:
+            parser.print_help();
+            break;
     }
 }
-cli();
+
+void parseCliArguments();
 //# sourceMappingURL=cli.mjs.map