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

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,6 @@ 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) => {
@@ -20,29 +19,20 @@ 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,
-	creExportsPaths?: string[],
-	pluginPath?: string | null,
-) => {
+export const main = async (inputFile?: string, outputFile?: string) => {
 	const cliArgs = process.argv.slice(3)
-	const { creExports: cliCreExports, plugin: cliPlugin, rest: cliRest } = parseCompileFlags(cliArgs)
 
-	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)
-	}
+	// Resolve input/output from params or CLI
+	const inputPath = inputFile ?? cliArgs[0]
+	const outputPathArg = outputFile ?? cliArgs[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)
 	}
 
@@ -57,35 +47,31 @@ export const main = async (
 		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}`)
 
-	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)
-
+	// 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 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')
-	const compilerPath = path.join(javyPluginRoot, 'bin/compile-workflow.ts')
+	const compilerPath = path.resolve(
+		scriptDir,
+		'../../../cre-sdk-javy-plugin/bin/compile-workflow.ts',
+	)
 	if (existsSync(compilerPath)) {
-		await runBun(['--bun', compilerPath, ...compileArgs])
+		await runBun(['--bun', compilerPath, resolvedInput, resolvedOutput])
 	} else {
-		await runBun(['x', 'cre-compile-workflow', ...compileArgs])
+		await runBun(['x', 'cre-compile-workflow', resolvedInput, resolvedOutput])
 	}
 
 	console.info(`✅ Compiled: ${resolvedOutput}`)

package/scripts/src/compile-workflow.ts

@@ -1,31 +1,59 @@
 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 { 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
+}
+
+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,
-	creExportsPaths?: string[],
-	pluginPath?: string | null,
+	options?: CompileWorkflowOptions,
 ) => {
-	const cliArgs = process.argv.slice(3)
-	const { creExports: cliCreExports, plugin: cliPlugin, rest: cliRest } = parseCompileFlags(cliArgs)
-
-	const inputPath = inputFile ?? cliRest[0]
-	const outputPathArg = outputWasmFile ?? cliRest[1]
-	const creExports = creExportsPaths ?? cliCreExports
-	const plugin = pluginPath !== undefined ? pluginPath : cliPlugin
+	let parsedInputPath: string | undefined
+	let parsedOutputPath: string | undefined
+	let parsedSkipTypeChecks = false
 
-	if (plugin != null && plugin !== '' && creExports.length > 0) {
-		console.error('❌ Error: --plugin and --cre-exports are mutually exclusive.')
-		process.exit(1)
+	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 = parsedInputPath
+	const outputPathArg = parsedOutputPath
+
 	if (!inputPath) {
-		console.error('Usage: bun compile:workflow <path/to/workflow.ts> [path/to/output.wasm]')
+		printUsage()
 		process.exit(1)
 	}
 
@@ -35,33 +63,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}`)
-	console.info(`🧪 JS out:  ${resolvedJsOutput}`)
-	console.info(`🎯 WASM out:${resolvedWasmOutput}\n`)
+	console.info(`🚀 Compiling workflow`)
+	console.info(`📁 Input:   ${resolvedInput}\n`)
+	if (parsedSkipTypeChecks) {
+		console.info(`⚠️  Skipping TypeScript checks (${skipTypeChecksFlag})`)
+	}
 
+	// Step 1: TS/JS → JS (bundled)
 	console.info('📦 Step 1: Compiling JS...')
-	await compileToJs(resolvedInput, resolvedJsOutput)
+	await compileToJs(resolvedInput, resolvedJsOutput, { skipTypeChecks: parsedSkipTypeChecks })
 
+	// Step 2: JS → WASM
 	console.info('\n🔨 Step 2: Compiling to WASM...')
