@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

package/dist/sdk/wasm/runner.test.js

@@ -0,0 +1,270 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack, EmptySchema } from '@bufbuild/protobuf/wkt';
+import { ConfigSchema, OutputsSchema, } from '../../generated/capabilities/internal/basictrigger/v1/basic_trigger_pb';
+import { AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, ExecuteRequestSchema, ExecutionResultSchema, GetSecretsRequestSchema, SecretResponseSchema, SecretResponsesSchema, SecretSchema, TriggerSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { BasicCapability as BasicTriggerCapability } from '../../generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen';
+import { cre } from '../cre';
+import { Value } from '../utils';
+import { Runner } from './runner';
+const anyConfig = Buffer.from('config');
+const anyMaxResponseSize = 2048n;
+const basicTrigger = new BasicTriggerCapability();
+const capID = BasicTriggerCapability.CAPABILITY_ID;
+const subscribeRequest = create(ExecuteRequestSchema, {
+    request: { case: 'subscribe', value: create(EmptySchema) },
+    maxResponseSize: anyMaxResponseSize,
+    config: anyConfig,
+});
+const anyExecuteRequest = create(ExecuteRequestSchema, {
+    request: {
+        case: 'trigger',
+        value: create(TriggerSchema, {
+            id: 0n,
+            payload: anyPack(OutputsSchema, create(OutputsSchema, { coolOutput: 'hi' })),
+        }),
+    },
+    maxResponseSize: anyMaxResponseSize,
+    config: anyConfig,
+});
+const mockHostBindings = {
+    sendResponse: mock(() => {
+        return 0;
+    }),
+    versionV2: mock(() => { }),
+    getWasiArgs: mock(() => {
+        throw new Error('override for tests');
+    }),
+    getSecrets: mock((data, maxResponseSize) => {
+        throw new Error('override for tests');
+    }),
+    awaitSecrets: mock((data, maxResponseSize) => {
+        throw new Error('override for tests');
+    }),
+};
+const proxyHostBindings = {
+    sendResponse: (data) => {
+        return mockHostBindings.sendResponse(data);
+    },
+    versionV2: () => {
+        return mockHostBindings.versionV2();
+    },
+    getWasiArgs: () => {
+        return mockHostBindings.getWasiArgs();
+    },
+    switchModes: mock(() => { }),
+    log: (message) => {
+        throw new Error('log called unexpectedly in test');
+    },
+    callCapability: (data) => {
+        throw new Error('callCapability called unexpectedly in test');
+    },
+    awaitCapabilities: (data, id) => {
+        throw new Error('awaitCapabilities called unexpectedly in test');
+    },
+    getSecrets: (data, id) => {
+        return mockHostBindings.getSecrets(data, id);
+    },
+    awaitSecrets: (data, id) => {
+        return mockHostBindings.awaitSecrets(data, id);
+    },
+    now: () => {
+        throw new Error('now called unexpectedly in test');
+    },
+};
+Object.assign(globalThis, proxyHostBindings);
+afterEach(() => {
+    mock.restore();
+});
+describe('runner', () => {
+    describe('run', () => {
+        test('gathers subscriptions', async () => {
+            var sentResponse = null;
+            mockHostBindings.sendResponse = mock((input) => {
+                sentResponse = fromBinary(ExecutionResultSchema, input);
+                return 0;
+            });
+            const runner = await getTestRunner(subscribeRequest);
+            await runner.run(async (_, secretsProvider) => {
+                return [
+                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), () => {
+                        throw new Error('Must not be called during registration to tiggers');
+                    }),
+                ];
+            });
+            expect(sentResponse).toBeDefined();
+            expect(sentResponse.result.case).toBe('triggerSubscriptions');
+            const responseValue = sentResponse.result.value;
+            expect(responseValue.subscriptions.length).toBe(1);
+            expect(responseValue.subscriptions[0].id).toBe(capID);
+            expect(responseValue.subscriptions[0].method).toBe('Trigger');
+            expect(responseValue.subscriptions[0].payload).toBeDefined();
+            const actualConfig = anyUnpack(responseValue.subscriptions[0].payload, ConfigSchema);
+            expect(actualConfig.name).toBe('foo');
+            expect(actualConfig.number).toBe(10);
+        });
+        test('executes workflow', async () => {
+            var sentResponse = null;
+            mockHostBindings.sendResponse = mock((input) => {
+                sentResponse = fromBinary(ExecutionResultSchema, input);
+                return 0;
+            });
+            const runner = await getTestRunner(anyExecuteRequest);
+            await runner.run(async (_, secretsProvider) => {
+                return [
+                    cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
+                        expect(runtime.config).toBe(anyConfig.toString());
+                        expect(trigger.coolOutput).toBe('hi');
+                        return 10;
+                    }),
+                ];
+            });
+            expect(sentResponse).toBeDefined();
+            expect(sentResponse.result.case).toBe('value');
+            expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(10);
+        });
+    });
+    test('executes subscribe error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(subscribeRequest);
+        await runner.run((_, secretsProvider) => {
+            throw new Error(anyError);
+        });
+    });
+    test('executes subscribe resolve error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(subscribeRequest);
+        await runner.run(async (_, secretsProvider) => {
+            return Promise.reject(new Error(anyError));
+        });
+    });
+    test('executes trigger error', async () => {
+        var sentResponse = null;
+        const anyError = 'error';
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            expect(sentResponse.result.case).toBe('error');
+            expect(sentResponse.result.value).toBe(anyError);
+            return 0;
+        });
+        const runner = await getTestRunner(anyExecuteRequest);
+        await runner.run(async (_, secretsProvider) => {
+            throw new Error(anyError);
+        });
+    });
+    test('executes workflow with multiple triggers', async () => {
+        var sentResponse = null;
+        mockHostBindings.sendResponse = mock((input) => {
+            sentResponse = fromBinary(ExecutionResultSchema, input);
+            return 0;
+        });
+        const testRequest = structuredClone(anyExecuteRequest);
+        const trigger = testRequest.request.value;
+        trigger.id = 1n;
+        const runner = await getTestRunner(testRequest);
+        await runner.run(async (_, secretsProvider) => {
+            return [
+                cre.handler(basicTrigger.trigger({ name: 'foo', number: 10 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 10;
+                }),
+                cre.handler(basicTrigger.trigger({ name: 'bar', number: 20 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 20;
+                }),
+                cre.handler(basicTrigger.trigger({ name: 'baz', number: 30 }), (runtime, trigger) => {
+                    expect(runtime.config).toBe(anyConfig.toString());
+                    expect(trigger.coolOutput).toBe('hi');
+                    return 30;
+                }),
+            ];
+        });
+        expect(sentResponse).toBeDefined();
+        expect(sentResponse.result.case).toBe('value');
+        expect(Value.wrap(sentResponse.result.value).unwrapToType({ instance: 10 })).toBe(20);
+    });
+    test('get secrets passes max response size', async () => {
+        const anySecretResponse = create(SecretResponseSchema, {
+            response: {
+                case: 'secret',
+                value: create(SecretSchema, { id: 'Bar', namespace: 'Foo', owner: 'Baz', value: 'Qux' }),
+            },
+        });
+        const anySecretsResponse = create(SecretResponsesSchema, {
+            responses: [anySecretResponse],
+        });
+        mockHostBindings.getSecrets = (data, maxResponseSize) => {
+            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
+            const secretsRequest = fromBinary(GetSecretsRequestSchema, dataBytes);
+            expect(secretsRequest.requests.length).toBe(1);
+            expect(secretsRequest.requests[0].namespace).toBe('Foo');
+            expect(secretsRequest.requests[0].id).toBe('Bar');
+            expect(secretsRequest.callbackId).toBe(0);
+            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
+            return 0;
+        };
+        mockHostBindings.awaitSecrets = (data, maxResponseSize) => {
+            const dataBytes = Array.isArray(data) ? new Uint8Array(data) : data;
+            const awaitSecretsRequest = fromBinary(AwaitSecretsRequestSchema, dataBytes);
+            expect(awaitSecretsRequest.ids.length).toBe(1);
+            expect(awaitSecretsRequest.ids[0]).toBe(0);
+            expect(maxResponseSize).toBe(Number(anyMaxResponseSize));
+            // Create the proper AwaitSecretsResponse with a map
+            const awaitSecretsResponse = create(AwaitSecretsResponseSchema, {
+                responses: {
+                    0: anySecretsResponse,
+                },
+            });
+            return toBinary(AwaitSecretsResponseSchema, awaitSecretsResponse);
+        };
+        const dr = getTestRunner(subscribeRequest);
+        await (await dr).run(async (_, secretsProvider) => {
+            const secret = await secretsProvider.getSecret({ namespace: 'Foo', id: 'Bar' }).result();
+            expect(secret.namespace).toBe('Foo');
+            expect(secret.id).toBe('Bar');
+            expect(secret.owner).toBe('Baz');
+            expect(secret.value).toBe('Qux');
+            return [cre.handler(basicTrigger.trigger({}), () => 10)];
+        });
+        expect(true).toBe(true);
+    });
+});
+function assertEnv(r) {
+    let ran = false;
+    const verifyEnv = (config, _) => {
+        ran = true;
+        expect(config).toBe(anyConfig.toString());
+        return [];
+    };
+    r.run(verifyEnv);
+    expect(ran).toBe(true);
+}
+function getTestRunner(request) {
+    const serialized = toBinary(ExecuteRequestSchema, request);
+    const encoded = Buffer.from(serialized).toString('base64');
+    // Update the mock to return the specific request
+    mockHostBindings.getWasiArgs = mock(() => JSON.stringify(['program', encoded]));
+    return Runner.newRunner({
+        configParser: (b) => {
+            const stringConfig = Buffer.from(b).toString();
+            expect(stringConfig).toBe(anyConfig.toString());
+            return stringConfig;
+        },
+    });
+}

