@chainlink/cre-sdk 1.6.0-alpha.2 → 1.6.0-alpha.4

package/README.md

@@ -58,10 +58,16 @@ CRE workflows are compiled to WASM and executed through Javy (QuickJS). This is
 
 - Node built-ins like `node:fs`, `node:crypto`, `node:http`, `node:net`, etc. are not supported in workflows.
 - Browser globals like `fetch`, `window`, and `setTimeout` are also not available in workflow runtime.
-- `cre compile:workflow` / `cre-compile` now validates workflow source and fails fast when unsupported APIs are used.
+- `cre compile:workflow` / `cre-compile` now typechecks your workflow project first (using your nearest `tsconfig.json`), then validates workflow source and fails fast when unsupported APIs are used.
 
 Use CRE capabilities (for example, `cre.capabilities.HTTPClient`) instead of direct Node/browser APIs.
 
+If you need to compile despite TypeScript errors, pass `--skip-type-checks`:
+
+```bash
+bun x cre-compile src/workflow.ts dist/workflow.wasm --skip-type-checks
+```
+
 ## Getting Started
 
 We recommend you consult the [getting started docs](https://docs.chain.link/cre/getting-started/cli-installation) and install the CRE CLI.

package/bin/cre-compile.ts

@@ -1,19 +1,31 @@
 #!/usr/bin/env bun
 
 import { main as compileWorkflow } from "../scripts/src/compile-workflow";
-import { parseCompileFlags } from "../../cre-sdk-javy-plugin/scripts/parse-compile-flags";
+import { parseCompileFlags } from "@chainlink/cre-sdk-javy-plugin/scripts/parse-compile-flags";
+import {
+  parseCompileCliArgs,
+  skipTypeChecksFlag,
+} from "../scripts/src/compile-cli-args";
+import { WorkflowTypecheckError } from "../scripts/src/typecheck-workflow";
 import { WorkflowRuntimeCompatibilityError } from "../scripts/src/validate-workflow-runtime-compat";
 
 const main = async () => {
   const cliArgs = process.argv.slice(2);
   const { creExports, plugin, rest } = parseCompileFlags(cliArgs);
 
-  const inputPath = rest[0];
-  const outputPathArg = rest[1];
+  let inputPath: string | undefined;
+  let outputPathArg: string | undefined;
+  let skipTypeChecks = false;
 
-  if (!inputPath) {
+  try {
+    const parsed = parseCompileCliArgs(rest);
+    inputPath = parsed.inputPath;
+    outputPathArg = parsed.outputPath;
+    skipTypeChecks = parsed.skipTypeChecks;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
     console.error(
-      "Usage: cre-compile [--plugin <path>] [--cre-exports <crate-dir>]... <path/to/workflow.ts> [path/to/output.wasm]"
+      `Usage: cre-compile [--plugin <path>] [--cre-exports <crate-dir>]... <path/to/workflow.ts> [path/to/output.wasm] [${skipTypeChecksFlag}]`,
     );
     process.exit(1);
   }
@@ -23,16 +35,33 @@ const main = async () => {
     process.exit(1);
   }
 
-  await compileWorkflow(
-    inputPath,
-    outputPathArg,
-    creExports.length > 0 ? creExports : undefined,
-    plugin ?? undefined,
-  );
+  if (!inputPath) {
+    console.error(
+      `Usage: cre-compile [--plugin <path>] [--cre-exports <crate-dir>]... <path/to/workflow.ts> [path/to/output.wasm] [${skipTypeChecksFlag}]`,
+    );
+    console.error("Examples:");
+    console.error("  cre-compile src/standard_tests/secrets/test.ts");
+    console.error(
+      "  cre-compile src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm",
+    );
+    console.error(
+      `  cre-compile src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm ${skipTypeChecksFlag}`,
+    );
+    process.exit(1);
+  }
+
+  await compileWorkflow(inputPath, outputPathArg, {
+    skipTypeChecks,
+    creExports: creExports.length > 0 ? creExports : undefined,
+    plugin,
+  });
 };
 
 main().catch((e) => {
-  if (e instanceof WorkflowRuntimeCompatibilityError) {
+  if (
+    e instanceof WorkflowRuntimeCompatibilityError ||
+    e instanceof WorkflowTypecheckError
+  ) {
     console.error(`\n❌ ${e.message}`);
   } else {
     console.error(e);

package/dist/sdk/report.js

@@ -227,21 +227,6 @@ function fetchDONInfo(runtime, env, donID) {
         signers.set(addr, nodeOperatorId);
     }
     const info = { f, signers };
-    if (donID === 1 && isProductionEnvironmentForReport(env)) {
-        const patch = (hexAddr, id) => {
-            info.signers.set(getAddress(hexAddr), id);
-        };
-        patch('0xcdf20f8ffd41b02c680988b20e68735cc8c1ca17', 5 + 1);
-        patch('0xff9b062fccb2f042311343048b9518068370f837', 4 + 1);
-        patch('0xde5cd1dd4300a0b4854f8223add60d20e1dfe21b', 1 + 1);
-        patch('0x4d6cfd44f94408a39fb1af94a53c107a730ba161', 9 + 1);
-        patch('0xf3baa9a99b5ad64f50779f449bac83baac8bfdb6', 0 + 1);
-        patch('0xd7f22fb5382ff477d2ff5c702cab0ef8abf18233', 7 + 1);
-        patch('0x4d7d71c7e584cfa1f5c06275e5d283b9d3176924', 8 + 1);
-        patch('0x1a89c98e75983ec384ad8e83eaf7d0176eeaf155', 3 + 1);
-        patch('0x4f99b550623e77b807df7cbed9c79d55e1163b48', 2 + 1);
-        patch('0xe55fcaf921e76c6bbcf9415bba12b1236f07b0c3', 6 + 1);
-    }
     donInfoCache.set(key, info);
     return info;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.6.0-alpha.2",
+	"version": "1.6.0-alpha.4",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -49,7 +49,7 @@
 		"format": "biome format --write ${BIOME_PATHS:-.}",
 		"full-checks": "bun generate:sdk && bun run build && bun typecheck && bun check && bun test && bun test:standard",
 		"generate:chain-selectors": "bun scripts/run.ts generate-chain-selectors && BIOME_PATHS=\"src/generated\" bun check",
-		"generate:proto": "bunx @bufbuild/buf generate && BIOME_PATHS=\"src/generated\" bun check",
+		"generate:proto": "bun x @bufbuild/buf generate && BIOME_PATHS=\"src/generated\" bun check",
 		"generate:sdk": "bun generate:proto && bun generate:chain-selectors && bun scripts/run generate-sdks && BIOME_PATHS=\"src/generated src/generated-sdk src/sdk/test/generated\" bun check",
 		"lint": "biome lint --write",
 		"prepublishOnly": "bun typecheck && bun check && bun test && bun test:standard",
@@ -60,7 +60,7 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.6.0-alpha.2",
+		"@chainlink/cre-sdk-javy-plugin": "1.6.0-alpha.4",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"

package/scripts/run.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env bun
 
+import { WorkflowTypecheckError } from './src/typecheck-workflow'
 import { WorkflowRuntimeCompatibilityError } from './src/validate-workflow-runtime-compat'
 
 const availableScripts = [
 	'build-types',
+	'check-determinism', // Check for non-deterministic patterns in workflow source
 	'compile-to-js',
 	'compile-to-wasm',
 	'compile-workflow', // TS -> JS -> WASM compilation in single script
@@ -39,7 +41,10 @@ const main = async () => {
 			process.exit(1)
 		}
 	} catch (error) {
-		if (error instanceof WorkflowRuntimeCompatibilityError) {
+		if (
+			error instanceof WorkflowRuntimeCompatibilityError ||
+			error instanceof WorkflowTypecheckError
+		) {
 			console.error(`\n❌ ${error.message}`)
 		} else {
 			console.error(`Failed to run script ${scriptName}:`, error)

package/scripts/src/check-determinism.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+let tempDir: string
+
+const scriptsDir = path.resolve(import.meta.dir, '..')
+const runScript = path.join(scriptsDir, 'run.ts')
+
+beforeEach(() => {
+	tempDir = mkdtempSync(path.join(tmpdir(), 'cre-check-determinism-test-'))
+})
+
+afterEach(() => {
+	rmSync(tempDir, { recursive: true, force: true })
+})
+
+const runCheckDeterminism = (filePath: string) =>
+	spawnSync(process.execPath, [runScript, 'check-determinism', filePath], {
+		cwd: scriptsDir,
+		encoding: 'utf-8',
+	})
+
+describe('check-determinism CLI', () => {
+	test('fails when the input file does not exist', () => {
+		const missingFile = path.join(tempDir, 'does-not-exist.ts')
+		const result = runCheckDeterminism(missingFile)
+
+		expect(result.status).toBe(1)
+		expect(result.stdout).not.toContain('No non-determinism warnings found.')
+		expect(result.stderr).toContain(`❌ File not found: ${missingFile}`)
+	})
+
+	test('prints warnings for non-deterministic patterns and exits 0', () => {
+		const filePath = path.join(tempDir, 'workflow.ts')
+		writeFileSync(filePath, `const result = await Promise.race([]);\n`, 'utf-8')
+		const result = runCheckDeterminism(filePath)
+
+		expect(result.status).toBe(0)
+		expect(result.stderr).toContain('Non-determinism warnings')
+		expect(result.stderr).toContain('Promise.race()')
+	})
+
+	test('prints success message for clean workflow and exits 0', () => {
+		const filePath = path.join(tempDir, 'workflow.ts')
+		writeFileSync(filePath, `const x = 1;\n`, 'utf-8')
+		const result = runCheckDeterminism(filePath)
+
+		expect(result.status).toBe(0)
+		expect(result.stdout).toContain('No non-determinism warnings found.')
+	})
+
+	test('fails when no input file is provided', () => {
+		const result = spawnSync(process.execPath, [runScript, 'check-determinism'], {
+			cwd: scriptsDir,
+			encoding: 'utf-8',
+		})
+
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain('Usage:')
+	})
+})

package/scripts/src/check-determinism.ts

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { checkWorkflowDeterminism, printDeterminismWarnings } from './validate-workflow-determinism'
+
+const printUsage = () => {
+	console.error('Usage: bun scripts/run.ts check-determinism <path/to/workflow.ts>')
+	console.error('Example:')
+	console.error('  bun scripts/run.ts check-determinism src/workflows/my-workflow/index.ts')
+}
+
+export const main = () => {
+	const inputPath = process.argv[3]
+
+	if (!inputPath) {
+		printUsage()
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	const warnings = checkWorkflowDeterminism(resolvedInput)
+
+	if (warnings.length > 0) {
+		printDeterminismWarnings(warnings)
+	} else {
+		console.info('No non-determinism warnings found.')
+	}
+}

package/scripts/src/compile-cli-args.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'bun:test'
+import { parseCompileCliArgs } from './compile-cli-args'
+
+describe('parseCompileCliArgs', () => {
+	test('parses positional input and output', () => {
+		const parsed = parseCompileCliArgs(['src/workflow.ts', 'dist/workflow.wasm'])
+		expect(parsed).toEqual({
+			inputPath: 'src/workflow.ts',
+			outputPath: 'dist/workflow.wasm',
+			skipTypeChecks: false,
+		})
+	})
+
+	test('parses --skip-type-checks flag', () => {
+		const parsed = parseCompileCliArgs(['src/workflow.ts', '--skip-type-checks'])
+		expect(parsed).toEqual({
+			inputPath: 'src/workflow.ts',
+			outputPath: undefined,
+			skipTypeChecks: true,
+		})
+	})
+
+	test('throws on unknown flags', () => {
+		expect(() => parseCompileCliArgs(['src/workflow.ts', '--foo'])).toThrow('Unknown option: --foo')
+	})
+
+	test('throws on too many positional args', () => {
+		expect(() => parseCompileCliArgs(['src/workflow.ts', 'dist/workflow.wasm', 'extra'])).toThrow(
+			'Too many positional arguments.',
+		)
+	})
+})

package/scripts/src/compile-cli-args.ts

@@ -0,0 +1,35 @@
+export const skipTypeChecksFlag = '--skip-type-checks'
+
+export type ParsedCompileArgs = {
+	inputPath?: string
+	outputPath?: string
+	skipTypeChecks: boolean
+}
+
+export const parseCompileCliArgs = (args: string[]): ParsedCompileArgs => {
+	const positionalArgs: string[] = []
+	let skipTypeChecks = false
+
+	for (const arg of args) {
+		if (arg === skipTypeChecksFlag) {
+			skipTypeChecks = true
+			continue
+		}
+
+		if (arg.startsWith('-')) {
+			throw new Error(`Unknown option: ${arg}`)
+		}
+
+		positionalArgs.push(arg)
+	}
+
+	if (positionalArgs.length > 2) {
+		throw new Error('Too many positional arguments.')
+	}
+
+	return {
+		inputPath: positionalArgs[0],
+		outputPath: positionalArgs[1],
+		skipTypeChecks,
+	}
+}

package/scripts/src/compile-to-js.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { main as compileToJs } from './compile-to-js'
+import { WorkflowTypecheckError } from './typecheck-workflow'
+
+let tempDir: string
+
+beforeEach(() => {
+	tempDir = mkdtempSync(path.join(process.cwd(), '.tmp-cre-compile-to-js-test-'))
+})
+
+afterEach(() => {
+	rmSync(tempDir, { recursive: true, force: true })
+})
+
+const writeTemp = (filename: string, content: string): string => {
+	const filePath = path.join(tempDir, filename)
+	mkdirSync(path.dirname(filePath), { recursive: true })
+	writeFileSync(filePath, content, 'utf-8')
+	return filePath
+}
+
+describe('compile-to-js typecheck behavior', () => {
+	test('fails on type errors by default', async () => {
+		writeTemp(
+			'tsconfig.json',
+			JSON.stringify(
+				{
+					compilerOptions: {
+						target: 'ES2022',
+						module: 'ESNext',
+						moduleResolution: 'Bundler',
+						skipLibCheck: true,
+						strict: true,
+						types: [],
+						lib: ['ESNext'],
+					},
+					include: ['src/**/*.ts'],
+				},
+				null,
+				2,
+			),
+		)
+		const entry = writeTemp('src/workflow.ts', "export const shouldBeNumber: number = 'oops'\n")
+		const output = path.join(tempDir, 'dist/workflow.js')
+
+		await expect(compileToJs(entry, output)).rejects.toBeInstanceOf(WorkflowTypecheckError)
+	})
+
+	test('continues when --skip-type-checks is enabled', async () => {
+		writeTemp(
+			'tsconfig.json',
+			JSON.stringify(
+				{
+					compilerOptions: {
+						target: 'ES2022',
+						module: 'ESNext',
+						moduleResolution: 'Bundler',
+						skipLibCheck: true,
+						strict: true,
+						types: [],
+						lib: ['ESNext'],
+					},
+					include: ['src/**/*.ts'],
+				},
+				null,
+				2,
+			),
+		)
+		const entry = writeTemp('src/workflow.ts', "export const shouldBeNumber: number = 'oops'\n")
+		const output = path.join(tempDir, 'dist/workflow.js')
+
+		let thrownError: unknown
+		let result: string | undefined
+		try {
+			result = await compileToJs(entry, output, {
+				skipTypeChecks: true,
+			})
+		} catch (error) {
+			thrownError = error
+		}
+
+		expect(thrownError).not.toBeInstanceOf(WorkflowTypecheckError)
+		if (typeof result === 'string') {
+			expect(result).toEqual(output)
+			expect(existsSync(output)).toBeTrue()
+		}
+	})
+})

package/scripts/src/compile-to-js.ts

@@ -2,25 +2,71 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
 import { $ } from 'bun'
+import { parseCompileCliArgs, skipTypeChecksFlag } from './compile-cli-args'
+import { assertWorkflowTypecheck } from './typecheck-workflow'
+import { checkWorkflowDeterminism, printDeterminismWarnings } from './validate-workflow-determinism'
 import { assertWorkflowRuntimeCompatibility } from './validate-workflow-runtime-compat'
 import { wrapWorkflowCode } from './workflow-wrapper'
 
-export const main = async (tsFilePath?: string, outputFilePath?: string) => {
-	const cliArgs = process.argv.slice(3)
+type CompileToJsOptions = {
+	skipTypeChecks?: boolean
+}
+
+const printUsage = () => {
+	console.error(`Usage: bun compile:ts-to-js <path-to-file> [output-file] [${skipTypeChecksFlag}]`)
+	console.error('Example:')
+	console.error('  bun compile:ts-to-js src/tests/foo.ts dist/tests/foo.bundle.js')
+	console.error(
+		`  bun compile:ts-to-js src/tests/foo.ts dist/tests/foo.bundle.js ${skipTypeChecksFlag}`,
+	)
+}
+
+export const main = async (
+	tsFilePath?: string,
+	outputFilePath?: string,
+	options?: CompileToJsOptions,
+) => {
+	let parsedInputPath: string | undefined
+	let parsedOutputPath: string | undefined
+	let parsedSkipTypeChecks = false
+
+	if (tsFilePath != null || outputFilePath != null || options?.skipTypeChecks != null) {
+		parsedInputPath = tsFilePath
+		parsedOutputPath = outputFilePath
+		parsedSkipTypeChecks = options?.skipTypeChecks ?? false
+	} else {
+		try {
+			const parsed = parseCompileCliArgs(process.argv.slice(3))
+			parsedInputPath = parsed.inputPath
+			parsedOutputPath = parsed.outputPath
+			parsedSkipTypeChecks = parsed.skipTypeChecks
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : error)
+			printUsage()
+			process.exit(1)
+		}
+	}
 
 	// Prefer function params, fallback to CLI args
-	const inputPath = tsFilePath ?? cliArgs[0]
-	const outputPathArg = outputFilePath ?? cliArgs[1]
+	const inputPath = parsedInputPath
+	const outputPathArg = parsedOutputPath
 
 	if (!inputPath) {
-		console.error('Usage: bun test:standard:compile:js <path-to-file> [output-file]')
-		console.error('Example:')
-		console.error('  bun test:standard:compile:js src/tests/foo.ts dist/tests/foo.bundle.js')
+		printUsage()
 		process.exit(1)
 	}
 
 	const resolvedInput = path.resolve(inputPath)
+	if (!parsedSkipTypeChecks) {
+		assertWorkflowTypecheck(resolvedInput)
+	}
 	assertWorkflowRuntimeCompatibility(resolvedInput)
+	if (!parsedSkipTypeChecks) {
+		const warnings = checkWorkflowDeterminism(resolvedInput)
+		if (warnings.length > 0) {
+			printDeterminismWarnings(warnings)
+		}
+	}
 	console.info(`📁 Using input file: ${resolvedInput}`)
 
 	// If no explicit output path → same dir, swap extension to .js

package/scripts/src/compile-to-wasm.ts

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
-import { parseCompileFlags } from '../../../cre-sdk-javy-plugin/scripts/parse-compile-flags'
+import { parseCompileFlags } from '@chainlink/cre-sdk-javy-plugin/scripts/parse-compile-flags'
 
 function runBun(args: string[]): Promise<void> {
 	return new Promise((resolve, reject) => {
@@ -77,10 +77,16 @@ export const main = async (
 	}
 	compileArgs.push(resolvedInput, resolvedOutput)
 
-	const scriptDir = import.meta.dir
-	const javyPluginRoot = process.env.CRE_SDK_JAVY_PLUGIN_HOME
-		? path.resolve(process.env.CRE_SDK_JAVY_PLUGIN_HOME)
-		: path.resolve(scriptDir, '../../../cre-sdk-javy-plugin')
+	let javyPluginRoot: string
+	if (process.env.CRE_SDK_JAVY_PLUGIN_HOME) {
+		javyPluginRoot = path.resolve(process.env.CRE_SDK_JAVY_PLUGIN_HOME)
+	} else {
+		try {
+			javyPluginRoot = path.dirname(require.resolve('@chainlink/cre-sdk-javy-plugin/package.json'))
+		} catch {
+			javyPluginRoot = path.resolve(import.meta.dir, '../../../cre-sdk-javy-plugin')
+		}
+	}
 	const compilerPath = path.join(javyPluginRoot, 'bin/compile-workflow.ts')
 	if (existsSync(compilerPath)) {
 		await runBun(['--bun', compilerPath, ...compileArgs])

package/scripts/src/compile-workflow.ts

@@ -1,31 +1,75 @@
 import { existsSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
-import { parseCompileFlags } from '../../../cre-sdk-javy-plugin/scripts/parse-compile-flags'
+import { parseCompileFlags } from '@chainlink/cre-sdk-javy-plugin/scripts/parse-compile-flags'
+import { parseCompileCliArgs, skipTypeChecksFlag } from './compile-cli-args'
 import { main as compileToJs } from './compile-to-js'
 import { main as compileToWasm } from './compile-to-wasm'
 
+type CompileWorkflowOptions = {
+	skipTypeChecks?: boolean
+	creExports?: string[]
+	plugin?: string | null
+}
+
+const printUsage = () => {
+	console.error(
+		`Usage: bun compile:workflow [--plugin <path>] [--cre-exports <crate-dir>]... <path/to/workflow.ts> [path/to/output.wasm] [${skipTypeChecksFlag}]`,
+	)
+	console.error('Examples:')
+	console.error('  bun compile:workflow src/standard_tests/secrets/test.ts')
+	console.error(
+		'  bun compile:workflow src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm',
+	)
+	console.error(
+		`  bun compile:workflow src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm ${skipTypeChecksFlag}`,
+	)
+}
+
 export const main = async (
 	inputFile?: string,
 	outputWasmFile?: string,
-	creExportsPaths?: string[],
-	pluginPath?: string | null,
+	options?: CompileWorkflowOptions,
 ) => {
-	const cliArgs = process.argv.slice(3)
-	const { creExports: cliCreExports, plugin: cliPlugin, rest: cliRest } = parseCompileFlags(cliArgs)
+	let parsedInputPath: string | undefined
+	let parsedOutputPath: string | undefined
+	let parsedSkipTypeChecks = false
+	let parsedCreExports: string[] = []
+	let parsedPlugin: string | null = null
 
-	const inputPath = inputFile ?? cliRest[0]
-	const outputPathArg = outputWasmFile ?? cliRest[1]
-	const creExports = creExportsPaths ?? cliCreExports
-	const plugin = pluginPath !== undefined ? pluginPath : cliPlugin
+	if (inputFile != null || outputWasmFile != null || options != null) {
+		parsedInputPath = inputFile
+		parsedOutputPath = outputWasmFile
+		parsedSkipTypeChecks = options?.skipTypeChecks ?? false
+		parsedCreExports = options?.creExports ?? []
+		parsedPlugin = options?.plugin !== undefined ? options.plugin : null
+	} else {
+		try {
+			const cliArgs = process.argv.slice(3)
+			const { creExports, plugin, rest } = parseCompileFlags(cliArgs)
+			const parsed = parseCompileCliArgs(rest)
+			parsedInputPath = parsed.inputPath
+			parsedOutputPath = parsed.outputPath
+			parsedSkipTypeChecks = parsed.skipTypeChecks
+			parsedCreExports = creExports
+			parsedPlugin = plugin
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : error)
+			printUsage()
+			process.exit(1)
+		}
+	}
 
-	if (plugin != null && plugin !== '' && creExports.length > 0) {
+	const inputPath = parsedInputPath
+	const outputPathArg = parsedOutputPath
+
+	if (parsedPlugin != null && parsedPlugin !== '' && parsedCreExports.length > 0) {
 		console.error('❌ Error: --plugin and --cre-exports are mutually exclusive.')
 		process.exit(1)
 	}
 
 	if (!inputPath) {
-		console.error('Usage: bun compile:workflow <path/to/workflow.ts> [path/to/output.wasm]')
+		printUsage()
 		process.exit(1)
 	}
 
@@ -48,12 +92,15 @@ export const main = async (
 	console.info(`📁 Input:   ${resolvedInput}`)
 	console.info(`🧪 JS out:  ${resolvedJsOutput}`)
 	console.info(`🎯 WASM out:${resolvedWasmOutput}\n`)
+	if (parsedSkipTypeChecks) {
+		console.info(`⚠️  Skipping TypeScript checks (${skipTypeChecksFlag})`)
+	}
 
 	console.info('📦 Step 1: Compiling JS...')
-	await compileToJs(resolvedInput, resolvedJsOutput)
+	await compileToJs(resolvedInput, resolvedJsOutput, { skipTypeChecks: parsedSkipTypeChecks })
 
 	console.info('\n🔨 Step 2: Compiling to WASM...')
-	await compileToWasm(resolvedJsOutput, resolvedWasmOutput, creExports, plugin)
+	await compileToWasm(resolvedJsOutput, resolvedWasmOutput, parsedCreExports, parsedPlugin)
 
 	console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`)
 	return resolvedWasmOutput