-	await compileToWasm(resolvedJsOutput, resolvedWasmOutput, creExports, plugin)
+	await compileToWasm(resolvedJsOutput, resolvedWasmOutput)
 
 	console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`)
 	return resolvedWasmOutput
 }
-
-if (import.meta.main) {
-	main().catch((e) => {
-		console.error(e)
-		process.exit(1)
-	})
-}

package/scripts/src/generate-chain-selectors.ts

@@ -78,34 +78,16 @@ const CHAIN_CONFIGS: ChainSelectorConfig[] = [
 	},
 ]
 
-const readYamlFile = (filename: string): string => {
-	// Look for chain-selectors in node_modules by trying multiple possible locations
-	// This handles different execution contexts (local dev, CI, etc.)
-	const possiblePaths = [
-		// Try workspace root (3 levels up from scripts/)
-		join(process.cwd(), '..', '..', '..', 'node_modules', 'chain-selectors', filename),
-		// Try 2 levels up (in case cwd is already in scripts/src/)
-		join(process.cwd(), '..', '..', 'node_modules', 'chain-selectors', filename),
-		// Try current directory's node_modules
-		join(process.cwd(), 'node_modules', 'chain-selectors', filename),
-		// Try parent directory's node_modules
-		join(process.cwd(), '..', 'node_modules', 'chain-selectors', filename),
-	]
-
-	for (const path of possiblePaths) {
-		try {
-			return readFileSync(path, 'utf-8')
-		} catch {
-			// Try next path
-			continue
-		}
-	}
+const resolveChainSelectorsDir = (): string => {
+	// Use require.resolve to find the package through bun/Node module resolution,
+	// which correctly handles workspace hoisting, .bun cache, etc.
+	const packageDir = require.resolve('chain-selectors/selectors.yml')
+	return join(packageDir, '..')
+}
 
-	throw new Error(
-		`Failed to find ${filename} in any of the expected locations. Tried:\n${possiblePaths.join(
-			'\n',
-		)}`,
-	)
+const readYamlFile = (filename: string): string => {
+	const filePath = join(resolveChainSelectorsDir(), filename)
+	return readFileSync(filePath, 'utf-8')
 }
 
 const parseChainSelectors = (): NetworkInfo[] => {

package/scripts/src/generate-sdks.ts

@@ -1,5 +1,7 @@
 import { rmSync } from 'node:fs'
+import { file_capabilities_blockchain_aptos_v1alpha_client } from '@cre/generated/capabilities/blockchain/aptos/v1alpha/client_pb'
 import { file_capabilities_blockchain_evm_v1alpha_client } from '@cre/generated/capabilities/blockchain/evm/v1alpha/client_pb'
+import { file_capabilities_blockchain_solana_v1alpha_client } from '@cre/generated/capabilities/blockchain/solana/v1alpha/client_pb'
 import { file_capabilities_internal_actionandtrigger_v1_action_and_trigger } from '@cre/generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb'
 import { file_capabilities_internal_basicaction_v1_basic_action } from '@cre/generated/capabilities/internal/basicaction/v1/basic_action_pb'
 import { file_capabilities_internal_basictrigger_v1_basic_trigger } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
@@ -63,6 +65,16 @@ export const main = () => {
 		...generateMocks(file_capabilities_blockchain_evm_v1alpha_client, TEST_GENERATED_DIR),
 	)
 
+	generateSdk(file_capabilities_blockchain_aptos_v1alpha_client, './src/generated-sdk')
+	allMockExports.push(
+		...generateMocks(file_capabilities_blockchain_aptos_v1alpha_client, TEST_GENERATED_DIR),
+	)
+
+	generateSdk(file_capabilities_blockchain_solana_v1alpha_client, './src/generated-sdk')
+	allMockExports.push(
+		...generateMocks(file_capabilities_blockchain_solana_v1alpha_client, TEST_GENERATED_DIR),
+	)
+
 	generateSdk(file_capabilities_networking_http_v1alpha_client, './src/generated-sdk')
 	allMockExports.push(
 		...generateMocks(file_capabilities_networking_http_v1alpha_client, TEST_GENERATED_DIR),

package/scripts/src/typecheck-workflow.test.ts

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

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