package/dist/sdk/wasm/runtime.d.ts

@@ -0,0 +1,7 @@
+import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+export declare class Runtime<C> extends RuntimeImpl<C> {
+    constructor(config: C, nextCallId: number, maxResponseSize: bigint);
+}
+export declare class NodeRuntime<C> extends NodeRuntimeImpl<C> {
+    constructor(config: C, nextCallId: number, maxResponseSize: bigint);
+}

package/dist/sdk/wasm/runtime.js

@@ -0,0 +1,55 @@
+import { fromBinary, toBinary } from '@bufbuild/protobuf';
+import { AwaitCapabilitiesRequestSchema, AwaitCapabilitiesResponseSchema, AwaitSecretsRequestSchema, AwaitSecretsResponseSchema, CapabilityRequestSchema, GetSecretsRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { NodeRuntimeImpl, RuntimeImpl } from '../impl/runtime-impl';
+import { hostBindings } from './host-bindings';
+export class Runtime extends RuntimeImpl {
+    constructor(config, nextCallId, maxResponseSize) {
+        super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
+    }
+}
+export class NodeRuntime extends NodeRuntimeImpl {
+    constructor(config, nextCallId, maxResponseSize) {
+        super(config, nextCallId, WasmRuntimeHelpers.getInstance(), maxResponseSize);
+    }
+}
+class WasmRuntimeHelpers {
+    static instance;
+    constructor() { }
+    now() {
+        return hostBindings.now();
+    }
+    static getInstance() {
+        if (!WasmRuntimeHelpers.instance) {
+            WasmRuntimeHelpers.instance = new WasmRuntimeHelpers();
+        }
+        return WasmRuntimeHelpers.instance;
+    }
+    call(request) {
+        return hostBindings.callCapability(toBinary(CapabilityRequestSchema, request)) >= 0;
+    }
+    await(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        const response = hostBindings.awaitCapabilities(toBinary(AwaitCapabilitiesRequestSchema, request), responseSize);
+        const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
+        return fromBinary(AwaitCapabilitiesResponseSchema, responseBytes);
+    }
+    getSecrets(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        return hostBindings.getSecrets(toBinary(GetSecretsRequestSchema, request), responseSize) >= 0;
+    }
+    awaitSecrets(request, maxResponseSize) {
+        // Convert bigint to integer for WASM host binding
+        // it's an i32, so we shouldn't need to trunc it (all i32 numbers are within the range of float64 without percision loss), but somehow it makes a difference...
+        const responseSize = Math.trunc(Number(maxResponseSize));
+        const response = hostBindings.awaitSecrets(toBinary(AwaitSecretsRequestSchema, request), responseSize);
+        const responseBytes = Array.isArray(response) ? new Uint8Array(response) : response;
+        return fromBinary(AwaitSecretsResponseSchema, responseBytes);
+    }
+    switchModes(mode) {
+        hostBindings.switchModes(mode);
+    }
+}

package/dist/sdk/workflow.d.ts

@@ -0,0 +1,17 @@
+import type { Message } from '@bufbuild/protobuf';
+import type { Secret, SecretRequest, SecretRequestJson } from '../generated/sdk/v1alpha/sdk_pb';
+import { type Runtime } from './runtime';
+import type { Trigger } from './utils/triggers/trigger-interface';
+import type { CreSerializable } from './utils';
+export type HandlerFn<TConfig, TTriggerOutput, TResult> = (runtime: Runtime<TConfig>, triggerOutput: TTriggerOutput) => Promise<CreSerializable<TResult>> | CreSerializable<TResult>;
+export interface HandlerEntry<TConfig, TRawTriggerOutput extends Message<string>, TTriggerOutput, TResult> {
+    trigger: Trigger<TRawTriggerOutput, TTriggerOutput>;
+    fn: HandlerFn<TConfig, TTriggerOutput, TResult>;
+}
+export type Workflow<TConfig> = ReadonlyArray<HandlerEntry<TConfig, any, any, any>>;
+export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
+export type SecretsProvider = {
+    getSecret(request: SecretRequest | SecretRequestJson): {
+        result: () => Promise<Secret>;
+    };
+};

package/dist/sdk/workflow.js

@@ -0,0 +1,5 @@
+import {} from './runtime';
+export const handler = (trigger, fn) => ({
+    trigger,
+    fn,
+});

package/package.json

@@ -1,9 +1,70 @@
 {
-            "name": "@chainlink/cre-sdk",
-            "version": "0.0.0",
-            "main": "",
-            "author": "",
-            "license": "ISC",
-            "repository": "git://github.com/smartcontractkit/cre-sdk-typescript.git",
-            "description": ""
-            }
+  "name": "@chainlink/cre-sdk",
+  "version": "0.0.2-alpha",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "cre-compile": "bin/cre-compile.ts"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "dist/",
+    "package.json",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "build": "bun run clean && bun run compile:build && bun run fix-imports",
+    "check": "biome check --write ${BIOME_PATHS:-.}",
+    "clean": "rm -rf dist",
+    "compile:all-standard-tests": "bun scripts/run.ts compile-all-standard-tests",
+    "compile:build": "tsc -p tsconfig.build.json",
+    "compile:js-to-wasm": "bun scripts/run.ts compile-to-wasm",
+    "compile:ts-to-js": "bun scripts/run.ts compile-to-js",
+    "compile:workflow": "bun scripts/run.ts compile-workflow",
+    "fix-imports": "bun scripts/run.ts fix-imports",
+    "format": "biome format --write ${BIOME_PATHS:-.}",
+    "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:sdk": "bun generate:proto && bun generate:chain-selectors && bun scripts/run generate-sdks && BIOME_PATHS=\"src/generated src/generated-sdk\" bun check",
+    "lint": "biome lint --write",
+    "prepublishOnly": "bun typecheck && bun lint && bun test",
+    "test": "bun test",
+    "test:standard": "./scripts/run-standard-tests.sh",
+    "typecheck": "tsc"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "2.6.3",
+    "@bufbuild/protoc-gen-es": "2.6.3",
+    "@chainlink/cre-sdk-javy-plugin": "0.0.2-alpha",
+    "@standard-schema/spec": "1.0.0",
+    "viem": "2.34.0",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.2.4",
+    "@bufbuild/buf": "1.56.0",
+    "@types/bun": "1.2.21",
+    "chain-selectors": "https://github.com/smartcontractkit/chain-selectors.git#8b963095ae797a3024c8e55822cced7bf618176f",
+    "fast-glob": "3.3.3",
+    "ts-proto": "2.7.5",
+    "typescript": "5.9.2",
+    "yaml": "2.8.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "SmartContract Chainlink Limited SEZC",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "engines": {
+    "bun": ">=1.2.21"
+  }
+}

