From 85c9cf4b07fe1d7f7deedee61e9d7578118b9c58 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Wed, 25 Feb 2026 16:07:02 +0100 Subject: [PATCH 01/20] remove node types and bun types from workflows --- bun.lock | 9 +++------ packages/cre-sdk-examples/package.json | 4 +--- .../workflows/http-fetch-no-sugar/index.ts | 5 +++-- .../src/workflows/proof-of-reserve/index.ts | 3 ++- packages/cre-sdk-examples/tsconfig.json | 3 +++ packages/cre-sdk/scripts/src/build-types.ts | 20 ++++++++++++++++++- 6 files changed, 31 insertions(+), 13 deletions(-) diff --git a/bun.lock b/bun.lock index 73d21f08..cc6f00b6 100644 --- a/bun.lock +++ b/bun.lock @@ -26,7 +26,7 @@ }, "packages/cre-sdk": { "name": "@chainlink/cre-sdk", - "version": "1.0.9", + "version": "1.1.2", "bin": { "cre-compile": "bin/cre-compile.ts", }, @@ -51,20 +51,17 @@ }, "packages/cre-sdk-examples": { "name": "@chainlink/cre-sdk-examples", - "version": "1.0.9", + "version": "1.1.2", "dependencies": { "@bufbuild/protobuf": "2.6.3", "@chainlink/cre-sdk": "workspace:*", "viem": "2.34.0", "zod": "3.25.76", }, - "devDependencies": { - "@types/bun": "1.3.8", - }, }, "packages/cre-sdk-javy-plugin": { "name": "@chainlink/cre-sdk-javy-plugin", - "version": "1.0.9", + "version": "1.1.1", "bin": { "cre-setup": "bin/setup.ts", "cre-compile-workflow": "bin/compile-workflow.ts", diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index ff1515bf..ed73f4d9 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -20,9 +20,7 @@ "viem": "2.34.0", "zod": "3.25.76" }, - "devDependencies": { - "@types/bun": "1.3.8" - }, + "devDependencies": {}, "engines": { "bun": ">=1.2.21" } diff --git a/packages/cre-sdk-examples/src/workflows/http-fetch-no-sugar/index.ts b/packages/cre-sdk-examples/src/workflows/http-fetch-no-sugar/index.ts index 5579ce2e..293987ad 100644 --- a/packages/cre-sdk-examples/src/workflows/http-fetch-no-sugar/index.ts +++ b/packages/cre-sdk-examples/src/workflows/http-fetch-no-sugar/index.ts @@ -6,6 +6,7 @@ import { type NodeRuntime, Runner, type Runtime, + text, } from '@chainlink/cre-sdk' import { z } from 'zod' @@ -38,8 +39,8 @@ const fetchMathResult = (nodeRuntime: NodeRuntime): bigint => { const resp = httpClient.sendRequest(nodeRuntime, req).result() // The mathjs.org API returns the result as a raw string in the body. // We need to parse it into a bigint. - const bodyText = new TextDecoder().decode(resp.body) - const val = BigInt(bodyText.trim()) + const bodyText = text(resp) + const val = BigInt(bodyText) return val } diff --git a/packages/cre-sdk-examples/src/workflows/proof-of-reserve/index.ts b/packages/cre-sdk-examples/src/workflows/proof-of-reserve/index.ts index 1ac90d2c..6135bc2f 100644 --- a/packages/cre-sdk-examples/src/workflows/proof-of-reserve/index.ts +++ b/packages/cre-sdk-examples/src/workflows/proof-of-reserve/index.ts @@ -19,6 +19,7 @@ import { Runner, type Runtime, TxStatus, + text, } from '@chainlink/cre-sdk' import { type Address, decodeFunctionResult, encodeFunctionData, zeroAddress } from 'viem' import { z } from 'zod' @@ -66,7 +67,7 @@ const fetchReserveInfo = (sendRequester: HTTPSendRequester, config: Config): Res throw new Error(`HTTP request failed with status: ${response.statusCode}`) } - const responseText = Buffer.from(response.body).toString('utf-8') + const responseText = text(response) const porResp: PORResponse = JSON.parse(responseText) if (porResp.ripcord) { diff --git a/packages/cre-sdk-examples/tsconfig.json b/packages/cre-sdk-examples/tsconfig.json index d8cb82fa..68da0445 100644 --- a/packages/cre-sdk-examples/tsconfig.json +++ b/packages/cre-sdk-examples/tsconfig.json @@ -21,6 +21,9 @@ "skipLibCheck": true, "noFallthroughCasesInSwitch": true, + // Do not auto-include @types/* — mirrors the customer WASM environment + "types": [], + // Some stricter flags (disabled by default) "noUnusedLocals": false, "noUnusedParameters": false, diff --git a/packages/cre-sdk/scripts/src/build-types.ts b/packages/cre-sdk/scripts/src/build-types.ts index 4172cefd..598d1165 100644 --- a/packages/cre-sdk/scripts/src/build-types.ts +++ b/packages/cre-sdk/scripts/src/build-types.ts @@ -1,5 +1,5 @@ import { glob } from 'fast-glob' -import { copyFile, mkdir } from 'fs/promises' +import { copyFile, mkdir, readFile, writeFile } from 'fs/promises' import { join } from 'path' const buildTypes = async () => { @@ -28,6 +28,24 @@ const buildTypes = async () => { } console.log(`✅ Copied ${typeFiles.length} type definition file(s) to dist/sdk/types`) + + // Prepend triple-slash references to dist/index.d.ts so consumers pick up + // global type augmentations (e.g. restricted-apis.d.ts) automatically. + // tsc strips these from the emitted .d.ts, so we add them back here. + const indexDts = join(packageRoot, 'dist/index.d.ts') + const sourceIndex = join(packageRoot, 'src/index.ts') + const sourceContent = await readFile(sourceIndex, 'utf-8') + + const tripleSlashRefs = sourceContent + .split('\n') + .filter((line) => line.startsWith('/// Date: Wed, 25 Feb 2026 16:12:13 +0100 Subject: [PATCH 02/20] Update comment --- packages/cre-sdk-examples/tsconfig.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/cre-sdk-examples/tsconfig.json b/packages/cre-sdk-examples/tsconfig.json index 68da0445..4905e437 100644 --- a/packages/cre-sdk-examples/tsconfig.json +++ b/packages/cre-sdk-examples/tsconfig.json @@ -21,7 +21,7 @@ "skipLibCheck": true, "noFallthroughCasesInSwitch": true, - // Do not auto-include @types/* — mirrors the customer WASM environment + // Do not auto-include @types/* — mirrors the customer cre cli initialized environment "types": [], // Some stricter flags (disabled by default) From e62a01fe9ecbb1654b5de0e32474ff8ce5029785 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Wed, 25 Feb 2026 16:28:08 +0100 Subject: [PATCH 03/20] Expose console types through global and add examples that serve as test that this setup actually works --- .../src/restricted-apis-example.ts | 59 +++++++++++++++++++ packages/cre-sdk/src/sdk/types/global.d.ts | 12 ++++ 2 files changed, 71 insertions(+) create mode 100644 packages/cre-sdk-examples/src/restricted-apis-example.ts diff --git a/packages/cre-sdk-examples/src/restricted-apis-example.ts b/packages/cre-sdk-examples/src/restricted-apis-example.ts new file mode 100644 index 00000000..8576cec2 --- /dev/null +++ b/packages/cre-sdk-examples/src/restricted-apis-example.ts @@ -0,0 +1,59 @@ +/** + * This example shows how CRE workflows mark restricted APIs as deprecated in TS. + * + * The restricted APIs covered in this example are: + * - fetch + * - window + * - document + * - XMLHttpRequest + * - localStorage + * - sessionStorage + * - setTimeout + * - setInterval + * + * There are also NodeJS APIs that do work with the QuickJS runtime, like console.log, which this file covers. + */ + +export const testFetch = async () => { + // @ts-expect-error - fetch is not available in the CRE SDK + fetch('https://api.chain.link/v1/price?symbol=ETH/USD') +} + +export const testWindow = async () => { + // @ts-expect-error - window is not available in the CRE SDK + window.alert('Hello, world!') +} + +export const testDocument = async () => { + // @ts-expect-error - document is not available in the CRE SDK + document.body.innerHTML = 'Hello, world!' +} + +export const testXMLHttpRequest = async () => { + // @ts-expect-error - XMLHttpRequest is not available in the CRE SDK + new XMLHttpRequest() +} + +export const testLocalStorage = async () => { + // @ts-expect-error - localStorage is not available in the CRE SDK + localStorage.setItem('test', 'Hello, world!') +} + +export const testSessionStorage = async () => { + // @ts-expect-error - sessionStorage is not available in the CRE SDK + sessionStorage.setItem('test', 'Hello, world!') +} + +export const testSetTimeout = async () => { + // @ts-expect-error - setTimeout is not available in the CRE SDK + setTimeout(() => { + console.log('Hello, world!') + }, 1000) +} + +export const testSetInterval = async () => { + // @ts-expect-error - setInterval is not available in the CRE SDK + setInterval(() => { + console.log('Hello, world!') + }, 1000) +} diff --git a/packages/cre-sdk/src/sdk/types/global.d.ts b/packages/cre-sdk/src/sdk/types/global.d.ts index e8036a46..b6c820e8 100644 --- a/packages/cre-sdk/src/sdk/types/global.d.ts +++ b/packages/cre-sdk/src/sdk/types/global.d.ts @@ -78,6 +78,18 @@ declare global { * @returns Unix timestamp in milliseconds */ function now(): number + + /** + * Console API available in the QuickJS runtime + */ + interface Console { + log(...args: unknown[]): void + warn(...args: unknown[]): void + error(...args: unknown[]): void + info(...args: unknown[]): void + debug(...args: unknown[]): void + } + var console: Console } export {} From 227700f2b88c65a82d971fb2d60fbf1bab3d6792 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Thu, 26 Feb 2026 11:56:39 +0100 Subject: [PATCH 04/20] Add node modules restrictions --- packages/cre-sdk/src/index.ts | 1 + packages/cre-sdk/src/sdk/types/global.d.ts | 29 ++++++++++++++ .../sdk/types/restricted-node-modules.d.ts | 40 +++++++++++++++++++ 3 files changed, 70 insertions(+) create mode 100644 packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts diff --git a/packages/cre-sdk/src/index.ts b/packages/cre-sdk/src/index.ts index d0fec607..8095eaa5 100644 --- a/packages/cre-sdk/src/index.ts +++ b/packages/cre-sdk/src/index.ts @@ -1,4 +1,5 @@ /// /// +/// export * from './sdk' diff --git a/packages/cre-sdk/src/sdk/types/global.d.ts b/packages/cre-sdk/src/sdk/types/global.d.ts index b6c820e8..4482d996 100644 --- a/packages/cre-sdk/src/sdk/types/global.d.ts +++ b/packages/cre-sdk/src/sdk/types/global.d.ts @@ -90,6 +90,35 @@ declare global { debug(...args: unknown[]): void } var console: Console + + /** + * TextEncoder/TextDecoder APIs available via Javy's text_encoding support + */ + interface TextEncoderEncodeIntoResult { + read: number + written: number + } + + interface TextEncoder { + readonly encoding: string + encode(input?: string): Uint8Array + encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult + } + var TextEncoder: { + prototype: TextEncoder + new (): TextEncoder + } + + interface TextDecoder { + readonly encoding: string + readonly fatal: boolean + readonly ignoreBOM: boolean + decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string + } + var TextDecoder: { + prototype: TextDecoder + new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder + } } export {} diff --git a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts new file mode 100644 index 00000000..e5c9389b --- /dev/null +++ b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts @@ -0,0 +1,40 @@ +// Restricted Node.js modules that are not available in CRE WASM workflows. +// These modules require native bindings or system access that cannot run in WebAssembly. +// Importing from these modules will produce a TypeScript error at development time, +// preventing cryptic WASM runtime failures. + +/** @deprecated node:crypto is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ +declare module 'node:crypto' {} + +/** @deprecated node:fs is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ +declare module 'node:fs' {} + +/** @deprecated node:fs/promises is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ +declare module 'node:fs/promises' {} + +/** @deprecated node:net is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +declare module 'node:net' {} + +/** @deprecated node:http is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +declare module 'node:http' {} + +/** @deprecated node:https is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +declare module 'node:https' {} + +/** @deprecated node:child_process is not available in CRE WASM workflows. It requires OS process spawning that is not available in WebAssembly. */ +declare module 'node:child_process' {} + +/** @deprecated node:os is not available in CRE WASM workflows. It requires OS access that is not available in WebAssembly. */ +declare module 'node:os' {} + +/** @deprecated node:stream is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ +declare module 'node:stream' {} + +/** @deprecated node:worker_threads is not available in CRE WASM workflows. It requires threading support that is not available in WebAssembly. */ +declare module 'node:worker_threads' {} + +/** @deprecated node:dns is not available in CRE WASM workflows. It requires network access that is not available in WebAssembly. */ +declare module 'node:dns' {} + +/** @deprecated node:zlib is not available in CRE WASM workflows. It requires native compression bindings that cannot run in WebAssembly. */ +declare module 'node:zlib' {} From a77661008d7698c5fb34a1abf27321d9d2bd4c8a Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Thu, 26 Feb 2026 13:41:05 +0100 Subject: [PATCH 05/20] Add more restricted node APIs --- packages/cre-sdk/scripts/src/build-types.ts | 21 +- packages/cre-sdk/src/index.ts | 1 - .../sdk/types/restricted-node-modules.d.ts | 356 +++++++++++++++++- packages/cre-sdk/tsconfig.json | 7 +- 4 files changed, 366 insertions(+), 19 deletions(-) diff --git a/packages/cre-sdk/scripts/src/build-types.ts b/packages/cre-sdk/scripts/src/build-types.ts index 598d1165..d2f272ae 100644 --- a/packages/cre-sdk/scripts/src/build-types.ts +++ b/packages/cre-sdk/scripts/src/build-types.ts @@ -32,18 +32,33 @@ const buildTypes = async () => { // Prepend triple-slash references to dist/index.d.ts so consumers pick up // global type augmentations (e.g. restricted-apis.d.ts) automatically. // tsc strips these from the emitted .d.ts, so we add them back here. + // + // Note: restricted-node-modules is intentionally NOT referenced from src/index.ts + // because the SDK's own build scripts legitimately use Node.js modules. It is + // added here explicitly so that workflow consumers still receive the restrictions. const indexDts = join(packageRoot, 'dist/index.d.ts') const sourceIndex = join(packageRoot, 'src/index.ts') const sourceContent = await readFile(sourceIndex, 'utf-8') - const tripleSlashRefs = sourceContent + const refsFromSource = sourceContent .split('\n') .filter((line) => line.startsWith('/// '] + + const tripleSlashRefs = [...refsFromSource, ...distributionOnlyRefs].join('\n') if (tripleSlashRefs) { const indexContent = await readFile(indexDts, 'utf-8') - await writeFile(indexDts, `${tripleSlashRefs}\n${indexContent}`) + // Strip any existing triple-slash references from the top of the file + // so that re-running build-types is idempotent. + const withoutExistingRefs = indexContent + .split('\n') + .filter((line) => !line.startsWith('/// /// -/// export * from './sdk' diff --git a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts index e5c9389b..2454d3f6 100644 --- a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts +++ b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts @@ -1,40 +1,368 @@ // Restricted Node.js modules that are not available in CRE WASM workflows. // These modules require native bindings or system access that cannot run in WebAssembly. -// Importing from these modules will produce a TypeScript error at development time, -// preventing cryptic WASM runtime failures. +// Importing from these modules is allowed by TypeScript, but all exports are typed as +// `never` so any usage produces a clear error at the call site. /** @deprecated node:crypto is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ -declare module 'node:crypto' {} +declare module 'node:crypto' { + export const randomBytes: never + export const randomUUID: never + export const randomInt: never + export const randomFillSync: never + export const randomFill: never + export const createHash: never + export const createHmac: never + export const createCipheriv: never + export const createDecipheriv: never + export const createSign: never + export const createVerify: never + export const createDiffieHellman: never + export const createDiffieHellmanGroup: never + export const createECDH: never + export const generateKey: never + export const generateKeySync: never + export const generateKeyPair: never + export const generateKeyPairSync: never + export const createPrivateKey: never + export const createPublicKey: never + export const createSecretKey: never + export const pbkdf2: never + export const pbkdf2Sync: never + export const scrypt: never + export const scryptSync: never + export const timingSafeEqual: never + export const publicEncrypt: never + export const publicDecrypt: never + export const privateDecrypt: never + export const privateEncrypt: never + export const getCiphers: never + export const getHashes: never + export const getCurves: never + export const getFips: never + export const setFips: never + export const getRandomValues: never + export const Hash: never + export const Hmac: never + export const Sign: never + export const Verify: never + export const KeyObject: never + export const Certificate: never + export const ECDH: never + export const DiffieHellman: never + export const DiffieHellmanGroup: never + export const Cipheriv: never + export const Decipheriv: never + export const webcrypto: never + export const subtle: never + export const crypto: never + export const fips: never + export const constants: never +} /** @deprecated node:fs is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ -declare module 'node:fs' {} +declare module 'node:fs' { + export const readFile: never + export const readFileSync: never + export const writeFile: never + export const writeFileSync: never + export const appendFile: never + export const appendFileSync: never + export const readdir: never + export const readdirSync: never + export const mkdir: never + export const mkdirSync: never + export const mkdtemp: never + export const mkdtempSync: never + export const rm: never + export const rmSync: never + export const rmdir: never + export const rmdirSync: never + export const unlink: never + export const unlinkSync: never + export const stat: never + export const statSync: never + export const lstat: never + export const lstatSync: never + export const fstat: never + export const fstatSync: never + export const statfs: never + export const statfsSync: never + export const exists: never + export const existsSync: never + export const copyFile: never + export const copyFileSync: never + export const cp: never + export const cpSync: never + export const rename: never + export const renameSync: never + export const readlink: never + export const readlinkSync: never + export const symlink: never + export const symlinkSync: never + export const link: never + export const linkSync: never + export const open: never + export const openSync: never + export const close: never + export const closeSync: never + export const read: never + export const readSync: never + export const write: never + export const writeSync: never + export const truncate: never + export const truncateSync: never + export const ftruncate: never + export const ftruncateSync: never + export const chmod: never + export const chmodSync: never + export const chown: never + export const chownSync: never + export const utimes: never + export const utimesSync: never + export const access: never + export const accessSync: never + export const createReadStream: never + export const createWriteStream: never + export const watch: never + export const watchFile: never + export const unwatchFile: never + export const realpath: never + export const realpathSync: never + export const promises: never + export const constants: never + export const Dir: never + export const Dirent: never + export const Stats: never + export const ReadStream: never + export const WriteStream: never + export const FileHandle: never + export const FSWatcher: never +} /** @deprecated node:fs/promises is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ -declare module 'node:fs/promises' {} +declare module 'node:fs/promises' { + export const readFile: never + export const writeFile: never + export const appendFile: never + export const readdir: never + export const mkdir: never + export const mkdtemp: never + export const rm: never + export const rmdir: never + export const unlink: never + export const stat: never + export const lstat: never + export const statfs: never + export const copyFile: never + export const cp: never + export const rename: never + export const readlink: never + export const symlink: never + export const link: never + export const open: never + export const truncate: never + export const chmod: never + export const chown: never + export const utimes: never + export const access: never + export const realpath: never + export const watch: never + export const constants: never + export const FileHandle: never +} /** @deprecated node:net is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ -declare module 'node:net' {} +declare module 'node:net' { + export const createServer: never + export const createConnection: never + export const connect: never + export const isIP: never + export const isIPv4: never + export const isIPv6: never + export const getDefaultAutoSelectFamily: never + export const setDefaultAutoSelectFamily: never + export const Socket: never + export const Server: never + export const BlockList: never + export const SocketAddress: never +} /** @deprecated node:http is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ -declare module 'node:http' {} +declare module 'node:http' { + export const createServer: never + export const request: never + export const get: never + export const validateHeaderName: never + export const validateHeaderValue: never + export const setMaxIdleHTTPParsers: never + export const Server: never + export const ClientRequest: never + export const IncomingMessage: never + export const ServerResponse: never + export const OutgoingMessage: never + export const Agent: never + export const globalAgent: never + export const METHODS: never + export const STATUS_CODES: never + export const maxHeaderSize: never +} /** @deprecated node:https is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ -declare module 'node:https' {} +declare module 'node:https' { + export const createServer: never + export const request: never + export const get: never + export const Server: never + export const Agent: never + export const globalAgent: never +} /** @deprecated node:child_process is not available in CRE WASM workflows. It requires OS process spawning that is not available in WebAssembly. */ -declare module 'node:child_process' {} +declare module 'node:child_process' { + export const spawn: never + export const spawnSync: never + export const exec: never + export const execSync: never + export const execFile: never + export const execFileSync: never + export const fork: never + export const ChildProcess: never +} /** @deprecated node:os is not available in CRE WASM workflows. It requires OS access that is not available in WebAssembly. */ -declare module 'node:os' {} +declare module 'node:os' { + export const hostname: never + export const platform: never + export const arch: never + export const type: never + export const release: never + export const version: never + export const machine: never + export const cpus: never + export const availableParallelism: never + export const freemem: never + export const totalmem: never + export const uptime: never + export const loadavg: never + export const homedir: never + export const tmpdir: never + export const userInfo: never + export const networkInterfaces: never + export const endianness: never + export const getPriority: never + export const setPriority: never + export const EOL: never + export const devNull: never + export const constants: never +} /** @deprecated node:stream is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ -declare module 'node:stream' {} +declare module 'node:stream' { + export const Readable: never + export const Writable: never + export const Duplex: never + export const Transform: never + export const PassThrough: never + export const Stream: never + export const pipeline: never + export const finished: never + export const promises: never + export const addAbortSignal: never + export const compose: never + export const isErrored: never + export const isReadable: never +} /** @deprecated node:worker_threads is not available in CRE WASM workflows. It requires threading support that is not available in WebAssembly. */ -declare module 'node:worker_threads' {} +declare module 'node:worker_threads' { + export const Worker: never + export const MessageChannel: never + export const MessagePort: never + export const BroadcastChannel: never + export const isMainThread: never + export const isInternalThread: never + export const parentPort: never + export const workerData: never + export const threadId: never + export const resourceLimits: never + export const SHARE_ENV: never + export const receiveMessageOnPort: never + export const moveMessagePortToContext: never + export const getEnvironmentData: never + export const setEnvironmentData: never + export const markAsUntransferable: never + export const markAsUncloneable: never + export const isMarkedAsUntransferable: never + export const postMessageToThread: never +} /** @deprecated node:dns is not available in CRE WASM workflows. It requires network access that is not available in WebAssembly. */ -declare module 'node:dns' {} +declare module 'node:dns' { + export const lookup: never + export const lookupService: never + export const resolve: never + export const resolve4: never + export const resolve6: never + export const resolveCname: never + export const resolveMx: never + export const resolveNs: never + export const resolvePtr: never + export const resolveSrv: never + export const resolveTxt: never + export const resolveNaptr: never + export const resolveSoa: never + export const resolveAny: never + export const reverse: never + export const setServers: never + export const getServers: never + export const setDefaultResultOrder: never + export const getDefaultResultOrder: never + export const promises: never + export const Resolver: never +} /** @deprecated node:zlib is not available in CRE WASM workflows. It requires native compression bindings that cannot run in WebAssembly. */ -declare module 'node:zlib' {} +declare module 'node:zlib' { + export const createGzip: never + export const createGunzip: never + export const createDeflate: never + export const createInflate: never + export const createDeflateRaw: never + export const createInflateRaw: never + export const createUnzip: never + export const createBrotliCompress: never + export const createBrotliDecompress: never + export const createZstdCompress: never + export const createZstdDecompress: never + export const gzip: never + export const gzipSync: never + export const gunzip: never + export const gunzipSync: never + export const deflate: never + export const deflateSync: never + export const inflate: never + export const inflateSync: never + export const deflateRaw: never + export const deflateRawSync: never + export const inflateRaw: never + export const inflateRawSync: never + export const unzip: never + export const unzipSync: never + export const brotliCompress: never + export const brotliCompressSync: never + export const brotliDecompress: never + export const brotliDecompressSync: never + export const crc32: never + export const constants: never + export const Gzip: never + export const Gunzip: never + export const Deflate: never + export const Inflate: never + export const DeflateRaw: never + export const InflateRaw: never + export const Unzip: never + export const BrotliCompress: never + export const BrotliDecompress: never + export const ZstdCompress: never + export const ZstdDecompress: never +} diff --git a/packages/cre-sdk/tsconfig.json b/packages/cre-sdk/tsconfig.json index 1a5841ff..49fc05c0 100644 --- a/packages/cre-sdk/tsconfig.json +++ b/packages/cre-sdk/tsconfig.json @@ -34,5 +34,10 @@ "experimentalDecorators": true, "emitDecoratorMetadata": true }, - "include": ["src/**/*", "scripts/**/*.ts", "bin/**/*.ts"] + "include": ["src/**/*", "scripts/**/*.ts", "bin/**/*.ts"], + // restricted-node-modules.d.ts is excluded from the SDK's own compilation + // because the SDK's build scripts legitimately use Node.js modules. It is + // injected into dist/index.d.ts by build-types.ts so workflow consumers + // still receive the restrictions. + "exclude": ["src/sdk/types/restricted-node-modules.d.ts"] } From 1e8ca6af8a0fe62d3ea7aedf24542727642f63a5 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Thu, 26 Feb 2026 18:07:53 +0100 Subject: [PATCH 06/20] Expose more apis through runtime --- packages/cre-sdk/src/sdk/types/global.d.ts | 53 +++++++++++++++++++ .../cre-sdk/src/sdk/utils/prepare-runtime.ts | 11 ++-- 2 files changed, 61 insertions(+), 3 deletions(-) diff --git a/packages/cre-sdk/src/sdk/types/global.d.ts b/packages/cre-sdk/src/sdk/types/global.d.ts index 4482d996..3fb9e68d 100644 --- a/packages/cre-sdk/src/sdk/types/global.d.ts +++ b/packages/cre-sdk/src/sdk/types/global.d.ts @@ -119,6 +119,59 @@ declare global { prototype: TextDecoder new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder } + + /** + * Base64 encoding/decoding — exposed via prepareRuntime() from node:buffer + */ + function atob(encodedData: string): string + function btoa(stringToEncode: string): string + + /** + * URL and URLSearchParams — exposed via prepareRuntime() from node:url + */ + interface URLSearchParams { + append(name: string, value: string): void + delete(name: string): void + get(name: string): string | null + getAll(name: string): string[] + has(name: string): boolean + set(name: string, value: string): void + sort(): void + toString(): string + forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void + entries(): IterableIterator<[string, string]> + keys(): IterableIterator + values(): IterableIterator + [Symbol.iterator](): IterableIterator<[string, string]> + readonly size: number + } + var URLSearchParams: { + prototype: URLSearchParams + new ( + init?: string | Record | [string, string][] | URLSearchParams, + ): URLSearchParams + } + + interface URL { + hash: string + host: string + hostname: string + href: string + readonly origin: string + password: string + pathname: string + port: string + protocol: string + search: string + readonly searchParams: URLSearchParams + username: string + toString(): string + toJSON(): string + } + var URL: { + prototype: URL + new (url: string, base?: string | URL): URL + } } export {} diff --git a/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts b/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts index dbb8faba..1c94f453 100644 --- a/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts +++ b/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts @@ -1,10 +1,15 @@ -import { Buffer } from 'node:buffer' +import { atob, Buffer, btoa } from 'node:buffer' +import { URL, URLSearchParams } from 'node:url' /** * This function is used to prepare the runtime for the SDK to work. * It should be called as a part of SDK initialization. - * It exposes NodeJS Buffer in global namespace, so it can be bundled and used in workflow code. + * It exposes Node.js APIs in global namespace, so they can be bundled and used in workflow code. */ export const prepareRuntime = () => { - globalThis.Buffer = Buffer as any + globalThis.Buffer = Buffer + globalThis.atob = atob + globalThis.btoa = btoa + globalThis.URL = URL as any + globalThis.URLSearchParams = URLSearchParams } From 87fa5a85c4acbc71cf7b79fa32d7a6ccfe043726 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 16:35:11 +0100 Subject: [PATCH 07/20] TS fixes --- .../src/restricted-apis-example.ts | 33 +- packages/cre-sdk/README.md | 13 +- packages/cre-sdk/scripts/run.ts | 6 +- packages/cre-sdk/scripts/src/build-types.ts | 9 +- packages/cre-sdk/scripts/src/compile-to-js.ts | 2 + .../src/validate-workflow-runtime-compat.ts | 378 ++++++++++++++++++ packages/cre-sdk/src/sdk/types/global.d.ts | 71 ++-- .../src/sdk/types/restricted-apis.d.ts | 26 +- 8 files changed, 447 insertions(+), 91 deletions(-) create mode 100644 packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts diff --git a/packages/cre-sdk-examples/src/restricted-apis-example.ts b/packages/cre-sdk-examples/src/restricted-apis-example.ts index 8576cec2..dc823bfd 100644 --- a/packages/cre-sdk-examples/src/restricted-apis-example.ts +++ b/packages/cre-sdk-examples/src/restricted-apis-example.ts @@ -3,15 +3,11 @@ * * The restricted APIs covered in this example are: * - fetch - * - window - * - document - * - XMLHttpRequest - * - localStorage - * - sessionStorage * - setTimeout * - setInterval * - * There are also NodeJS APIs that do work with the QuickJS runtime, like console.log, which this file covers. + * Other unsupported globals/modules are enforced by cre-compile runtime checks. + * There are also NodeJS APIs that do work with the QuickJS runtime, like console.log. */ export const testFetch = async () => { @@ -19,31 +15,6 @@ export const testFetch = async () => { fetch('https://api.chain.link/v1/price?symbol=ETH/USD') } -export const testWindow = async () => { - // @ts-expect-error - window is not available in the CRE SDK - window.alert('Hello, world!') -} - -export const testDocument = async () => { - // @ts-expect-error - document is not available in the CRE SDK - document.body.innerHTML = 'Hello, world!' -} - -export const testXMLHttpRequest = async () => { - // @ts-expect-error - XMLHttpRequest is not available in the CRE SDK - new XMLHttpRequest() -} - -export const testLocalStorage = async () => { - // @ts-expect-error - localStorage is not available in the CRE SDK - localStorage.setItem('test', 'Hello, world!') -} - -export const testSessionStorage = async () => { - // @ts-expect-error - sessionStorage is not available in the CRE SDK - sessionStorage.setItem('test', 'Hello, world!') -} - export const testSetTimeout = async () => { // @ts-expect-error - setTimeout is not available in the CRE SDK setTimeout(() => { diff --git a/packages/cre-sdk/README.md b/packages/cre-sdk/README.md index 95ad9648..c4fb8771 100644 --- a/packages/cre-sdk/README.md +++ b/packages/cre-sdk/README.md @@ -8,6 +8,7 @@ The Chainlink Runtime Environment (CRE) SDK for TypeScript enables developers to - [Examples](#examples) - [Simulate locally with CRE CLI](#simulate-locally-with-cre-cli) - [Installation](#installation) +- [Runtime Compatibility Constraints](#runtime-compatibility-constraints) - [Core Concepts](#core-concepts) - [Workflows](#workflows) - [Runtime Modes](#runtime-modes) @@ -47,10 +48,20 @@ This package must be used along with the [CRE CLI tool](https://github.com/smart ## Prerequisites -1. the [bun runtime](https://bun.com/). The wasm compilation currently is only supported by the bun runtime which has near-complete NodeJS compatibility. +1. the [bun runtime](https://bun.com/) for local tooling and workflow compilation. 2. the [CRE CLI tool](https://github.com/smartcontractkit/cre-cli) installed. +## Runtime Compatibility Constraints + +CRE workflows are compiled to WASM and executed through Javy (QuickJS). This is **not** a full Node.js runtime. + +- 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. + +Use CRE capabilities (for example, `cre.capabilities.HTTPClient`) instead of direct Node/browser APIs. + ## Getting Started We recommend you consult the [getting started docs](https://docs.chain.link/cre/getting-started/cli-installation) and install the CRE CLI. diff --git a/packages/cre-sdk/scripts/run.ts b/packages/cre-sdk/scripts/run.ts index a4a1afd3..11c801a6 100644 --- a/packages/cre-sdk/scripts/run.ts +++ b/packages/cre-sdk/scripts/run.ts @@ -37,7 +37,11 @@ const main = async () => { process.exit(1) } } catch (error) { - console.error(`Failed to load script ${scriptName}:`, error) + if (error instanceof Error && error.name === 'WorkflowRuntimeCompatibilityError') { + console.error(error.message) + } else { + console.error(`Failed to run script ${scriptName}:`, error) + } process.exit(1) } } diff --git a/packages/cre-sdk/scripts/src/build-types.ts b/packages/cre-sdk/scripts/src/build-types.ts index d2f272ae..2c483f2c 100644 --- a/packages/cre-sdk/scripts/src/build-types.ts +++ b/packages/cre-sdk/scripts/src/build-types.ts @@ -32,10 +32,6 @@ const buildTypes = async () => { // Prepend triple-slash references to dist/index.d.ts so consumers pick up // global type augmentations (e.g. restricted-apis.d.ts) automatically. // tsc strips these from the emitted .d.ts, so we add them back here. - // - // Note: restricted-node-modules is intentionally NOT referenced from src/index.ts - // because the SDK's own build scripts legitimately use Node.js modules. It is - // added here explicitly so that workflow consumers still receive the restrictions. const indexDts = join(packageRoot, 'dist/index.d.ts') const sourceIndex = join(packageRoot, 'src/index.ts') const sourceContent = await readFile(sourceIndex, 'utf-8') @@ -44,10 +40,7 @@ const buildTypes = async () => { .split('\n') .filter((line) => line.startsWith('/// '] - - const tripleSlashRefs = [...refsFromSource, ...distributionOnlyRefs].join('\n') + const tripleSlashRefs = refsFromSource.join('\n') if (tripleSlashRefs) { const indexContent = await readFile(indexDts, 'utf-8') diff --git a/packages/cre-sdk/scripts/src/compile-to-js.ts b/packages/cre-sdk/scripts/src/compile-to-js.ts index 250b36ef..8ef9f97d 100644 --- a/packages/cre-sdk/scripts/src/compile-to-js.ts +++ b/packages/cre-sdk/scripts/src/compile-to-js.ts @@ -2,6 +2,7 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs' import { mkdir } from 'node:fs/promises' import path from 'node:path' import { $ } from 'bun' +import { assertWorkflowRuntimeCompatibility } from './validate-workflow-runtime-compat' import { wrapWorkflowCode } from './workflow-wrapper' export const main = async (tsFilePath?: string, outputFilePath?: string) => { @@ -19,6 +20,7 @@ export const main = async (tsFilePath?: string, outputFilePath?: string) => { } const resolvedInput = path.resolve(inputPath) + assertWorkflowRuntimeCompatibility(resolvedInput) console.info(`📁 Using input file: ${resolvedInput}`) // If no explicit output path → same dir, swap extension to .js diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts new file mode 100644 index 00000000..cbf42905 --- /dev/null +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts @@ -0,0 +1,378 @@ +import { existsSync, readFileSync } from 'node:fs' +import path from 'node:path' +import * as ts from 'typescript' + +type Violation = { + filePath: string + line: number + column: number + message: string +} + +const restrictedModuleSpecifiers = new Set([ + 'crypto', + 'node:crypto', + 'fs', + 'node:fs', + 'fs/promises', + 'node:fs/promises', + 'net', + 'node:net', + 'http', + 'node:http', + 'https', + 'node:https', + 'child_process', + 'node:child_process', + 'os', + 'node:os', + 'stream', + 'node:stream', + 'worker_threads', + 'node:worker_threads', + 'dns', + 'node:dns', + 'zlib', + 'node:zlib', +]) + +const restrictedGlobalApis = new Set([ + 'fetch', + 'window', + 'document', + 'XMLHttpRequest', + 'localStorage', + 'sessionStorage', + 'setTimeout', + 'setInterval', +]) + +const sourceExtensions = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'] + +class WorkflowRuntimeCompatibilityError extends Error { + constructor(violations: Violation[]) { + const sortedViolations = [...violations].sort((a, b) => { + if (a.filePath !== b.filePath) return a.filePath.localeCompare(b.filePath) + if (a.line !== b.line) return a.line - b.line + return a.column - b.column + }) + + const formattedViolations = sortedViolations + .map((violation) => { + const relativePath = path.relative(process.cwd(), violation.filePath) + return `- ${relativePath}:${violation.line}:${violation.column} ${violation.message}` + }) + .join('\n') + + super( + 'Unsupported API usage found in workflow source.\n' + + 'CRE workflows run on Javy (QuickJS), not full Node.js.\n' + + 'Use CRE capabilities instead (for example, HTTPClient instead of fetch/node:http).\n\n' + + formattedViolations, + ) + this.name = 'WorkflowRuntimeCompatibilityError' + } +} + +const toAbsolutePath = (filePath: string) => path.resolve(filePath) + +const getScriptKind = (filePath: string): ts.ScriptKind => { + switch (path.extname(filePath).toLowerCase()) { + case '.js': + return ts.ScriptKind.JS + case '.jsx': + return ts.ScriptKind.JSX + case '.mjs': + return ts.ScriptKind.JS + case '.cjs': + return ts.ScriptKind.JS + case '.tsx': + return ts.ScriptKind.TSX + case '.mts': + return ts.ScriptKind.TS + case '.cts': + return ts.ScriptKind.TS + default: + return ts.ScriptKind.TS + } +} + +const createViolation = ( + filePath: string, + pos: number, + sourceFile: ts.SourceFile, + message: string, +): Violation => { + const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos) + return { + filePath: toAbsolutePath(filePath), + line: line + 1, + column: character + 1, + message, + } +} + +const isRelativeImport = (specifier: string) => { + return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/') +} + +const resolveRelativeImport = (fromFilePath: string, specifier: string): string | null => { + const basePath = specifier.startsWith('/') + ? path.resolve(specifier) + : path.resolve(path.dirname(fromFilePath), specifier) + + if (existsSync(basePath)) { + return toAbsolutePath(basePath) + } + + for (const extension of sourceExtensions) { + const withExtension = `${basePath}${extension}` + if (existsSync(withExtension)) { + return toAbsolutePath(withExtension) + } + } + + for (const extension of sourceExtensions) { + const asIndex = path.join(basePath, `index${extension}`) + if (existsSync(asIndex)) { + return toAbsolutePath(asIndex) + } + } + + return null +} + +const getStringLiteralFromCall = (node: ts.CallExpression): string | null => { + const [firstArg] = node.arguments + if (!firstArg || !ts.isStringLiteral(firstArg)) return null + return firstArg.text +} + +const collectModuleUsage = ( + sourceFile: ts.SourceFile, + filePath: string, + violations: Violation[], + enqueueFile: (nextFile: string) => void, +) => { + const checkModuleSpecifier = (specifier: string, pos: number) => { + if (restrictedModuleSpecifiers.has(specifier)) { + violations.push( + createViolation( + filePath, + pos, + sourceFile, + `'${specifier}' is not available in CRE workflow runtime.`, + ), + ) + } + + if (!isRelativeImport(specifier)) return + const resolved = resolveRelativeImport(filePath, specifier) + if (resolved) { + enqueueFile(resolved) + } + } + + const visit = (node: ts.Node) => { + if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) { + checkModuleSpecifier(node.moduleSpecifier.text, node.moduleSpecifier.getStart(sourceFile)) + } + + if ( + ts.isExportDeclaration(node) && + node.moduleSpecifier && + ts.isStringLiteral(node.moduleSpecifier) + ) { + checkModuleSpecifier(node.moduleSpecifier.text, node.moduleSpecifier.getStart(sourceFile)) + } + + if ( + ts.isImportEqualsDeclaration(node) && + ts.isExternalModuleReference(node.moduleReference) && + node.moduleReference.expression && + ts.isStringLiteral(node.moduleReference.expression) + ) { + checkModuleSpecifier( + node.moduleReference.expression.text, + node.moduleReference.expression.getStart(sourceFile), + ) + } + + if (ts.isCallExpression(node)) { + if (ts.isIdentifier(node.expression) && node.expression.text === 'require') { + const requiredModule = getStringLiteralFromCall(node) + if (requiredModule) { + checkModuleSpecifier(requiredModule, node.arguments[0].getStart(sourceFile)) + } + } + + if (node.expression.kind === ts.SyntaxKind.ImportKeyword) { + const importedModule = getStringLiteralFromCall(node) + if (importedModule) { + checkModuleSpecifier(importedModule, node.arguments[0].getStart(sourceFile)) + } + } + } + + ts.forEachChild(node, visit) + } + + visit(sourceFile) +} + +const isDeclarationName = (identifier: ts.Identifier): boolean => { + const parent = identifier.parent + + if ( + (ts.isFunctionDeclaration(parent) && parent.name === identifier) || + (ts.isFunctionExpression(parent) && parent.name === identifier) || + (ts.isClassDeclaration(parent) && parent.name === identifier) || + (ts.isClassExpression(parent) && parent.name === identifier) || + (ts.isInterfaceDeclaration(parent) && parent.name === identifier) || + (ts.isTypeAliasDeclaration(parent) && parent.name === identifier) || + (ts.isEnumDeclaration(parent) && parent.name === identifier) || + (ts.isModuleDeclaration(parent) && parent.name === identifier) || + (ts.isTypeParameterDeclaration(parent) && parent.name === identifier) || + (ts.isVariableDeclaration(parent) && parent.name === identifier) || + (ts.isParameter(parent) && parent.name === identifier) || + (ts.isBindingElement(parent) && parent.name === identifier) || + (ts.isImportClause(parent) && parent.name === identifier) || + (ts.isImportSpecifier(parent) && parent.name === identifier) || + (ts.isNamespaceImport(parent) && parent.name === identifier) || + (ts.isImportEqualsDeclaration(parent) && parent.name === identifier) || + (ts.isNamespaceExport(parent) && parent.name === identifier) || + (ts.isEnumMember(parent) && parent.name === identifier) || + (ts.isPropertyDeclaration(parent) && parent.name === identifier) || + (ts.isPropertySignature(parent) && parent.name === identifier) || + (ts.isMethodDeclaration(parent) && parent.name === identifier) || + (ts.isMethodSignature(parent) && parent.name === identifier) || + (ts.isGetAccessorDeclaration(parent) && parent.name === identifier) || + (ts.isSetAccessorDeclaration(parent) && parent.name === identifier) || + (ts.isPropertyAssignment(parent) && parent.name === identifier) || + (ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) || + (ts.isLabeledStatement(parent) && parent.label === identifier) + ) { + return true + } + + if ( + (ts.isPropertyAccessExpression(parent) && parent.name === identifier) || + (ts.isQualifiedName(parent) && parent.right === identifier) || + (ts.isTypeReferenceNode(parent) && parent.typeName === identifier) + ) { + return true + } + + return false +} + +const collectGlobalApiUsage = ( + program: ts.Program, + localSourceFiles: Set, + violations: Violation[], +) => { + const checker = program.getTypeChecker() + + for (const sourceFile of program.getSourceFiles()) { + const resolvedSourcePath = toAbsolutePath(sourceFile.fileName) + if (!localSourceFiles.has(resolvedSourcePath)) continue + + const visit = (node: ts.Node) => { + if ( + ts.isIdentifier(node) && + restrictedGlobalApis.has(node.text) && + !isDeclarationName(node) + ) { + const symbol = checker.getSymbolAtLocation(node) + const hasLocalDeclaration = + symbol?.declarations?.some((declaration) => + localSourceFiles.has(toAbsolutePath(declaration.getSourceFile().fileName)), + ) ?? false + + if (!hasLocalDeclaration) { + violations.push( + createViolation( + resolvedSourcePath, + node.getStart(sourceFile), + sourceFile, + `'${node.text}' is not available in CRE workflow runtime.`, + ), + ) + } + } + + if ( + ts.isPropertyAccessExpression(node) && + ts.isIdentifier(node.expression) && + node.expression.text === 'globalThis' && + restrictedGlobalApis.has(node.name.text) + ) { + violations.push( + createViolation( + resolvedSourcePath, + node.name.getStart(sourceFile), + sourceFile, + `'globalThis.${node.name.text}' is not available in CRE workflow runtime.`, + ), + ) + } + + ts.forEachChild(node, visit) + } + + visit(sourceFile) + } +} + +export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { + const rootFile = toAbsolutePath(entryFilePath) + const filesToScan = [rootFile] + const scannedFiles = new Set() + const localSourceFiles = new Set() + const violations: Violation[] = [] + + while (filesToScan.length > 0) { + const currentFile = filesToScan.pop() + if (!currentFile || scannedFiles.has(currentFile)) continue + scannedFiles.add(currentFile) + + if (!existsSync(currentFile)) continue + localSourceFiles.add(currentFile) + + const fileContents = readFileSync(currentFile, 'utf-8') + const sourceFile = ts.createSourceFile( + currentFile, + fileContents, + ts.ScriptTarget.Latest, + true, + getScriptKind(currentFile), + ) + + collectModuleUsage(sourceFile, currentFile, violations, (nextFile) => { + if (!scannedFiles.has(nextFile)) { + filesToScan.push(nextFile) + } + }) + } + + const program = ts.createProgram({ + rootNames: [...localSourceFiles], + options: { + allowJs: true, + checkJs: true, + noEmit: true, + skipLibCheck: true, + target: ts.ScriptTarget.ESNext, + module: ts.ModuleKind.ESNext, + moduleResolution: ts.ModuleResolutionKind.Bundler, + }, + }) + + collectGlobalApiUsage(program, localSourceFiles, violations) + + if (violations.length > 0) { + throw new WorkflowRuntimeCompatibilityError(violations) + } +} + +export { WorkflowRuntimeCompatibilityError } diff --git a/packages/cre-sdk/src/sdk/types/global.d.ts b/packages/cre-sdk/src/sdk/types/global.d.ts index 3fb9e68d..a93c895c 100644 --- a/packages/cre-sdk/src/sdk/types/global.d.ts +++ b/packages/cre-sdk/src/sdk/types/global.d.ts @@ -1,5 +1,8 @@ -// Global type declarations for the CRE SDK runtime -// Those are the methods that the Host exposes to the Guest. +// Global type declarations for the CRE SDK runtime. +// These are the methods and globals exposed by the Host to the Guest. + +type ExistingGlobal = + typeof globalThis extends Record ? T : Fallback /** * Host functions exposed by the CRE runtime to WASM guests @@ -82,43 +85,46 @@ declare global { /** * Console API available in the QuickJS runtime */ - interface Console { + type CreConsole = { log(...args: unknown[]): void warn(...args: unknown[]): void error(...args: unknown[]): void info(...args: unknown[]): void debug(...args: unknown[]): void } - var console: Console + var console: ExistingGlobal<'console', CreConsole> /** * TextEncoder/TextDecoder APIs available via Javy's text_encoding support */ - interface TextEncoderEncodeIntoResult { + interface CreTextEncoderEncodeIntoResult { read: number written: number } - interface TextEncoder { + interface CreTextEncoder { readonly encoding: string encode(input?: string): Uint8Array - encodeInto(input: string, dest: Uint8Array): TextEncoderEncodeIntoResult - } - var TextEncoder: { - prototype: TextEncoder - new (): TextEncoder + encodeInto(input: string, dest: Uint8Array): CreTextEncoderEncodeIntoResult } + var TextEncoder: ExistingGlobal< + 'TextEncoder', + { prototype: CreTextEncoder; new (): CreTextEncoder } + > - interface TextDecoder { + interface CreTextDecoder { readonly encoding: string readonly fatal: boolean readonly ignoreBOM: boolean decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string } - var TextDecoder: { - prototype: TextDecoder - new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder - } + var TextDecoder: ExistingGlobal< + 'TextDecoder', + { + prototype: CreTextDecoder + new (label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): CreTextDecoder + } + > /** * Base64 encoding/decoding — exposed via prepareRuntime() from node:buffer @@ -129,7 +135,7 @@ declare global { /** * URL and URLSearchParams — exposed via prepareRuntime() from node:url */ - interface URLSearchParams { + interface CreURLSearchParams { append(name: string, value: string): void delete(name: string): void get(name: string): string | null @@ -138,21 +144,24 @@ declare global { set(name: string, value: string): void sort(): void toString(): string - forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void + forEach(callback: (value: string, key: string, parent: CreURLSearchParams) => void): void entries(): IterableIterator<[string, string]> keys(): IterableIterator values(): IterableIterator [Symbol.iterator](): IterableIterator<[string, string]> readonly size: number } - var URLSearchParams: { - prototype: URLSearchParams - new ( - init?: string | Record | [string, string][] | URLSearchParams, - ): URLSearchParams - } - - interface URL { + var URLSearchParams: ExistingGlobal< + 'URLSearchParams', + { + prototype: CreURLSearchParams + new ( + init?: string | Record | [string, string][] | CreURLSearchParams, + ): CreURLSearchParams + } + > + + interface CreURL { hash: string host: string hostname: string @@ -163,15 +172,15 @@ declare global { port: string protocol: string search: string - readonly searchParams: URLSearchParams + readonly searchParams: CreURLSearchParams username: string toString(): string toJSON(): string } - var URL: { - prototype: URL - new (url: string, base?: string | URL): URL - } + var URL: ExistingGlobal< + 'URL', + { prototype: CreURL; new (url: string, base?: string | CreURL): CreURL } + > } export {} diff --git a/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts b/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts index 91196ec7..a39dfe4d 100644 --- a/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts +++ b/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts @@ -1,27 +1,15 @@ declare global { - /** @deprecated fetch is not available in CRE WASM workflows. Use cre.capabilities.HTTPClient instead. */ - const fetch: never - - /** @deprecated window is not available in CRE WASM workflows. */ - const window: never - - /** @deprecated document is not available in CRE WASM workflows. */ - const document: never - - /** @deprecated XMLHttpRequest is not available in CRE WASM workflows. Use cre.capabilities.HTTPClient instead. */ - const XMLHttpRequest: never - - /** @deprecated localStorage is not available in CRE WASM workflows. */ - const localStorage: never - - /** @deprecated sessionStorage is not available in CRE WASM workflows. */ - const sessionStorage: never + /** + * @deprecated fetch is not available in CRE WASM workflows. + * Use cre.capabilities.HTTPClient instead. + */ + function fetch(_notAvailable: never): never /** @deprecated setTimeout is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. */ - const setTimeout: never + function setTimeout(_notAvailable: never, ..._args: never[]): never /** @deprecated setInterval is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. */ - const setInterval: never + function setInterval(_notAvailable: never, ..._args: never[]): never } export {} From afd12704b58facd0de3d4d422de827d4fb34ce69 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 17:26:07 +0100 Subject: [PATCH 08/20] Fix prepare runtime --- packages/cre-sdk/src/sdk/utils/prepare-runtime.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts b/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts index 1c94f453..f48841fb 100644 --- a/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts +++ b/packages/cre-sdk/src/sdk/utils/prepare-runtime.ts @@ -10,6 +10,8 @@ export const prepareRuntime = () => { globalThis.Buffer = Buffer globalThis.atob = atob globalThis.btoa = btoa - globalThis.URL = URL as any - globalThis.URLSearchParams = URLSearchParams + // node:url constructor types are slightly narrower than lib.dom/global types. + // Runtime behavior is compatible; cast to the global constructor shapes. + globalThis.URL = URL as unknown as typeof globalThis.URL + globalThis.URLSearchParams = URLSearchParams as unknown as typeof globalThis.URLSearchParams } From 8352563ca35ba5dbf47110d45d590838113c3afd Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 17:56:12 +0100 Subject: [PATCH 09/20] Add links to the docs --- .../src/validate-workflow-runtime-compat.ts | 3 +- .../src/sdk/types/restricted-apis.d.ts | 11 +++- .../sdk/types/restricted-node-modules.d.ts | 61 +++++++++++++++---- 3 files changed, 60 insertions(+), 15 deletions(-) diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts index cbf42905..dc108d25 100644 --- a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts @@ -67,7 +67,8 @@ class WorkflowRuntimeCompatibilityError extends Error { super( 'Unsupported API usage found in workflow source.\n' + 'CRE workflows run on Javy (QuickJS), not full Node.js.\n' + - 'Use CRE capabilities instead (for example, HTTPClient instead of fetch/node:http).\n\n' + + 'Use CRE capabilities instead (for example, HTTPClient instead of fetch/node:http).\n' + + 'See https://docs.chain.link/cre/concepts/typescript-wasm-runtime\n\n' + formattedViolations, ) this.name = 'WorkflowRuntimeCompatibilityError' diff --git a/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts b/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts index a39dfe4d..434d3e01 100644 --- a/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts +++ b/packages/cre-sdk/src/sdk/types/restricted-apis.d.ts @@ -2,13 +2,20 @@ declare global { /** * @deprecated fetch is not available in CRE WASM workflows. * Use cre.capabilities.HTTPClient instead. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ function fetch(_notAvailable: never): never - /** @deprecated setTimeout is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. */ + /** + * @deprecated setTimeout is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ function setTimeout(_notAvailable: never, ..._args: never[]): never - /** @deprecated setInterval is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. */ + /** + * @deprecated setInterval is not available in CRE WASM workflows. Use cre.capabilities.CronCapability for scheduling. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ function setInterval(_notAvailable: never, ..._args: never[]): never } diff --git a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts index 2454d3f6..83538a4d 100644 --- a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts +++ b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts @@ -2,8 +2,12 @@ // These modules require native bindings or system access that cannot run in WebAssembly. // Importing from these modules is allowed by TypeScript, but all exports are typed as // `never` so any usage produces a clear error at the call site. +// See https://docs.chain.link/cre/concepts/typescript-wasm-runtime -/** @deprecated node:crypto is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ +/** + * @deprecated node:crypto is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:crypto' { export const randomBytes: never export const randomUUID: never @@ -59,7 +63,10 @@ declare module 'node:crypto' { export const constants: never } -/** @deprecated node:fs is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ +/** + * @deprecated node:fs is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:fs' { export const readFile: never export const readFileSync: never @@ -139,7 +146,10 @@ declare module 'node:fs' { export const FSWatcher: never } -/** @deprecated node:fs/promises is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. */ +/** + * @deprecated node:fs/promises is not available in CRE WASM workflows. It requires filesystem access that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:fs/promises' { export const readFile: never export const writeFile: never @@ -171,7 +181,10 @@ declare module 'node:fs/promises' { export const FileHandle: never } -/** @deprecated node:net is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +/** + * @deprecated node:net is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:net' { export const createServer: never export const createConnection: never @@ -187,7 +200,10 @@ declare module 'node:net' { export const SocketAddress: never } -/** @deprecated node:http is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +/** + * @deprecated node:http is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:http' { export const createServer: never export const request: never @@ -207,7 +223,10 @@ declare module 'node:http' { export const maxHeaderSize: never } -/** @deprecated node:https is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. */ +/** + * @deprecated node:https is not available in CRE WASM workflows. It requires network access. Use cre.capabilities.HTTPClient instead. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:https' { export const createServer: never export const request: never @@ -217,7 +236,10 @@ declare module 'node:https' { export const globalAgent: never } -/** @deprecated node:child_process is not available in CRE WASM workflows. It requires OS process spawning that is not available in WebAssembly. */ +/** + * @deprecated node:child_process is not available in CRE WASM workflows. It requires OS process spawning that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:child_process' { export const spawn: never export const spawnSync: never @@ -229,7 +251,10 @@ declare module 'node:child_process' { export const ChildProcess: never } -/** @deprecated node:os is not available in CRE WASM workflows. It requires OS access that is not available in WebAssembly. */ +/** + * @deprecated node:os is not available in CRE WASM workflows. It requires OS access that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:os' { export const hostname: never export const platform: never @@ -256,7 +281,10 @@ declare module 'node:os' { export const constants: never } -/** @deprecated node:stream is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. */ +/** + * @deprecated node:stream is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:stream' { export const Readable: never export const Writable: never @@ -273,7 +301,10 @@ declare module 'node:stream' { export const isReadable: never } -/** @deprecated node:worker_threads is not available in CRE WASM workflows. It requires threading support that is not available in WebAssembly. */ +/** + * @deprecated node:worker_threads is not available in CRE WASM workflows. It requires threading support that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:worker_threads' { export const Worker: never export const MessageChannel: never @@ -296,7 +327,10 @@ declare module 'node:worker_threads' { export const postMessageToThread: never } -/** @deprecated node:dns is not available in CRE WASM workflows. It requires network access that is not available in WebAssembly. */ +/** + * @deprecated node:dns is not available in CRE WASM workflows. It requires network access that is not available in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:dns' { export const lookup: never export const lookupService: never @@ -321,7 +355,10 @@ declare module 'node:dns' { export const Resolver: never } -/** @deprecated node:zlib is not available in CRE WASM workflows. It requires native compression bindings that cannot run in WebAssembly. */ +/** + * @deprecated node:zlib is not available in CRE WASM workflows. It requires native compression bindings that cannot run in WebAssembly. + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ declare module 'node:zlib' { export const createGzip: never export const createGunzip: never From f55557d066f74408c6f21801ed36a3a4fd82b60e Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 18:00:13 +0100 Subject: [PATCH 10/20] Update versions --- packages/cre-sdk-examples/package.json | 2 +- packages/cre-sdk/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index ed73f4d9..fbf719f6 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.2", + "version": "1.1.3", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index 9c540220..9a8a90d9 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.2", + "version": "1.1.3", "type": "module", "main": "dist/index.js", "types": "dist/index.d.ts", From d809ee7d2d2582e2c099274ae329a525bc442340 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 18:34:25 +0100 Subject: [PATCH 11/20] Add node modules examples --- .../src/restricted-node-modules-example.ts | 133 ++++++++++++++++++ packages/cre-sdk/scripts/src/build-types.ts | 6 +- 2 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 packages/cre-sdk-examples/src/restricted-node-modules-example.ts diff --git a/packages/cre-sdk-examples/src/restricted-node-modules-example.ts b/packages/cre-sdk-examples/src/restricted-node-modules-example.ts new file mode 100644 index 00000000..f68290fc --- /dev/null +++ b/packages/cre-sdk-examples/src/restricted-node-modules-example.ts @@ -0,0 +1,133 @@ +/** + * This example shows how CRE workflows mark restricted Node.js modules as `never` in TS. + * + * CRE workflows run on QuickJS (via Javy/WASM), not full Node.js. + * All exports from restricted modules are typed as `never`, so any usage + * produces a clear TypeScript error at the call site. + * + * The restricted modules covered in this example are: + * - node:crypto + * - node:fs + * - node:fs/promises + * - node:net + * - node:http + * - node:https + * - node:child_process + * - node:os + * - node:stream + * - node:worker_threads + * - node:dns + * - node:zlib + * + * For HTTP requests, use cre.capabilities.HTTPClient instead of node:http/node:https/node:net. + * For scheduling, use cre.capabilities.CronCapability instead of setTimeout/setInterval. + * + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ + +import { exec } from 'node:child_process' +import { createHash, randomBytes } from 'node:crypto' +import { lookup } from 'node:dns' +import { readFileSync } from 'node:fs' +import { readFile } from 'node:fs/promises' +import { request as httpRequest } from 'node:http' +import { request as httpsRequest } from 'node:https' +import { createConnection } from 'node:net' +import { cpus, hostname } from 'node:os' +import { Readable } from 'node:stream' +import { Worker } from 'node:worker_threads' +import { createGzip } from 'node:zlib' + +// --- node:crypto --- + +export const testCryptoRandomBytes = () => { + // @ts-expect-error - node:crypto is not available in CRE WASM workflows + randomBytes(32) +} + +export const testCryptoCreateHash = () => { + // @ts-expect-error - node:crypto is not available in CRE WASM workflows + createHash('sha256') +} + +// --- node:fs --- + +export const testFsReadFileSync = () => { + // @ts-expect-error - node:fs is not available in CRE WASM workflows + readFileSync('/etc/passwd', 'utf-8') +} + +// --- node:fs/promises --- + +export const testFsPromisesReadFile = async () => { + // @ts-expect-error - node:fs/promises is not available in CRE WASM workflows + await readFile('/etc/passwd', 'utf-8') +} + +// --- node:net --- + +export const testNetCreateConnection = () => { + // @ts-expect-error - node:net is not available in CRE WASM workflows + createConnection({ host: 'localhost', port: 8080 }) +} + +// --- node:http --- + +export const testHttpRequest = () => { + // @ts-expect-error - node:http is not available in CRE WASM workflows + httpRequest('http://example.com') +} + +// --- node:https --- + +export const testHttpsRequest = () => { + // @ts-expect-error - node:https is not available in CRE WASM workflows + httpsRequest('https://example.com') +} + +// --- node:child_process --- + +export const testChildProcessExec = () => { + // @ts-expect-error - node:child_process is not available in CRE WASM workflows + exec('ls -la') +} + +// --- node:os --- + +export const testOsHostname = () => { + // @ts-expect-error - node:os is not available in CRE WASM workflows + hostname() +} + +export const testOsCpus = () => { + // @ts-expect-error - node:os is not available in CRE WASM workflows + cpus() +} + +// --- node:stream --- + +export const testStreamReadable = () => { + // @ts-expect-error - node:stream is not available in CRE WASM workflows + new Readable() +} + +// --- node:worker_threads --- + +export const testWorkerThreads = () => { + // @ts-expect-error - node:worker_threads is not available in CRE WASM workflows + new Worker('./worker.js') +} + +// --- node:dns --- + +export const testDnsLookup = () => { + // @ts-expect-error - node:dns is not available in CRE WASM workflows + lookup('example.com', () => {}) +} + +// --- node:zlib --- + +export const testZlibCreateGzip = () => { + // @ts-expect-error - node:zlib is not available in CRE WASM workflows + createGzip() +} diff --git a/packages/cre-sdk/scripts/src/build-types.ts b/packages/cre-sdk/scripts/src/build-types.ts index 2c483f2c..082d80e0 100644 --- a/packages/cre-sdk/scripts/src/build-types.ts +++ b/packages/cre-sdk/scripts/src/build-types.ts @@ -40,7 +40,11 @@ const buildTypes = async () => { .split('\n') .filter((line) => line.startsWith('/// '] + + const tripleSlashRefs = [...refsFromSource, ...consumerOnlyRefs].join('\n') if (tripleSlashRefs) { const indexContent = await readFile(indexDts, 'utf-8') From 8934ae78ba891fd70f7e02c5322a034a7456200f Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 2 Mar 2026 18:45:07 +0100 Subject: [PATCH 12/20] Add documentation around workflow validation --- .../src/validate-workflow-runtime-compat.ts | 193 ++++++++++++++++++ 1 file changed, 193 insertions(+) diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts index dc108d25..239fe21b 100644 --- a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts @@ -1,14 +1,96 @@ +/** + * Workflow Runtime Compatibility Validator + * + * CRE (Compute Runtime Environment) workflows are compiled from TypeScript to + * WebAssembly and executed inside a Javy/QuickJS sandbox — NOT a full Node.js + * runtime. This means many APIs that developers take for granted (filesystem, + * network sockets, crypto, child processes, etc.) are simply not available at + * runtime and will silently fail or crash. + * + * This module performs **static analysis** on workflow source code to catch + * these issues at build time, before the workflow is compiled to WASM. It + * operates in two passes: + * + * 1. **Module import analysis** — walks the AST of every reachable source file + * (starting from the workflow entry point) and flags imports from restricted + * Node.js built-in modules (e.g. `node:fs`, `node:crypto`, `node:http`). + * This catches `import`, `export ... from`, `require()`, and dynamic + * `import()` syntax. + * + * 2. **Global API analysis** — uses the TypeScript type-checker to detect + * references to browser/Node globals that don't exist in QuickJS (e.g. + * `fetch`, `setTimeout`, `window`, `document`). Only flags identifiers + * that resolve to non-local declarations, so user-defined variables with + * the same name (e.g. `const fetch = cre.capabilities.HTTPClient`) are + * not flagged. + * + * The validator follows relative imports transitively so that violations in + * helper files reachable from the entry point are also caught. + * + * ## How it's used + * + * This validator runs automatically as part of the `cre-compile` build pipeline: + * + * ``` + * cre-compile [path/to/output.wasm] + * ``` + * + * The pipeline is: `cre-compile` (CLI) -> `compile-workflow` -> `compile-to-js` + * -> **`assertWorkflowRuntimeCompatibility()`** -> bundle -> compile to WASM. + * + * The validation happens before any bundling or WASM compilation, so developers + * get fast, actionable error messages pointing to exact file:line:column + * locations instead of cryptic WASM runtime failures. + * + * ## Layers of protection + * + * This validator is one of two complementary mechanisms that prevent usage of + * unavailable APIs: + * + * 1. **Compile-time types** (`restricted-apis.d.ts` and `restricted-node-modules.d.ts`) + * — mark restricted APIs as `never` so the TypeScript compiler flags them + * with red squiggles in the IDE. This gives instant feedback while coding. + * + * 2. **Build-time validation** (this module) — performs AST-level static + * analysis during `cre-compile`. This catches cases that type-level + * restrictions can't cover, such as `require()` calls, dynamic `import()`, + * and usage inside plain `.js` files that don't go through `tsc`. + * + * @example + * ```ts + * import { assertWorkflowRuntimeCompatibility } from './validate-workflow-runtime-compat' + * + * // Throws WorkflowRuntimeCompatibilityError if violations are found + * assertWorkflowRuntimeCompatibility('./src/workflow.ts') + * ``` + * + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ + import { existsSync, readFileSync } from 'node:fs' import path from 'node:path' import * as ts from 'typescript' +/** + * A single detected violation: a location in the source code where a + * restricted API is referenced. + */ type Violation = { + /** Absolute path to the file containing the violation. */ filePath: string + /** 1-based line number. */ line: number + /** 1-based column number. */ column: number + /** Human-readable description of the violation. */ message: string } +/** + * Node.js built-in module specifiers that are not available in the QuickJS + * runtime. Both bare (`fs`) and prefixed (`node:fs`) forms are included + * because TypeScript/bundlers accept either. + */ const restrictedModuleSpecifiers = new Set([ 'crypto', 'node:crypto', @@ -36,6 +118,11 @@ const restrictedModuleSpecifiers = new Set([ 'node:zlib', ]) +/** + * Global identifiers (browser and Node.js) that do not exist in the QuickJS + * runtime. For network requests, workflows should use `cre.capabilities.HTTPClient`; + * for scheduling, `cre.capabilities.CronCapability`. + */ const restrictedGlobalApis = new Set([ 'fetch', 'window', @@ -47,8 +134,14 @@ const restrictedGlobalApis = new Set([ 'setInterval', ]) +/** File extensions treated as scannable source code. */ const sourceExtensions = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'] +/** + * Error thrown when one or more runtime-incompatible API usages are detected. + * The message includes a docs link and a formatted list of every violation + * with file path, line, column, and description. + */ class WorkflowRuntimeCompatibilityError extends Error { constructor(violations: Violation[]) { const sortedViolations = [...violations].sort((a, b) => { @@ -75,8 +168,13 @@ class WorkflowRuntimeCompatibilityError extends Error { } } +/** Resolves a file path to an absolute path using the current working directory. */ const toAbsolutePath = (filePath: string) => path.resolve(filePath) +/** + * Maps a file extension to the appropriate TypeScript {@link ts.ScriptKind} + * so the parser handles JSX, CommonJS, and ESM files correctly. + */ const getScriptKind = (filePath: string): ts.ScriptKind => { switch (path.extname(filePath).toLowerCase()) { case '.js': @@ -98,6 +196,10 @@ const getScriptKind = (filePath: string): ts.ScriptKind => { } } +/** + * Creates a {@link Violation} with 1-based line and column numbers derived + * from a character position in the source file. + */ const createViolation = ( filePath: string, pos: number, @@ -113,10 +215,17 @@ const createViolation = ( } } +/** Returns `true` if the specifier looks like a relative or absolute file path. */ const isRelativeImport = (specifier: string) => { return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/') } +/** + * Attempts to resolve a relative import specifier to an absolute file path. + * Tries the path as-is first, then appends each known source extension, then + * looks for an index file inside the directory. Returns `null` if nothing is + * found on disk. + */ const resolveRelativeImport = (fromFilePath: string, specifier: string): string | null => { const basePath = specifier.startsWith('/') ? path.resolve(specifier) @@ -143,12 +252,32 @@ const resolveRelativeImport = (fromFilePath: string, specifier: string): string return null } +/** + * Extracts a string literal from the first argument of a call expression. + * Used for `require('node:fs')` and `import('node:fs')` patterns. + * Returns `null` if the first argument is not a static string literal. + */ const getStringLiteralFromCall = (node: ts.CallExpression): string | null => { const [firstArg] = node.arguments if (!firstArg || !ts.isStringLiteral(firstArg)) return null return firstArg.text } +/** + * **Pass 1 — Module import analysis.** + * + * Walks the AST of a single source file and: + * - Flags any import/export/require/dynamic-import of a restricted module. + * - Enqueues relative imports for recursive scanning so the validator + * transitively covers the entire local dependency graph. + * + * Handles all module import syntaxes: + * - `import ... from 'node:fs'` + * - `export ... from 'node:fs'` + * - `import fs = require('node:fs')` + * - `require('node:fs')` + * - `import('node:fs')` + */ const collectModuleUsage = ( sourceFile: ts.SourceFile, filePath: string, @@ -175,10 +304,12 @@ const collectModuleUsage = ( } const visit = (node: ts.Node) => { + // import ... from 'specifier' if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) { checkModuleSpecifier(node.moduleSpecifier.text, node.moduleSpecifier.getStart(sourceFile)) } + // export ... from 'specifier' if ( ts.isExportDeclaration(node) && node.moduleSpecifier && @@ -187,6 +318,7 @@ const collectModuleUsage = ( checkModuleSpecifier(node.moduleSpecifier.text, node.moduleSpecifier.getStart(sourceFile)) } + // import fs = require('specifier') if ( ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && @@ -200,6 +332,7 @@ const collectModuleUsage = ( } if (ts.isCallExpression(node)) { + // require('specifier') if (ts.isIdentifier(node.expression) && node.expression.text === 'require') { const requiredModule = getStringLiteralFromCall(node) if (requiredModule) { @@ -207,6 +340,7 @@ const collectModuleUsage = ( } } + // import('specifier') if (node.expression.kind === ts.SyntaxKind.ImportKeyword) { const importedModule = getStringLiteralFromCall(node) if (importedModule) { @@ -221,9 +355,20 @@ const collectModuleUsage = ( visit(sourceFile) } +/** + * Checks whether an identifier AST node is the **name being declared** (as + * opposed to a reference/usage). For example, in `const fetch = ...` the + * `fetch` token is a declaration name, while in `fetch(url)` it is a usage. + * + * This distinction is critical so that user-defined variables that shadow + * restricted global names are not flagged as violations. + */ const isDeclarationName = (identifier: ts.Identifier): boolean => { const parent = identifier.parent + // Variable, function, class, interface, type alias, enum, module, + // type parameter, parameter, binding element, import names, enum member, + // property/method declarations, property assignments, and labels. if ( (ts.isFunctionDeclaration(parent) && parent.name === identifier) || (ts.isFunctionExpression(parent) && parent.name === identifier) || @@ -256,6 +401,9 @@ const isDeclarationName = (identifier: ts.Identifier): boolean => { return true } + // Property access (obj.fetch), qualified names (Ns.fetch), and type + // references (SomeType) — the right-hand identifier is not a standalone + // usage of the global name. if ( (ts.isPropertyAccessExpression(parent) && parent.name === identifier) || (ts.isQualifiedName(parent) && parent.right === identifier) || @@ -267,6 +415,19 @@ const isDeclarationName = (identifier: ts.Identifier): boolean => { return false } +/** + * **Pass 2 — Global API analysis.** + * + * Uses the TypeScript type-checker to find references to restricted global + * identifiers (e.g. `fetch`, `setTimeout`, `window`). An identifier is only + * flagged if: + * - It matches a name in {@link restrictedGlobalApis}. + * - It is **not** a declaration name (see {@link isDeclarationName}). + * - Its symbol resolves to a declaration outside the local source files, + * meaning it comes from the global scope rather than user code. + * + * This also catches `globalThis.fetch`-style access patterns. + */ const collectGlobalApiUsage = ( program: ts.Program, localSourceFiles: Set, @@ -279,6 +440,7 @@ const collectGlobalApiUsage = ( if (!localSourceFiles.has(resolvedSourcePath)) continue const visit = (node: ts.Node) => { + // Direct usage: fetch(...), setTimeout(...) if ( ts.isIdentifier(node) && restrictedGlobalApis.has(node.text) && @@ -302,6 +464,7 @@ const collectGlobalApiUsage = ( } } + // Property access on globalThis: globalThis.fetch(...) if ( ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && @@ -325,6 +488,34 @@ const collectGlobalApiUsage = ( } } +/** + * Validates that a workflow entry file (and all local files it transitively + * imports) only uses APIs available in the CRE QuickJS/WASM runtime. + * + * The check runs in two passes: + * + * 1. **Module import scan** — starting from `entryFilePath`, recursively + * parses every reachable local source file and flags imports from + * restricted Node.js built-in modules. + * + * 2. **Global API scan** — creates a TypeScript program from the collected + * source files and uses the type-checker to flag references to restricted + * global identifiers that resolve to non-local (i.e. global) declarations. + * + * @param entryFilePath - Path to the workflow entry file (absolute or relative). + * @throws {WorkflowRuntimeCompatibilityError} If any violations are found. + * The error message includes a link to the CRE runtime docs and a formatted + * list of every violation with file:line:column and description. + * + * @example + * ```ts + * // During the cre-compile build step: + * assertWorkflowRuntimeCompatibility('./src/workflow.ts') + * // Throws if the workflow (or any file it imports) uses fetch, node:fs, etc. + * ``` + * + * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime + */ export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { const rootFile = toAbsolutePath(entryFilePath) const filesToScan = [rootFile] @@ -332,6 +523,7 @@ export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { const localSourceFiles = new Set() const violations: Violation[] = [] + // Pass 1: Walk the local import graph and collect module-level violations. while (filesToScan.length > 0) { const currentFile = filesToScan.pop() if (!currentFile || scannedFiles.has(currentFile)) continue @@ -356,6 +548,7 @@ export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { }) } + // Pass 2: Use the type-checker to detect restricted global API usage. const program = ts.createProgram({ rootNames: [...localSourceFiles], options: { From 504996a95c75f44814db3816c92f898ba8da8592 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 12:33:26 +0100 Subject: [PATCH 13/20] Add tests and fixed bug caught up by the test --- .../src/restricted-node-modules-example.ts | 1 - .../validate-workflow-runtime-compat.test.ts | 412 ++++++++++++++++++ .../src/validate-workflow-runtime-compat.ts | 15 +- 3 files changed, 420 insertions(+), 8 deletions(-) create mode 100644 packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts diff --git a/packages/cre-sdk-examples/src/restricted-node-modules-example.ts b/packages/cre-sdk-examples/src/restricted-node-modules-example.ts index f68290fc..a97ac831 100644 --- a/packages/cre-sdk-examples/src/restricted-node-modules-example.ts +++ b/packages/cre-sdk-examples/src/restricted-node-modules-example.ts @@ -20,7 +20,6 @@ * - node:zlib * * For HTTP requests, use cre.capabilities.HTTPClient instead of node:http/node:https/node:net. - * For scheduling, use cre.capabilities.CronCapability instead of setTimeout/setInterval. * * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts new file mode 100644 index 00000000..b1cb92a7 --- /dev/null +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts @@ -0,0 +1,412 @@ +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 { + assertWorkflowRuntimeCompatibility, + WorkflowRuntimeCompatibilityError, +} from './validate-workflow-runtime-compat' + +let tempDir: string + +beforeEach(() => { + tempDir = mkdtempSync(path.join(tmpdir(), 'cre-validate-test-')) +}) + +afterEach(() => { + rmSync(tempDir, { recursive: true, force: true }) +}) + +/** Write a file in the temp directory and return its absolute path. */ +const writeTemp = (filename: string, content: string): string => { + const filePath = path.join(tempDir, filename) + const dir = path.dirname(filePath) + mkdirSync(dir, { recursive: true }) + writeFileSync(filePath, content, 'utf-8') + return filePath +} + +/** Assert that the validator throws with violations matching the given patterns. */ +const expectViolations = (entryPath: string, expectedPatterns: (string | RegExp)[]) => { + try { + assertWorkflowRuntimeCompatibility(entryPath) + throw new Error('Expected WorkflowRuntimeCompatibilityError but none was thrown') + } catch (error) { + expect(error).toBeInstanceOf(WorkflowRuntimeCompatibilityError) + const message = (error as Error).message + for (const pattern of expectedPatterns) { + if (typeof pattern === 'string') { + expect(message).toContain(pattern) + } else { + expect(message).toMatch(pattern) + } + } + } +} + +/** Assert that the validator does NOT throw. */ +const expectNoViolations = (entryPath: string) => { + expect(() => assertWorkflowRuntimeCompatibility(entryPath)).not.toThrow() +} + +// --------------------------------------------------------------------------- +// Pass 1: Module import analysis +// --------------------------------------------------------------------------- + +describe('module import analysis', () => { + test("detects import ... from 'node:fs'", () => { + const entry = writeTemp('workflow.ts', `import { readFileSync } from 'node:fs';\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test("detects bare module specifier 'fs' (without node: prefix)", () => { + const entry = writeTemp('workflow.ts', `import { readFileSync } from 'fs';\n`) + expectViolations(entry, ["'fs' is not available"]) + }) + + test('detects export ... from restricted module', () => { + const entry = writeTemp('workflow.ts', `export { createHash } from 'node:crypto';\n`) + expectViolations(entry, ["'node:crypto' is not available"]) + }) + + test('detects import = require() syntax', () => { + const entry = writeTemp('workflow.ts', `import fs = require('node:fs');\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('detects require() call', () => { + const entry = writeTemp('workflow.js', `const fs = require('node:fs');\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('detects dynamic import()', () => { + const entry = writeTemp('workflow.ts', `const fs = await import('node:fs');\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('detects all restricted modules in a single file', () => { + const modules = [ + 'crypto', + 'node:crypto', + 'fs', + 'node:fs', + 'fs/promises', + 'node:fs/promises', + 'net', + 'node:net', + 'http', + 'node:http', + 'https', + 'node:https', + 'child_process', + 'node:child_process', + 'os', + 'node:os', + 'stream', + 'node:stream', + 'worker_threads', + 'node:worker_threads', + 'dns', + 'node:dns', + 'zlib', + 'node:zlib', + ] + + const imports = modules.map((mod, i) => `import m${i} from '${mod}';`).join('\n') + const entry = writeTemp('workflow.ts', `${imports}\n`) + expectViolations( + entry, + modules.map((mod) => `'${mod}' is not available`), + ) + }) + + test('does NOT flag allowed third-party modules', () => { + const entry = writeTemp( + 'workflow.ts', + `import { something } from '@chainlink/cre-sdk';\nimport lodash from 'lodash';\n`, + ) + expectNoViolations(entry) + }) + + test('does NOT flag relative imports themselves', () => { + const helper = writeTemp('helper.ts', `export const add = (a: number, b: number) => a + b;\n`) + const entry = writeTemp( + 'workflow.ts', + `import { add } from './helper';\nconsole.log(add(1, 2));\n`, + ) + expectNoViolations(entry) + }) + + test('follows relative imports transitively and detects violations in them', () => { + writeTemp('deep.ts', `import { readFileSync } from 'node:fs';\nexport const x = 1;\n`) + writeTemp('middle.ts', `import { x } from './deep';\nexport const y = x;\n`) + const entry = writeTemp('workflow.ts', `import { y } from './middle';\nconsole.log(y);\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('handles circular relative imports without infinite loop', () => { + writeTemp('a.ts', `import { b } from './b';\nexport const a = 'a';\n`) + writeTemp('b.ts', `import { a } from './a';\nexport const b = 'b';\n`) + const entry = writeTemp('workflow.ts', `import { a } from './a';\n`) + expectNoViolations(entry) + }) + + test('resolves imports without file extension', () => { + writeTemp('utils.ts', `import { cpus } from 'node:os';\nexport const x = 1;\n`) + const entry = writeTemp('workflow.ts', `import { x } from './utils';\nconsole.log(x);\n`) + expectViolations(entry, ["'node:os' is not available"]) + }) + + test('resolves index file imports', () => { + writeTemp('lib/index.ts', `import { hostname } from 'node:os';\nexport const name = 'test';\n`) + const entry = writeTemp('workflow.ts', `import { name } from './lib';\nconsole.log(name);\n`) + expectViolations(entry, ["'node:os' is not available"]) + }) + + test('reports multiple violations from multiple files', () => { + writeTemp('helper.ts', `import { exec } from 'node:child_process';\nexport const run = exec;\n`) + const entry = writeTemp( + 'workflow.ts', + `import { run } from './helper';\nimport { readFileSync } from 'node:fs';\n`, + ) + expectViolations(entry, ["'node:child_process' is not available", "'node:fs' is not available"]) + }) +}) + +// --------------------------------------------------------------------------- +// Pass 2: Global API analysis +// --------------------------------------------------------------------------- + +describe('global API analysis', () => { + test('detects bare fetch() usage', () => { + const entry = writeTemp('workflow.ts', `const res = fetch('https://example.com');\n`) + expectViolations(entry, ["'fetch' is not available"]) + }) + + test('detects setTimeout usage', () => { + const entry = writeTemp('workflow.ts', `setTimeout(() => {}, 1000);\n`) + expectViolations(entry, ["'setTimeout' is not available"]) + }) + + test('detects setInterval usage', () => { + const entry = writeTemp('workflow.ts', `setInterval(() => {}, 1000);\n`) + expectViolations(entry, ["'setInterval' is not available"]) + }) + + test('detects window reference', () => { + const entry = writeTemp('workflow.ts', `const w = window;\n`) + expectViolations(entry, ["'window' is not available"]) + }) + + test('detects document reference', () => { + const entry = writeTemp('workflow.ts', `const el = document.getElementById('app');\n`) + expectViolations(entry, ["'document' is not available"]) + }) + + test('detects XMLHttpRequest usage', () => { + const entry = writeTemp('workflow.ts', `const xhr = new XMLHttpRequest();\n`) + expectViolations(entry, ["'XMLHttpRequest' is not available"]) + }) + + test('detects localStorage usage', () => { + const entry = writeTemp('workflow.ts', `localStorage.setItem('key', 'value');\n`) + expectViolations(entry, ["'localStorage' is not available"]) + }) + + test('detects sessionStorage usage', () => { + const entry = writeTemp('workflow.ts', `sessionStorage.getItem('key');\n`) + expectViolations(entry, ["'sessionStorage' is not available"]) + }) + + test('detects globalThis.fetch access', () => { + const entry = writeTemp('workflow.ts', `const res = globalThis.fetch('https://example.com');\n`) + expectViolations(entry, ["'globalThis.fetch' is not available"]) + }) + + test('detects globalThis.setTimeout access', () => { + const entry = writeTemp('workflow.ts', `globalThis.setTimeout(() => {}, 100);\n`) + expectViolations(entry, ["'globalThis.setTimeout' is not available"]) + }) + + test('does NOT flag user-defined variable named fetch', () => { + const entry = writeTemp( + 'workflow.ts', + `export const fetch = (url: string) => url;\nconst result = fetch('test');\n`, + ) + expectNoViolations(entry) + }) + + test('does NOT flag user-defined function named fetch', () => { + const entry = writeTemp( + 'workflow.ts', + `export function fetch(url: string) { return url; }\nconst result = fetch('test');\n`, + ) + expectNoViolations(entry) + }) + + test('does NOT flag function parameter named fetch', () => { + const entry = writeTemp( + 'workflow.ts', + `export function doRequest(fetch: (url: string) => void) { fetch('test'); }\n`, + ) + expectNoViolations(entry) + }) + + test('does NOT flag property access obj.fetch', () => { + const entry = writeTemp('workflow.ts', `const obj = { fetch: () => {} };\nobj.fetch();\n`) + expectNoViolations(entry) + }) + + test('does NOT flag interface property named fetch', () => { + const entry = writeTemp('workflow.ts', `interface Client { fetch: (url: string) => void; }\n`) + expectNoViolations(entry) + }) + + test('does NOT flag destructured property named fetch from local object', () => { + const entry = writeTemp( + 'workflow.ts', + `const capabilities = { fetch: (url: string) => url };\nconst { fetch } = capabilities;\nexport const result = fetch('test');\n`, + ) + expectNoViolations(entry) + }) + + test('does NOT flag class method named fetch', () => { + const entry = writeTemp( + 'workflow.ts', + `class HttpClient {\n fetch(url: string) { return url; }\n}\nnew HttpClient().fetch('test');\n`, + ) + expectNoViolations(entry) + }) + + test('detects global APIs in transitively imported files', () => { + writeTemp('helper.ts', `export const doFetch = () => fetch('https://example.com');\n`) + const entry = writeTemp('workflow.ts', `import { doFetch } from './helper';\ndoFetch();\n`) + expectViolations(entry, ["'fetch' is not available"]) + }) +}) + +// --------------------------------------------------------------------------- +// Combined / integration tests +// --------------------------------------------------------------------------- + +describe('integration', () => { + test('clean workflow passes validation', () => { + const entry = writeTemp( + 'workflow.ts', + ` +import { Runner, cre } from '@chainlink/cre-sdk'; + +export async function main() { + const runner = await Runner.newRunner(); + console.log('Hello from CRE'); +} +`, + ) + expectNoViolations(entry) + }) + + test('detects both module and global API violations in same file', () => { + const entry = writeTemp( + 'workflow.ts', + ` +import { readFileSync } from 'node:fs'; +const data = readFileSync('/tmp/data.json', 'utf-8'); +const res = fetch('https://api.example.com'); +`, + ) + expectViolations(entry, ["'node:fs' is not available", "'fetch' is not available"]) + }) + + test('error message includes file path and line/column info', () => { + const entry = writeTemp('workflow.ts', `import { readFileSync } from 'node:fs';\n`) + try { + assertWorkflowRuntimeCompatibility(entry) + throw new Error('Expected error') + } catch (error) { + expect(error).toBeInstanceOf(WorkflowRuntimeCompatibilityError) + const msg = (error as Error).message + // Should contain relative or absolute path to the file + expect(msg).toContain('workflow.ts') + // Should contain line:column format + expect(msg).toMatch(/:\d+:\d+/) + } + }) + + test('error message includes docs link', () => { + const entry = writeTemp('workflow.ts', `import { readFileSync } from 'node:fs';\n`) + try { + assertWorkflowRuntimeCompatibility(entry) + throw new Error('Expected error') + } catch (error) { + const msg = (error as Error).message + expect(msg).toContain('https://docs.chain.link/cre/concepts/typescript-wasm-runtime') + } + }) + + test('handles .js files', () => { + const entry = writeTemp('workflow.js', `const fs = require('node:fs');\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('handles .mjs files', () => { + const entry = writeTemp('workflow.mjs', `import { readFileSync } from 'node:fs';\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('handles .cjs files', () => { + const entry = writeTemp('workflow.cjs', `const fs = require('node:fs');\n`) + expectViolations(entry, ["'node:fs' is not available"]) + }) + + test('violations are sorted by file path, then line, then column', () => { + writeTemp( + 'b-helper.ts', + `import { exec } from 'node:child_process';\nexport const run = exec;\n`, + ) + const entry = writeTemp( + 'a-workflow.ts', + `import { run } from './b-helper';\nimport { readFileSync } from 'node:fs';\nimport { cpus } from 'node:os';\n`, + ) + try { + assertWorkflowRuntimeCompatibility(entry) + throw new Error('Expected error') + } catch (error) { + const msg = (error as Error).message + const violationLines = msg.split('\n').filter((line) => line.startsWith('- ')) + + // Should have 3 violations minimum + expect(violationLines.length).toBeGreaterThanOrEqual(3) + + // Extract file paths from violation lines + const filePaths = violationLines.map((line) => line.split(':')[0].replace('- ', '')) + + // Verify sorted order: a-workflow.ts violations before b-helper.ts + const aIndexes = filePaths + .map((f, i) => (f.includes('a-workflow') ? i : -1)) + .filter((i) => i >= 0) + const bIndexes = filePaths + .map((f, i) => (f.includes('b-helper') ? i : -1)) + .filter((i) => i >= 0) + + if (aIndexes.length > 0 && bIndexes.length > 0) { + expect(Math.max(...aIndexes)).toBeLessThan(Math.min(...bIndexes)) + } + } + }) + + test('empty file passes validation', () => { + const entry = writeTemp('workflow.ts', '') + expectNoViolations(entry) + }) + + test('file with only comments passes validation', () => { + const entry = writeTemp('workflow.ts', `// This is a comment\n/* Block comment */\n`) + expectNoViolations(entry) + }) + + test('non-existent entry file does not throw', () => { + const nonExistent = path.join(tempDir, 'does-not-exist.ts') + // Should not throw since the file doesn't exist - it just won't find violations + expectNoViolations(nonExistent) + }) +}) diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts index 239fe21b..9f2bee32 100644 --- a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts @@ -67,7 +67,7 @@ * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ -import { existsSync, readFileSync } from 'node:fs' +import { existsSync, readFileSync, statSync } from 'node:fs' import path from 'node:path' import * as ts from 'typescript' @@ -158,11 +158,12 @@ class WorkflowRuntimeCompatibilityError extends Error { .join('\n') super( - 'Unsupported API usage found in workflow source.\n' + - 'CRE workflows run on Javy (QuickJS), not full Node.js.\n' + - 'Use CRE capabilities instead (for example, HTTPClient instead of fetch/node:http).\n' + - 'See https://docs.chain.link/cre/concepts/typescript-wasm-runtime\n\n' + - formattedViolations, + `Unsupported API usage found in workflow source. +CRE workflows run on Javy (QuickJS), not full Node.js. +Use CRE capabilities instead (for example, HTTPClient instead of fetch/node:http). +See https://docs.chain.link/cre/concepts/typescript-wasm-runtime + +${formattedViolations}`, ) this.name = 'WorkflowRuntimeCompatibilityError' } @@ -231,7 +232,7 @@ const resolveRelativeImport = (fromFilePath: string, specifier: string): string ? path.resolve(specifier) : path.resolve(path.dirname(fromFilePath), specifier) - if (existsSync(basePath)) { + if (existsSync(basePath) && statSync(basePath).isFile()) { return toAbsolutePath(basePath) } From 28414a3c49c053084c5c627c882a0be8a1ec02a2 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 13:14:05 +0100 Subject: [PATCH 14/20] Set version for alpha --- packages/cre-sdk-examples/package.json | 4 ++-- packages/cre-sdk/package.json | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index fbf719f6..011f23b5 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.3", + "version": "1.1.3-alpha.1", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", @@ -16,7 +16,7 @@ }, "dependencies": { "@bufbuild/protobuf": "2.6.3", - "@chainlink/cre-sdk": "workspace:*", + "@chainlink/cre-sdk": "1.1.3-alpha.1", "viem": "2.34.0", "zod": "3.25.76" }, diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index 9a8a90d9..105a7ac5 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.3", + "version": "1.1.3-alpha.1", "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": "workspace:*", + "@chainlink/cre-sdk-javy-plugin": "1.1.1", "@standard-schema/spec": "1.0.0", "viem": "2.34.0", "zod": "3.25.76" From e742d67ad77ea7bd1fbc0c7a326b86425a494d9a Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 14:07:53 +0100 Subject: [PATCH 15/20] Restore 1.1.3 version --- packages/cre-sdk-examples/package.json | 4 ++-- packages/cre-sdk/package.json | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index 011f23b5..fbf719f6 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.3-alpha.1", + "version": "1.1.3", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", @@ -16,7 +16,7 @@ }, "dependencies": { "@bufbuild/protobuf": "2.6.3", - "@chainlink/cre-sdk": "1.1.3-alpha.1", + "@chainlink/cre-sdk": "workspace:*", "viem": "2.34.0", "zod": "3.25.76" }, diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index 105a7ac5..9a8a90d9 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.3-alpha.1", + "version": "1.1.3", "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.1.1", + "@chainlink/cre-sdk-javy-plugin": "workspace:*", "@standard-schema/spec": "1.0.0", "viem": "2.34.0", "zod": "3.25.76" From ccc00e36a1d95b14764586d20c0a3a5401c6ed04 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 14:27:08 +0100 Subject: [PATCH 16/20] Simplify error messages --- packages/cre-sdk/bin/cre-compile.ts | 7 ++++++- packages/cre-sdk/scripts/src/compile-workflow.ts | 11 +++++++---- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/packages/cre-sdk/bin/cre-compile.ts b/packages/cre-sdk/bin/cre-compile.ts index 5e23ca18..38a34a19 100755 --- a/packages/cre-sdk/bin/cre-compile.ts +++ b/packages/cre-sdk/bin/cre-compile.ts @@ -1,6 +1,7 @@ #!/usr/bin/env bun import { main as compileWorkflow } from "../scripts/src/compile-workflow"; +import { WorkflowRuntimeCompatibilityError } from "../scripts/src/validate-workflow-runtime-compat"; const main = async () => { const cliArgs = process.argv.slice(2); @@ -26,6 +27,10 @@ const main = async () => { // CLI entry point main().catch((e) => { - console.error(e); + if (e instanceof WorkflowRuntimeCompatibilityError) { + console.error(`\n❌ ${e.message}`); + } else { + console.error(e); + } process.exit(1); }); diff --git a/packages/cre-sdk/scripts/src/compile-workflow.ts b/packages/cre-sdk/scripts/src/compile-workflow.ts index ebe6775b..7e11eab9 100644 --- a/packages/cre-sdk/scripts/src/compile-workflow.ts +++ b/packages/cre-sdk/scripts/src/compile-workflow.ts @@ -3,6 +3,7 @@ import { mkdir } from 'node:fs/promises' import path from 'node:path' import { main as compileToJs } from './compile-to-js' import { main as compileToWasm } from './compile-to-wasm' +import { WorkflowRuntimeCompatibilityError } from './validate-workflow-runtime-compat' export const main = async (inputFile?: string, outputWasmFile?: string) => { const cliArgs = process.argv.slice(3) @@ -41,9 +42,7 @@ export const main = async (inputFile?: string, outputWasmFile?: string) => { 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(`📁 Input: ${resolvedInput}\n`) // Step 1: TS/JS → JS (bundled) console.info('📦 Step 1: Compiling JS...') @@ -60,7 +59,11 @@ export const main = async (inputFile?: string, outputWasmFile?: string) => { // Optional: allow direct CLI usage if (import.meta.main) { main().catch((e) => { - console.error(e) + if (e instanceof WorkflowRuntimeCompatibilityError) { + console.error(`\n❌ ${e.message}`) + } else { + console.error(e) + } process.exit(1) }) } From 3a1136d6806eca90a7d6f582ba5cedbde8baa56e Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 14:37:26 +0100 Subject: [PATCH 17/20] Alpha release 2 --- packages/cre-sdk-examples/package.json | 4 ++-- packages/cre-sdk/package.json | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index fbf719f6..641e784f 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.3", + "version": "1.1.3-alpha.2", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", @@ -16,7 +16,7 @@ }, "dependencies": { "@bufbuild/protobuf": "2.6.3", - "@chainlink/cre-sdk": "workspace:*", + "@chainlink/cre-sdk": "1.1.3-alpha.2", "viem": "2.34.0", "zod": "3.25.76" }, diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index 9a8a90d9..8011db02 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.3", + "version": "1.1.3-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": "workspace:*", + "@chainlink/cre-sdk-javy-plugin": "1.1.1", "@standard-schema/spec": "1.0.0", "viem": "2.34.0", "zod": "3.25.76" From f4cf52791553873481d86af905b497f1da4fb1c7 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Tue, 3 Mar 2026 15:23:59 +0100 Subject: [PATCH 18/20] Restore correct versions --- packages/cre-sdk-examples/package.json | 4 ++-- packages/cre-sdk/package.json | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index 641e784f..fbf719f6 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.3-alpha.2", + "version": "1.1.3", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", @@ -16,7 +16,7 @@ }, "dependencies": { "@bufbuild/protobuf": "2.6.3", - "@chainlink/cre-sdk": "1.1.3-alpha.2", + "@chainlink/cre-sdk": "workspace:*", "viem": "2.34.0", "zod": "3.25.76" }, diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index 8011db02..9a8a90d9 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.3-alpha.2", + "version": "1.1.3", "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.1.1", + "@chainlink/cre-sdk-javy-plugin": "workspace:*", "@standard-schema/spec": "1.0.0", "viem": "2.34.0", "zod": "3.25.76" From d8acbcdf93a8daa8ebb55e84ecf3540d4c556969 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 9 Mar 2026 12:13:33 +0100 Subject: [PATCH 19/20] Update version, add option to use user tsconfig --- packages/cre-sdk-examples/package.json | 2 +- .../dist/javy_chainlink_sdk.wasm | Bin 1302976 -> 1318480 bytes packages/cre-sdk-javy-plugin/package.json | 2 +- packages/cre-sdk/package.json | 2 +- .../validate-workflow-runtime-compat.test.ts | 21 +++++ .../src/validate-workflow-runtime-compat.ts | 64 ++++++++++++- .../prepare-runtime-globals-contract.test.ts | 80 +++++++++++++++++ .../sdk/test/runtime-globals-types.test.ts | 84 ++++++++++++++++++ packages/cre-sdk/src/sdk/types/global.d.ts | 43 ++++++++- 9 files changed, 291 insertions(+), 7 deletions(-) create mode 100644 packages/cre-sdk/src/sdk/test/prepare-runtime-globals-contract.test.ts create mode 100644 packages/cre-sdk/src/sdk/test/runtime-globals-types.test.ts diff --git a/packages/cre-sdk-examples/package.json b/packages/cre-sdk-examples/package.json index 8b2d3674..0931cbe2 100644 --- a/packages/cre-sdk-examples/package.json +++ b/packages/cre-sdk-examples/package.json @@ -1,7 +1,7 @@ { "name": "@chainlink/cre-sdk-examples", "private": true, - "version": "1.1.4", + "version": "1.2.0", "type": "module", "author": "Ernest Nowacki", "license": "BUSL-1.1", diff --git a/packages/cre-sdk-javy-plugin/dist/javy_chainlink_sdk.wasm b/packages/cre-sdk-javy-plugin/dist/javy_chainlink_sdk.wasm index 3087edefa8817fd6a54d009c910abb7ad06a13b4..1d2e29f5bf6cdc8abbbac7d53964d804196bab30 100755 GIT binary patch delta 369243 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:t;F1S6Xlf9fr#P1|sBF+x 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%0A?dj| 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 diff --git a/packages/cre-sdk-javy-plugin/package.json b/packages/cre-sdk-javy-plugin/package.json index a5192039..69d722d0 100644 --- a/packages/cre-sdk-javy-plugin/package.json +++ b/packages/cre-sdk-javy-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk-javy-plugin", - "version": "1.1.1", + "version": "1.2.0", "type": "module", "bin": { "cre-setup": "bin/setup.ts", diff --git a/packages/cre-sdk/package.json b/packages/cre-sdk/package.json index c84fbcfc..88b8df0d 100644 --- a/packages/cre-sdk/package.json +++ b/packages/cre-sdk/package.json @@ -1,6 +1,6 @@ { "name": "@chainlink/cre-sdk", - "version": "1.1.4", + "version": "1.2.0", "type": "module", "main": "dist/index.js", "types": "dist/index.d.ts", diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts index b1cb92a7..1691829d 100644 --- a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.test.ts @@ -283,6 +283,27 @@ describe('global API analysis', () => { const entry = writeTemp('workflow.ts', `import { doFetch } from './helper';\ndoFetch();\n`) expectViolations(entry, ["'fetch' is not available"]) }) + + test('handles a nearby tsconfig with sparse libs and no ambient types', () => { + writeTemp( + 'tsconfig.json', + JSON.stringify( + { + compilerOptions: { + lib: ['ESNext'], + module: 'ESNext', + moduleResolution: 'Bundler', + skipLibCheck: true, + types: [], + }, + }, + null, + 2, + ), + ) + const entry = writeTemp('workflow.ts', `fetch('https://example.com');\n`) + expectViolations(entry, ["'fetch' is not available"]) + }) }) // --------------------------------------------------------------------------- diff --git a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts index 9f2bee32..7bb637de 100644 --- a/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts +++ b/packages/cre-sdk/scripts/src/validate-workflow-runtime-compat.ts @@ -172,6 +172,64 @@ ${formattedViolations}`, /** Resolves a file path to an absolute path using the current working directory. */ const toAbsolutePath = (filePath: string) => path.resolve(filePath) +const defaultValidationCompilerOptions: ts.CompilerOptions = { + allowJs: true, + checkJs: true, + noEmit: true, + skipLibCheck: true, + target: ts.ScriptTarget.ESNext, + module: ts.ModuleKind.ESNext, + moduleResolution: ts.ModuleResolutionKind.Bundler, +} + +const formatDiagnostic = (diagnostic: ts.Diagnostic) => { + const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n') + if (!diagnostic.file || diagnostic.start == null) { + return message + } + + const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) + return `${toAbsolutePath(diagnostic.file.fileName)}:${line + 1}:${character + 1} ${message}` +} + +/** + * Loads compiler options from the nearest tsconfig.json so validation runs + * against the same ambient/type environment as the workflow project. + */ +const loadClosestTsconfigCompilerOptions = (entryFilePath: string): ts.CompilerOptions | null => { + const configPath = ts.findConfigFile( + path.dirname(entryFilePath), + ts.sys.fileExists, + 'tsconfig.json', + ) + if (!configPath) { + return null + } + + let unrecoverableDiagnostic: ts.Diagnostic | null = null + const parsed = ts.getParsedCommandLineOfConfigFile( + configPath, + {}, + { + ...ts.sys, + onUnRecoverableConfigFileDiagnostic: (diagnostic) => { + unrecoverableDiagnostic = diagnostic + }, + }, + ) + + if (!parsed) { + if (unrecoverableDiagnostic) { + throw new Error( + `Failed to parse TypeScript config for workflow validation.\n${formatDiagnostic(unrecoverableDiagnostic)}`, + ) + } + return null + } + + return parsed.options +} + /** * Maps a file extension to the appropriate TypeScript {@link ts.ScriptKind} * so the parser handles JSX, CommonJS, and ESM files correctly. @@ -519,6 +577,7 @@ const collectGlobalApiUsage = ( */ export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { const rootFile = toAbsolutePath(entryFilePath) + const projectCompilerOptions = loadClosestTsconfigCompilerOptions(rootFile) ?? {} const filesToScan = [rootFile] const scannedFiles = new Set() const localSourceFiles = new Set() @@ -553,13 +612,12 @@ export const assertWorkflowRuntimeCompatibility = (entryFilePath: string) => { const program = ts.createProgram({ rootNames: [...localSourceFiles], options: { + ...defaultValidationCompilerOptions, + ...projectCompilerOptions, allowJs: true, checkJs: true, noEmit: true, skipLibCheck: true, - target: ts.ScriptTarget.ESNext, - module: ts.ModuleKind.ESNext, - moduleResolution: ts.ModuleResolutionKind.Bundler, }, }) diff --git a/packages/cre-sdk/src/sdk/test/prepare-runtime-globals-contract.test.ts b/packages/cre-sdk/src/sdk/test/prepare-runtime-globals-contract.test.ts new file mode 100644 index 00000000..6344f183 --- /dev/null +++ b/packages/cre-sdk/src/sdk/test/prepare-runtime-globals-contract.test.ts @@ -0,0 +1,80 @@ +import { describe, expect, test } from 'bun:test' +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' +import * as ts from 'typescript' + +const prepareRuntimePath = resolve(import.meta.dir, '../utils/prepare-runtime.ts') +const globalTypesPath = resolve(import.meta.dir, '../types/global.d.ts') + +const parseSourceFile = (filePath: string) => + ts.createSourceFile(filePath, readFileSync(filePath, 'utf-8'), ts.ScriptTarget.Latest, true) + +const collectPreparedGlobals = (sourceFile: ts.SourceFile) => { + const preparedGlobals = new Set() + + const visit = (node: ts.Node) => { + if ( + ts.isBinaryExpression(node) && + node.operatorToken.kind === ts.SyntaxKind.EqualsToken && + ts.isPropertyAccessExpression(node.left) && + ts.isIdentifier(node.left.expression) && + node.left.expression.text === 'globalThis' + ) { + preparedGlobals.add(node.left.name.text) + } + + ts.forEachChild(node, visit) + } + + visit(sourceFile) + return preparedGlobals +} + +const collectDeclaredGlobals = (sourceFile: ts.SourceFile) => { + const declaredGlobals = new Set() + + const collectFromGlobalBlock = (node: ts.Node) => { + if (ts.isFunctionDeclaration(node) && node.name) { + declaredGlobals.add(node.name.text) + } + + if (ts.isVariableStatement(node)) { + for (const declaration of node.declarationList.declarations) { + if (ts.isIdentifier(declaration.name)) { + declaredGlobals.add(declaration.name.text) + } + } + } + + ts.forEachChild(node, collectFromGlobalBlock) + } + + const visit = (node: ts.Node) => { + if ( + ts.isModuleDeclaration(node) && + ts.isIdentifier(node.name) && + node.name.text === 'global' && + node.body + ) { + collectFromGlobalBlock(node.body) + } + + ts.forEachChild(node, visit) + } + + visit(sourceFile) + return declaredGlobals +} + +describe('prepareRuntime globals contract', () => { + test('every global exposed at runtime is declared in ambient types', () => { + const preparedGlobals = collectPreparedGlobals(parseSourceFile(prepareRuntimePath)) + const declaredGlobals = collectDeclaredGlobals(parseSourceFile(globalTypesPath)) + const missingDeclarations = [...preparedGlobals] + .filter((name) => !declaredGlobals.has(name)) + .sort() + + expect(preparedGlobals.size).toBeGreaterThan(0) + expect(missingDeclarations).toEqual([]) + }) +}) diff --git a/packages/cre-sdk/src/sdk/test/runtime-globals-types.test.ts b/packages/cre-sdk/src/sdk/test/runtime-globals-types.test.ts new file mode 100644 index 00000000..3bcb6066 --- /dev/null +++ b/packages/cre-sdk/src/sdk/test/runtime-globals-types.test.ts @@ -0,0 +1,84 @@ +/** + * Regression test for runtime globals exposed through the published type surface. + * + * Requires a prior `bun run build` so dist/ exists. + * `bun run full-checks` (and CI) always build before testing. + */ + +import { afterAll, describe, expect, test } from 'bun:test' +import { spawnSync } from 'node:child_process' +import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join, resolve } from 'node:path' + +const pkgRoot = resolve(import.meta.dir, '../../..') +const tscBin = resolve(pkgRoot, '../../node_modules/typescript/bin/tsc') +const tmpDir = mkdtempSync(join(tmpdir(), 'cre-sdk-runtime-globals-test-')) + +afterAll(() => { + rmSync(tmpDir, { recursive: true, force: true }) +}) + +describe('runtime globals types (end-user style)', () => { + test('published package exposes allowed globals without Node ambient types', () => { + mkdirSync(join(tmpDir, 'node_modules', '@chainlink'), { recursive: true }) + symlinkSync(pkgRoot, join(tmpDir, 'node_modules', '@chainlink', 'cre-sdk')) + writeFileSync( + join(tmpDir, 'package.json'), + JSON.stringify({ name: 'runtime-globals-types-test', type: 'module' }), + ) + writeFileSync( + join(tmpDir, 'tsconfig.json'), + JSON.stringify( + { + compilerOptions: { + lib: ['ESNext'], + module: 'ESNext', + moduleResolution: 'Bundler', + noEmit: true, + skipLibCheck: true, + target: 'ESNext', + types: [], + }, + }, + null, + 2, + ), + ) + writeFileSync( + join(tmpDir, 'workflow.ts'), + [ + "import '@chainlink/cre-sdk'", + "const payload = Buffer.from(new Uint8Array([1, 2, 3])).toString('base64')", + "const copy = Buffer.concat([Buffer.from('hi'), Buffer.from(payload, 'base64')])", + 'const length = Buffer.byteLength(payload, "base64")', + 'const isBuffer = Buffer.isBuffer(copy)', + 'const decoded = atob(payload)', + "const encoded = btoa('hello')", + "const url = new URL('https://example.com/path?foo=bar')", + 'const params = new URLSearchParams({ foo: "bar" })', + 'void [length, isBuffer, decoded, encoded, url.hostname, params.toString()]', + '// @ts-expect-error fetch is intentionally unavailable in CRE workflows', + "fetch('https://example.com')", + "import { readFileSync } from 'node:fs'", + '// @ts-expect-error node:fs exports are intentionally unavailable in CRE workflows', + "readFileSync('/tmp/test.txt', 'utf8')", + 'export {}', + ].join('\n'), + ) + + const result = spawnSync('bun', [tscBin, '--project', join(tmpDir, 'tsconfig.json')], { + cwd: tmpDir, + }) + const stderr = result.stderr?.toString() ?? '' + const stdout = result.stdout?.toString() ?? '' + + if (result.status !== 0) { + throw new Error( + `runtime globals typecheck failed (status ${result.status}):\n${stderr}\n${stdout}`, + ) + } + + expect(stderr).toBe('') + }) +}) diff --git a/packages/cre-sdk/src/sdk/types/global.d.ts b/packages/cre-sdk/src/sdk/types/global.d.ts index a93c895c..1acc7282 100644 --- a/packages/cre-sdk/src/sdk/types/global.d.ts +++ b/packages/cre-sdk/src/sdk/types/global.d.ts @@ -127,8 +127,49 @@ declare global { > /** - * Base64 encoding/decoding — exposed via prepareRuntime() from node:buffer + * Buffer and Base64 APIs exposed via prepareRuntime() from node:buffer. + * Declared structurally so they work even when consumers opt out of @types/node. */ + type CreBufferEncoding = + | 'ascii' + | 'base64' + | 'base64url' + | 'binary' + | 'hex' + | 'latin1' + | 'ucs-2' + | 'ucs2' + | 'utf-8' + | 'utf-16le' + | 'utf8' + | 'utf16le' + + interface CreBuffer extends Uint8Array { + toString(encoding?: CreBufferEncoding, start?: number, end?: number): string + slice(start?: number, end?: number): CreBuffer + subarray(begin?: number, end?: number): CreBuffer + } + + var Buffer: ExistingGlobal< + 'Buffer', + { + prototype: CreBuffer + alloc( + size: number, + fill?: string | number | Uint8Array | ArrayBuffer | ArrayBufferView, + encoding?: CreBufferEncoding, + ): CreBuffer + byteLength( + value: string | Uint8Array | ArrayBuffer | ArrayBufferView, + encoding?: CreBufferEncoding, + ): number + concat(list: readonly Uint8Array[], totalLength?: number): CreBuffer + from(value: string, encoding?: CreBufferEncoding): CreBuffer + from(value: Uint8Array | ArrayBuffer | ArrayBufferView | ArrayLike): CreBuffer + isBuffer(value: unknown): value is CreBuffer + } + > + function atob(encodedData: string): string function btoa(stringToEncode: string): string From bd0a14005e9c9b8b89296d7ca43fa939c49028e5 Mon Sep 17 00:00:00 2001 From: ernest-nowacki Date: Mon, 9 Mar 2026 12:32:47 +0100 Subject: [PATCH 20/20] Small fixes --- packages/cre-sdk/scripts/run.ts | 6 +- packages/cre-sdk/scripts/src/build-types.ts | 2 +- packages/cre-sdk/scripts/src/compile-to-js.ts | 9 +-- .../cre-sdk/scripts/src/compile-workflow.ts | 13 ----- .../sdk/types/restricted-node-modules.d.ts | 57 +++++++++++++++++++ 5 files changed, 65 insertions(+), 22 deletions(-) diff --git a/packages/cre-sdk/scripts/run.ts b/packages/cre-sdk/scripts/run.ts index 11c801a6..703f3ae1 100644 --- a/packages/cre-sdk/scripts/run.ts +++ b/packages/cre-sdk/scripts/run.ts @@ -1,5 +1,7 @@ #!/usr/bin/env bun +import { WorkflowRuntimeCompatibilityError } from './src/validate-workflow-runtime-compat' + const availableScripts = [ 'build-types', 'compile-to-js', @@ -37,8 +39,8 @@ const main = async () => { process.exit(1) } } catch (error) { - if (error instanceof Error && error.name === 'WorkflowRuntimeCompatibilityError') { - console.error(error.message) + if (error instanceof WorkflowRuntimeCompatibilityError) { + console.error(`\n❌ ${error.message}`) } else { console.error(`Failed to run script ${scriptName}:`, error) } diff --git a/packages/cre-sdk/scripts/src/build-types.ts b/packages/cre-sdk/scripts/src/build-types.ts index 082d80e0..fe06f1cc 100644 --- a/packages/cre-sdk/scripts/src/build-types.ts +++ b/packages/cre-sdk/scripts/src/build-types.ts @@ -52,7 +52,7 @@ const buildTypes = async () => { // so that re-running build-types is idempotent. const withoutExistingRefs = indexContent .split('\n') - .filter((line) => !line.startsWith('/// { 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}`) + if (!existsSync(resolvedOutput)) { + console.error(`❌ Expected file not found: ${resolvedOutput}`) process.exit(1) } // Bundle into the final file (overwrite) - await $`bun build ${builtFile} --bundle --outfile=${resolvedOutput}` + await $`bun build ${resolvedOutput} --bundle --outfile=${resolvedOutput}` console.info(`✅ Built: ${resolvedOutput}`) return resolvedOutput diff --git a/packages/cre-sdk/scripts/src/compile-workflow.ts b/packages/cre-sdk/scripts/src/compile-workflow.ts index 7e11eab9..fa2f9267 100644 --- a/packages/cre-sdk/scripts/src/compile-workflow.ts +++ b/packages/cre-sdk/scripts/src/compile-workflow.ts @@ -3,7 +3,6 @@ import { mkdir } from 'node:fs/promises' import path from 'node:path' import { main as compileToJs } from './compile-to-js' import { main as compileToWasm } from './compile-to-wasm' -import { WorkflowRuntimeCompatibilityError } from './validate-workflow-runtime-compat' export const main = async (inputFile?: string, outputWasmFile?: string) => { const cliArgs = process.argv.slice(3) @@ -55,15 +54,3 @@ export const main = async (inputFile?: string, outputWasmFile?: string) => { console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`) return resolvedWasmOutput } - -// Optional: allow direct CLI usage -if (import.meta.main) { - main().catch((e) => { - if (e instanceof WorkflowRuntimeCompatibilityError) { - console.error(`\n❌ ${e.message}`) - } else { - console.error(e) - } - process.exit(1) - }) -} diff --git a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts index 83538a4d..5d4c3689 100644 --- a/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts +++ b/packages/cre-sdk/src/sdk/types/restricted-node-modules.d.ts @@ -2,8 +2,65 @@ // These modules require native bindings or system access that cannot run in WebAssembly. // Importing from these modules is allowed by TypeScript, but all exports are typed as // `never` so any usage produces a clear error at the call site. +// Both bare specifiers (e.g. 'crypto') and node:-prefixed specifiers (e.g. 'node:crypto') +// are covered so IDE red-squiggles appear regardless of import style. // See https://docs.chain.link/cre/concepts/typescript-wasm-runtime +// --- Bare-specifier aliases --- +// Re-export from the node:-prefixed declarations below so that +// `import { createHash } from 'crypto'` gets the same `never` types. + +/** @deprecated crypto is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'crypto' { + export * from 'node:crypto' +} +/** @deprecated fs is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'fs' { + export * from 'node:fs' +} +/** @deprecated fs/promises is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'fs/promises' { + export * from 'node:fs/promises' +} +/** @deprecated net is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'net' { + export * from 'node:net' +} +/** @deprecated http is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'http' { + export * from 'node:http' +} +/** @deprecated https is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'https' { + export * from 'node:https' +} +/** @deprecated child_process is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'child_process' { + export * from 'node:child_process' +} +/** @deprecated os is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'os' { + export * from 'node:os' +} +/** @deprecated stream is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'stream' { + export * from 'node:stream' +} +/** @deprecated worker_threads is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'worker_threads' { + export * from 'node:worker_threads' +} +/** @deprecated dns is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'dns' { + export * from 'node:dns' +} +/** @deprecated zlib is not available in CRE WASM workflows. @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime */ +declare module 'zlib' { + export * from 'node:zlib' +} + +// --- node:-prefixed declarations (canonical definitions) --- + /** * @deprecated node:crypto is not available in CRE WASM workflows. It requires native bindings that cannot run in WebAssembly. * @see https://docs.chain.link/cre/concepts/typescript-wasm-runtime