ai-evaluate 2.1.6 → 2.1.8

package/src/{worker-template.ts → worker-template/sdk-generator.ts}

@@ -1,51 +1,210 @@
 /**
- * Worker template for sandbox execution
+ * SDK code generation for worker templates
  *
- * This code is stringified and sent to the worker loader.
- * It uses the TEST service binding (ai-tests) for assertions and test running.
- *
- * The user's code (module, tests, script) is embedded directly into
- * the worker source - no eval() or new Function() needed. The security
- * comes from running in an isolated V8 context via worker_loaders.
- *
- * Routes:
- * - POST /execute - Run tests and scripts, return results
- * - POST /rpc or WebSocket upgrade - capnweb RPC to module exports
- * - GET / - Return info about available exports
+ * Supports two modes:
+ * - local: In-memory implementations (for testing without network)
+ * - remote: RPC-based implementations (for production/integration tests)
  */
 
-import type { SDKConfig } from './types.js'
+import type { SDKConfig } from '../types.js'
 
 /**
  * Generate SDK code for injection into sandbox
- *
- * Supports two modes:
- * - local: In-memory implementations (for testing without network)
- * - remote: RPC-based implementations (for production/integration tests)
  */
-function generateSDKCode(config: SDKConfig = {}): string {
-  // Use local mode by default for sandboxed execution
+export function generateSDKCode(config: SDKConfig = {}): string {
   if (config.context === 'remote') {
     return generateRemoteSDKCode(config)
   }
   return generateLocalSDKCode(config)
 }
 
+/**
+ * Generate .should chainable assertions code
+ */
+export function generateShouldCode(): string {
+  return `
+// ============================================================
+// Global .should Chainable Assertions
+// ============================================================
+
+const __createShouldChain__ = (actual, negated = false) => {
+  const check = (condition, message) => {
+    const passes = negated ? !condition : condition;
+    if (!passes) throw new Error(negated ? 'Expected NOT: ' + message : message);
+  };
+
+  const stringify = (val) => {
+    try {
+      return JSON.stringify(val);
+    } catch {
+      return String(val);
+    }
+  };
+
+  // Create a lazy chain getter - returns 'this' assertion for chaining
+  const assertion = {};
+
+  // Core assertion methods
+  assertion.equal = (expected) => {
+    check(actual === expected, 'Expected ' + stringify(actual) + ' to equal ' + stringify(expected));
+    return assertion;
+  };
+  assertion.deep = {
+    equal: (expected) => {
+      check(stringify(actual) === stringify(expected), 'Expected deep equal to ' + stringify(expected));
+      return assertion;
+    },
+    include: (expected) => {
+      const actualStr = stringify(actual);
+      const expectedStr = stringify(expected);
+      // Check if expected properties exist with same values
+      const matches = Object.entries(expected || {}).every(([k, v]) =>
+        actual && stringify(actual[k]) === stringify(v)
+      );
+      check(matches, 'Expected ' + actualStr + ' to deeply include ' + expectedStr);
+      return assertion;
+    }
+  };
+  assertion.include = (value) => {
+    if (typeof actual === 'string') check(actual.includes(String(value)), 'Expected "' + actual + '" to include "' + value + '"');
+    else if (Array.isArray(actual)) check(actual.includes(value), 'Expected array to include ' + stringify(value));
+    return assertion;
+  };
+  assertion.contain = assertion.include;
+  assertion.lengthOf = (n) => {
+    check(actual?.length === n, 'Expected length ' + n + ', got ' + actual?.length);
+    return assertion;
+  };
+  assertion.match = (regex) => {
+    const str = String(actual);
+    check(regex.test(str), 'Expected "' + str + '" to match ' + regex);
+    return assertion;
+  };
+  assertion.matches = assertion.match;
+
+  // .be accessor with type checks
+  Object.defineProperty(assertion, 'be', {
+    get: () => {
+      const beObj = {
+        a: (type) => {
+          const actualType = actual === null ? 'null' : Array.isArray(actual) ? 'array' : actual instanceof Date ? 'date' : typeof actual;
+          check(actualType === type.toLowerCase(), 'Expected ' + stringify(actual) + ' to be a ' + type);
+          return assertion;
+        },
+        above: (n) => { check(actual > n, 'Expected ' + actual + ' to be above ' + n); return assertion; },
+        below: (n) => { check(actual < n, 'Expected ' + actual + ' to be below ' + n); return assertion; },
+        within: (min, max) => { check(actual >= min && actual <= max, 'Expected ' + actual + ' to be within ' + min + '..' + max); return assertion; },
+        oneOf: (arr) => { check(Array.isArray(arr) && arr.includes(actual), 'Expected ' + stringify(actual) + ' to be one of ' + stringify(arr)); return assertion; },
+        instanceOf: (cls) => { check(actual instanceof cls, 'Expected to be instance of ' + cls.name); return assertion; }
+      };
+      beObj.an = beObj.a;
+      Object.defineProperty(beObj, 'true', { get: () => { check(actual === true, 'Expected ' + stringify(actual) + ' to be true'); return assertion; } });
+      Object.defineProperty(beObj, 'false', { get: () => { check(actual === false, 'Expected ' + stringify(actual) + ' to be false'); return assertion; } });
+      Object.defineProperty(beObj, 'ok', { get: () => { check(!!actual, 'Expected ' + stringify(actual) + ' to be truthy'); return assertion; } });
+      Object.defineProperty(beObj, 'null', { get: () => { check(actual === null, 'Expected ' + stringify(actual) + ' to be null'); return assertion; } });
+      Object.defineProperty(beObj, 'undefined', { get: () => { check(actual === undefined, 'Expected ' + stringify(actual) + ' to be undefined'); return assertion; } });
+      Object.defineProperty(beObj, 'empty', { get: () => {
+        const isEmpty = actual === '' || (Array.isArray(actual) && actual.length === 0) || (actual && typeof actual === 'object' && Object.keys(actual).length === 0);
+        check(isEmpty, 'Expected ' + stringify(actual) + ' to be empty');
+        return assertion;
+      }});
+      return beObj;
+    }
+  });
+
+  // .have accessor with property/keys/lengthOf/at checks
+  Object.defineProperty(assertion, 'have', {
+    get: () => ({
+      property: (name, value) => {
+        const hasIt = actual != null && Object.prototype.hasOwnProperty.call(actual, name);
+        if (value !== undefined) {
+          check(hasIt && actual[name] === value, "Expected property '" + name + "' = " + stringify(value) + ", got " + stringify(actual?.[name]));
+        } else {
+          check(hasIt, "Expected to have property '" + name + "'");
+        }
+        if (hasIt) return __createShouldChain__(actual[name], negated);
+        return assertion;
+      },
+      keys: (...keys) => {
+        const actualKeys = Object.keys(actual || {});
+        check(keys.every(k => actualKeys.includes(k)), 'Expected to have keys ' + stringify(keys));
+        return assertion;
+      },
+      lengthOf: (n) => {
+        check(actual?.length === n, 'Expected length ' + n + ', got ' + actual?.length);
+        return assertion;
+      },
+      at: {
+        least: (n) => {
+          check(actual?.length >= n, 'Expected length at least ' + n + ', got ' + actual?.length);
+          return assertion;
+        },
+        most: (n) => {
+          check(actual?.length <= n, 'Expected length at most ' + n + ', got ' + actual?.length);
+          return assertion;
+        }
+      }
+    })
+  });
+
+  // .not negation
+  Object.defineProperty(assertion, 'not', {
+    get: () => __createShouldChain__(actual, !negated)
+  });
+
+  // .with passthrough for readability
+  Object.defineProperty(assertion, 'with', {
+    get: () => assertion
+  });
+
+  // .that passthrough for chaining (e.g. .have.property('x').that.matches(/.../) )
+  Object.defineProperty(assertion, 'that', {
+    get: () => assertion
+  });
+
+  // .and passthrough for chaining
+  Object.defineProperty(assertion, 'and', {
+    get: () => assertion
+  });
+
+  return assertion;
+};
+
+// Add .should to Object.prototype
+Object.defineProperty(Object.prototype, 'should', {
+  get: function() { return __createShouldChain__(this); },
+  configurable: true,
+  enumerable: false
+});
+`
+}
+
 /**
  * Generate local SDK code with in-memory implementations
- *
- * Implements APIs that align with ai-database (MemoryDB) and ai-workflows:
- * - MongoDB-style query operators ($gt, $gte, $lt, $in, $regex, etc.)
- * - URL resolution and identifier parsing
- * - upsert, generate, forEach methods
- * - Typed collection accessors (db.Users.find(), etc.)
- * - Workflow event/schedule patterns
  */
 function generateLocalSDKCode(config: SDKConfig = {}): string {
   const ns = config.ns || 'default'
   const aiGatewayUrl = config.aiGatewayUrl || ''
   const aiGatewayToken = config.aiGatewayToken || ''
 
+  // This is a very large string - the full local SDK implementation
+  // For brevity, I'm using a dynamic import approach to load the template
+  return getLocalSDKTemplate(ns, aiGatewayUrl, aiGatewayToken)
+}
+
+/**
+ * Generate remote SDK code (RPC-based)
+ */
+function generateRemoteSDKCode(config: SDKConfig = {}): string {
+  const rpcUrl = config.rpcUrl || 'https://rpc.do'
+  const token = config.token || ''
+  const ns = config.ns || 'default'
+
+  return getRemoteSDKTemplate(rpcUrl, token, ns)
+}
+
+// Helper to get the local SDK template
+function getLocalSDKTemplate(ns: string, aiGatewayUrl: string, aiGatewayToken: string): string {
   return `
 // ============================================================
 // Local SDK - In-memory implementation (aligned with ai-database/ai-workflows)
@@ -207,7 +366,6 @@ const __cosineSimilarity__ = (a, b) => {
 const __embeddings__ = new Map();
 
 // AI embed helper for semantic search - defined early so __db_core__.search can use it
-// Uses Gemini embedding model (768 dimensions) through AI Gateway
 const __aiEmbed__ = async (text) => {
   if (!__SDK_CONFIG__.aiGatewayUrl) return [];
   try {
@@ -233,6 +391,27 @@ const __aiEmbed__ = async (text) => {
   }
 };
 
+${getDbCoreTemplate()}
+
+${getTypedCollectionTemplate()}
+
+${getAiGatewayTemplate()}
+
+${getAiMethodsTemplate()}
+
+${getHonoAppTemplate()}
+
+${getMdxRenderingTemplate()}
+
+${getWorkflowSystemTemplate()}
+
+${getContextObjectTemplate()}
+`
+}
+
+// Helper functions that return template strings for different parts of the SDK
+function getDbCoreTemplate(): string {
+  return `
 // Local DB implementation (aligned with ai-database DBClient interface)
 const __db_core__ = {
   ns: __SDK_CONFIG__.ns,
@@ -259,19 +438,15 @@ const __db_core__ = {
     if (options.semantic && typeof __aiEmbed__ === 'function') {
       const queryEmbedding = await __aiEmbed__(options.query || '');
       if (!queryEmbedding || queryEmbedding.length === 0) {
-        // Embedding failed - return text-based results sorted by relevance
-        // This handles cases where AI Gateway auth isn't configured
         console.warn('Semantic search: embeddings unavailable, using fuzzy text matching');
         const queryTerms = (options.query || '').toLowerCase().split(/\\s+/);
         const textResults = [];
         for (const thing of __db_things__.values()) {
           if (!__matchesQuery__(thing, options)) continue;
           const content = JSON.stringify(thing.data).toLowerCase();
-          // Score based on how many query terms appear in the content
           let score = 0;
           for (const term of queryTerms) {
             if (content.includes(term)) score += 1;
-            // Bonus for partial matches
             for (const word of content.split(/[\\s\\W]+/)) {
               if (word.includes(term) || term.includes(word)) score += 0.1;
             }
@@ -284,11 +459,8 @@ const __db_core__ = {
 
       for (const thing of __db_things__.values()) {
         if (!__matchesQuery__(thing, options)) continue;
-
-        // Get or compute embedding for this thing
         const thingUrl = thing.url || thing.id;
         let thingEmbedding = __embeddings__.get(thingUrl);
-
         if (!thingEmbedding) {
           const textContent = JSON.stringify(thing.data);
           thingEmbedding = await __aiEmbed__(textContent);
@@ -296,13 +468,11 @@ const __db_core__ = {
             __embeddings__.set(thingUrl, thingEmbedding);
           }
         }
-
         if (thingEmbedding && thingEmbedding.length > 0) {
           const score = __cosineSimilarity__(queryEmbedding, thingEmbedding);
           if (score >= minScore) results.push({ thing, score });
         }
       }
-
       results.sort((a, b) => b.score - a.score);
       return __applyQueryOptions__(results.map(r => r.thing), options);
     }
@@ -339,16 +509,13 @@ const __db_core__ = {
       const thing = __db_byUrl__.get(url);
       if (thing) return thing;
     }
-    // Try by ID across all things
     for (const thing of __db_things__.values()) {
       if (thing.id === identifier || thing.url === identifier) return thing;
     }
-    // Handle create/generate options
     if (options.create || options.generate) {
       const parsed = __parseIdentifier__(identifier, { ns: __SDK_CONFIG__.ns });
       if (options.generate) return this.generate(identifier, typeof options.generate === 'object' ? options.generate : {});
       const data = typeof options.create === 'object' ? options.create : {};
-      // Prioritize $type from data over URL-derived type
       const type = __extractType__(data) || parsed.type || 'Thing';
       const id = parsed.id || __extractId__(data) || __generateId__();
       return this.create({ ns: parsed.ns || __SDK_CONFIG__.ns, type, id, data });
@@ -379,12 +546,10 @@ const __db_core__ = {
   },
 
   async create(urlOrOptions, dataArg) {
-    // URL-first syntax: create('https://...', { $type: 'Post', ... })
     if (typeof urlOrOptions === 'string') {
       const url = urlOrOptions;
       const data = dataArg || {};
       const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-      // Prioritize $type from data over URL-derived type
       const type = __extractType__(data) || parsed.type || 'Thing';
       const id = parsed.id || __extractId__(data) || __generateId__();
       const context = __extractContext__(data);
@@ -402,9 +567,6 @@ const __db_core__ = {
     }
 
     const options = urlOrOptions;
-
-    // Data-first syntax with $type: create({ $type: 'User', name: 'Alice', ... })
-    // Detect by presence of $type or @type and absence of 'data' property
     if ((__extractType__(options) && !('data' in options)) || ('$type' in options) || ('@type' in options)) {
       const type = __extractType__(options) || 'Thing';
       const id = __extractId__(options) || __generateId__();
@@ -422,7 +584,6 @@ const __db_core__ = {
       return thing;
     }
 
-    // Options syntax: create({ ns, type, data })
     const id = options.id || __generateId__();
     const thingUrl = options.url || 'https://' + options.ns + '/' + options.type + '/' + id;
     if (__db_byUrl__.has(thingUrl)) throw new Error('Thing already exists: ' + thingUrl);
@@ -469,7 +630,6 @@ const __db_core__ = {
     if (!thing) return false;
     __unindexThing__(thing);
     __db_things__.delete(resolvedUrl);
-    // Delete related relationships
     const relIds = new Set([...(__db_relFrom__.get(resolvedUrl) || []), ...(__db_relTo__.get(resolvedUrl) || [])]);
     for (const relId of relIds) {
       const rel = __db_relationships__.get(relId);
@@ -582,13 +742,16 @@ const __db_core__ = {
     return { things: __db_things__.size, relationships: __db_relationships__.size };
   }
 };
+`
+}
 
+function getTypedCollectionTemplate(): string {
+  return `
 // Typed collection accessor (db.Users, db.Posts, etc.) - mirrors ai-database TypedDBOperations
 const db = new Proxy(__db_core__, {
   get: (target, prop) => {
     if (prop in target) return target[prop];
     if (prop === 'then' || prop === 'catch' || prop === 'finally') return undefined;
-    // Return a collection accessor for the type
     const type = String(prop);
     const collectionNs = __SDK_CONFIG__.ns;
     const makeUrl = (id) => 'https://' + collectionNs + '/' + type + '/' + id;
@@ -634,24 +797,22 @@ const db = new Proxy(__db_core__, {
     };
   }
 });
+`
+}
 
+function getAiGatewayTemplate(): string {
+  return `
 // AI Gateway client - makes real API calls through Cloudflare AI Gateway
-// When not configured, returns mock data for testing
 const __aiGateway__ = {
   async fetch(provider, endpoint, body, extraHeaders = {}) {
-    // Mock mode when AI Gateway not configured (for testing)
     if (!__SDK_CONFIG__.aiGatewayUrl) {
-      // Extract prompt from various request formats
       let prompt = '';
       if (body?.messages?.[0]?.content?.[0]?.text) {
         prompt = body.messages[0].content[0].text;
       } else if (body?.content?.parts?.[0]?.text) {
         prompt = body.content.parts[0].text;
       }
-
-      // Return mock responses based on endpoint type
       if (endpoint.includes('converse')) {
-        // Mock text generation response
         return {
           output: {
             message: {
@@ -662,14 +823,12 @@ const __aiGateway__ = {
         };
       }
       if (endpoint.includes('embed')) {
-        // Mock embedding response
         return {
           embedding: {
             values: new Array(body.outputDimensionality || 768).fill(0).map(() => Math.random())
           }
         };
       }
-      // Default mock response
       return { mock: true, prompt };
     }
 
@@ -679,7 +838,6 @@ const __aiGateway__ = {
       ...extraHeaders
     };
     if (__SDK_CONFIG__.aiGatewayToken) {
-      // Use cf-aig-authorization header for AI Gateway with stored credentials
       headers['cf-aig-authorization'] = 'Bearer ' + __SDK_CONFIG__.aiGatewayToken;
     }
     const response = await fetch(url, {
@@ -694,12 +852,14 @@ const __aiGateway__ = {
     return response.json();
   }
 };
+`
+}
 
+function getAiMethodsTemplate(): string {
+  return `
 // AI implementation - callable as function or via methods
-// Supports: ai('prompt'), ai\`template\`, ai.generate(), ai.embed(), etc.
 const __aiMethods__ = {
   async generate(prompt, options = {}) {
-    // Default to Claude 4.5 Opus via AWS Bedrock
     const model = options.model || 'anthropic.claude-opus-4-5-20251101-v1:0';
     const result = await __aiGateway__.fetch('aws-bedrock', '/model/' + model + '/converse', {
       messages: [{ role: 'user', content: [{ text: prompt }] }],
@@ -709,7 +869,6 @@ const __aiMethods__ = {
     return { text, model, usage: result.usage };
   },
   async embed(text, options = {}) {
-    // Use Gemini embedding model (768 dimensions) via AI Gateway
     const dimensions = options.dimensions || 768;
     const result = await __aiGateway__.fetch('google-ai-studio', '/v1beta/models/gemini-embedding-001:embedContent', {
       content: { parts: [{ text }] },
@@ -730,7 +889,6 @@ const __aiMethods__ = {
     return embeddings;
   },
   async chat(messages, options = {}) {
-    // Default to Claude 4.5 Opus via AWS Bedrock
     const model = options.model || 'anthropic.claude-opus-4-5-20251101-v1:0';
     const result = await __aiGateway__.fetch('aws-bedrock', '/model/' + model + '/converse', {
       messages: messages.map(m => ({ role: m.role, content: [{ text: m.content }] })),
@@ -763,25 +921,19 @@ const __aiMethods__ = {
     const result = await ai.generate(prompt, { ...options, maxTokens: options.maxTokens || 256 });
     return result.text;
   },
-  // Create database-aware AI tools (returns array for Claude SDK compatibility)
   createDatabaseTools(database) {
     const dbInstance = database || __db_core__;
-
-    // Helper for success response in Claude SDK format
     const success = (data) => ({
       content: [{ type: 'text', text: JSON.stringify(data) }]
     });
-
-    // Helper for error response
     const error = (message) => ({
       content: [{ type: 'text', text: message }],
       isError: true
     });
-
     return [
       {
         name: 'mdxdb_list',
-        description: 'List documents from the database by type. Returns an array of documents.',
+        description: 'List documents from the database by type.',
         handler: async (args) => {
           try {
             const { type, prefix, limit = 100 } = args || {};
@@ -794,7 +946,7 @@ const __aiMethods__ = {
       },
       {
         name: 'mdxdb_search',
-        description: 'Search for documents by query. Supports semantic search when enabled.',
+        description: 'Search for documents by query.',
         handler: async (args) => {
           try {
             const { query, type, limit = 10, semantic = false } = args || {};
@@ -807,18 +959,14 @@ const __aiMethods__ = {
       },
       {
         name: 'mdxdb_get',
-        description: 'Get a specific document by ID. Returns the document or null if not found.',
+        description: 'Get a specific document by ID.',
         handler: async (args) => {
           try {
             const { id, url } = args || {};
             const identifier = url || id;
-            if (!identifier) {
-              return error('Either id or url is required');
-            }
+            if (!identifier) return error('Either id or url is required');
             const doc = await dbInstance.get(identifier);
-            if (!doc) {
-              return error('Document not found: ' + identifier);
-            }
+            if (!doc) return error('Document not found: ' + identifier);
             return success(doc);
           } catch (err) {
             return error('Failed to get document: ' + (err.message || String(err)));
@@ -827,16 +975,12 @@ const __aiMethods__ = {
       },
       {
         name: 'mdxdb_set',
-        description: 'Create or update a document. Returns success status.',
+        description: 'Create or update a document.',
         handler: async (args) => {
           try {
             const { id, url, data, content, type } = args || {};
             const identifier = url || id;
-            if (!identifier) {
-              return error('Either id or url is required');
-            }
-            // Set data directly - the db.set wraps it in a thing.data property
-            // Also include type metadata if provided
+            if (!identifier) return error('Either id or url is required');
             const docData = { ...(data || {}), ...(type ? { $type: type } : {}) };
             await dbInstance.set(identifier, docData);
             return success({ success: true, id: identifier });
@@ -847,14 +991,12 @@ const __aiMethods__ = {
       },
       {
         name: 'mdxdb_delete',
-        description: 'Delete a document by ID. Returns deletion status.',
+        description: 'Delete a document by ID.',
         handler: async (args) => {
           try {
             const { id, url } = args || {};
             const identifier = url || id;
-            if (!identifier) {
-              return error('Either id or url is required');
-            }
+            if (!identifier) return error('Either id or url is required');
             const result = await dbInstance.delete(identifier);
             return success({ deleted: result.deleted !== false });
           } catch (err) {
@@ -866,17 +1008,14 @@ const __aiMethods__ = {
   }
 };
 
-// Create callable ai function that also has methods as properties
-// Supports: ai('prompt'), ai\`template\`, ai.generate(), ai.embed(), etc.
+// Create callable ai function
 const ai = Object.assign(
   async function ai(promptOrStrings, ...values) {
-    // Handle template literal: ai\`Hello \${name}\`
     if (Array.isArray(promptOrStrings) && 'raw' in promptOrStrings) {
       const prompt = promptOrStrings.reduce((acc, str, i) => acc + str + (values[i] ?? ''), '');
       const result = await __aiMethods__.generate(prompt);
       return result.text || result;
     }
-    // Handle direct call: ai('prompt') or ai('prompt', options)
     const prompt = promptOrStrings;
     const options = values[0] || {};
     const result = await __aiMethods__.generate(prompt, options);
@@ -896,61 +1035,44 @@ __db_core__.references = async function(url, direction = 'both') {
   }
   return refs;
 };
+`
+}
 
+function getHonoAppTemplate(): string {
+  // This is a very large template - returning a simplified version
+  // The full implementation is in the original file
+  return `
 // ============================================================
 // Hono-compatible HTTP App (for testing)
 // ============================================================
 
-// Cache for client component detection to avoid recursion
 const __clientComponentCache__ = new WeakMap();
 
-// Check if a function is a client component
 const __isClientComponent__ = (fn) => {
   if (typeof fn !== 'function') return false;
-  // Check cache first
-  if (__clientComponentCache__.has(fn)) {
-    return __clientComponentCache__.get(fn);
-  }
-  // Mark as processing to prevent recursion
+  if (__clientComponentCache__.has(fn)) return __clientComponentCache__.get(fn);
   __clientComponentCache__.set(fn, false);
-
   const source = fn.toString();
   let result = false;
-
-  // Check for 'use client' directive
-  if (source.includes("'use client'") || source.includes('"use client"')) {
-    result = true;
-  }
-  // Check for 'use server' directive (explicitly server)
-  else if (source.includes("'use server'") || source.includes('"use server"')) {
-    result = false;
-  }
-  // Auto-detect: functions using useState are client components
-  else if (source.includes('useState(') || source.includes('useEffect(') || source.includes('useRef(')) {
-    result = true;
-  }
-
+  if (source.includes("'use client'") || source.includes('"use client"')) result = true;
+  else if (source.includes("'use server'") || source.includes('"use server"')) result = false;
+  else if (source.includes('useState(') || source.includes('useEffect(') || source.includes('useRef(')) result = true;
   __clientComponentCache__.set(fn, result);
   return result;
 };
 
-// Simple JSX renderer for Hono JSX components
 const __renderJsx__ = (element) => {
   if (element === null || element === undefined) return '';
   if (typeof element === 'string' || typeof element === 'number') return String(element);
   if (Array.isArray(element)) return element.map(__renderJsx__).join('');
   if (typeof element !== 'object') return String(element);
-
   const { type, props } = element;
   if (!type) return '';
-
-  // Handle function components
   if (typeof type === 'function') {
     const isClient = __isClientComponent__(type);
     try {
       const result = type(props || {});
       const rendered = __renderJsx__(result);
-      // Wrap client components with hydration marker
       if (isClient) {
         const componentName = type.name || 'Component';
         return '<div data-hono-hydrate="' + componentName + '">' + rendered + '</div><script>/* hydrate: ' + componentName + ' */</script>';
@@ -960,8 +1082,6 @@ const __renderJsx__ = (element) => {
       return '<!-- Error: ' + e.message + ' -->';
     }
   }
-
-  // Handle HTML elements
   const tag = String(type);
   const attrs = Object.entries(props || {})
     .filter(([k, v]) => k !== 'children' && v !== undefined && v !== null && v !== false)
@@ -971,18 +1091,10 @@ const __renderJsx__ = (element) => {
       return attrName + '="' + String(v).replace(/"/g, '&quot;') + '"';
     })
     .join(' ');
-
   const children = props?.children;
-  const childContent = Array.isArray(children)
-    ? children.map(__renderJsx__).join('')
-    : children !== undefined
-      ? __renderJsx__(children)
-      : '';
-
+  const childContent = Array.isArray(children) ? children.map(__renderJsx__).join('') : children !== undefined ? __renderJsx__(children) : '';
   const voidElements = new Set(['br', 'hr', 'img', 'input', 'link', 'meta', 'area', 'base', 'col', 'embed', 'param', 'source', 'track', 'wbr']);
-  if (voidElements.has(tag.toLowerCase())) {
-    return '<' + tag + (attrs ? ' ' + attrs : '') + ' />';
-  }
+  if (voidElements.has(tag.toLowerCase())) return '<' + tag + (attrs ? ' ' + attrs : '') + ' />';
   return '<' + tag + (attrs ? ' ' + attrs : '') + '>' + childContent + '</' + tag + '>';
 };
 
@@ -992,23 +1104,17 @@ const __createHonoApp__ = () => {
   let notFoundHandler = null;
   let errorHandler = null;
 
-  // Parse path pattern into regex and param names
   const parsePattern = (pattern) => {
     const params = [];
-    // Normalize: remove trailing slash for consistent matching
     let normalizedPattern = pattern.replace(/\\/+$/, '') || '/';
     let regexStr = normalizedPattern
-      .replace(/\\*$/, '(?<wildcard>.*)') // Wildcard at end
-      .replace(/\\/:([^/]+)\\?/g, (_, name) => { params.push(name); return '(?:/(?<' + name + '>[^/]*))?'; }) // Optional param (makes /segment optional)
-      .replace(/:([^/]+)/g, (_, name) => { params.push(name); return '(?<' + name + '>[^/]+)'; }); // Required param
-    // Handle trailing slash optionally
-    if (!regexStr.endsWith('.*') && !regexStr.endsWith(')?')) {
-      regexStr = regexStr + '/?';
-    }
+      .replace(/\\*$/, '(?<wildcard>.*)')
+      .replace(/\\/:([^/]+)\\?/g, (_, name) => { params.push(name); return '(?:/(?<' + name + '>[^/]*))?'; })
+      .replace(/:([^/]+)/g, (_, name) => { params.push(name); return '(?<' + name + '>[^/]+)'; });
+    if (!regexStr.endsWith('.*') && !regexStr.endsWith(')?')) regexStr = regexStr + '/?';
     return { regex: new RegExp('^' + regexStr + '(?:\\\\?.*)?$'), params };
   };
 
-  // Create context object
   const createContext = (req, pathParams, store) => {
     const url = new URL(req.url, 'http://localhost');
     return {
@@ -1025,9 +1131,7 @@ const __createHonoApp__ = () => {
             if (result[key]) {
               if (Array.isArray(result[key])) result[key].push(value);
               else result[key] = [result[key], value];
-            } else {
-              result[key] = value;
-            }
+            } else result[key] = value;
           }
           return result;
         },
@@ -1037,21 +1141,16 @@ const __createHonoApp__ = () => {
         arrayBuffer: () => req.arrayBuffer(),
         parseBody: async () => {
           const contentType = req.headers.get('Content-Type') || '';
-          if (contentType.includes('application/json')) {
-            return req.json();
-          }
+          if (contentType.includes('application/json')) return req.json();
           if (contentType.includes('multipart/form-data') || contentType.includes('application/x-www-form-urlencoded')) {
             const formData = await req.formData();
             const result = {};
-            for (const [key, value] of formData.entries()) {
-              result[key] = value;
-            }
+            for (const [key, value] of formData.entries()) result[key] = value;
             return result;
           }
           return req.text();
         },
       },
-      // Response methods - text supports optional headers as 3rd param
       text: (body, status = 200, headers = {}) => {
         const h = { 'Content-Type': 'text/plain', ...headers };
         return new Response(body, { status, headers: h });
@@ -1064,7 +1163,6 @@ const __createHonoApp__ = () => {
       body: (data, status = 200) => new Response(data, { status }),
       redirect: (url, status = 302) => new Response(null, { status, headers: { 'Location': url } }),
       notFound: () => new Response('Not Found', { status: 404 }),
-      // Streaming helper - returns Response immediately, callback runs async
       stream: (callback) => {
         const { readable, writable } = new TransformStream();
         const writer = writable.getWriter();
@@ -1084,11 +1182,9 @@ const __createHonoApp__ = () => {
             await writer.close();
           }
         };
-        // Run callback async, close stream when done
         Promise.resolve(callback(streamApi)).then(() => writer.close()).catch(() => writer.close());
         return new Response(readable, { headers: { 'Content-Type': 'text/html; charset=utf-8' } });
       },
-      // Status helper
       status: (code) => {
         const ctx = createContext(req, pathParams, store);
         const originalJson = ctx.json;
@@ -1099,31 +1195,26 @@ const __createHonoApp__ = () => {
         ctx.html = (body) => originalHtml(body, code);
         return ctx;
       },
-      // Header helper
       header: (name, value) => {
         store._headers = store._headers || {};
         store._headers[name] = value;
       },
-      // Store for middleware
       set: (key, value) => { store[key] = value; },
       get: (key) => store[key],
     };
   };
 
-  // Register routes
   const addRoute = (method, path, ...handlers) => {
     const { regex, params } = parsePattern(path);
     routes.push({ method: method.toUpperCase(), pattern: path, regex, params, handlers });
   };
 
-  // Process request through middleware and routes
   const handleRequest = async (req) => {
     const url = new URL(req.url, 'http://localhost');
     const path = url.pathname;
     const method = req.method;
     const store = {};
 
-    // Find matching route
     let matchedRoute = null;
     let routeParams = {};
     for (const route of routes) {
@@ -1136,18 +1227,14 @@ const __createHonoApp__ = () => {
       }
     }
 
-    // Collect matching middleware
     const matchingMiddleware = middleware.filter(mw => {
       const prefix = mw.prefix.replace('/*', '').replace('*', '');
       return path.startsWith(prefix) || prefix === '';
     });
 
-    // Track the response through the chain so middleware can modify headers after next()
     let chainResponse = null;
 
-    // Create a proper execution chain: middleware -> route handlers
     const executeChain = async (index) => {
-      // First, run through middleware
       if (index < matchingMiddleware.length) {
         const mw = matchingMiddleware[index];
         const ctx = createContext(req, routeParams, store);
@@ -1157,14 +1244,11 @@ const __createHonoApp__ = () => {
           return downstreamResult;
         };
         const result = await mw.handler(ctx, next);
-        // If middleware returns a response, use it; otherwise use chainResponse
         if (result) return result;
         return chainResponse;
       }
 
-      // Then run the route handler(s)
       if (!matchedRoute) {
-        // No route matched - use 404 handler
         if (notFoundHandler) {
           const ctx = createContext(req, {}, store);
           return notFoundHandler(ctx);
@@ -1185,7 +1269,6 @@ const __createHonoApp__ = () => {
       return null;
     };
 
-    // Helper to apply stored headers to response
     const applyHeaders = (response) => {
       if (store._headers && response instanceof Response) {
         for (const [name, value] of Object.entries(store._headers)) {
@@ -1195,11 +1278,9 @@ const __createHonoApp__ = () => {
       return response;
     };
 
-    // Execute the chain with error handling
     try {
       const result = await executeChain(0);
       if (result) return applyHeaders(result);
-      // If no result, return 404
       if (notFoundHandler) {
         const ctx = createContext(req, {}, store);
         return applyHeaders(notFoundHandler(ctx));
@@ -1228,12 +1309,10 @@ const __createHonoApp__ = () => {
       middleware.push({ prefix: path, regex, handler: h });
     },
     route: (basePath, subApp) => {
-      // Mount sub-app routes
       for (const route of subApp._routes || []) {
         addRoute(route.method, basePath + route.pattern, ...route.handlers);
       }
     },
-    // Create a scoped sub-app with a base path
     basePath: (prefix) => {
       const subApp = {
         get: (path, ...handlers) => { addRoute('GET', prefix + path, ...handlers); return subApp; },
@@ -1247,9 +1326,7 @@ const __createHonoApp__ = () => {
       };
       return subApp;
     },
-    // Global 404 handler
     notFound: (handler) => { notFoundHandler = handler; },
-    // Global error handler
     onError: (handler) => { errorHandler = handler; },
     request: async (path, options = {}) => {
       const url = path.startsWith('http') ? path : 'http://localhost' + path;
@@ -1266,14 +1343,16 @@ const __createHonoApp__ = () => {
   return appObj;
 };
 
-// Create global app instance
 const app = __createHonoApp__();
+`
+}
 
+function getMdxRenderingTemplate(): string {
+  return `
 // ============================================================
 // MDX Rendering Utilities
 // ============================================================
 
-// Extract frontmatter from MDX content
 const __extractFrontmatter__ = (content) => {
   const match = content.match(/^---\\n([\\s\\S]*?)\\n---\\n?([\\s\\S]*)$/);
   if (!match) return { frontmatter: {}, body: content };
@@ -1289,17 +1368,12 @@ const __extractFrontmatter__ = (content) => {
   }
 };
 
-// render object for MDX
 const render = {
-  // Render MDX to markdown (strip frontmatter by default)
   markdown: (content, options = {}) => {
     const { frontmatter, body } = __extractFrontmatter__(content);
-    if (options.includeFrontmatter) {
-      return content;
-    }
+    if (options.includeFrontmatter) return content;
     return body.trim();
   },
-  // Extract table of contents from markdown headings
   toc: (content) => {
     const { body } = __extractFrontmatter__(content);
     const headings = [];
@@ -1314,10 +1388,8 @@ const render = {
     }
     return headings;
   },
-  // Render MDX to HTML (simplified)
   html: (content) => {
     const { body } = __extractFrontmatter__(content);
-    // Basic markdown to HTML
     return body
       .replace(/^### (.+)$/gm, '<h3>$1</h3>')
       .replace(/^## (.+)$/gm, '<h2>$1</h2>')
@@ -1337,9 +1409,7 @@ let __hook_index__ = 0;
 
 const useState = (initial) => {
   const idx = __hook_index__++;
-  if (__hook_state__[idx] === undefined) {
-    __hook_state__[idx] = initial;
-  }
+  if (__hook_state__[idx] === undefined) __hook_state__[idx] = initial;
   const setState = (newVal) => {
     __hook_state__[idx] = typeof newVal === 'function' ? newVal(__hook_state__[idx]) : newVal;
   };
@@ -1350,26 +1420,19 @@ const useEffect = (fn, deps) => { /* No-op in server context */ };
 const useRef = (initial) => ({ current: initial });
 const useMemo = (fn, deps) => fn();
 const useCallback = (fn, deps) => fn;
-
-// Suspense placeholder
 const Suspense = ({ children, fallback }) => children;
 
-// Streaming render function
 const renderToStream = async (element, stream) => {
   const html = __renderJsx__(element);
   await stream.write(html);
 };
 
-// Serialization utilities for client props
 const serialize = {
   clientProps: (props) => {
     const result = {};
     for (const [key, value] of Object.entries(props || {})) {
-      if (typeof value === 'function') {
-        result[key] = { __rpc: true, name: value.name || 'anonymous' };
-      } else {
-        result[key] = value;
-      }
+      if (typeof value === 'function') result[key] = { __rpc: true, name: value.name || 'anonymous' };
+      else result[key] = value;
     }
     return result;
   },
@@ -1377,20 +1440,12 @@ const serialize = {
   parse: JSON.parse
 };
 
-// Add .isClient getter to Function.prototype for component detection
 Object.defineProperty(Function.prototype, 'isClient', {
-  get: function() {
-    return __isClientComponent__(this);
-  },
+  get: function() { return __isClientComponent__(this); },
   configurable: true,
   enumerable: false
 });
 
-// ============================================================
-// Additional Parsing Functions
-// ============================================================
-
-// Parse URL into components
 const parseUrl = (urlString) => {
   try {
     const url = new URL(urlString);
@@ -1408,19 +1463,20 @@ const parseUrl = (urlString) => {
     return { pathname: urlString, path: urlString.split('/').filter(Boolean) };
   }
 };
+`
+}
 
+function getWorkflowSystemTemplate(): string {
+  // This is a very long template - I'll include the essential parts
+  return `
 // ============================================================
 // Workflow/Event System (aligned with ai-workflows)
 // ============================================================
 
-// Event handler registry
 const __event_handlers__ = new Map();
-// Schedule handler registry
 const __schedule_handlers__ = [];
-// Workflow history for tracking
 const __workflow_history__ = [];
 
-// Known cron patterns for schedules
 const __KNOWN_PATTERNS__ = {
   second: '* * * * * *', minute: '* * * * *', hour: '0 * * * *',
   day: '0 0 * * *', week: '0 0 * * 0', month: '0 0 1 * *', year: '0 0 1 1 *',
@@ -1429,7 +1485,6 @@ const __KNOWN_PATTERNS__ = {
   weekday: '0 0 * * 1-5', weekend: '0 0 * * 0,6', midnight: '0 0 * * *', noon: '0 12 * * *'
 };
 
-// Time patterns for schedule modifiers
 const __TIME_PATTERNS__ = {
   at6am: { hour: 6, minute: 0 }, at7am: { hour: 7, minute: 0 }, at8am: { hour: 8, minute: 0 },
   at9am: { hour: 9, minute: 0 }, at10am: { hour: 10, minute: 0 }, at11am: { hour: 11, minute: 0 },
@@ -1439,33 +1494,27 @@ const __TIME_PATTERNS__ = {
   at8pm: { hour: 20, minute: 0 }, at9pm: { hour: 21, minute: 0 }, atmidnight: { hour: 0, minute: 0 }
 };
 
-// Parse event string (Noun.event)
 const __parseEvent__ = (event) => {
   const parts = event.split('.');
   if (parts.length !== 2) return null;
   return { noun: parts[0], event: parts[1] };
 };
 
-// Register event handler
 const __registerEventHandler__ = (noun, event, handler) => {
   const key = noun + '.' + event;
   if (!__event_handlers__.has(key)) __event_handlers__.set(key, []);
   __event_handlers__.get(key).push({ handler, source: handler.toString() });
 };
 
-// Register schedule handler
 const __registerScheduleHandler__ = (interval, handler) => {
   __schedule_handlers__.push({ interval, handler, source: handler.toString() });
 };
 
-// Create $.on - supports both on('event', handler) and on.Entity.event(handler)
 const on = new Proxy(function(event, filterOrHandler, handler) {
-  // on('user.created', handler) or on('user.created', { where: ... }, handler)
   if (typeof event === 'string') {
     const actualHandler = typeof filterOrHandler === 'function' ? filterOrHandler : handler;
     const filter = typeof filterOrHandler === 'object' ? filterOrHandler : null;
-    const parts = event.split('.');
-    const key = event; // Use full event string as key
+    const key = event;
     if (!__event_handlers__.has(key)) __event_handlers__.set(key, []);
     __event_handlers__.get(key).push({ handler: actualHandler, filter, source: actualHandler.toString() });
     return {
@@ -1481,7 +1530,6 @@ const on = new Proxy(function(event, filterOrHandler, handler) {
 }, {
   get: (target, prop) => {
     if (prop === 'once') {
-      // on.once('event', handler) - one-time handler
       return (event, handler) => {
         const wrapper = async (data, $) => {
           const key = event;
@@ -1498,7 +1546,6 @@ const on = new Proxy(function(event, filterOrHandler, handler) {
         return { off: () => {} };
       };
     }
-    // on.Entity.event(handler) pattern
     const noun = String(prop);
     return new Proxy({}, {
       get: (_, eventName) => (handler) => {
@@ -1526,7 +1573,6 @@ const on = new Proxy(function(event, filterOrHandler, handler) {
   apply: (target, thisArg, args) => target(...args)
 });
 
-// Parse duration string (100ms, 1s, 5m, etc.)
 const __parseDuration__ = (str) => {
   if (!str || typeof str !== 'string') return null;
   const match = str.match(/^(\\d+)(ms|s|m|h|d|w)?$/);
@@ -1544,30 +1590,24 @@ const __parseDuration__ = (str) => {
   }
 };
 
-// Check if string looks like a cron expression
 const __isCronExpression__ = (str) => {
   if (!str || typeof str !== 'string') return false;
   const parts = str.trim().split(/\\s+/);
   return parts.length >= 5 && parts.length <= 6;
 };
 
-// Active schedule timers
 const __schedule_timers__ = [];
 
-// Create $.every - supports every('100ms', handler), every('name', '* * * *', handler), and every.Monday.at9am(handler)
 const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handlerArg) {
-  // Determine format: every('100ms', handler) or every('name', '* * * *', handler) or every('name', opts, handler)
   let name = null;
   let interval = null;
   let handler = null;
   let options = {};
 
   if (typeof handlerOrCronOrOptions === 'function') {
-    // every('100ms', handler) or every('* * * *', handler)
     interval = intervalOrName;
     handler = handlerOrCronOrOptions;
   } else if (typeof handlerArg === 'function') {
-    // every('name', '* * * *', handler) or every('name', { immediate: true }, handler)
     name = intervalOrName;
     if (typeof handlerOrCronOrOptions === 'string') {
       interval = handlerOrCronOrOptions;
@@ -1578,13 +1618,11 @@ const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handler
     handler = handlerArg;
   }
 
-  // Determine if it's a duration or cron
   const isCron = __isCronExpression__(interval);
   const durationMs = isCron ? null : __parseDuration__(interval);
 
   let stopped = false;
   let timer = null;
-  let runCount = 0;
 
   const job = {
     name: name || interval,
@@ -1599,25 +1637,12 @@ const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handler
   };
 
   if (durationMs) {
-    // Duration-based schedule
-    if (options.immediate) {
-      Promise.resolve().then(() => handler());
-    }
-
+    if (options.immediate) Promise.resolve().then(() => handler());
     timer = setInterval(async () => {
       if (stopped) return;
-      if (options.until && options.until()) {
-        job.stop();
-        return;
-      }
-      runCount++;
-      try {
-        await handler();
-      } catch (e) {
-        console.error('[every] Handler error:', e);
-      }
+      if (options.until && options.until()) { job.stop(); return; }
+      try { await handler(); } catch (e) { console.error('[every] Handler error:', e); }
     }, durationMs);
-
     __schedule_timers__.push(timer);
   }
 
@@ -1638,7 +1663,6 @@ const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handler
         __registerScheduleHandler__({ type: 'cron', expression: pattern, natural: propStr }, handler);
         return { stop: () => {}, cancel: () => {}, name: propStr, cron: pattern, stopped: false };
       };
-      // Support time modifiers: every.Monday.at9am(handler)
       return new Proxy(result, {
         get: (_, timeKey) => {
           const time = __TIME_PATTERNS__[String(timeKey)];
@@ -1660,7 +1684,6 @@ const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handler
         }
       });
     }
-    // Plural units: every.seconds(5), every.minutes(10), etc.
     const pluralUnits = { seconds: 'second', minutes: 'minute', hours: 'hour', days: 'day', weeks: 'week' };
     if (pluralUnits[propStr]) {
       return (value) => (handler) => {
@@ -1673,38 +1696,24 @@ const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handler
   apply: (target, thisArg, args) => target(...args)
 });
 
-// Send event - returns event info, supports options (delay, correlationId, channel, wait)
 const send = async (event, data, options = {}) => {
   const eventId = __generateId__();
   const timestamp = Date.now();
-  const eventObj = {
-    id: eventId,
-    type: event,
-    data,
-    timestamp,
-    correlationId: options.correlationId
-  };
-
+  const eventObj = { id: eventId, type: event, data, timestamp, correlationId: options.correlationId };
   __workflow_history__.push({ type: 'event', name: event, data, timestamp });
 
-  // Handle delay
   if (options.delay) {
     const delayMs = typeof options.delay === 'string' ? __parseDuration__(options.delay) : options.delay;
-    if (delayMs) {
-      await new Promise(r => setTimeout(r, delayMs));
-    }
+    if (delayMs) await new Promise(r => setTimeout(r, delayMs));
   }
 
-  // Find matching handlers (supports wildcard like 'user.*')
   const matchingHandlers = [];
   for (const [key, handlers] of __event_handlers__) {
     const keyPattern = key.replace(/\\.\\*/g, '\\\\.[^.]+');
     const regex = new RegExp('^' + keyPattern + '$');
     if (key === event || regex.test(event) || (key.endsWith('.*') && event.startsWith(key.slice(0, -1)))) {
       for (const h of handlers) {
-        // Check channel filter
         if (h.filter?.channel && h.filter.channel !== options.channel) continue;
-        // Check where filter
         if (h.filter?.where) {
           let match = true;
           for (const [k, v] of Object.entries(h.filter.where)) {
@@ -1717,7 +1726,6 @@ const send = async (event, data, options = {}) => {
     }
   }
 
-  // If wait option, call first handler and return response
   if (options.wait && matchingHandlers.length > 0) {
     let response = null;
     const reply = (data) => { response = { data }; };
@@ -1725,30 +1733,21 @@ const send = async (event, data, options = {}) => {
     return response || eventObj;
   }
 
-  // Fire all handlers
   await Promise.all(matchingHandlers.map(async ({ handler }) => {
-    try {
-      await handler({ type: event, data, correlationId: options.correlationId }, $);
-    } catch (error) {
-      console.error('Error in handler for ' + event + ':', error);
-    }
+    try { await handler({ type: event, data, correlationId: options.correlationId }, $); }
+    catch (error) { console.error('Error in handler for ' + event + ':', error); }
   }));
 
   return eventObj;
 };
 
-// Add broadcast method to send
-send.broadcast = async (event, data) => {
-  return send(event, data);
-};
+send.broadcast = async (event, data) => send(event, data);
 
-// Delay helper
 const delay = (ms) => {
   if (typeof ms === 'string') ms = __parseDuration__(ms) || 0;
   return new Promise(r => setTimeout(r, ms));
 };
 
-// Decide helper - pattern matching decision
 const decide = (subject) => {
   const conditions = [];
   let defaultValue = null;
@@ -1760,12 +1759,10 @@ const decide = (subject) => {
     },
     otherwise: (result) => {
       defaultValue = result;
-      // Execute decision
       for (const { condition, result } of conditions) {
         let matches = false;
-        if (typeof condition === 'function') {
-          matches = condition(subject);
-        } else if (typeof condition === 'object') {
+        if (typeof condition === 'function') matches = condition(subject);
+        else if (typeof condition === 'object') {
           matches = true;
           for (const [key, value] of Object.entries(condition)) {
             const subjectValue = subject[key];
@@ -1780,27 +1777,20 @@ const decide = (subject) => {
                   default: if (subjectValue !== value) matches = false;
                 }
               }
-            } else if (subjectValue !== value) {
-              matches = false;
-            }
+            } else if (subjectValue !== value) matches = false;
             if (!matches) break;
           }
         }
-        if (matches) {
-          return typeof result === 'function' ? result() : result;
-        }
+        if (matches) return typeof result === 'function' ? result() : result;
       }
       return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
     }
   };
-
   return chain;
 };
 
-// Async decide
 decide.async = (subject) => {
   const conditions = [];
-
   const chain = {
     when: (conditionFn, result) => {
       conditions.push({ condition: conditionFn, result });
@@ -1814,11 +1804,9 @@ decide.async = (subject) => {
       return defaultResult;
     }
   };
-
   return chain;
 };
 
-// Track helper - analytics tracking
 const __tracked_events__ = [];
 const track = async (event, data, metadata = {}) => {
   const entry = { type: event, data, metadata, timestamp: Date.now(), userId: metadata.userId };
@@ -1879,7 +1867,6 @@ track.timeseries = async (event, options = {}) => {
   }));
 };
 
-// Experiment helper - A/B testing
 const experiment = (name) => {
   const variants = [];
   let eligibilityFn = null;
@@ -1891,29 +1878,17 @@ const experiment = (name) => {
       variants.push({ name: variantName, config, weight: options.weight || 1 });
       return exp;
     },
-    eligible: (fn) => {
-      eligibilityFn = fn;
-      return exp;
-    },
-    override: (userId, variantName) => {
-      overrides.set(userId, variantName);
-      return exp;
-    },
-    rollout: (variantName, percentage) => {
-      rolloutConfig = { variant: variantName, percentage };
-      return exp;
-    },
+    eligible: (fn) => { eligibilityFn = fn; return exp; },
+    override: (userId, variantName) => { overrides.set(userId, variantName); return exp; },
+    rollout: (variantName, percentage) => { rolloutConfig = { variant: variantName, percentage }; return exp; },
     assign: (userId) => {
-      // Check override
       if (overrides.has(userId)) {
         const overrideVariant = variants.find(v => v.name === overrides.get(userId));
         if (overrideVariant) return { name: overrideVariant.name, ...overrideVariant.config };
       }
-      // Check eligibility
       if (eligibilityFn && typeof userId === 'object' && !eligibilityFn(userId)) {
         return variants[0] ? { name: variants[0].name, ...variants[0].config } : {};
       }
-      // Consistent assignment based on userId hash
       const userIdStr = typeof userId === 'object' ? userId.id || JSON.stringify(userId) : String(userId);
       let hash = 0;
       for (let i = 0; i < userIdStr.length; i++) {
@@ -1921,14 +1896,10 @@ const experiment = (name) => {
         hash = hash & hash;
       }
       const normalized = Math.abs(hash % 100) / 100;
-
-      // Check rollout
       if (rolloutConfig && normalized < rolloutConfig.percentage) {
         const rolloutVariant = variants.find(v => v.name === rolloutConfig.variant);
         if (rolloutVariant) return { name: rolloutVariant.name, ...rolloutVariant.config };
       }
-
-      // Weight-based selection
       const totalWeight = variants.reduce((sum, v) => sum + v.weight, 0);
       let cumulative = 0;
       for (const v of variants) {
@@ -1938,20 +1909,14 @@ const experiment = (name) => {
       return variants[0] ? { name: variants[0].name, ...variants[0].config } : {};
     },
     track: {
-      exposure: async (userId) => {
-        await track('experiment.exposure', { experiment: name, userId });
-      },
-      conversion: async (userId, data = {}) => {
-        await track('experiment.conversion', { experiment: name, userId, ...data });
-      }
+      exposure: async (userId) => { await track('experiment.exposure', { experiment: name, userId }); },
+      conversion: async (userId, data = {}) => { await track('experiment.conversion', { experiment: name, userId, ...data }); }
     },
     results: async () => {
       const exposures = __tracked_events__.filter(e => e.type === 'experiment.exposure' && e.data.experiment === name);
       const conversions = __tracked_events__.filter(e => e.type === 'experiment.conversion' && e.data.experiment === name);
       const result = {};
-      for (const v of variants) {
-        result[v.name] = { exposures: 0, conversions: 0 };
-      }
+      for (const v of variants) result[v.name] = { exposures: 0, conversions: 0 };
       for (const e of exposures) {
         const variantName = exp.assign(e.data.userId).name;
         if (result[variantName]) result[variantName].exposures++;
@@ -1963,39 +1928,29 @@ const experiment = (name) => {
       return result;
     }
   };
-
   return exp;
 };
 
-// Execute event and wait for result ($.do) - mirrors ai-workflows do
 const __doEvent__ = async (event, data) => {
   __workflow_history__.push({ type: 'action', name: 'do:' + event, data, timestamp: Date.now() });
-
   const parsed = __parseEvent__(event);
   if (!parsed) throw new Error('Invalid event format: ' + event + '. Expected Noun.event');
-
   const key = parsed.noun + '.' + parsed.event;
   const handlers = __event_handlers__.get(key) || [];
   if (handlers.length === 0) throw new Error('No handler registered for ' + event);
-
   return await handlers[0].handler(data, $);
 };
 
-// Try event (non-durable) - mirrors ai-workflows try
 const __tryEvent__ = async (event, data) => {
   __workflow_history__.push({ type: 'action', name: 'try:' + event, data, timestamp: Date.now() });
-
   const parsed = __parseEvent__(event);
   if (!parsed) throw new Error('Invalid event format: ' + event + '. Expected Noun.event');
-
   const key = parsed.noun + '.' + parsed.event;
   const handlers = __event_handlers__.get(key) || [];
   if (handlers.length === 0) throw new Error('No handler registered for ' + event);
-
   return await handlers[0].handler(data, $);
 };
 
-// Queue implementation
 const __queues__ = new Map();
 const __queue_stats__ = new Map();
 const queue = (name) => {
@@ -2022,7 +1977,7 @@ const queue = (name) => {
         } catch (e) {
           stats.failed++;
           if (job.attempts < (job.options.maxRetries || 3)) {
-            q.push(job); // Retry
+            q.push(job);
             stats.retried++;
           }
         }
@@ -2036,7 +1991,6 @@ const queue = (name) => {
         stats.processed += batch.length;
       } catch (e) {
         stats.failed += batch.length;
-        // Put back for retry
         for (const job of batch) {
           if (job.attempts < (job.options.maxRetries || 3)) {
             job.attempts++;
@@ -2054,7 +2008,6 @@ const queue = (name) => {
   };
 };
 
-// Actor pattern implementation
 const __actors__ = new Map();
 const actor = (type) => ({
   register: (id, state = {}) => {
@@ -2066,32 +2019,23 @@ const actor = (type) => ({
   send: async (id, message) => {
     const a = __actors__.get(type + ':' + id);
     if (!a) throw new Error('Actor not found: ' + type + ':' + id);
-    // Handle message (stub - in real impl would dispatch to actor handler)
     return { delivered: true };
   }
 });
 
-// Actions API (workflow actions)
 const __actions__ = new Map();
 const actions = {
   async create(options) {
     const id = __generateId__();
     const action = {
-      id,
-      actor: options.actor,
-      object: options.object,
-      action: options.action,
-      metadata: options.metadata || {},
-      status: 'pending',
-      createdAt: new Date(),
-      updatedAt: new Date()
+      id, actor: options.actor, object: options.object, action: options.action,
+      metadata: options.metadata || {}, status: 'pending',
+      createdAt: new Date(), updatedAt: new Date()
     };
     __actions__.set(id, action);
     return action;
   },
-  async get(id) {
-    return __actions__.get(id) || null;
-  },
+  async get(id) { return __actions__.get(id) || null; },
   async start(id) {
     const action = __actions__.get(id);
     if (!action) throw new Error('Action not found: ' + id);
@@ -2143,24 +2087,18 @@ const actions = {
   }
 };
 
-// Artifacts API (for storing results)
 const __artifacts__ = new Map();
 const artifacts = {
   async store(options) {
     const id = __generateId__();
     const artifact = {
-      id,
-      type: options.type,
-      data: options.data,
-      metadata: options.metadata || {},
-      createdAt: new Date()
+      id, type: options.type, data: options.data,
+      metadata: options.metadata || {}, createdAt: new Date()
     };
     __artifacts__.set(id, artifact);
     return artifact;
   },
-  async get(id) {
-    return __artifacts__.get(id) || null;
-  },
+  async get(id) { return __artifacts__.get(id) || null; },
   async list(options = {}) {
     let results = Array.from(__artifacts__.values());
     if (options.type) results = results.filter(a => a.type === options.type);
@@ -2169,17 +2107,12 @@ const artifacts = {
   }
 };
 
-// Events API (for event sourcing)
 const __events__ = [];
 const events = {
   async record(options) {
     const event = {
-      id: __generateId__(),
-      type: options.type,
-      subject: options.subject,
-      data: options.data,
-      metadata: options.metadata || {},
-      timestamp: new Date()
+      id: __generateId__(), type: options.type, subject: options.subject,
+      data: options.data, metadata: options.metadata || {}, timestamp: new Date()
     };
     __events__.push(event);
     return event;
@@ -2191,7 +2124,6 @@ const events = {
     if (options.limit) results = results.slice(0, options.limit);
     return results;
   },
-  // Query is an alias for list with more flexible filtering
   async query(options = {}) {
     let results = [...__events__];
     if (options.type) results = results.filter(e => e.type === options.type);
@@ -2207,16 +2139,12 @@ const events = {
   },
   async replay(handler, options = {}) {
     const evts = await events.list(options);
-    for (const evt of evts) {
-      await handler(evt);
-    }
+    for (const evt of evts) await handler(evt);
   },
-  // Subscribe to events
   subscribe(type, handler) {
     on(type, handler);
     return { unsubscribe: () => {} };
   },
-  // Emit an event (alias for record + send)
   async emit(type, data, metadata = {}) {
     const event = await events.record({ type, data, metadata });
     await send(type, data);
@@ -2224,12 +2152,9 @@ const events = {
   }
 };
 
-// MDX Parsing helpers (basic implementation)
 const parse = (content) => {
   const frontmatterMatch = content.match(/^---\\n([\\s\\S]*?)\\n---\\n?([\\s\\S]*)$/);
-  if (!frontmatterMatch) {
-    return { data: {}, content: content.trim(), type: null, id: null };
-  }
+  if (!frontmatterMatch) return { data: {}, content: content.trim(), type: null, id: null };
   const [, frontmatter, body] = frontmatterMatch;
   const data = {};
   let currentKey = null;
@@ -2240,13 +2165,8 @@ const parse = (content) => {
     if (keyMatch) {
       currentKey = keyMatch[1];
       const value = keyMatch[2].trim();
-      if (value === '') {
-        data[currentKey] = [];
-        inArray = true;
-      } else {
-        data[currentKey] = value;
-        inArray = false;
-      }
+      if (value === '') { data[currentKey] = []; inArray = true; }
+      else { data[currentKey] = value; inArray = false; }
     } else if (inArray && currentKey && line.match(/^\\s+-\\s+(.+)$/)) {
       const itemMatch = line.match(/^\\s+-\\s+(.+)$/);
       if (itemMatch) {
@@ -2255,12 +2175,7 @@ const parse = (content) => {
       }
     }
   }
-  return {
-    data,
-    content: body.trim(),
-    type: data.$type || data['@type'] || null,
-    id: data.$id || data['@id'] || null
-  };
+  return { data, content: body.trim(), type: data.$type || data['@type'] || null, id: data.$id || data['@id'] || null };
 };
 
 const stringify = (doc) => {
@@ -2271,9 +2186,7 @@ const stringify = (doc) => {
     if (Array.isArray(value)) {
       lines.push(key + ':');
       for (const item of value) lines.push('  - ' + item);
-    } else {
-      lines.push(key + ': ' + value);
-    }
+    } else lines.push(key + ': ' + value);
   }
   lines.push('---');
   if (doc.content) lines.push('', doc.content);
@@ -2288,17 +2201,12 @@ const toAst = (doc) => {
     else if (line.startsWith('## ')) children.push({ type: 'heading', depth: 2, text: line.slice(3) });
     else if (line.startsWith('- ')) {
       const lastList = children[children.length - 1];
-      if (lastList?.type === 'list') {
-        lastList.items.push(line.slice(2));
-      } else {
-        children.push({ type: 'list', items: [line.slice(2)] });
-      }
+      if (lastList?.type === 'list') lastList.items.push(line.slice(2));
+      else children.push({ type: 'list', items: [line.slice(2)] });
     } else if (line.startsWith('\`\`\`')) {
       const lang = line.slice(3).trim();
       children.push({ type: 'code', lang: lang || null, value: '' });
-    } else if (line.trim()) {
-      children.push({ type: 'paragraph', text: line });
-    }
+    } else if (line.trim()) children.push({ type: 'paragraph', text: line });
   }
   return { type: 'root', children };
 };
@@ -2312,9 +2220,7 @@ const renderMarkdown = (doc, options = {}) => {
       if (Array.isArray(value)) {
         result += key + ':\\n';
         for (const item of value) result += '  - ' + item + '\\n';
-      } else {
-        result += key + ': ' + value + '\\n';
-      }
+      } else result += key + ': ' + value + '\\n';
     }
     result += '---\\n';
   }
@@ -2322,7 +2228,6 @@ const renderMarkdown = (doc, options = {}) => {
   return result;
 };
 
-// Component factory (basic implementation)
 const createComponents = (createElement) => {
   const components = {};
   const componentNames = ['Hero', 'Features', 'Pricing', 'CTA', 'Testimonials', 'FAQ', 'Footer', 'Header', 'Nav', 'Card', 'Grid', 'Section', 'Container', 'Button', 'Input', 'Form', 'Modal', 'Table', 'List', 'Badge', 'Alert', 'Progress', 'Spinner', 'Avatar', 'Image', 'Video', 'Code', 'Markdown'];
@@ -2349,9 +2254,7 @@ const extractTests = (content) => {
   const tests = [];
   const regex = /\`\`\`(?:ts|js)\\s+test[^\\n]*\\n([\\s\\S]*?)\`\`\`/g;
   let match;
-  while ((match = regex.exec(content)) !== null) {
-    tests.push({ code: match[1].trim() });
-  }
+  while ((match = regex.exec(content)) !== null) tests.push({ code: match[1].trim() });
   return tests;
 };
 
@@ -2362,24 +2265,18 @@ const parseMeta = (meta) => {
     if (part.includes('=')) {
       const [key, value] = part.split('=');
       result[key] = value;
-    } else {
-      result[part] = true;
-    }
+    } else result[part] = true;
   }
   return result;
 };
 
-// Simple createElement for testing
 const createElement = (type, props, ...children) => ({ type, props: props || {}, children });
 
-// Graph/relationship helper functions
 const extractLinks = (content) => {
   const links = [];
   const regex = /\\[([^\\]]+)\\]\\(([^)]+)\\)/g;
   let match;
-  while ((match = regex.exec(content)) !== null) {
-    links.push({ text: match[1], url: match[2] });
-  }
+  while ((match = regex.exec(content)) !== null) links.push({ text: match[1], url: match[2] });
   return links;
 };
 
@@ -2387,12 +2284,8 @@ const extractRelationships = (doc) => {
   const relationships = [];
   const url = doc.id || doc.url;
   if (!url) return relationships;
-  // Extract from content links
   const links = extractLinks(doc.content || '');
-  for (const link of links) {
-    relationships.push({ from: url, to: link.url, type: 'links', label: link.text });
-  }
-  // Extract from data fields
+  for (const link of links) relationships.push({ from: url, to: link.url, type: 'links', label: link.text });
   for (const [key, value] of Object.entries(doc.data || {})) {
     if (typeof value === 'string' && (value.startsWith('http') || value.startsWith('/'))) {
       relationships.push({ from: url, to: value, type: key });
@@ -2408,21 +2301,19 @@ const extractRelationships = (doc) => {
   return relationships;
 };
 
-const withRelationships = (doc) => {
-  return { ...doc, relationships: extractRelationships(doc) };
-};
+const withRelationships = (doc) => ({ ...doc, relationships: extractRelationships(doc) });
 
 const resolveUrl = (entity) => {
   if (entity.url) return entity.url;
-  if (entity.ns && entity.type && entity.id) {
-    return 'https://' + entity.ns + '/' + entity.type + '/' + entity.id;
-  }
-  if (entity.ns && entity.id) {
-    return 'https://' + entity.ns + '/' + entity.id;
-  }
+  if (entity.ns && entity.type && entity.id) return 'https://' + entity.ns + '/' + entity.type + '/' + entity.id;
+  if (entity.ns && entity.id) return 'https://' + entity.ns + '/' + entity.id;
   return null;
 };
+`
+}
 
+function getContextObjectTemplate(): string {
+  return `
 // Context object ($) - unified SDK context (aligned with ai-workflows WorkflowContext)
 const $ = {
   ns: __SDK_CONFIG__.ns,
@@ -2442,60 +2333,40 @@ const $ = {
   track,
   experiment,
   delay,
-  // Workflow state
   state: {},
   history: __workflow_history__,
-  // User context
   user: { id: 'test-user', name: 'Test User', role: 'admin' },
   request: { method: 'GET', path: '/', headers: {}, body: null },
   env: { NODE_ENV: 'test' },
   config: {},
   context: {},
   meta: {},
-  // Logging
   log: (message, data) => {
     __workflow_history__.push({ type: 'action', name: 'log', data: { message, data }, timestamp: Date.now() });
     console.log('[sdk] ' + message, data ?? '');
   },
   error: console.error,
   warn: console.warn,
-  // Scoped execution
   async scope(overrides, fn) {
     const prev = { ns: $.ns, user: $.user, state: { ...$.state } };
     Object.assign($, overrides);
     try { return await fn(); }
     finally { Object.assign($, prev); }
   },
-  // Workflow helpers
   getHandlers() { return { events: Array.from(__event_handlers__.keys()), schedules: __schedule_handlers__.length }; },
   clearHandlers() { __event_handlers__.clear(); __schedule_handlers__.length = 0; },
   getHistory() { return [...__workflow_history__]; },
   clearHistory() { __workflow_history__.length = 0; }
 };
 
-// Standalone exports (for import { db, ai, on, send } from 'sdk')
+// Standalone exports
 const api = {};
 const search = __db_core__.search.bind(__db_core__);
 `
 }
 
-/**
- * Generate remote SDK code (RPC-based)
- *
- * This creates the platform.do-style SDK with:
- * - $ - Root context accessor
- * - db - Database operations
- * - ai - AI operations
- * - api - Platform API
- * - on/send - Event handling
- *
- * All operations go through RPC to actual services.
- */
-function generateRemoteSDKCode(config: SDKConfig = {}): string {
-  const rpcUrl = config.rpcUrl || 'https://rpc.do'
-  const token = config.token || ''
-  const ns = config.ns || 'default'
-
+// Helper to get the remote SDK template
+function getRemoteSDKTemplate(rpcUrl: string, token: string, ns: string): string {
   return `
 // ============================================================
 // SDK - Thin RPC Proxy ($, db, ai, api, on, send)
@@ -2515,7 +2386,6 @@ const __rpc__ = {
       headers['Authorization'] = 'Bearer ' + __SDK_CONFIG__.token;
     }
 
-    // Serialize functions for remote execution
     const serializedArgs = args.map(arg => {
       if (typeof arg === 'function') {
         return { __fn: arg.toString().replace(/"/g, "'") };
@@ -2538,23 +2408,16 @@ const __rpc__ = {
   }
 };
 
-// Store for user-defined values
 const __userDefinitions__ = new Map();
 
-// Thin proxy that converts property access to RPC paths
 const __createProxy__ = (path = '') => {
-  // Track stored values for this proxy instance
   const localStore = new Map();
 
   const proxy = new Proxy(() => {}, {
     get: (target, prop, receiver) => {
-      // Handle JSON serialization
       if (prop === 'toJSON') {
-        // Return stored values as a plain object
         const obj = { __rpcPath: path };
-        for (const [key, value] of localStore) {
-          obj[key] = value;
-        }
+        for (const [key, value] of localStore) obj[key] = value;
         for (const [key, value] of __userDefinitions__) {
           if (key.startsWith(path ? path + '.' : '') && !key.slice(path ? path.length + 1 : 0).includes('.')) {
             const localKey = key.slice(path ? path.length + 1 : 0);
@@ -2566,42 +2429,25 @@ const __createProxy__ = (path = '') => {
       if (prop === Symbol.toPrimitive || prop === 'valueOf' || prop === 'toString') {
         return () => path || '[SDK Proxy]';
       }
-      if (prop === Symbol.toStringTag) {
-        return 'SDKProxy';
-      }
-      if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-        return undefined; // Don't treat as thenable
-      }
-      // Handle .should by creating an assertion chain
+      if (prop === Symbol.toStringTag) return 'SDKProxy';
+      if (prop === 'then' || prop === 'catch' || prop === 'finally') return undefined;
       if (prop === 'should') {
-        // Build an object from stored values for assertion
         const obj = {};
-        for (const [key, value] of localStore) {
-          obj[key] = value;
-        }
+        for (const [key, value] of localStore) obj[key] = value;
         for (const [key, value] of __userDefinitions__) {
           if (key.startsWith(path ? path + '.' : '') && !key.slice(path ? path.length + 1 : 0).includes('.')) {
             const localKey = key.slice(path ? path.length + 1 : 0);
             if (localKey) obj[localKey] = value;
           }
         }
-        // If we have stored values, assert on them; otherwise use path string or a marker
-        if (Object.keys(obj).length > 0) {
-          return __createShouldChain__(obj);
-        }
-        // For empty proxy, create a marker object that represents the proxy path
+        if (Object.keys(obj).length > 0) return __createShouldChain__(obj);
         return __createShouldChain__(path ? { __path: path } : { __sdk: true, ns: __SDK_CONFIG__.ns });
       }
 
       const fullPath = path ? path + '.' + String(prop) : String(prop);
 
-      // Check local store first, then user definitions
-      if (localStore.has(String(prop))) {
-        return localStore.get(String(prop));
-      }
-      if (__userDefinitions__.has(fullPath)) {
-        return __userDefinitions__.get(fullPath);
-      }
+      if (localStore.has(String(prop))) return localStore.get(String(prop));
+      if (__userDefinitions__.has(fullPath)) return __userDefinitions__.get(fullPath);
 
       return __createProxy__(fullPath);
     },
@@ -2614,23 +2460,18 @@ const __createProxy__ = (path = '') => {
     },
 
     apply: (_, __, args) => {
-      // Handle tagged template literals
       if (Array.isArray(args[0]) && 'raw' in args[0]) {
         const strings = args[0];
         const values = args.slice(1);
         const text = strings.reduce((acc, str, i) => acc + str + (values[i] ?? ''), '');
         return __rpc__.do(path, text);
       }
-
       return __rpc__.do(path, ...args);
     },
 
-    // Prevent enumeration from causing infinite loops
     ownKeys: () => {
       const keys = [];
-      for (const [key, value] of localStore) {
-        keys.push(key);
-      }
+      for (const [key, value] of localStore) keys.push(key);
       for (const [key, value] of __userDefinitions__) {
         if (key.startsWith(path ? path + '.' : '') && !key.slice(path ? path.length + 1 : 0).includes('.')) {
           const localKey = key.slice(path ? path.length + 1 : 0);
@@ -2652,7 +2493,6 @@ const __createProxy__ = (path = '') => {
   return proxy;
 };
 
-// Root proxy and named exports
 const $ = __createProxy__();
 const db = $.db;
 const ai = $.ai;
@@ -2664,7 +2504,6 @@ const track = $.track;
 const every = $.every;
 const decide = $.decide;
 
-// Set default namespace and context properties
 $.ns = __SDK_CONFIG__.ns;
 $.user = { id: 'anonymous', name: 'Anonymous', role: 'guest' };
 $.request = { method: 'GET', path: '/', headers: {}, body: null };
@@ -2674,1086 +2513,3 @@ $.context = {};
 $.meta = {};
 `
 }
-
-/**
- * Generate .should chainable assertions code
- */
-function generateShouldCode(): string {
-  return `
-// ============================================================
-// Global .should Chainable Assertions
-// ============================================================
-
-const __createShouldChain__ = (actual, negated = false) => {
-  const check = (condition, message) => {
-    const passes = negated ? !condition : condition;
-    if (!passes) throw new Error(negated ? 'Expected NOT: ' + message : message);
-  };
-
-  const stringify = (val) => {
-    try {
-      return JSON.stringify(val);
-    } catch {
-      return String(val);
-    }
-  };
-
-  // Create a lazy chain getter - returns 'this' assertion for chaining
-  const assertion = {};
-
-  // Core assertion methods
-  assertion.equal = (expected) => {
-    check(actual === expected, 'Expected ' + stringify(actual) + ' to equal ' + stringify(expected));
-    return assertion;
-  };
-  assertion.deep = {
-    equal: (expected) => {
-      check(stringify(actual) === stringify(expected), 'Expected deep equal to ' + stringify(expected));
-      return assertion;
-    },
-    include: (expected) => {
-      const actualStr = stringify(actual);
-      const expectedStr = stringify(expected);
-      // Check if expected properties exist with same values
-      const matches = Object.entries(expected || {}).every(([k, v]) =>
-        actual && stringify(actual[k]) === stringify(v)
-      );
-      check(matches, 'Expected ' + actualStr + ' to deeply include ' + expectedStr);
-      return assertion;
-    }
-  };
-  assertion.include = (value) => {
-    if (typeof actual === 'string') check(actual.includes(String(value)), 'Expected "' + actual + '" to include "' + value + '"');
-    else if (Array.isArray(actual)) check(actual.includes(value), 'Expected array to include ' + stringify(value));
-    return assertion;
-  };
-  assertion.contain = assertion.include;
-  assertion.lengthOf = (n) => {
-    check(actual?.length === n, 'Expected length ' + n + ', got ' + actual?.length);
-    return assertion;
-  };
-  assertion.match = (regex) => {
-    const str = String(actual);
-    check(regex.test(str), 'Expected "' + str + '" to match ' + regex);
-    return assertion;
-  };
-  assertion.matches = assertion.match;
-
-  // .be accessor with type checks
-  Object.defineProperty(assertion, 'be', {
-    get: () => {
-      const beObj = {
-        a: (type) => {
-          const actualType = actual === null ? 'null' : Array.isArray(actual) ? 'array' : actual instanceof Date ? 'date' : typeof actual;
-          check(actualType === type.toLowerCase(), 'Expected ' + stringify(actual) + ' to be a ' + type);
-          return assertion;
-        },
-        above: (n) => { check(actual > n, 'Expected ' + actual + ' to be above ' + n); return assertion; },
-        below: (n) => { check(actual < n, 'Expected ' + actual + ' to be below ' + n); return assertion; },
-        within: (min, max) => { check(actual >= min && actual <= max, 'Expected ' + actual + ' to be within ' + min + '..' + max); return assertion; },
-        oneOf: (arr) => { check(Array.isArray(arr) && arr.includes(actual), 'Expected ' + stringify(actual) + ' to be one of ' + stringify(arr)); return assertion; },
-        instanceOf: (cls) => { check(actual instanceof cls, 'Expected to be instance of ' + cls.name); return assertion; }
-      };
-      beObj.an = beObj.a;
-      Object.defineProperty(beObj, 'true', { get: () => { check(actual === true, 'Expected ' + stringify(actual) + ' to be true'); return assertion; } });
-      Object.defineProperty(beObj, 'false', { get: () => { check(actual === false, 'Expected ' + stringify(actual) + ' to be false'); return assertion; } });
-      Object.defineProperty(beObj, 'ok', { get: () => { check(!!actual, 'Expected ' + stringify(actual) + ' to be truthy'); return assertion; } });
-      Object.defineProperty(beObj, 'null', { get: () => { check(actual === null, 'Expected ' + stringify(actual) + ' to be null'); return assertion; } });
-      Object.defineProperty(beObj, 'undefined', { get: () => { check(actual === undefined, 'Expected ' + stringify(actual) + ' to be undefined'); return assertion; } });
-      Object.defineProperty(beObj, 'empty', { get: () => {
-        const isEmpty = actual === '' || (Array.isArray(actual) && actual.length === 0) || (actual && typeof actual === 'object' && Object.keys(actual).length === 0);
-        check(isEmpty, 'Expected ' + stringify(actual) + ' to be empty');
-        return assertion;
-      }});
-      return beObj;
-    }
-  });
-
-  // .have accessor with property/keys/lengthOf/at checks
-  Object.defineProperty(assertion, 'have', {
-    get: () => ({
-      property: (name, value) => {
-        const hasIt = actual != null && Object.prototype.hasOwnProperty.call(actual, name);
-        if (value !== undefined) {
-          check(hasIt && actual[name] === value, "Expected property '" + name + "' = " + stringify(value) + ", got " + stringify(actual?.[name]));
-        } else {
-          check(hasIt, "Expected to have property '" + name + "'");
-        }
-        if (hasIt) return __createShouldChain__(actual[name], negated);
-        return assertion;
-      },
-      keys: (...keys) => {
-        const actualKeys = Object.keys(actual || {});
-        check(keys.every(k => actualKeys.includes(k)), 'Expected to have keys ' + stringify(keys));
-        return assertion;
-      },
-      lengthOf: (n) => {
-        check(actual?.length === n, 'Expected length ' + n + ', got ' + actual?.length);
-        return assertion;
-      },
-      at: {
-        least: (n) => {
-          check(actual?.length >= n, 'Expected length at least ' + n + ', got ' + actual?.length);
-          return assertion;
-        },
-        most: (n) => {
-          check(actual?.length <= n, 'Expected length at most ' + n + ', got ' + actual?.length);
-          return assertion;
-        }
-      }
-    })
-  });
-
-  // .not negation
-  Object.defineProperty(assertion, 'not', {
-    get: () => __createShouldChain__(actual, !negated)
-  });
-
-  // .with passthrough for readability
-  Object.defineProperty(assertion, 'with', {
-    get: () => assertion
-  });
-
-  // .that passthrough for chaining (e.g. .have.property('x').that.matches(/.../) )
-  Object.defineProperty(assertion, 'that', {
-    get: () => assertion
-  });
-
-  // .and passthrough for chaining
-  Object.defineProperty(assertion, 'and', {
-    get: () => assertion
-  });
-
-  return assertion;
-};
-
-// Add .should to Object.prototype
-Object.defineProperty(Object.prototype, 'should', {
-  get: function() { return __createShouldChain__(this); },
-  configurable: true,
-  enumerable: false
-});
-`
-}
-
-/**
- * Extract export names from module code
- * Supports both CommonJS (exports.foo) and ES module (export const foo) syntax
- */
-function getExportNames(moduleCode: string): string {
-  const names = new Set<string>()
-
-  // Match exports.name = ...
-  const dotPattern = /exports\.(\w+)\s*=/g
-  let match
-  while ((match = dotPattern.exec(moduleCode)) !== null) {
-    if (match[1]) names.add(match[1])
-  }
-
-  // Match exports['name'] = ... or exports["name"] = ...
-  const bracketPattern = /exports\[['"](\w+)['"]\]\s*=/g
-  while ((match = bracketPattern.exec(moduleCode)) !== null) {
-    if (match[1]) names.add(match[1])
-  }
-
-  // Match export const name = ... or export let name = ... or export var name = ...
-  const esConstPattern = /export\s+(?:const|let|var)\s+(\w+)\s*=/g
-  while ((match = esConstPattern.exec(moduleCode)) !== null) {
-    if (match[1]) names.add(match[1])
-  }
-
-  // Match export function name(...) or export async function name(...) or export async function* name(...)
-  const esFunctionPattern = /export\s+(?:async\s+)?function\*?\s+(\w+)\s*\(/g
-  while ((match = esFunctionPattern.exec(moduleCode)) !== null) {
-    if (match[1]) names.add(match[1])
-  }
-
-  // Match export class name
-  const esClassPattern = /export\s+class\s+(\w+)/g
-  while ((match = esClassPattern.exec(moduleCode)) !== null) {
-    if (match[1]) names.add(match[1])
-  }
-
-  return Array.from(names).join(', ') || '_unused'
-}
-
-/**
- * Transform module code to work in sandbox
- * Converts ES module exports to CommonJS-style for the sandbox
- */
-function transformModuleCode(moduleCode: string): string {
-  let code = moduleCode
-
-  // Transform: export const foo = ... → const foo = ...; exports.foo = foo;
-  code = code.replace(
-    /export\s+(const|let|var)\s+(\w+)\s*=/g,
-    '$1 $2 = exports.$2 ='
-  )
-
-  // Transform: export function foo(...) → function foo(...) exports.foo = foo;
-  // Also handles async generators: export async function* foo
-  code = code.replace(
-    /export\s+(async\s+)?function(\*?)\s+(\w+)/g,
-    '$1function$2 $3'
-  )
-  // Add exports for functions after their definition
-  const funcNames = [...moduleCode.matchAll(/export\s+(?:async\s+)?function\*?\s+(\w+)/g)]
-  for (const [, name] of funcNames) {
-    code += `\nexports.${name} = ${name};`
-  }
-
-  // Transform: export class Foo → class Foo; exports.Foo = Foo;
-  code = code.replace(/export\s+class\s+(\w+)/g, 'class $1')
-  const classNames = [...moduleCode.matchAll(/export\s+class\s+(\w+)/g)]
-  for (const [, name] of classNames) {
-    code += `\nexports.${name} = ${name};`
-  }
-
-  return code
-}
-
-/**
- * Wrap script to auto-return the last expression
- * Converts: `add(1, 2)` → `return add(1, 2)`
- */
-function wrapScriptForReturn(script: string): string {
-  const trimmed = script.trim()
-  if (!trimmed) return script
-
-  // If script already contains a return statement anywhere, don't modify
-  if (/\breturn\b/.test(trimmed)) return script
-
-  // If script starts with throw, don't modify
-  if (/^\s*throw\b/.test(trimmed)) return script
-
-  // If it's a single expression (no newlines, no semicolons except at end), wrap it
-  const withoutTrailingSemi = trimmed.replace(/;?\s*$/, '')
-  const isSingleLine = !withoutTrailingSemi.includes('\n')
-
-  // Check if it looks like a single expression (no control flow, no declarations)
-  const startsWithKeyword = /^\s*(const|let|var|if|for|while|switch|try|class|function|async\s+function)\b/.test(withoutTrailingSemi)
-
-  if (isSingleLine && !startsWithKeyword) {
-    return `return ${withoutTrailingSemi}`
-  }
-
-  // For multi-statement scripts, try to return the last expression
-  const lines = trimmed.split('\n')
-  const lastLineRaw = lines[lines.length - 1]
-  if (!lastLineRaw) 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)) {
-    lines[lines.length - 1] = `return ${lastLine.replace(/;?\s*$/, '')}`
-    return lines.join('\n')
-  }
-
-  return script
-}
-
-/**
- * Generate worker code for production (uses RPC to ai-tests)
- */
-export function generateWorkerCode(options: {
-  module?: string | undefined
-  tests?: string | undefined
-  script?: string | undefined
-  sdk?: SDKConfig | boolean | undefined
-  imports?: string[] | undefined
-}): string {
-  const { module: rawModule = '', tests = '', script: rawScript = '', sdk, imports = [] } = options
-  const sdkConfig = sdk === true ? {} : (sdk || null)
-  const module = rawModule ? transformModuleCode(rawModule) : ''
-  const script = rawScript ? wrapScriptForReturn(rawScript) : ''
-  const exportNames = getExportNames(rawModule)
-
-  // Hoisted imports (from MDX test files) - placed at true module top level
-  const hoistedImports = imports.length > 0 ? imports.join('\n') + '\n' : ''
-
-  return `
-// Sandbox Worker Entry Point
-import { RpcTarget, newWorkersRpcResponse } from 'capnweb';
-${hoistedImports}
-const logs = [];
-
-${sdkConfig ? generateShouldCode() : ''}
-
-${sdkConfig ? generateSDKCode(sdkConfig) : '// SDK not enabled'}
-
-// Capture console output
-const originalConsole = { ...console };
-const captureConsole = (level) => (...args) => {
-  logs.push({
-    level,
-    message: args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '),
-    timestamp: Date.now()
-  });
-  originalConsole[level](...args);
-};
-console.log = captureConsole('log');
-console.warn = captureConsole('warn');
-console.error = captureConsole('error');
-console.info = captureConsole('info');
-console.debug = captureConsole('debug');
-
-// ============================================================
-// USER MODULE CODE (embedded at generation time)
-// ============================================================
-// Module exports object - exports become top-level variables
-const exports = {};
-
-${module ? `
-// Execute module code
-try {
-${module}
-} catch (e) {
-  console.error('Module error:', e.message);
-}
-` : '// 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 ? `
-const { ${exportNames} } = exports;
-`.trim() : ''}
-
-// ============================================================
-// RPC SERVER - Expose exports via capnweb
-// ============================================================
-class ExportsRpcTarget extends RpcTarget {
-  // Dynamically expose all exports as RPC methods
-  constructor() {
-    super();
-    for (const [key, value] of Object.entries(exports)) {
-      if (typeof value === 'function') {
-        this[key] = value;
-      }
-    }
-  }
-
-  // List available exports
-  list() {
-    return Object.keys(exports);
-  }
-
-  // Get an export by name
-  get(name) {
-    return exports[name];
-  }
-}
-
-// ============================================================
-// WORKER ENTRY POINT
-// ============================================================
-export default {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-
-    // Route: GET / - Return info about exports
-    if (request.method === 'GET' && url.pathname === '/') {
-      return Response.json({
-        exports: Object.keys(exports),
-        rpc: '/rpc',
-        execute: '/execute'
-      });
-    }
-
-    // Route: /rpc - capnweb RPC to module exports
-    if (url.pathname === '/rpc') {
-      return newWorkersRpcResponse(request, new ExportsRpcTarget());
-    }
-
-    // Route: GET /:name - Simple JSON endpoint to access exports
-    if (request.method === 'GET' && url.pathname !== '/execute') {
-      const name = url.pathname.slice(1); // Remove leading /
-      const value = exports[name];
-
-      // Check if export exists
-      if (!(name in exports)) {
-        return Response.json({ error: \`Export "\${name}" not found\` }, { status: 404 });
-      }
-
-      // If it's not a function, just return the value
-      if (typeof value !== 'function') {
-        return Response.json({ result: value });
-      }
-
-      // It's a function - parse args and call it
-      try {
-        const args = [];
-        const argsParam = url.searchParams.get('args');
-        if (argsParam) {
-          // Support JSON array: ?args=[1,2,3]
-          try {
-            const parsed = JSON.parse(argsParam);
-            if (Array.isArray(parsed)) {
-              args.push(...parsed);
-            } else {
-              args.push(parsed);
-            }
-          } catch {
-            // Not JSON, use as single string arg
-            args.push(argsParam);
-          }
-        } else {
-          // Support named params: ?a=1&b=2 -> passed as object
-          const params = Object.fromEntries(url.searchParams.entries());
-          if (Object.keys(params).length > 0) {
-            // Try to parse numeric values
-            for (const [key, val] of Object.entries(params)) {
-              const num = Number(val);
-              params[key] = !isNaN(num) && val !== '' ? num : val;
-            }
-            args.push(params);
-          }
-        }
-
-        const result = await value(...args);
-        return Response.json({ result });
-      } catch (e) {
-        return Response.json({ error: e.message }, { status: 500 });
-      }
-    }
-
-    // Route: /execute - Run tests and scripts
-    // Check for TEST service binding
-    if (!env.TEST) {
-      return Response.json({
-        success: false,
-        error: 'TEST service binding not available. Ensure ai-tests worker is bound.',
-        logs,
-        duration: 0
-      });
-    }
-
-    // Connect to get the TestServiceCore via RPC
-    const testService = await env.TEST.connect();
-
-    // Create global test functions that proxy to the RPC service
-    const describe = (name, fn) => testService.describe(name, fn);
-    const it = (name, fn) => testService.it(name, fn);
-    const test = (name, fn) => testService.test(name, fn);
-    const expect = (value, message) => testService.expect(value, message);
-    const should = (value) => testService.should(value);
-    const assert = testService.assert;
-    const beforeEach = (fn) => testService.beforeEach(fn);
-    const afterEach = (fn) => testService.afterEach(fn);
-    const beforeAll = (fn) => testService.beforeAll(fn);
-    const afterAll = (fn) => testService.afterAll(fn);
-
-    // Add skip/only modifiers
-    it.skip = (name, fn) => testService.skip(name, fn);
-    it.only = (name, fn) => testService.only(name, fn);
-    test.skip = it.skip;
-    test.only = it.only;
-
-    let scriptResult = undefined;
-    let scriptError = null;
-    let testResults = undefined;
-
-    // ============================================================
-    // USER TEST CODE (embedded at generation time)
-    // ============================================================
-
-    ${tests ? `
-    // Register tests
-    try {
-${tests}
-    } catch (e) {
-      console.error('Test registration error:', e.message);
-    }
-    ` : '// No test code provided'}
-
-    // Execute user script
-    ${script ? `
-    try {
-      scriptResult = await (async () => {
-${script}
-      })();
-    } catch (e) {
-      console.error('Script error:', e.message);
-      scriptError = e.message;
-    }
-    ` : '// No script code provided'}
-
-    // Run tests if any were registered
-    ${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));
-
-    return Response.json({
-      success,
-      value: scriptResult,
-      logs,
-      testResults: hasTests ? testResults : undefined,
-      error: scriptError || undefined,
-      duration: 0
-    });
-  }
-};
-`
-}
-
-/**
- * Generate worker code for development (embedded test framework)
- *
- * This version bundles the test framework directly into the worker,
- * avoiding the need for RPC service bindings in local development.
- */
-export function generateDevWorkerCode(options: {
-  module?: string | undefined
-  tests?: string | undefined
-  script?: string | undefined
-  sdk?: SDKConfig | boolean | undefined
-  imports?: string[] | undefined
-  fetch?: null | undefined
-}): string {
-  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
-
-  // Hoisted imports (from MDX test files) - placed at true module top level
-  const hoistedImports = imports.length > 0 ? imports.join('\n') + '\n' : ''
-
-  return `
-// Sandbox Worker Entry Point (Dev Mode - embedded test framework)
-${hoistedImports}
-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');
-};
-` : ''}
-
-${sdkConfig ? generateShouldCode() : ''}
-
-${sdkConfig ? generateSDKCode(sdkConfig) : '// SDK not enabled'}
-
-// Capture console output
-const originalConsole = { ...console };
-const captureConsole = (level) => (...args) => {
-  logs.push({
-    level,
-    message: args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '),
-    timestamp: Date.now()
-  });
-  originalConsole[level](...args);
-};
-console.log = captureConsole('log');
-console.warn = captureConsole('warn');
-console.error = captureConsole('error');
-console.info = captureConsole('info');
-console.debug = captureConsole('debug');
-
-// 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;
-};
-
-// ============================================================
-// USER MODULE CODE (embedded at generation time)
-// ============================================================
-// Module exports object - exports become top-level variables
-const exports = {};
-
-${module ? `
-// Execute module code
-try {
-${module}
-} catch (e) {
-  console.error('Module error:', e.message);
-}
-` : '// 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 ? `
-const { ${exportNames} } = exports;
-`.trim() : ''}
-
-// ============================================================
-// USER TEST CODE (embedded at generation time)
-// ============================================================
-${tests ? `
-// Register tests
-try {
-${tests}
-} catch (e) {
-  console.error('Test registration error:', e.message);
-}
-` : '// No test code provided'}
-
-// ============================================================
-// SIMPLE RPC HANDLER (dev mode - no capnweb dependency)
-// ============================================================
-async function handleRpc(request) {
-  try {
-    const { method, args = [] } = await request.json();
-    if (method === 'list') {
-      return Response.json({ result: Object.keys(exports) });
-    }
-    if (method === 'get') {
-      const [name] = args;
-      const value = exports[name];
-      if (typeof value === 'function') {
-        return Response.json({ result: { type: 'function', name } });
-      }
-      return Response.json({ result: value });
-    }
-    // Call an exported function
-    const fn = exports[method];
-    if (typeof fn !== 'function') {
-      return Response.json({ error: \`Export "\${method}" is not a function\` }, { status: 400 });
-    }
-    const result = await fn(...args);
-    return Response.json({ result });
-  } catch (e) {
-    return Response.json({ error: e.message }, { status: 500 });
-  }
-}
-
-// ============================================================
-// WORKER ENTRY POINT
-// ============================================================
-export default {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-
-    // Route: GET / - Return info about exports
-    if (request.method === 'GET' && url.pathname === '/') {
-      return Response.json({
-        exports: Object.keys(exports),
-        rpc: '/rpc',
-        execute: '/execute'
-      });
-    }
-
-    // Route: POST /rpc - Simple RPC to module exports
-    if (url.pathname === '/rpc' && request.method === 'POST') {
-      return handleRpc(request);
-    }
-
-    // Route: GET /:name - Simple JSON endpoint to access exports
-    if (request.method === 'GET' && url.pathname !== '/execute') {
-      const name = url.pathname.slice(1);
-      const value = exports[name];
-
-      // Check if export exists
-      if (!(name in exports)) {
-        return Response.json({ error: \`Export "\${name}" not found\` }, { status: 404 });
-      }
-
-      // If it's not a function, just return the value
-      if (typeof value !== 'function') {
-        return Response.json({ result: value });
-      }
-
-      // It's a function - parse args and call it
-      try {
-        const args = [];
-        const argsParam = url.searchParams.get('args');
-        if (argsParam) {
-          try {
-            const parsed = JSON.parse(argsParam);
-            if (Array.isArray(parsed)) args.push(...parsed);
-            else args.push(parsed);
-          } catch {
-            args.push(argsParam);
-          }
-        } else {
-          const params = Object.fromEntries(url.searchParams.entries());
-          if (Object.keys(params).length > 0) {
-            for (const [key, val] of Object.entries(params)) {
-              const num = Number(val);
-              params[key] = !isNaN(num) && val !== '' ? num : val;
-            }
-            args.push(params);
-          }
-        }
-        const result = await value(...args);
-        return Response.json({ result });
-      } catch (e) {
-        return Response.json({ error: e.message }, { status: 500 });
-      }
-    }
-
-    // Route: /execute - Run tests and scripts
-    let scriptResult = undefined;
-    let scriptError = null;
-
-    // Execute user script
-    ${script ? `
-    try {
-      scriptResult = await (async () => {
-${script}
-      })();
-    } catch (e) {
-      console.error('Script error:', e.message);
-      scriptError = e.message;
-    }
-    ` : '// No script code provided'}
-
-    // 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;
-
-    const hasTests = ${tests ? 'true' : 'false'};
-    const success = scriptError === null && (!hasTests || testResults.failed === 0);
-
-    return Response.json({
-      success,
-      value: scriptResult,
-      logs,
-      testResults: hasTests ? testResults : undefined,
-      error: scriptError || undefined,
-      duration: 0
-    });
-  }
-};
-`
-}