package/scripts/run-standard-tests.sh

@@ -0,0 +1,21 @@
+#!/bin/zsh
+
+# Run standard tests script
+# Usage: ./scripts/run-standard-tests.sh
+
+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"
+    exit 1
+fi
+
+# Copy standard test files to dist
+echo "Copying test files..." && cp -r ./src/standard_tests/* ./dist/workflows/standard_tests/
+
+# Run standard tests
+make standard_tests

package/scripts/run.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+
+const availableScripts = [
+	'compile-to-js',
+	'compile-to-wasm',
+	'compile-workflow', // TS -> JS -> WASM compilation in single script
+	'compile-all-standard-tests', // Do the above but for all standard tests
+
+	'generate-chain-selectors',
+	'generate-sdks',
+	'fix-imports', // Fix @cre/* imports to relative paths
+]
+
+/**
+ * Main entry point for scripts related to the development of the SDK.
+ */
+const main = async () => {
+	const scriptName = process.argv[2]
+
+	if (!scriptName) {
+		console.error('Usage: bun run.ts <script-name>')
+		console.error('Available scripts:')
+		availableScripts.forEach((script) => {
+			console.error(`  ${script}`)
+		})
+		process.exit(1)
+	}
+
+	try {
+		const scriptPath = `./src/${scriptName}.ts`
+		const script = await import(scriptPath)
+
+		if (typeof script.main === 'function') {
+			await script.main()
+		} else {
+			console.error(`Script ${scriptName} does not export a main function`)
+			process.exit(1)
+		}
+	} catch (error) {
+		console.error(`Failed to load script ${scriptName}:`, error)
+		process.exit(1)
+	}
+}
+
+main()

