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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.6.0-alpha.1",
+	"version": "1.6.0-alpha.2",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -60,7 +60,7 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.5.0-alpha.1",
+		"@chainlink/cre-sdk-javy-plugin": "1.6.0-alpha.2",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"

package/scripts/run-standard-tests.sh

@@ -8,9 +8,9 @@ set -e
 # Create dist test workflow folder
 mkdir -p ./dist/workflows/standard_tests
 
-# Build javy wasm
-if [ ! -f ../cre-sdk-javy-plugin/dist/javy_chainlink_sdk.wasm ]; then
-    echo "Error: javy_chainlink_sdk.wasm not found"
+# Plugin package must be built (initialized plugin is what we ship).
+if [ ! -f ../cre-sdk-javy-plugin/dist/javy-chainlink-sdk.plugin.wasm ]; then
+    echo "Error: javy-chainlink-sdk.plugin.wasm not found (run cre-sdk-javy-plugin build first)"
     exit 1
 fi
 

package/scripts/run.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env bun
 
-import { WorkflowTypecheckError } from './src/typecheck-workflow'
 import { WorkflowRuntimeCompatibilityError } from './src/validate-workflow-runtime-compat'
 
 const availableScripts = [
@@ -40,10 +39,7 @@ const main = async () => {
 			process.exit(1)
 		}
 	} catch (error) {
-		if (
-			error instanceof WorkflowRuntimeCompatibilityError ||
-			error instanceof WorkflowTypecheckError
-		) {
+		if (error instanceof WorkflowRuntimeCompatibilityError) {
 			console.error(`\n❌ ${error.message}`)
 		} else {
 			console.error(`Failed to run script ${scriptName}:`, error)

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

@@ -2,63 +2,24 @@ 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 { assertWorkflowRuntimeCompatibility } from './validate-workflow-runtime-compat'
 import { wrapWorkflowCode } from './workflow-wrapper'
 
-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)
-		}
-	}
+export const main = async (tsFilePath?: string, outputFilePath?: string) => {
+	const cliArgs = process.argv.slice(3)
 
 	// Prefer function params, fallback to CLI args
-	const inputPath = parsedInputPath
-	const outputPathArg = parsedOutputPath
+	const inputPath = tsFilePath ?? cliArgs[0]
+	const outputPathArg = outputFilePath ?? cliArgs[1]
 
 	if (!inputPath) {
-		printUsage()
+		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')
 		process.exit(1)
 	}
 
 	const resolvedInput = path.resolve(inputPath)
-	if (!parsedSkipTypeChecks) {
-		assertWorkflowTypecheck(resolvedInput)
-	}
 	assertWorkflowRuntimeCompatibility(resolvedInput)
 	console.info(`📁 Using input file: ${resolvedInput}`)
 

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

@@ -2,6 +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'
 
 function runBun(args: string[]): Promise<void> {
 	return new Promise((resolve, reject) => {
@@ -19,20 +20,29 @@ function runBun(args: string[]): Promise<void> {
 
 const isJsFile = (p: string) => ['.js', '.mjs', '.cjs'].includes(path.extname(p).toLowerCase())
 
-export const main = async (inputFile?: string, outputFile?: string) => {
+export const main = async (
+	inputFile?: string,
+	outputFile?: string,
+	creExportsPaths?: string[],
+	pluginPath?: string | null,
+) => {
 	const cliArgs = process.argv.slice(3)
+	const { creExports: cliCreExports, plugin: cliPlugin, rest: cliRest } = parseCompileFlags(cliArgs)
 
-	// Resolve input/output from params or CLI
-	const inputPath = inputFile ?? cliArgs[0]
-	const outputPathArg = outputFile ?? cliArgs[1]
+	const inputPath = inputFile ?? cliRest[0]
+	const outputPathArg = outputFile ?? cliRest[1]
+	const creExports = creExportsPaths ?? cliCreExports
+	const plugin = pluginPath !== undefined ? pluginPath : cliPlugin
+
+	if (plugin !== null && plugin !== undefined && creExports.length > 0) {
+		console.error('❌ Error: --plugin and --cre-exports are mutually exclusive.')
+		process.exit(1)
+	}
 
 	if (!inputPath) {
 		console.error(
 			'Usage: bun compile:js-to-wasm <path/to/input.(js|mjs|cjs)> [path/to/output.wasm]',
 		)
-		console.error('Examples:')
-		console.error('  bun compile:js-to-wasm ./build/workflows/test.js')
-		console.error('  bun compile:js-to-wasm ./build/workflows/test.mjs ./artifacts/test.wasm')
 		process.exit(1)
 	}
 
@@ -47,31 +57,35 @@ export const main = async (inputFile?: string, outputFile?: string) => {
 		process.exit(1)
 	}
 
-	// Default output = same dir, same basename, .wasm extension
 	const defaultOut = path.join(
 		path.dirname(resolvedInput),
 		path.basename(resolvedInput).replace(/\.(m|c)?js$/i, '.wasm'),
 	)
 	const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : defaultOut
 
-	// Ensure output directory exists
 	await mkdir(path.dirname(resolvedOutput), { recursive: true })
 
-	console.info(`🔨 Compiling to WASM`)
+	console.info('🔨 Compiling to WASM')
 	console.info(`📁 Input:  ${resolvedInput}`)
 	console.info(`🎯 Output: ${resolvedOutput}`)
 
-	// Prefer the sibling @chainlink/cre-sdk-javy-plugin install (same as monorepo layout).
-	// Bun's shell `$` template can throw EINVAL on some Linux/arm64 Docker setups; use spawn.
+	const compileArgs: string[] = []
+	if (plugin != null && plugin !== '') {
+		compileArgs.push('--plugin', path.resolve(plugin))
+	} else {
+		compileArgs.push(...creExports.flatMap((p) => ['--cre-exports', path.resolve(p)]))
+	}
+	compileArgs.push(resolvedInput, resolvedOutput)
+
 	const scriptDir = import.meta.dir
-	const compilerPath = path.resolve(
-		scriptDir,
-		'../../../cre-sdk-javy-plugin/bin/compile-workflow.ts',
-	)
+	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')
+	const compilerPath = path.join(javyPluginRoot, 'bin/compile-workflow.ts')
 	if (existsSync(compilerPath)) {
-		await runBun(['--bun', compilerPath, resolvedInput, resolvedOutput])
+		await runBun(['--bun', compilerPath, ...compileArgs])
 	} else {
-		await runBun(['x', 'cre-compile-workflow', resolvedInput, resolvedOutput])
+		await runBun(['x', 'cre-compile-workflow', ...compileArgs])
 	}
 
 	console.info(`✅ Compiled: ${resolvedOutput}`)

package/scripts/src/compile-workflow.ts

@@ -1,59 +1,31 @@
 import { existsSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
-import { parseCompileCliArgs, skipTypeChecksFlag } from './compile-cli-args'
+import { parseCompileFlags } from '../../../cre-sdk-javy-plugin/scripts/parse-compile-flags'
 import { main as compileToJs } from './compile-to-js'
 import { main as compileToWasm } from './compile-to-wasm'
 
-type CompileWorkflowOptions = {
-	skipTypeChecks?: boolean
-}
-
-const printUsage = () => {
-	console.error(
-		`Usage: bun compile:workflow <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,
-	options?: CompileWorkflowOptions,
+	creExportsPaths?: string[],
+	pluginPath?: string | null,
 ) => {
-	let parsedInputPath: string | undefined
-	let parsedOutputPath: string | undefined
-	let parsedSkipTypeChecks = false
+	const cliArgs = process.argv.slice(3)
+	const { creExports: cliCreExports, plugin: cliPlugin, rest: cliRest } = parseCompileFlags(cliArgs)
 
-	if (inputFile != null || outputWasmFile != null || options?.skipTypeChecks != null) {
-		parsedInputPath = inputFile
-		parsedOutputPath = outputWasmFile
-		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)
-		}
-	}
+	const inputPath = inputFile ?? cliRest[0]
+	const outputPathArg = outputWasmFile ?? cliRest[1]
+	const creExports = creExportsPaths ?? cliCreExports
+	const plugin = pluginPath !== undefined ? pluginPath : cliPlugin
 
-	const inputPath = parsedInputPath
-	const outputPathArg = parsedOutputPath
+	if (plugin != null && plugin !== '' && creExports.length > 0) {
+		console.error('❌ Error: --plugin and --cre-exports are mutually exclusive.')
+		process.exit(1)
+	}
 
 	if (!inputPath) {
-		printUsage()
+		console.error('Usage: bun compile:workflow <path/to/workflow.ts> [path/to/output.wasm]')
 		process.exit(1)
 	}
 
@@ -63,33 +35,33 @@ export const main = async (
 		process.exit(1)
 	}
 
-	// Default final output = same dir, same basename, .wasm
 	const defaultWasmOut = path.join(
 		path.dirname(resolvedInput),
 		path.basename(resolvedInput).replace(/\.[^.]+$/, '.wasm'),
 	)
 	const resolvedWasmOutput = outputPathArg ? path.resolve(outputPathArg) : defaultWasmOut
-
-	// Put the intermediate JS next to the final wasm (so custom outputs stay together)
 	const resolvedJsOutput = resolvedWasmOutput.replace(/\.wasm$/i, '.js')
 
-	// Ensure directories exist (handles both intermediate JS dir and wasm dir)
 	await mkdir(path.dirname(resolvedJsOutput), { recursive: true })
 
-	console.info(`🚀 Compiling workflow`)
-	console.info(`📁 Input:   ${resolvedInput}\n`)
-	if (parsedSkipTypeChecks) {
-		console.info(`⚠️  Skipping TypeScript checks (${skipTypeChecksFlag})`)
-	}
+	console.info('🚀 Compiling workflow')
+	console.info(`📁 Input:   ${resolvedInput}`)
+	console.info(`🧪 JS out:  ${resolvedJsOutput}`)
+	console.info(`🎯 WASM out:${resolvedWasmOutput}\n`)
 
-	// Step 1: TS/JS → JS (bundled)
 	console.info('📦 Step 1: Compiling JS...')
-	await compileToJs(resolvedInput, resolvedJsOutput, { skipTypeChecks: parsedSkipTypeChecks })
+	await compileToJs(resolvedInput, resolvedJsOutput)
 
-	// Step 2: JS → WASM
 	console.info('\n🔨 Step 2: Compiling to WASM...')
-	await compileToWasm(resolvedJsOutput, resolvedWasmOutput)
+	await compileToWasm(resolvedJsOutput, resolvedWasmOutput, creExports, plugin)
 
 	console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`)
 	return resolvedWasmOutput
 }
+
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error(e)
+		process.exit(1)
+	})
+}

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

@@ -1,32 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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/typecheck-workflow.test.ts

@@ -1,77 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-import { assertWorkflowTypecheck, WorkflowTypecheckError } from './typecheck-workflow'
-
-let tempDir: string
-
-beforeEach(() => {
-	tempDir = mkdtempSync(path.join(tmpdir(), 'cre-typecheck-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('assertWorkflowTypecheck', () => {
-	test('passes for valid project using nearby tsconfig', () => {
-		writeTemp(
-			'tsconfig.json',
-			JSON.stringify(
-				{
-					compilerOptions: {
-						target: 'ES2022',
-						module: 'ESNext',
-						moduleResolution: 'Bundler',
-						skipLibCheck: true,
-					},
-					include: ['src/**/*.ts'],
-				},
-				null,
-				2,
-			),
-		)
-		const entry = writeTemp('src/workflow.ts', 'export const value: number = 42\n')
-		expect(() => assertWorkflowTypecheck(entry)).not.toThrow()
-	})
-
-	test('fails when tsconfig cannot be found', () => {
-		const entry = writeTemp('src/workflow.ts', 'export const value = 1\n')
-		expect(() => assertWorkflowTypecheck(entry)).toThrow(WorkflowTypecheckError)
-		expect(() => assertWorkflowTypecheck(entry)).toThrow('Could not find tsconfig.json')
-	})
-
-	test('fails on whole-project type errors outside entry file', () => {
-		writeTemp(
-			'tsconfig.json',
-			JSON.stringify(
-				{
-					compilerOptions: {
-						target: 'ES2022',
-						module: 'ESNext',
-						moduleResolution: 'Bundler',
-						skipLibCheck: true,
-						strict: true,
-					},
-					include: ['src/**/*.ts'],
-				},
-				null,
-				2,
-			),
-		)
-
-		const entry = writeTemp('src/workflow.ts', 'export const value: number = 1\n')
-		writeTemp('src/unrelated.ts', "export const shouldBeNumber: number = 'not-a-number'\n")
-
-		expect(() => assertWorkflowTypecheck(entry)).toThrow(WorkflowTypecheckError)
-		expect(() => assertWorkflowTypecheck(entry)).toThrow('unrelated.ts')
-	})
-})

package/scripts/src/typecheck-workflow.ts

@@ -1,96 +0,0 @@
-import path from 'node:path'
-import * as ts from 'typescript'
-import { skipTypeChecksFlag } from './compile-cli-args'
-
-const toAbsolutePath = (filePath: string) => path.resolve(filePath)
-
-const formatDiagnostic = (diagnostic: ts.Diagnostic): string => {
-	const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
-	if (!diagnostic.file || diagnostic.start == null) {
-		return message
-	}
-
-	const absoluteFilePath = toAbsolutePath(diagnostic.file.fileName)
-	const relativeFilePath = path.relative(process.cwd(), absoluteFilePath)
-	const displayPath = relativeFilePath || absoluteFilePath
-	const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
-	return `${displayPath}:${line + 1}:${character + 1} ${message}`
-}
-
-class WorkflowTypecheckError extends Error {
-	constructor(message: string) {
-		super(message)
-		this.name = 'WorkflowTypecheckError'
-	}
-}
-
-const findNearestTsconfigPath = (entryFilePath: string): string | null => {
-	const configPath = ts.findConfigFile(
-		path.dirname(entryFilePath),
-		ts.sys.fileExists,
-		'tsconfig.json',
-	)
-	return configPath ?? null
-}
-
-export const assertWorkflowTypecheck = (entryFilePath: string) => {
-	const rootFile = toAbsolutePath(entryFilePath)
-	const configPath = findNearestTsconfigPath(rootFile)
-	if (!configPath) {
-		throw new WorkflowTypecheckError(
-			`TypeScript typecheck failed before workflow compilation.
-Could not find tsconfig.json near: ${rootFile}
-Create a tsconfig.json in your workflow project, or re-run compile with ${skipTypeChecksFlag}.`,
-		)
-	}
-
-	let unrecoverableDiagnostic: ts.Diagnostic | null = null
-	const parsedConfig = ts.getParsedCommandLineOfConfigFile(
-		configPath,
-		{},
-		{
-			...ts.sys,
-			onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
-				unrecoverableDiagnostic = diagnostic
-			},
-		},
-	)
-
-	if (!parsedConfig) {
-		const details = unrecoverableDiagnostic ? formatDiagnostic(unrecoverableDiagnostic) : ''
-		throw new WorkflowTypecheckError(
-			`TypeScript typecheck failed before workflow compilation.
-Failed to parse tsconfig.json: ${configPath}
-${details}
-Fix your tsconfig.json, or re-run compile with ${skipTypeChecksFlag}.`,
-		)
-	}
-
-	const program = ts.createProgram({
-		rootNames: parsedConfig.fileNames,
-		options: {
-			...parsedConfig.options,
-			noEmit: true,
-		},
-		projectReferences: parsedConfig.projectReferences,
-	})
-
-	const diagnostics = [...parsedConfig.errors, ...ts.getPreEmitDiagnostics(program)].filter(
-		(diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error,
-	)
-
-	if (diagnostics.length > 0) {
-		const formatted = diagnostics.map(formatDiagnostic).join('\n')
-		const relativeConfigPath = path.relative(process.cwd(), toAbsolutePath(configPath))
-		const displayConfigPath = relativeConfigPath || toAbsolutePath(configPath)
-		throw new WorkflowTypecheckError(
-			`TypeScript typecheck failed before workflow compilation.
-Using tsconfig: ${displayConfigPath}
-Fix TypeScript errors, or re-run compile with ${skipTypeChecksFlag}.
-
-${formatted}`,
-		)
-	}
-}
-
-export { WorkflowTypecheckError }