import { runJavaScript, startJavaScript } from 'wasm-rquickjs:execution';
import { stripTypeScriptTypes } from 'node:module';
export async function run() {
await runJavaScript({ source: `
const fs = await import('node:fs');
fs.mkdirSync('/tmp/execution-app/node_modules/execution-pkg', { recursive: true });
fs.mkdirSync('/tmp/execution-other', { recursive: true });
fs.mkdirSync('/tmp/execution-isolation-left', { recursive: true });
fs.mkdirSync('/tmp/execution-isolation-right', { recursive: true });
fs.mkdirSync('/tmp/execution-cache/node_modules/cache-pkg', { recursive: true });
fs.writeFileSync('/tmp/execution-shared-mode.txt', 'shared');
for (const path of ['/tmp/execution-ready-left', '/tmp/execution-ready-right']) {
try { fs.rmSync(path, { force: true, recursive: true }); } catch {}
}
fs.writeFileSync('/tmp/execution-app/local.mjs', 'export default "local";');
fs.writeFileSync('/tmp/execution-app/local.cjs', 'module.exports = "cjs";');
fs.writeFileSync('/tmp/execution-app/value.json', JSON.stringify({ value: 'json' }));
fs.writeFileSync('/tmp/execution-app/node_modules/execution-pkg/package.json', JSON.stringify({
name: 'execution-pkg', type: 'module', exports: './index.mjs',
}));
fs.writeFileSync('/tmp/execution-app/node_modules/execution-pkg/index.mjs',
'export default "package";');
fs.writeFileSync('/tmp/execution-app/entry.mjs',
'export function run() { return { kind: "entry", argv: process.argv }; }');
fs.writeFileSync('/tmp/execution-cache/node_modules/cache-pkg/package.json', JSON.stringify({
name: 'cache-pkg', type: 'module', exports: './first.mjs',
}));
fs.writeFileSync('/tmp/execution-cache/node_modules/cache-pkg/first.mjs',
'export default "first";');
fs.writeFileSync('/tmp/execution-cache/node_modules/cache-pkg/second.mjs',
'export default "second";');
` });
let firstChunkResolve;
const firstChunk = new Promise(resolve => { firstChunkResolve = resolve; });
let resultSettled = false;
let liveStdout = '';
let liveStderr = '';
const ordering = [];
const live = startJavaScript({ source: `
console.log('live:first');
await new Promise(resolve => setTimeout(resolve, 20));
console.warn('live:warn');
console.error('live:error');
console.log('live:last');
return { label: process.env.LABEL, argv: process.argv };
`, env: { LABEL: 'live' }, argv: ['execution', 'live'] });
live.result.finally(() => { resultSettled = true; });
live.stdout.setEncoding('utf8');
live.stderr.setEncoding('utf8');
live.stdout.on('data', chunk => {
liveStdout += chunk;
ordering.push('data');
firstChunkResolve();
});
live.stderr.on('data', chunk => { liveStderr += chunk; });
await firstChunk;
const streamedBeforeResult = !resultSettled;
let parentProgress = false;
await new Promise(resolve => setTimeout(() => { parentProgress = true; resolve(); }, 1));
const liveResult = await live.result;
ordering.push('result');
const [left, right] = await Promise.all([
runJavaScript({ source: `console.log(process.env.LABEL); return process.env.LABEL;`, env: { LABEL: 'left' } }),
runJavaScript({ source: `console.log(process.env.LABEL); return process.env.LABEL;`, env: { LABEL: 'right' } }),
]);
process.env.EXECUTION_PARENT_SECRET = 'must-not-cross-runtime-boundary';
const defaultEnvironment = await runJavaScript({ source: `
return {
keys: Object.keys(process.env).sort(),
parentSecret: process.env.EXECUTION_PARENT_SECRET,
};
` });
const explicitEnvironment = await runJavaScript({
source: `return { keys: Object.keys(process.env).sort(), allowed: process.env.ALLOWED,
parentSecret: process.env.EXECUTION_PARENT_SECRET };`,
env: { ALLOWED: 'visible' },
});
delete process.env.EXECUTION_PARENT_SECRET;
const packageCacheFirst = await runJavaScript({
cwd: '/tmp/execution-cache', source: `return (await import('cache-pkg')).default;`,
});
await runJavaScript({ source: `
const fs = await import('node:fs');
fs.writeFileSync('/tmp/execution-cache/node_modules/cache-pkg/package.json', JSON.stringify({
name: 'cache-pkg', type: 'module', exports: './second.mjs',
}));
` });
const packageCacheSecond = await runJavaScript({
cwd: '/tmp/execution-cache', source: `return (await import('cache-pkg')).default;`,
});
const timeoutSuccess = await runJavaScript({ source: `return 'quick';`, timeoutMs: 1000 });
let timeoutError;
try {
await runJavaScript({ source: `await new Promise(resolve => setTimeout(resolve, 50));`, timeoutMs: 10 });
} catch (error) {
timeoutError = error.message;
}
let tightLoopTimeoutError;
try {
await runJavaScript({ source: `while (true) {}`, timeoutMs: 5 });
} catch (error) {
tightLoopTimeoutError = error.message;
}
const cpuBeforeSuspend = startJavaScript({ source: `
console.log('burn:start:' + Date.now());
const burnStarted = Date.now();
while (Date.now() - burnStarted < 300) {}
await new Promise(() => {});
`, timeoutMs: 400 });
cpuBeforeSuspend.stdout.setEncoding('utf8');
const cpuBeforeSuspendStarted = await new Promise((resolve, reject) => {
cpuBeforeSuspend.stdout.once('data', chunk => {
const match = /^burn:start:(\d+)\n$/.exec(chunk);
if (match === null) {
reject(new Error(`unexpected burn sentinel: ${chunk}`));
return;
}
resolve(Number(match[1]));
});
});
let cpuBeforeSuspendTimeoutError;
try {
await cpuBeforeSuspend.result;
} catch (error) {
cpuBeforeSuspendTimeoutError = error.message;
}
const cpuBeforeSuspendElapsedMs = Date.now() - cpuBeforeSuspendStarted;
let zeroTimeoutCode;
try { startJavaScript({ source: `return 1;`, timeoutMs: 0 }); }
catch (error) { zeroTimeoutCode = error.code; }
let hugeTimeoutCode;
try { startJavaScript({ source: `return 1;`, timeoutMs: Number.MAX_SAFE_INTEGER }); }
catch (error) { hugeTimeoutCode = error.code; }
const invalidProgramOptions = {};
for (const [name, options] of Object.entries({
invalidEntry: { entry: 42 },
invalidSource: { source: 42 },
invalidEntryWithSource: { entry: 42, source: `return 1;` },
invalidSourceWithEntry: { entry: './entry.mjs', source: 42 },
both: { entry: './entry.mjs', source: `return 1;` },
})) {
try { startJavaScript(options); }
catch (error) { invalidProgramOptions[name] = error.code ?? error.message; }
}
let overflowError;
try {
await runJavaScript({
source: `console.log('123456'); await new Promise(() => {});`, maxBytes: 4,
});
} catch (error) {
overflowError = error.message;
}
const truncated = await runJavaScript({
source: `process.stderr.write('ééé'); return 'ok';`, maxBytes: 5, overflow: 'truncate',
});
const entry = await runJavaScript({ entry: './entry.mjs', cwd: '/tmp/execution-app' });
const defaultArgv = await runJavaScript({ source: `return process.argv;` });
const largeJavaScript = await runJavaScript({
source: `${' '.repeat(256 * 1024)}return 'large-javascript';`,
});
let disabledStripError;
try { stripTypeScriptTypes('const value: number = 1;'); }
catch (error) { disabledStripError = error.message; }
let disabledExecutionError;
try {
await runJavaScript({ source: 'return 1 as number;', language: 'typescript' });
} catch (error) {
disabledExecutionError = error.message;
}
const imports = await runJavaScript({ cwd: '/tmp/execution-app', source: `
const local = await import('./local.mjs');
const pkg = await import('execution-pkg');
const { createRequire } = await import('node:module');
const require = createRequire(process.cwd() + '/__wasm_rquickjs_execution_inline.mjs');
const json = require('./value.json');
const cjs = require('./local.cjs');
process.chdir('/tmp/execution-other');
const afterChdir = await import('./local.mjs');
return { local: local.default, package: pkg.default, json: json.value,
cjs, afterChdir: afterChdir.default, cwd: process.cwd() };
` });
const privateImport = await runJavaScript({ cwd: '/tmp/execution-app', source: `
try { await import('__wasm_rquickjs_builtin/execution_native'); }
catch (error) { return error.code; }
return 'unexpected-success';
` });
const removedAliases = await runJavaScript({ source: `
let legacySpecifier;
try { await import('golem:code-runner'); }
catch (error) { legacySpecifier = error.code; }
const execution = await import('wasm-rquickjs:execution');
return { legacySpecifier, spawnJavaScript: typeof execution.spawnJavaScript };
` });
const clone = await runJavaScript({ source: `
const cycle = { label: 'cycle' };
cycle.self = cycle;
return {
missing: undefined, nan: NaN, infinity: Infinity, negativeInfinity: -Infinity,
negativeZero: -0, bigint: 12345678901234567890n, cycle,
map: new Map([['key', 7]]), set: new Set(['value']),
bytes: new Uint8Array([1, 2, 3]),
};
` });
const cloneChecks = {
hasUndefined: Object.hasOwn(clone.value, 'missing') && clone.value.missing === undefined,
nan: Number.isNaN(clone.value.nan),
infinity: clone.value.infinity === Infinity,
negativeInfinity: clone.value.negativeInfinity === -Infinity,
negativeZero: Object.is(clone.value.negativeZero, -0),
bigint: clone.value.bigint === 12345678901234567890n,
cycle: clone.value.cycle.self === clone.value.cycle,
map: clone.value.map instanceof Map && clone.value.map.get('key') === 7,
set: clone.value.set instanceof Set && clone.value.set.has('value'),
bytes: clone.value.bytes instanceof Uint8Array && clone.value.bytes.join(',') === '1,2,3',
};
let resourceError;
try {
await runJavaScript({ source: `
return { [Symbol.for('__wasm_rquickjs.structuredClone')]() { return 1; } };
` });
} catch (error) {
resourceError = error.message;
}
const pathAliases = await runJavaScript({ source: `
const fs = await import('node:fs');
fs.mkdirSync('/tmp/alias/sub', { recursive: true });
fs.writeFileSync('/tmp/alias/file.txt', 'before');
fs.chmodSync('/tmp/alias/sub/../file.txt', 0o611);
const mode = fs.statSync('/tmp/alias/file.txt').mode & 0o7777;
fs.symlinkSync('./sub/../file.txt', '/tmp/alias/link.txt');
const link = fs.readlinkSync('/tmp/alias/sub/../link.txt');
const real = fs.realpathSync('/tmp/alias/sub/../link.txt');
fs.renameSync('/tmp/alias/sub/../file.txt', '/tmp/alias/sub/../renamed.txt');
const renamed = fs.readFileSync('/tmp/alias/renamed.txt', 'utf8');
return { mode, link, real, renamed };
` });
const persistentSymlinkCreated = await runJavaScript({ source: `
const fs = await import('node:fs');
fs.mkdirSync('/tmp/persistent-link', { recursive: true });
fs.writeFileSync('/tmp/persistent-link/target.txt', 'persistent');
fs.symlinkSync('target.txt', '/tmp/persistent-link/link.txt');
let absoluteError;
try {
fs.symlinkSync('/tmp/persistent-link/target.txt', '/tmp/persistent-link/absolute.txt');
} catch (error) {
absoluteError = error.code;
}
fs.writeFileSync('/tmp/persistent-link/existing.txt', 'preserved');
let existingError;
try {
fs.symlinkSync('/tmp/persistent-link/target.txt', '/tmp/persistent-link/existing.txt');
} catch (error) {
existingError = error.code;
}
let missingParentError;
try {
fs.symlinkSync('/tmp/persistent-link/target.txt', '/tmp/persistent-link/missing/link.txt');
} catch (error) {
missingParentError = error.code;
}
fs.writeFileSync('/tmp/persistent-link/parent-file', 'parent');
let parentFileError;
try {
fs.symlinkSync('/tmp/persistent-link/target.txt', '/tmp/persistent-link/parent-file/link.txt');
} catch (error) {
parentFileError = error.code;
}
let relativeParentFileError;
try {
fs.symlinkSync('target.txt', '/tmp/persistent-link/parent-file/relative-link.txt');
} catch (error) {
relativeParentFileError = error.code;
}
process.chdir('/tmp/persistent-link');
let bareDestinationError;
try {
fs.symlinkSync('/tmp/persistent-link/target.txt', 'bare.txt');
} catch (error) {
bareDestinationError = error.code;
}
return {
absoluteError,
absoluteExists: fs.existsSync('/tmp/persistent-link/absolute.txt'),
existingError,
existingValue: fs.readFileSync('/tmp/persistent-link/existing.txt', 'utf8'),
missingParentError,
parentFileError,
relativeParentFileError,
bareDestinationError,
bareDestinationExists: fs.existsSync('bare.txt'),
};
` });
const persistentSymlinkRead = await runJavaScript({ source: `
const fs = await import('node:fs');
return {
target: fs.readlinkSync('/tmp/persistent-link/link.txt'),
value: fs.readFileSync('/tmp/persistent-link/link.txt', 'utf8'),
realpath: fs.realpathSync('/tmp/persistent-link/link.txt'),
isSymbolicLink: fs.lstatSync('/tmp/persistent-link/link.txt').isSymbolicLink(),
};
` });
const persistentSymlinkEdges = await runJavaScript({ source: `
const fs = await import('node:fs');
fs.symlinkSync('missing.txt', '/tmp/persistent-link/broken.txt');
fs.symlinkSync('cycle-b.txt', '/tmp/persistent-link/cycle-a.txt');
fs.symlinkSync('cycle-a.txt', '/tmp/persistent-link/cycle-b.txt');
fs.mkdirSync('/tmp/persistent-link/tree/target', { recursive: true });
fs.writeFileSync('/tmp/persistent-link/tree/target/file.txt', 'tree');
fs.symlinkSync('target', '/tmp/persistent-link/tree/linked-target');
const recursiveNames = fs.readdirSync('/tmp/persistent-link/tree', { recursive: true }).sort();
const recursiveCallbackNames = await new Promise((resolve, reject) => {
fs.readdir('/tmp/persistent-link/tree', { recursive: true }, (error, entries) => {
if (error) reject(error);
else resolve(entries.sort());
});
});
const recursivePromiseNames = (
await fs.promises.readdir('/tmp/persistent-link/tree', { recursive: true })
).sort();
fs.mkdirSync('/tmp/persistent-link/watch-tree/target', { recursive: true });
fs.writeFileSync('/tmp/persistent-link/watch-tree/target/file.txt', 'watch');
fs.symlinkSync('.', '/tmp/persistent-link/watch-tree/self');
const recursiveWatchEvents = [];
let targetCreatedEventCount = 0;
let resolveWatchPoll;
const watchPoll = new Promise((resolve) => { resolveWatchPoll = resolve; });
const watcher = fs.watch('/tmp/persistent-link/watch-tree', { recursive: true }, (event, filename) => {
if (filename == null) return;
const name = filename.toString();
recursiveWatchEvents.push([event, name]);
if (name === 'target/created.txt' && ++targetCreatedEventCount === 2) resolveWatchPoll();
});
const recursiveWatcherIsFsWatcher = watcher instanceof fs.FSWatcher;
fs.writeFileSync('/tmp/persistent-link/watch-tree/target/created.txt', 'created');
await Promise.race([
watchPoll,
new Promise((_, reject) => setTimeout(() => reject(new Error('recursive watch poll timed out')), 2000)),
]);
watcher.close();
let cycleError;
try { fs.realpathSync('/tmp/persistent-link/cycle-a.txt'); }
catch (error) { cycleError = error.code; }
let cycleDestinationError;
try { fs.symlinkSync('target.txt', '/tmp/persistent-link/cycle-a.txt/child.txt'); }
catch (error) { cycleDestinationError = error.code; }
fs.renameSync('/tmp/persistent-link/link.txt', '/tmp/persistent-link/moved.txt');
const movedTarget = fs.readlinkSync('/tmp/persistent-link/moved.txt');
fs.unlinkSync('/tmp/persistent-link/moved.txt');
return {
brokenExists: fs.existsSync('/tmp/persistent-link/broken.txt'),
brokenIsSymbolicLink: fs.lstatSync('/tmp/persistent-link/broken.txt').isSymbolicLink(),
brokenTarget: fs.readlinkSync('/tmp/persistent-link/broken.txt'),
cycleError,
cycleDestinationError,
recursiveNames,
recursiveCallbackNames,
recursivePromiseNames,
recursiveWatcherIsFsWatcher,
recursiveWatchEvents,
movedTarget,
movedExistsAfterUnlink: fs.existsSync('/tmp/persistent-link/moved.txt'),
};
` });
const isolationSource = `
const fs = await import('node:fs');
const label = process.env.LABEL;
const other = label === 'left' ? 'right' : 'left';
const expectedMode = label === 'left' ? 0o600 : 0o640;
fs.writeFileSync('./data.txt', label);
const fd = fs.openSync('./data.txt', 'r');
const secondFd = label === 'left' ? fs.openSync('./data.txt', 'r') : null;
let foreignFdError = null;
if (label === 'right') {
try { fs.fstatSync(fd + 1); } catch (error) { foreignFdError = error.code; }
}
fs.chmodSync('/tmp/execution-shared-mode.txt', expectedMode);
fs.writeFileSync('./target.txt', label + ':target');
fs.symlinkSync('./target.txt', './link.txt');
fs.mkdirSync('./node_modules/isolation-pkg', { recursive: true });
fs.writeFileSync('./node_modules/isolation-pkg/package.json', JSON.stringify({
name: 'isolation-pkg', type: 'module', exports: './index.mjs',
}));
fs.writeFileSync('./node_modules/isolation-pkg/index.mjs',
'export default process.env.LABEL + ":package";');
fs.writeFileSync('/tmp/execution-ready-' + label, 'ready');
while (!fs.existsSync('/tmp/execution-ready-' + other)) {
await new Promise(resolve => setTimeout(resolve, 1));
}
const mode = fs.statSync('/tmp/execution-shared-mode.txt').mode & 0o7777;
const linkTarget = fs.readlinkSync('./link.txt');
const linkValue = fs.readFileSync('./link.txt', 'utf8');
const packageModule = await import('isolation-pkg');
console.log(label + ':stdout');
process.stderr.write(label + ':stderr\\n');
fs.closeSync(fd);
if (secondFd !== null) fs.closeSync(secondFd);
return { label, cwd: process.cwd(), fd, secondFd, foreignFdError,
mode, linkTarget, linkValue, packageValue: packageModule.default };
`;
const [isolationLeft, isolationRight] = await Promise.all([
runJavaScript({ cwd: '/tmp/execution-isolation-left', source: isolationSource,
env: { LABEL: 'left' }, timeoutMs: 2000 }),
runJavaScript({ cwd: '/tmp/execution-isolation-right', source: isolationSource,
env: { LABEL: 'right' }, timeoutMs: 2000 }),
]);
const cancelledJob = startJavaScript({ source: `await new Promise(() => {});` });
setTimeout(() => cancelledJob.cancel(), 1);
let cancellationError;
try { await cancelledJob.result; }
catch (error) { cancellationError = error.message; }
const nested = await runJavaScript({ source: `
const { startJavaScript } = await import('wasm-rquickjs:execution');
try { startJavaScript({ source: "return 'nested';" }); }
catch (error) { return error.message; }
` });
const heldJobs = Array.from({ length: 8 }, () => startJavaScript({
source: `await new Promise(() => {});`,
}));
let capacityError;
try { startJavaScript({ source: `return 'ninth';` }); }
catch (error) { capacityError = error.message; }
for (const job of heldJobs) job.cancel();
await Promise.allSettled(heldJobs.map(job => job.result));
const reclaimed = await runJavaScript({ source: `return 'reclaimed';` });
return JSON.stringify({
liveStdout, liveStderr, liveResult, ordering, streamedBeforeResult, parentProgress,
left, right, defaultEnvironment, explicitEnvironment,
packageCacheFirst, packageCacheSecond,
timeoutSuccess, timeoutError, tightLoopTimeoutError,
cpuBeforeSuspendTimeoutError, cpuBeforeSuspendElapsedMs,
zeroTimeoutCode, hugeTimeoutCode, invalidProgramOptions,
overflowError, truncated, entry, defaultArgv, largeJavaScript,
typescriptDisabled: process.features.typescript === false,
disabledStripError, disabledExecutionError, imports,
privateImport, removedAliases, cloneChecks, resourceError, pathAliases,
persistentSymlinkCreated, persistentSymlinkRead, persistentSymlinkEdges,
cancellationError, nested, capacityError, reclaimed,
isolation: { left: isolationLeft, right: isolationRight },
});
}