ai-evaluate 2.1.6 → 2.1.8

package/dist/worker-template/sdk-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-generator.js","sourceRoot":"","sources":["../../src/worker-template/sdk-generator.ts"],"names":[],"mappings":"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"}

package/dist/worker-template/test-generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Test framework embedding for worker templates
+ *
+ * Generates the embedded test framework code used in dev mode
+ * (vitest-compatible API without external dependencies)
+ */
+/**
+ * Generate the embedded test framework code
+ * This creates a vitest-compatible testing API that runs in the sandbox
+ */
+export declare function generateTestFrameworkCode(): string;
+/**
+ * Generate the test runner code that executes pending tests
+ */
+export declare function generateTestRunnerCode(): string;
+//# sourceMappingURL=test-generator.d.ts.map

package/dist/worker-template/test-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-generator.d.ts","sourceRoot":"","sources":["../../src/worker-template/test-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CA0RlD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CA2D/C"}

package/dist/worker-template/test-generator.js

@@ -0,0 +1,357 @@
+/**
+ * Test framework embedding for worker templates
+ *
+ * Generates the embedded test framework code used in dev mode
+ * (vitest-compatible API without external dependencies)
+ */
+/**
+ * Generate the embedded test framework code
+ * This creates a vitest-compatible testing API that runs in the sandbox
+ */
+export function generateTestFrameworkCode() {
+    return `
+// Test framework (vitest-compatible API)
+let currentDescribe = '';
+let beforeEachFns = [];
+let afterEachFns = [];
+
+const describe = (name, fn) => {
+  const prev = currentDescribe;
+  const prevBeforeEach = [...beforeEachFns];
+  const prevAfterEach = [...afterEachFns];
+  currentDescribe = currentDescribe ? currentDescribe + ' > ' + name : name;
+  try { fn(); } finally {
+    currentDescribe = prev;
+    beforeEachFns = prevBeforeEach;
+    afterEachFns = prevAfterEach;
+  }
+};
+
+// Hooks
+const beforeEach = (fn) => { beforeEachFns.push(fn); };
+const afterEach = (fn) => { afterEachFns.push(fn); };
+
+const it = (name, fn) => {
+  const fullName = currentDescribe ? currentDescribe + ' > ' + name : name;
+  const hooks = { before: [...beforeEachFns], after: [...afterEachFns] };
+  pendingTests.push({ name: fullName, fn, hooks });
+};
+const test = it;
+
+it.skip = (name, fn) => {
+  const fullName = currentDescribe ? currentDescribe + ' > ' + name : name;
+  pendingTests.push({ name: fullName, fn: null, skip: true });
+};
+test.skip = it.skip;
+
+it.only = (name, fn) => {
+  const fullName = currentDescribe ? currentDescribe + ' > ' + name : name;
+  const hooks = { before: [...beforeEachFns], after: [...afterEachFns] };
+  pendingTests.push({ name: fullName, fn, hooks, only: true });
+};
+test.only = it.only;
+
+// Deep equality check
+const deepEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(k => deepEqual(a[k], b[k]));
+};
+
+// Expect implementation with vitest-compatible matchers
+const expect = (actual) => {
+  const matchers = {
+    toBe: (expected) => {
+      if (actual !== expected) {
+        throw new Error(\`Expected \${JSON.stringify(expected)} but got \${JSON.stringify(actual)}\`);
+      }
+    },
+    toEqual: (expected) => {
+      if (!deepEqual(actual, expected)) {
+        throw new Error(\`Expected \${JSON.stringify(expected)} but got \${JSON.stringify(actual)}\`);
+      }
+    },
+    toStrictEqual: (expected) => {
+      if (!deepEqual(actual, expected)) {
+        throw new Error(\`Expected \${JSON.stringify(expected)} but got \${JSON.stringify(actual)}\`);
+      }
+    },
+    toBeTruthy: () => {
+      if (!actual) throw new Error(\`Expected truthy but got \${JSON.stringify(actual)}\`);
+    },
+    toBeFalsy: () => {
+      if (actual) throw new Error(\`Expected falsy but got \${JSON.stringify(actual)}\`);
+    },
+    toBeNull: () => {
+      if (actual !== null) throw new Error(\`Expected null but got \${JSON.stringify(actual)}\`);
+    },
+    toBeUndefined: () => {
+      if (actual !== undefined) throw new Error(\`Expected undefined but got \${JSON.stringify(actual)}\`);
+    },
+    toBeDefined: () => {
+      if (actual === undefined) throw new Error('Expected defined but got undefined');
+    },
+    toBeNaN: () => {
+      if (!Number.isNaN(actual)) throw new Error(\`Expected NaN but got \${actual}\`);
+    },
+    toContain: (item) => {
+      if (Array.isArray(actual)) {
+        if (!actual.includes(item)) throw new Error(\`Expected array to contain \${JSON.stringify(item)}\`);
+      } else if (typeof actual === 'string') {
+        if (!actual.includes(item)) throw new Error(\`Expected string to contain "\${item}"\`);
+      } else {
+        throw new Error('toContain only works on arrays and strings');
+      }
+    },
+    toContainEqual: (item) => {
+      if (!Array.isArray(actual)) throw new Error('toContainEqual only works on arrays');
+      if (!actual.some(v => deepEqual(v, item))) {
+        throw new Error(\`Expected array to contain \${JSON.stringify(item)}\`);
+      }
+    },
+    toHaveLength: (length) => {
+      if (actual?.length !== length) {
+        throw new Error(\`Expected length \${length} but got \${actual?.length}\`);
+      }
+    },
+    toHaveProperty: function(path, value) {
+      const parts = typeof path === 'string' ? path.split('.') : [path];
+      let obj = actual;
+      for (const part of parts) {
+        if (obj == null || !(part in obj)) {
+          throw new Error(\`Expected object to have property "\${path}"\`);
+        }
+        obj = obj[part];
+      }
+      if (arguments.length > 1 && !deepEqual(obj, value)) {
+        throw new Error(\`Expected property "\${path}" to be \${JSON.stringify(value)} but got \${JSON.stringify(obj)}\`);
+      }
+    },
+    toMatchObject: (expected) => {
+      if (typeof actual !== 'object' || actual === null) {
+        throw new Error('toMatchObject expects an object');
+      }
+      for (const key of Object.keys(expected)) {
+        if (!deepEqual(actual[key], expected[key])) {
+          throw new Error(\`Expected property "\${key}" to be \${JSON.stringify(expected[key])} but got \${JSON.stringify(actual[key])}\`);
+        }
+      }
+    },
+    toThrow: (expected) => {
+      if (typeof actual !== 'function') throw new Error('toThrow expects a function');
+      let threw = false;
+      let error;
+      try {
+        actual();
+      } catch (e) {
+        threw = true;
+        error = e;
+      }
+      if (!threw) throw new Error('Expected function to throw');
+      if (expected !== undefined) {
+        if (typeof expected === 'string' && !error.message.includes(expected)) {
+          throw new Error(\`Expected error message to contain "\${expected}" but got "\${error.message}"\`);
+        }
+        if (expected instanceof RegExp && !expected.test(error.message)) {
+          throw new Error(\`Expected error message to match \${expected} but got "\${error.message}"\`);
+        }
+        if (typeof expected === 'function' && !(error instanceof expected)) {
+          throw new Error(\`Expected error to be instance of \${expected.name}\`);
+        }
+      }
+    },
+    toBeGreaterThan: (n) => {
+      if (!(actual > n)) throw new Error(\`Expected \${actual} to be greater than \${n}\`);
+    },
+    toBeLessThan: (n) => {
+      if (!(actual < n)) throw new Error(\`Expected \${actual} to be less than \${n}\`);
+    },
+    toBeGreaterThanOrEqual: (n) => {
+      if (!(actual >= n)) throw new Error(\`Expected \${actual} to be >= \${n}\`);
+    },
+    toBeLessThanOrEqual: (n) => {
+      if (!(actual <= n)) throw new Error(\`Expected \${actual} to be <= \${n}\`);
+    },
+    toBeCloseTo: (n, digits = 2) => {
+      const diff = Math.abs(actual - n);
+      const threshold = Math.pow(10, -digits) / 2;
+      if (diff > threshold) {
+        throw new Error(\`Expected \${actual} to be close to \${n}\`);
+      }
+    },
+    toMatch: (pattern) => {
+      if (typeof actual !== 'string') throw new Error('toMatch expects a string');
+      const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+      if (!regex.test(actual)) {
+        throw new Error(\`Expected "\${actual}" to match \${pattern}\`);
+      }
+    },
+    toBeInstanceOf: (cls) => {
+      if (!(actual instanceof cls)) {
+        throw new Error(\`Expected instance of \${cls.name}\`);
+      }
+    },
+    toBeTypeOf: (type) => {
+      if (typeof actual !== type) {
+        throw new Error(\`Expected typeof to be "\${type}" but got "\${typeof actual}"\`);
+      }
+    },
+  };
+
+  matchers.not = {
+    toBe: (expected) => {
+      if (actual === expected) throw new Error(\`Expected not \${JSON.stringify(expected)}\`);
+    },
+    toEqual: (expected) => {
+      if (deepEqual(actual, expected)) {
+        throw new Error(\`Expected not equal to \${JSON.stringify(expected)}\`);
+      }
+    },
+    toBeTruthy: () => {
+      if (actual) throw new Error('Expected not truthy');
+    },
+    toBeFalsy: () => {
+      if (!actual) throw new Error('Expected not falsy');
+    },
+    toBeNull: () => {
+      if (actual === null) throw new Error('Expected not null');
+    },
+    toBeUndefined: () => {
+      if (actual === undefined) throw new Error('Expected not undefined');
+    },
+    toBeDefined: () => {
+      if (actual !== undefined) throw new Error('Expected undefined');
+    },
+    toContain: (item) => {
+      if (Array.isArray(actual) && actual.includes(item)) {
+        throw new Error(\`Expected array not to contain \${JSON.stringify(item)}\`);
+      }
+      if (typeof actual === 'string' && actual.includes(item)) {
+        throw new Error(\`Expected string not to contain "\${item}"\`);
+      }
+    },
+    toHaveProperty: (path) => {
+      const parts = typeof path === 'string' ? path.split('.') : [path];
+      let obj = actual;
+      try {
+        for (const part of parts) {
+          if (obj == null || !(part in obj)) return;
+          obj = obj[part];
+        }
+        throw new Error(\`Expected object not to have property "\${path}"\`);
+      } catch {}
+    },
+    toThrow: () => {
+      if (typeof actual !== 'function') throw new Error('toThrow expects a function');
+      try {
+        actual();
+      } catch (e) {
+        throw new Error('Expected function not to throw');
+      }
+    },
+    toMatch: (pattern) => {
+      if (typeof actual !== 'string') throw new Error('toMatch expects a string');
+      const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+      if (regex.test(actual)) {
+        throw new Error(\`Expected "\${actual}" not to match \${pattern}\`);
+      }
+    },
+  };
+
+  matchers.resolves = new Proxy({}, {
+    get: (_, prop) => async (...args) => {
+      const resolved = await actual;
+      return expect(resolved)[prop](...args);
+    }
+  });
+
+  matchers.rejects = new Proxy({}, {
+    get: (_, prop) => async (...args) => {
+      try {
+        await actual;
+        throw new Error('Expected promise to reject');
+      } catch (e) {
+        if (e.message === 'Expected promise to reject') throw e;
+        return expect(e)[prop](...args);
+      }
+    }
+  });
+
+  return matchers;
+};
+`;
+}
+/**
+ * Generate the test runner code that executes pending tests
+ */
+export function generateTestRunnerCode() {
+    return `
+    // Run all pending tests
+    const testStart = Date.now();
+    const hasOnly = pendingTests.some(t => t.only);
+    const testsToRun = hasOnly ? pendingTests.filter(t => t.only || t.skip) : pendingTests;
+
+    for (const { name, fn, hooks, skip } of testsToRun) {
+      testResults.total++;
+
+      if (skip) {
+        testResults.skipped++;
+        testResults.tests.push({ name, passed: true, skipped: true, duration: 0 });
+        continue;
+      }
+
+      const start = Date.now();
+      try {
+        // Run beforeEach hooks
+        if (hooks?.before) {
+          for (const hook of hooks.before) {
+            const hookResult = hook();
+            if (hookResult && typeof hookResult.then === 'function') {
+              await hookResult;
+            }
+          }
+        }
+
+        // Run the test
+        const result = fn();
+        if (result && typeof result.then === 'function') {
+          await result;
+        }
+
+        // Run afterEach hooks
+        if (hooks?.after) {
+          for (const hook of hooks.after) {
+            const hookResult = hook();
+            if (hookResult && typeof hookResult.then === 'function') {
+              await hookResult;
+            }
+          }
+        }
+
+        testResults.passed++;
+        testResults.tests.push({ name, passed: true, duration: Date.now() - start });
+      } catch (e) {
+        testResults.failed++;
+        testResults.tests.push({
+          name,
+          passed: false,
+          error: e.message || String(e),
+          duration: Date.now() - start
+        });
+      }
+    }
+
+    testResults.duration = Date.now() - testStart;
+`;
+}
+//# sourceMappingURL=test-generator.js.map