package/scripts/src/compile-all-standard-tests.ts

@@ -0,0 +1,81 @@
+// compile-all-standard-tests.ts
+import path from 'node:path'
+import fg from 'fast-glob'
+import { main as compileWorkflow } from './compile-workflow'
+
+/** Mirror the input file under .temp/<original path> and swap extension to .wasm */
+export function toTempMirrorWasmPath(inputPath: string) {
+	const resolved = path.resolve(inputPath)
+	const relFromCwd = path.relative(process.cwd(), resolved)
+	const pathParts = relFromCwd.split(path.sep)
+	const filteredParts = pathParts.filter((part) => part !== 'src')
+	const mirrored = path.join('.temp', ...filteredParts)
+	return mirrored.replace(/\.[^.]+$/, '.wasm')
+}
+
+export const main = async (baseDir?: string, pattern?: string) => {
+	// CLI fallback: bun test:standard:compile:all [baseDir] [pattern]
+	const args = process.argv.slice(3)
+	const root = baseDir ?? args[0] ?? 'src/standard_tests'
+	const glob = pattern ?? args[1] ?? '**/test.ts'
+
+	console.info('🚀 Compiling all standard tests...\n')
+	console.info(`📂 Root:    ${path.resolve(root)}`)
+	console.info(`🔎 Pattern: ${glob}\n`)
+
+	// Find all test.ts files
+	const files = await fg(`${root.replace(/\\/g, '/')}/${glob}`, { dot: false })
+
+	if (files.length === 0) {
+		console.error('❌ No standard test files found')
+		process.exit(1)
+	}
+
+	console.info(`📋 Found ${files.length} test(s):`)
+	for (const f of files) console.info(`   • ${f}`)
+	console.info('')
+
+	let success = 0
+	let failed = 0
+	const failures: string[] = []
+
+	// Sequential for readable logs (switch to Promise.allSettled for parallel if desired)
+	for (const testPath of files) {
+		const rel = path.relative(process.cwd(), testPath)
+		const wasmOut = toTempMirrorWasmPath(testPath)
+
+		try {
+			console.info(`🔨 Compiling: ${rel}`)
+			console.info(`   → Output:  ${path.relative(process.cwd(), wasmOut)}`)
+			await compileWorkflow(testPath, wasmOut)
+			console.info(`✅ Success:   ${rel}\n`)
+			success++
+		} catch (err) {
+			console.error(`❌ Failed:    ${rel}`)
+			console.error(`   Error: ${err}\n`)
+			failed++
+			failures.push(rel)
+		}
+	}
+
+	// Summary
+	console.info('📊 Compilation Summary:')
+	console.info(`   ✅ Successful: ${success}`)
+	console.info(`   ❌ Failed:     ${failed}`)
+
+	if (failures.length > 0) {
+		console.info('   Failed tests:')
+		for (const f of failures) console.info(`   • ${f}`)
+		process.exit(1)
+	}
+
+	console.info(`\n🎉 All ${success} standard tests compiled successfully!`)
+}
+
+// Allow direct CLI usage
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error(e)
+		process.exit(1)
+	})
+}

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