package/dist/worker-template/test-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-generator.js","sourceRoot":"","sources":["../../src/worker-template/test-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwRR,CAAA;AACD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDR,CAAA;AACD,CAAC"}

package/dist/worker-template.d.ts

@@ -13,7 +13,7 @@
  * - POST /rpc or WebSocket upgrade - capnweb RPC to module exports
  * - GET / - Return info about available exports
  */
-import type { SDKConfig } from './types.js';
+import type { SDKConfig, FetchConfig } from './types.js';
 /**
  * Generate worker code for production (uses RPC to ai-tests)
  */
@@ -36,6 +36,6 @@ export declare function generateDevWorkerCode(options: {
     script?: string | undefined;
     sdk?: SDKConfig | boolean | undefined;
     imports?: string[] | undefined;
-    fetch?: null | undefined;
+    fetch?: null | FetchConfig | undefined;
 }): string;
 //# sourceMappingURL=worker-template.d.ts.map

package/dist/worker-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-template.d.ts","sourceRoot":"","sources":["../src/worker-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AA03F3C;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAC/B,GAAG,MAAM,CAgPT;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IAC9B,KAAK,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;CACzB,GAAG,MAAM,CA4hBT"}
+{"version":3,"file":"worker-template.d.ts","sourceRoot":"","sources":["../src/worker-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AA23FxD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAC/B,GAAG,MAAM,CAoQT;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IAC9B,KAAK,CAAC,EAAE,IAAI,GAAG,WAAW,GAAG,SAAS,CAAA;CACvC,GAAG,MAAM,CAikBT"}

package/dist/worker-template.js

@@ -13,6 +13,7 @@
  * - POST /rpc or WebSocket upgrade - capnweb RPC to module exports
  * - GET / - Return info about available exports
  */
+import { generateDomainCheckCode } from './shared.js';
 /**
  * Generate SDK code for injection into sandbox
  *
@@ -2919,7 +2920,8 @@ function wrapScriptForReturn(script) {
         return script;
     const lastLine = lastLineRaw.trim();
     // If last line is an expression (not a declaration, control flow, or throw)
-    if (lastLine && !/^\s*(const|let|var|if|for|while|switch|try|class|function|return|throw)\b/.test(lastLine)) {
+    if (lastLine &&
+        !/^\s*(const|let|var|if|for|while|switch|try|class|function|return|throw)\b/.test(lastLine)) {
         lines[lines.length - 1] = `return ${lastLine.replace(/;?\s*$/, '')}`;
         return lines.join('\n');
     }
@@ -2930,7 +2932,7 @@ function wrapScriptForReturn(script) {
  */
 export function generateWorkerCode(options) {
     const { module: rawModule = '', tests = '', script: rawScript = '', sdk, imports = [] } = options;
-    const sdkConfig = sdk === true ? {} : (sdk || null);
+    const sdkConfig = sdk === true ? {} : sdk || null;
     const module = rawModule ? transformModuleCode(rawModule) : '';
     const script = rawScript ? wrapScriptForReturn(rawScript) : '';
     const exportNames = getExportNames(rawModule);
@@ -2938,7 +2940,7 @@ export function generateWorkerCode(options) {
     const hoistedImports = imports.length > 0 ? imports.join('\n') + '\n' : '';
     return `
 // Sandbox Worker Entry Point
-import { RpcTarget, newWorkersRpcResponse } from 'capnweb';
+import { RpcTarget, newWorkersRpcResponse } from 'capnweb.js';
 ${hoistedImports}
 const logs = [];
 
@@ -2968,20 +2970,24 @@ console.debug = captureConsole('debug');
 // Module exports object - exports become top-level variables
 const exports = {};
 
-${module ? `
+${module
+        ? `
 // Execute module code
 try {
 ${module}
 } catch (e) {
   console.error('Module error:', e.message);
 }
-` : '// No module code provided'}
+`
+        : '// No module code provided'}
 
 // Expose all exports as top-level variables for tests and scripts
 // This allows: export const add = (a, b) => a + b; then later: add(1, 2)
-${rawModule ? `
+${rawModule
+        ? `
 const { ${exportNames} } = exports;
-`.trim() : ''}
+`.trim()
+        : ''}
 
 // ============================================================
 // RPC SERVER - Expose exports via capnweb
@@ -3121,17 +3127,20 @@ export default {
     // USER TEST CODE (embedded at generation time)
     // ============================================================
 
-    ${tests ? `
+    ${tests
+        ? `
     // Register tests
     try {
 ${tests}
     } catch (e) {
       console.error('Test registration error:', e.message);
     }
-    ` : '// No test code provided'}
+    `
+        : '// No test code provided'}
 
     // Execute user script
-    ${script ? `
+    ${script
+        ? `
     try {
       scriptResult = await (async () => {
 ${script}
@@ -3140,17 +3149,20 @@ ${script}
       console.error('Script error:', e.message);
       scriptError = e.message;
     }
-    ` : '// No script code provided'}
+    `
+        : '// No script code provided'}
 
     // Run tests if any were registered
-    ${tests ? `
+    ${tests
+        ? `
     try {
       testResults = await testService.run();
     } catch (e) {
       console.error('Test run error:', e.message);
       testResults = { total: 0, passed: 0, failed: 1, skipped: 0, tests: [], duration: 0, error: e.message };
     }
-    ` : ''}
+    `
+        : ''}
 
     const hasTests = ${tests ? 'true' : 'false'};
     const success = scriptError === null && (!hasTests || (testResults && testResults.failed === 0));
@@ -3174,14 +3186,33 @@ ${script}
  * avoiding the need for RPC service bindings in local development.
  */
 export function generateDevWorkerCode(options) {
-    const { module: rawModule = '', tests = '', script: rawScript = '', sdk, imports = [], fetch: fetchOption } = options;
-    const sdkConfig = sdk === true ? {} : (sdk || null);
+    const { module: rawModule = '', tests = '', script: rawScript = '', sdk, imports = [], fetch: fetchOption, } = options;
+    const sdkConfig = sdk === true ? {} : sdk || null;
     const module = rawModule ? transformModuleCode(rawModule) : '';
     const script = rawScript ? wrapScriptForReturn(rawScript) : '';
     const exportNames = getExportNames(rawModule);
-    const blockFetch = fetchOption === null;
+    // Determine fetch handling mode
+    // - null or { mode: 'block' } -> block all network
+    // - { mode: 'allowlist', allowedDomains: [...] } -> domain filtering
+    // - undefined or { mode: 'allow' } -> allow all (no wrapper needed)
+    const blockFetch = fetchOption === null || (fetchOption && fetchOption.mode === 'block');
+    const useAllowlist = fetchOption && fetchOption.mode === 'allowlist' && fetchOption.allowedDomains;
     // Hoisted imports (from MDX test files) - placed at true module top level
     const hoistedImports = imports.length > 0 ? imports.join('\n') + '\n' : '';
+    // Generate fetch control code based on mode
+    let fetchControlCode = '';
+    if (blockFetch) {
+        fetchControlCode = `
+// Block fetch when fetch: null or mode: 'block' is specified
+const __originalFetch__ = globalThis.fetch;
+globalThis.fetch = async (...args) => {
+  throw new Error('Network access blocked: fetch is disabled in this sandbox');
+};
+`;
+    }
+    else if (useAllowlist) {
+        fetchControlCode = generateDomainCheckCode(fetchOption.allowedDomains);
+    }
     return `
 // Sandbox Worker Entry Point (Dev Mode - embedded test framework)
 ${hoistedImports}
@@ -3189,13 +3220,7 @@ const logs = [];
 const testResults = { total: 0, passed: 0, failed: 0, skipped: 0, tests: [], duration: 0 };
 const pendingTests = [];
 
-${blockFetch ? `
-// Block fetch when fetch: null is specified
-const __originalFetch__ = globalThis.fetch;
-globalThis.fetch = async (...args) => {
-  throw new Error('Network access blocked: fetch is disabled in this sandbox');
-};
-` : ''}
+${fetchControlCode}
 
 ${sdkConfig ? generateShouldCode() : ''}
 
@@ -3503,32 +3528,38 @@ const expect = (actual) => {
 // Module exports object - exports become top-level variables
 const exports = {};
 
-${module ? `
+${module
+        ? `
 // Execute module code
 try {
 ${module}
 } catch (e) {
   console.error('Module error:', e.message);
 }
-` : '// No module code provided'}
+`
+        : '// No module code provided'}
 
 // Expose all exports as top-level variables for tests and scripts
 // This allows: export const add = (a, b) => a + b; then later: add(1, 2)
-${rawModule ? `
+${rawModule
+        ? `
 const { ${exportNames} } = exports;
-`.trim() : ''}
+`.trim()
+        : ''}
 
 // ============================================================
 // USER TEST CODE (embedded at generation time)
 // ============================================================
-${tests ? `
+${tests
+        ? `
 // Register tests
 try {
 ${tests}
 } catch (e) {
   console.error('Test registration error:', e.message);
 }
-` : '// No test code provided'}
+`
+        : '// No test code provided'}
 
 // ============================================================
 // SIMPLE RPC HANDLER (dev mode - no capnweb dependency)
@@ -3629,7 +3660,8 @@ export default {
     let scriptError = null;
 
     // Execute user script
-    ${script ? `
+    ${script
+        ? `
     try {
       scriptResult = await (async () => {
 ${script}
@@ -3638,7 +3670,8 @@ ${script}
       console.error('Script error:', e.message);
       scriptError = e.message;
     }
-    ` : '// No script code provided'}
+    `
+        : '// No script code provided'}
 
     // Run all pending tests
     const testStart = Date.now();