@@ -0,0 +1,57 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { $ } from 'bun'
+
+export const main = async (tsFilePath?: string, outputFilePath?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Prefer function params, fallback to CLI args
+	const inputPath = tsFilePath ?? cliArgs[0]
+	const outputPathArg = outputFilePath ?? cliArgs[1]
+
+	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')
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	console.info(`📁 Using input file: ${resolvedInput}`)
+
+	// If no explicit output path → same dir, swap extension to .js
+	const resolvedOutput =
+		outputPathArg != null
+			? path.resolve(outputPathArg)
+			: path.join(
+					path.dirname(resolvedInput),
+					path.basename(resolvedInput).replace(/\.[^.]+$/, '.js'),
+				)
+
+	// Ensure the output directory exists
+	await mkdir(path.dirname(resolvedOutput), { recursive: true })
+
+	// Build step (emit next to output file, then overwrite)
+	await Bun.build({
+		entrypoints: [resolvedInput],
+		outdir: path.dirname(resolvedOutput),
+		target: 'node',
+		format: 'esm',
+		naming: path.basename(resolvedOutput),
+	})
+
+	// The file Bun will emit before bundling
+	const builtFile = path.join(path.dirname(resolvedOutput), path.basename(resolvedOutput))
+
+	if (!existsSync(builtFile)) {
+		console.error(`❌ Expected file not found: ${builtFile}`)
+		process.exit(1)
+	}
+
+	// Bundle into the final file (overwrite)
+	await $`bun build ${builtFile} --bundle --outfile=${resolvedOutput}`
+
+	console.info(`✅ Built: ${resolvedOutput}`)
+	return resolvedOutput
+}