ai-evaluate 2.1.8 → 2.2.0

package/src/worker-template/sdk-generator.ts

@@ -1,2515 +0,0 @@
-/**
- * SDK code generation for worker templates
- *
- * 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'
-
-/**
- * Generate SDK code for injection into sandbox
- */
-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
- */
-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)
-// ============================================================
-
-const __SDK_CONFIG__ = {
-  ns: '${ns}',
-  aiGatewayUrl: '${aiGatewayUrl}',
-  aiGatewayToken: '${aiGatewayToken}'
-};
-
-// In-memory database storage (mirrors MemoryDB structure)
-const __db_things__ = new Map();
-const __db_relationships__ = new Map();
-// Indexes for efficient lookups
-const __db_byUrl__ = new Map();
-const __db_byNsType__ = new Map();
-const __db_relFrom__ = new Map();
-const __db_relTo__ = new Map();
-
-// ID generator (crypto.randomUUID not available in all environments)
-const __generateId__ = () => {
-  const bytes = new Uint8Array(16);
-  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
-  }
-  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
-  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant
-  const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
-  return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20);
-};
-
-// URL resolution (mirrors ai-database resolveUrl)
-const __resolveUrl__ = (entity) => {
-  if (entity.url) return entity.url;
-  return 'https://' + entity.ns + '/' + entity.type + '/' + entity.id;
-};
-
-// Parse identifier (mirrors ai-database parseIdentifier)
-const __parseIdentifier__ = (identifier, defaults = {}) => {
-  if (identifier.includes('://')) {
-    try {
-      const parsed = new URL(identifier);
-      const parts = parsed.pathname.split('/').filter(Boolean);
-      return {
-        ns: parsed.host,
-        type: parts[0] || '',
-        id: parts.slice(1).join('/') || '',
-        url: identifier
-      };
-    } catch { return { ns: defaults.ns, id: identifier }; }
-  }
-  if (identifier.includes('/')) {
-    const parts = identifier.split('/');
-    return { ns: defaults.ns, type: parts[0], id: parts.slice(1).join('/') };
-  }
-  return { ns: defaults.ns, type: defaults.type, id: identifier };
-};
-
-// Extract mdxld metadata from data object
-const __extractType__ = (data) => data && (data.$type || data['@type']);
-const __extractId__ = (data) => data && (data.$id || data['@id']);
-const __extractContext__ = (data) => data && (data.$context || data['@context']);
-
-// Index management
-const __indexThing__ = (thing) => {
-  const url = __resolveUrl__(thing);
-  __db_byUrl__.set(url, thing);
-  const nsTypeKey = thing.ns + '/' + thing.type;
-  if (!__db_byNsType__.has(nsTypeKey)) __db_byNsType__.set(nsTypeKey, new Set());
-  __db_byNsType__.get(nsTypeKey).add(url);
-};
-const __unindexThing__ = (thing) => {
-  const url = __resolveUrl__(thing);
-  __db_byUrl__.delete(url);
-  const nsTypeKey = thing.ns + '/' + thing.type;
-  const set = __db_byNsType__.get(nsTypeKey);
-  if (set) set.delete(url);
-};
-const __indexRelationship__ = (rel) => {
-  if (!__db_relFrom__.has(rel.from)) __db_relFrom__.set(rel.from, new Set());
-  __db_relFrom__.get(rel.from).add(rel.id);
-  if (!__db_relTo__.has(rel.to)) __db_relTo__.set(rel.to, new Set());
-  __db_relTo__.get(rel.to).add(rel.id);
-};
-const __unindexRelationship__ = (rel) => {
-  const fromSet = __db_relFrom__.get(rel.from);
-  if (fromSet) fromSet.delete(rel.id);
-  const toSet = __db_relTo__.get(rel.to);
-  if (toSet) toSet.delete(rel.id);
-};
-
-// MongoDB-style query matching (mirrors MemoryDB.matchesQuery)
-const __matchesQuery__ = (thing, options) => {
-  if (options.ns && thing.ns !== options.ns) return false;
-  if (options.type && thing.type !== options.type) return false;
-  if (options.where) {
-    for (const [key, value] of Object.entries(options.where)) {
-      const thingValue = thing.data[key];
-      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        for (const [op, opVal] of Object.entries(value)) {
-          switch (op) {
-            case '$gt': if (!(thingValue > opVal)) return false; break;
-            case '$gte': if (!(thingValue >= opVal)) return false; break;
-            case '$lt': if (!(thingValue < opVal)) return false; break;
-            case '$lte': if (!(thingValue <= opVal)) return false; break;
-            case '$ne': if (thingValue === opVal) return false; break;
-            case '$in': if (!Array.isArray(opVal) || !opVal.includes(thingValue)) return false; break;
-            case '$nin': if (Array.isArray(opVal) && opVal.includes(thingValue)) return false; break;
-            case '$exists': if (opVal && thingValue === undefined) return false; if (!opVal && thingValue !== undefined) return false; break;
-            case '$regex': if (typeof thingValue !== 'string') return false; const regex = typeof opVal === 'string' ? new RegExp(opVal) : opVal; if (!regex.test(thingValue)) return false; break;
-            default: if (thingValue !== value) return false;
-          }
-        }
-      } else if (thingValue !== value) return false;
-    }
-  }
-  return true;
-};
-
-// Apply query options (sort, limit, offset)
-const __applyQueryOptions__ = (items, options) => {
-  let result = [...items];
-  if (options.orderBy) {
-    const field = options.orderBy;
-    const dir = options.order === 'desc' ? -1 : 1;
-    result.sort((a, b) => {
-      const aVal = a[field] ?? a.data?.[field];
-      const bVal = b[field] ?? b.data?.[field];
-      if (aVal === undefined && bVal === undefined) return 0;
-      if (aVal === undefined) return dir;
-      if (bVal === undefined) return -dir;
-      if (aVal < bVal) return -dir;
-      if (aVal > bVal) return dir;
-      return 0;
-    });
-  }
-  if (options.offset) result = result.slice(options.offset);
-  if (options.limit) result = result.slice(0, options.limit);
-  return result;
-};
-
-// Cosine similarity helper for semantic search
-const __cosineSimilarity__ = (a, b) => {
-  if (!a || !b || a.length !== b.length || a.length === 0) return 0;
-  let dotProduct = 0, normA = 0, normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  return magnitude === 0 ? 0 : dotProduct / magnitude;
-};
-
-// Embedding cache for semantic search (stores URL -> embedding)
-const __embeddings__ = new Map();
-
-// AI embed helper for semantic search - defined early so __db_core__.search can use it
-const __aiEmbed__ = async (text) => {
-  if (!__SDK_CONFIG__.aiGatewayUrl) return [];
-  try {
-    const url = __SDK_CONFIG__.aiGatewayUrl + '/google-ai-studio/v1beta/models/gemini-embedding-001:embedContent';
-    const headers = { 'Content-Type': 'application/json' };
-    if (__SDK_CONFIG__.aiGatewayToken) {
-      headers['cf-aig-authorization'] = 'Bearer ' + __SDK_CONFIG__.aiGatewayToken;
-    }
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        content: { parts: [{ text }] },
-        outputDimensionality: 768
-      })
-    });
-    if (!response.ok) return [];
-    const result = await response.json();
-    return result.embedding?.values || [];
-  } catch (err) {
-    console.warn('Embedding failed:', err.message);
-    return [];
-  }
-};
-
-${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,
-
-  async list(options = {}) {
-    const results = [];
-    for (const thing of __db_things__.values()) {
-      if (__matchesQuery__(thing, options)) results.push(thing);
-    }
-    return __applyQueryOptions__(results, options);
-  },
-
-  async find(options = {}) {
-    return this.list(options);
-  },
-
-  async search(options = {}) {
-    const query = (options.query || '').toLowerCase();
-    const fields = options.fields || ['data'];
-    const minScore = options.minScore || 0;
-    const results = [];
-
-    // Semantic search using embeddings
-    if (options.semantic && typeof __aiEmbed__ === 'function') {
-      const queryEmbedding = await __aiEmbed__(options.query || '');
-      if (!queryEmbedding || queryEmbedding.length === 0) {
-        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();
-          let score = 0;
-          for (const term of queryTerms) {
-            if (content.includes(term)) score += 1;
-            for (const word of content.split(/[\\s\\W]+/)) {
-              if (word.includes(term) || term.includes(word)) score += 0.1;
-            }
-          }
-          if (score > 0) textResults.push({ thing, score });
-        }
-        textResults.sort((a, b) => b.score - a.score);
-        return __applyQueryOptions__(textResults.map(r => r.thing), options);
-      }
-
-      for (const thing of __db_things__.values()) {
-        if (!__matchesQuery__(thing, options)) continue;
-        const thingUrl = thing.url || thing.id;
-        let thingEmbedding = __embeddings__.get(thingUrl);
-        if (!thingEmbedding) {
-          const textContent = JSON.stringify(thing.data);
-          thingEmbedding = await __aiEmbed__(textContent);
-          if (thingEmbedding && thingEmbedding.length > 0) {
-            __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);
-    }
-
-    // Text-based search
-    for (const thing of __db_things__.values()) {
-      if (!__matchesQuery__(thing, options)) continue;
-      const searchIn = fields.includes('data')
-        ? JSON.stringify(thing.data).toLowerCase()
-        : fields.map(f => String(thing[f] || '')).join(' ').toLowerCase();
-      if (searchIn.includes(query)) {
-        const index = searchIn.indexOf(query);
-        const score = 1 - (index / searchIn.length);
-        if (score >= minScore) results.push({ thing, score });
-      }
-    }
-    results.sort((a, b) => b.score - a.score);
-    return __applyQueryOptions__(results.map(r => r.thing), options);
-  },
-
-  async get(identifier, options = {}) {
-    let url;
-    try {
-      const parsed = __parseIdentifier__(identifier, { ns: __SDK_CONFIG__.ns });
-      if (parsed.url) url = parsed.url;
-      else if (parsed.ns && parsed.type && parsed.id) url = 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id;
-      else if (parsed.ns && parsed.id) {
-        for (const [thingUrl, thing] of __db_byUrl__) {
-          if (thing.ns === parsed.ns && thing.id === parsed.id) return thing;
-        }
-      }
-    } catch { }
-    if (url) {
-      const thing = __db_byUrl__.get(url);
-      if (thing) return thing;
-    }
-    for (const thing of __db_things__.values()) {
-      if (thing.id === identifier || thing.url === identifier) return thing;
-    }
-    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 : {};
-      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 });
-    }
-    return null;
-  },
-
-  async set(url, data) {
-    const existing = __db_byUrl__.get(url);
-    if (existing) {
-      existing.data = data;
-      existing.updatedAt = new Date();
-      return existing;
-    }
-    const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-    const thing = {
-      ns: parsed.ns || __SDK_CONFIG__.ns,
-      type: parsed.type || '',
-      id: parsed.id || __generateId__(),
-      url,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      data
-    };
-    __db_things__.set(url, thing);
-    __indexThing__(thing);
-    return thing;
-  },
-
-  async create(urlOrOptions, dataArg) {
-    if (typeof urlOrOptions === 'string') {
-      const url = urlOrOptions;
-      const data = dataArg || {};
-      const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-      const type = __extractType__(data) || parsed.type || 'Thing';
-      const id = parsed.id || __extractId__(data) || __generateId__();
-      const context = __extractContext__(data);
-      const ns = parsed.ns || __SDK_CONFIG__.ns;
-      const cleanData = { ...data };
-      delete cleanData.$type; delete cleanData.$id; delete cleanData.$context;
-      delete cleanData['@type']; delete cleanData['@id']; delete cleanData['@context'];
-      const thingUrl = parsed.url || 'https://' + ns + '/' + type + '/' + id;
-      if (__db_byUrl__.has(thingUrl)) throw new Error('Thing already exists: ' + thingUrl);
-      const thing = { ns, type, id, url: thingUrl, createdAt: new Date(), updatedAt: new Date(), data: cleanData };
-      if (context) thing['@context'] = context;
-      __db_things__.set(thingUrl, thing);
-      __indexThing__(thing);
-      return thing;
-    }
-
-    const options = urlOrOptions;
-    if ((__extractType__(options) && !('data' in options)) || ('$type' in options) || ('@type' in options)) {
-      const type = __extractType__(options) || 'Thing';
-      const id = __extractId__(options) || __generateId__();
-      const context = __extractContext__(options);
-      const ns = __SDK_CONFIG__.ns;
-      const cleanData = { ...options };
-      delete cleanData.$type; delete cleanData.$id; delete cleanData.$context;
-      delete cleanData['@type']; delete cleanData['@id']; delete cleanData['@context'];
-      const thingUrl = 'https://' + ns + '/' + type + '/' + id;
-      if (__db_byUrl__.has(thingUrl)) throw new Error('Thing already exists: ' + thingUrl);
-      const thing = { ns, type, id, url: thingUrl, createdAt: new Date(), updatedAt: new Date(), data: cleanData };
-      if (context) thing['@context'] = context;
-      __db_things__.set(thingUrl, thing);
-      __indexThing__(thing);
-      return thing;
-    }
-
-    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);
-    const thing = { ns: options.ns, type: options.type, id, url: thingUrl, createdAt: new Date(), updatedAt: new Date(), data: options.data };
-    if (options['@context']) thing['@context'] = options['@context'];
-    __db_things__.set(thingUrl, thing);
-    __indexThing__(thing);
-    return thing;
-  },
-
-  async update(url, options) {
-    const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-    const resolvedUrl = parsed.url || 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id;
-    const existing = __db_byUrl__.get(resolvedUrl);
-    if (!existing) throw new Error('Thing not found: ' + resolvedUrl);
-    existing.data = { ...existing.data, ...options.data };
-    existing.updatedAt = new Date();
-    return existing;
-  },
-
-  async upsert(urlOrOptions, dataArg) {
-    if (typeof urlOrOptions === 'string') {
-      const parsed = __parseIdentifier__(urlOrOptions, { ns: __SDK_CONFIG__.ns });
-      const resolvedUrl = parsed.url || (parsed.ns && parsed.type && parsed.id ? 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id : null);
-      if (resolvedUrl && __db_byUrl__.has(resolvedUrl)) {
-        return this.update(resolvedUrl, { data: dataArg || {} });
-      }
-      return this.create(urlOrOptions, dataArg);
-    }
-    const options = urlOrOptions;
-    const url = options.url || 'https://' + options.ns + '/' + options.type + '/' + (options.id || __generateId__());
-    if (__db_byUrl__.has(url)) return this.update(url, { data: options.data });
-    return this.create({ ...options, url });
-  },
-
-  async delete(url) {
-    const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-    let resolvedUrl = parsed.url;
-    if (!resolvedUrl && parsed.ns && parsed.type && parsed.id) {
-      resolvedUrl = 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id;
-    }
-    if (!resolvedUrl) return false;
-    const thing = __db_byUrl__.get(resolvedUrl);
-    if (!thing) return false;
-    __unindexThing__(thing);
-    __db_things__.delete(resolvedUrl);
-    const relIds = new Set([...(__db_relFrom__.get(resolvedUrl) || []), ...(__db_relTo__.get(resolvedUrl) || [])]);
-    for (const relId of relIds) {
-      const rel = __db_relationships__.get(relId);
-      if (rel) { __unindexRelationship__(rel); __db_relationships__.delete(relId); }
-    }
-    return true;
-  },
-
-  async generate(identifier, options = {}) {
-    const parsed = __parseIdentifier__(identifier, { ns: __SDK_CONFIG__.ns });
-    const type = parsed.type || 'Thing';
-    const id = parsed.id || __generateId__();
-    const thing = {
-      ns: parsed.ns || __SDK_CONFIG__.ns, type, id,
-      url: parsed.url || 'https://' + (parsed.ns || __SDK_CONFIG__.ns) + '/' + type + '/' + id,
-      createdAt: new Date(), updatedAt: new Date(),
-      data: { _generated: true, _prompt: options.prompt, _model: options.model }
-    };
-    __db_things__.set(thing.url, thing);
-    __indexThing__(thing);
-    return thing;
-  },
-
-  async forEach(options, callback) {
-    const things = await this.list(options);
-    for (const thing of things) await callback(thing);
-  },
-
-  async relate(options) {
-    const id = __generateId__();
-    const rel = { id, type: options.type, from: options.from, to: options.to, createdAt: new Date(), data: options.data };
-    __db_relationships__.set(id, rel);
-    __indexRelationship__(rel);
-    return rel;
-  },
-
-  async unrelate(from, type, to) {
-    for (const [id, rel] of __db_relationships__) {
-      if (rel.from === from && rel.type === type && rel.to === to) {
-        __unindexRelationship__(rel);
-        __db_relationships__.delete(id);
-        return true;
-      }
-    }
-    return false;
-  },
-
-  async related(url, relationshipType, direction = 'both') {
-    const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-    const resolvedUrl = parsed.url || 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id;
-    const relatedUrls = new Set();
-    if (direction === 'from' || direction === 'both') {
-      const fromRels = __db_relFrom__.get(resolvedUrl);
-      if (fromRels) {
-        for (const relId of fromRels) {
-          const rel = __db_relationships__.get(relId);
-          if (rel && (!relationshipType || rel.type === relationshipType)) relatedUrls.add(rel.to);
-        }
-      }
-    }
-    if (direction === 'to' || direction === 'both') {
-      const toRels = __db_relTo__.get(resolvedUrl);
-      if (toRels) {
-        for (const relId of toRels) {
-          const rel = __db_relationships__.get(relId);
-          if (rel && (!relationshipType || rel.type === relationshipType)) relatedUrls.add(rel.from);
-        }
-      }
-    }
-    const results = [];
-    for (const relatedUrl of relatedUrls) {
-      const thing = __db_byUrl__.get(relatedUrl);
-      if (thing) results.push(thing);
-    }
-    return results;
-  },
-
-  async relationships(url, type, direction = 'both') {
-    const parsed = __parseIdentifier__(url, { ns: __SDK_CONFIG__.ns });
-    const resolvedUrl = parsed.url || 'https://' + parsed.ns + '/' + parsed.type + '/' + parsed.id;
-    const results = [];
-    if (direction === 'from' || direction === 'both') {
-      const fromRels = __db_relFrom__.get(resolvedUrl);
-      if (fromRels) {
-        for (const relId of fromRels) {
-          const rel = __db_relationships__.get(relId);
-          if (rel && (!type || rel.type === type)) results.push(rel);
-        }
-      }
-    }
-    if (direction === 'to' || direction === 'both') {
-      const toRels = __db_relTo__.get(resolvedUrl);
-      if (toRels) {
-        for (const relId of toRels) {
-          const rel = __db_relationships__.get(relId);
-          if (rel && (!type || rel.type === type)) results.push(rel);
-        }
-      }
-    }
-    return results;
-  },
-
-  clear() {
-    __db_things__.clear(); __db_relationships__.clear();
-    __db_byUrl__.clear(); __db_byNsType__.clear();
-    __db_relFrom__.clear(); __db_relTo__.clear();
-  },
-
-  stats() {
-    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;
-    const type = String(prop);
-    const collectionNs = __SDK_CONFIG__.ns;
-    const makeUrl = (id) => 'https://' + collectionNs + '/' + type + '/' + id;
-    return {
-      async list(options = {}) {
-        return __db_core__.list({ ...options, type, ns: collectionNs });
-      },
-      async find(options = {}) {
-        return __db_core__.find({ ...options, type, ns: collectionNs });
-      },
-      async search(options) {
-        return __db_core__.search({ ...options, type, ns: collectionNs });
-      },
-      async get(id, options = {}) {
-        return __db_core__.get(makeUrl(id), options);
-      },
-      async create(idOrData, data) {
-        if (typeof idOrData === 'string') {
-          return __db_core__.create({ ns: collectionNs, type, id: idOrData, data: data || {} });
-        }
-        const extractedId = __extractId__(idOrData);
-        return __db_core__.create({ ns: collectionNs, type, id: extractedId || __generateId__(), data: idOrData });
-      },
-      async update(id, data) {
-        return __db_core__.update(makeUrl(id), { data });
-      },
-      async upsert(idOrData, data) {
-        if (typeof idOrData === 'string') {
-          return __db_core__.upsert({ ns: collectionNs, type, id: idOrData, data: data || {} });
-        }
-        const extractedId = __extractId__(idOrData);
-        return __db_core__.upsert({ ns: collectionNs, type, id: extractedId || __generateId__(), data: idOrData });
-      },
-      async delete(id) {
-        return __db_core__.delete(makeUrl(id));
-      },
-      async forEach(optionsOrCallback, callback) {
-        if (typeof optionsOrCallback === 'function') {
-          return __db_core__.forEach({ type, ns: collectionNs }, optionsOrCallback);
-        }
-        return __db_core__.forEach({ ...optionsOrCallback, type, ns: collectionNs }, callback);
-      }
-    };
-  }
-});
-`
-}
-
-function getAiGatewayTemplate(): string {
-  return `
-// AI Gateway client - makes real API calls through Cloudflare AI Gateway
-const __aiGateway__ = {
-  async fetch(provider, endpoint, body, extraHeaders = {}) {
-    if (!__SDK_CONFIG__.aiGatewayUrl) {
-      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;
-      }
-      if (endpoint.includes('converse')) {
-        return {
-          output: {
-            message: {
-              content: [{ text: 'Mock AI response to: ' + prompt.slice(0, 50) }]
-            }
-          },
-          usage: { inputTokens: 10, outputTokens: 20 }
-        };
-      }
-      if (endpoint.includes('embed')) {
-        return {
-          embedding: {
-            values: new Array(body.outputDimensionality || 768).fill(0).map(() => Math.random())
-          }
-        };
-      }
-      return { mock: true, prompt };
-    }
-
-    const url = __SDK_CONFIG__.aiGatewayUrl + '/' + provider + endpoint;
-    const headers = {
-      'Content-Type': 'application/json',
-      ...extraHeaders
-    };
-    if (__SDK_CONFIG__.aiGatewayToken) {
-      headers['cf-aig-authorization'] = 'Bearer ' + __SDK_CONFIG__.aiGatewayToken;
-    }
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error('AI Gateway error: ' + response.status + ' ' + error);
-    }
-    return response.json();
-  }
-};
-`
-}
-
-function getAiMethodsTemplate(): string {
-  return `
-// AI implementation - callable as function or via methods
-const __aiMethods__ = {
-  async generate(prompt, options = {}) {
-    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 }] }],
-      inferenceConfig: { maxTokens: options.maxTokens || 1024 }
-    });
-    const text = result.output?.message?.content?.[0]?.text || '';
-    return { text, model, usage: result.usage };
-  },
-  async embed(text, options = {}) {
-    const dimensions = options.dimensions || 768;
-    const result = await __aiGateway__.fetch('google-ai-studio', '/v1beta/models/gemini-embedding-001:embedContent', {
-      content: { parts: [{ text }] },
-      outputDimensionality: dimensions
-    });
-    return result.embedding?.values || [];
-  },
-  async embedMany(texts, options = {}) {
-    const dimensions = options.dimensions || 768;
-    const embeddings = [];
-    for (const text of texts) {
-      const result = await __aiGateway__.fetch('google-ai-studio', '/v1beta/models/gemini-embedding-001:embedContent', {
-        content: { parts: [{ text }] },
-        outputDimensionality: dimensions
-      });
-      embeddings.push(result.embedding?.values || []);
-    }
-    return embeddings;
-  },
-  async chat(messages, options = {}) {
-    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 }] })),
-      inferenceConfig: { maxTokens: options.maxTokens || 1024 }
-    });
-    const content = result.output?.message?.content?.[0]?.text || '';
-    return { role: 'assistant', content, usage: result.usage };
-  },
-  async complete(prompt, options = {}) {
-    const result = await ai.generate(prompt, options);
-    return result.text;
-  },
-  async classify(text, labels, options = {}) {
-    const prompt = 'Classify the following text into one of these categories: ' + labels.join(', ') + '\\n\\nText: ' + text + '\\n\\nRespond with just the category name.';
-    const result = await ai.generate(prompt, { ...options, maxTokens: 50 });
-    const label = labels.find(l => result.text.toLowerCase().includes(l.toLowerCase())) || labels[0];
-    return { label, confidence: 0.9 };
-  },
-  async extract(text, schema, options = {}) {
-    const prompt = 'Extract the following information from the text and return as JSON:\\n\\nSchema: ' + JSON.stringify(schema) + '\\n\\nText: ' + text + '\\n\\nRespond with valid JSON only.';
-    const result = await ai.generate(prompt, options);
-    try {
-      return JSON.parse(result.text);
-    } catch {
-      return { _extracted: true, raw: result.text };
-    }
-  },
-  async summarize(text, options = {}) {
-    const prompt = 'Summarize the following text concisely:\\n\\n' + text;
-    const result = await ai.generate(prompt, { ...options, maxTokens: options.maxTokens || 256 });
-    return result.text;
-  },
-  createDatabaseTools(database) {
-    const dbInstance = database || __db_core__;
-    const success = (data) => ({
-      content: [{ type: 'text', text: JSON.stringify(data) }]
-    });
-    const error = (message) => ({
-      content: [{ type: 'text', text: message }],
-      isError: true
-    });
-    return [
-      {
-        name: 'mdxdb_list',
-        description: 'List documents from the database by type.',
-        handler: async (args) => {
-          try {
-            const { type, prefix, limit = 100 } = args || {};
-            const result = await dbInstance.list({ type, prefix, limit });
-            return success(result);
-          } catch (err) {
-            return error('Failed to list documents: ' + (err.message || String(err)));
-          }
-        }
-      },
-      {
-        name: 'mdxdb_search',
-        description: 'Search for documents by query.',
-        handler: async (args) => {
-          try {
-            const { query, type, limit = 10, semantic = false } = args || {};
-            const result = await dbInstance.search({ query, type, limit, semantic });
-            return success(result);
-          } catch (err) {
-            return error('Failed to search documents: ' + (err.message || String(err)));
-          }
-        }
-      },
-      {
-        name: 'mdxdb_get',
-        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');
-            const doc = await dbInstance.get(identifier);
-            if (!doc) return error('Document not found: ' + identifier);
-            return success(doc);
-          } catch (err) {
-            return error('Failed to get document: ' + (err.message || String(err)));
-          }
-        }
-      },
-      {
-        name: 'mdxdb_set',
-        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');
-            const docData = { ...(data || {}), ...(type ? { $type: type } : {}) };
-            await dbInstance.set(identifier, docData);
-            return success({ success: true, id: identifier });
-          } catch (err) {
-            return error('Failed to set document: ' + (err.message || String(err)));
-          }
-        }
-      },
-      {
-        name: 'mdxdb_delete',
-        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');
-            const result = await dbInstance.delete(identifier);
-            return success({ deleted: result.deleted !== false });
-          } catch (err) {
-            return error('Failed to delete document: ' + (err.message || String(err)));
-          }
-        }
-      }
-    ];
-  }
-};
-
-// Create callable ai function
-const ai = Object.assign(
-  async function ai(promptOrStrings, ...values) {
-    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;
-    }
-    const prompt = promptOrStrings;
-    const options = values[0] || {};
-    const result = await __aiMethods__.generate(prompt, options);
-    return result.text || result;
-  },
-  __aiMethods__
-);
-
-// Add references method to db_core
-__db_core__.references = async function(url, direction = 'both') {
-  const rels = await this.relationships(url, undefined, direction);
-  const refs = [];
-  for (const rel of rels) {
-    const targetUrl = direction === 'from' ? rel.to : direction === 'to' ? rel.from : (rel.from === url ? rel.to : rel.from);
-    const target = await this.get(targetUrl);
-    if (target) refs.push({ ...target, relationship: rel });
-  }
-  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)
-// ============================================================
-
-const __clientComponentCache__ = new WeakMap();
-
-const __isClientComponent__ = (fn) => {
-  if (typeof fn !== 'function') return false;
-  if (__clientComponentCache__.has(fn)) return __clientComponentCache__.get(fn);
-  __clientComponentCache__.set(fn, false);
-  const source = fn.toString();
-  let result = false;
-  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;
-};
-
-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 '';
-  if (typeof type === 'function') {
-    const isClient = __isClientComponent__(type);
-    try {
-      const result = type(props || {});
-      const rendered = __renderJsx__(result);
-      if (isClient) {
-        const componentName = type.name || 'Component';
-        return '<div data-hono-hydrate="' + componentName + '">' + rendered + '</div><script>/* hydrate: ' + componentName + ' */</script>';
-      }
-      return rendered;
-    } catch (e) {
-      return '<!-- Error: ' + e.message + ' -->';
-    }
-  }
-  const tag = String(type);
-  const attrs = Object.entries(props || {})
-    .filter(([k, v]) => k !== 'children' && v !== undefined && v !== null && v !== false)
-    .map(([k, v]) => {
-      if (v === true) return k;
-      const attrName = k === 'className' ? 'class' : k.replace(/([A-Z])/g, '-$1').toLowerCase();
-      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 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 : '') + ' />';
-  return '<' + tag + (attrs ? ' ' + attrs : '') + '>' + childContent + '</' + tag + '>';
-};
-
-const __createHonoApp__ = () => {
-  const routes = [];
-  const middleware = [];
-  let notFoundHandler = null;
-  let errorHandler = null;
-
-  const parsePattern = (pattern) => {
-    const params = [];
-    let normalizedPattern = pattern.replace(/\\/+$/, '') || '/';
-    let regexStr = normalizedPattern
-      .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 };
-  };
-
-  const createContext = (req, pathParams, store) => {
-    const url = new URL(req.url, 'http://localhost');
-    return {
-      req: {
-        raw: req,
-        url: req.url,
-        method: req.method,
-        path: url.pathname,
-        param: (name) => name === '*' ? pathParams.wildcard : pathParams[name],
-        query: (name) => url.searchParams.get(name),
-        queries: () => {
-          const result = {};
-          for (const [key, value] of url.searchParams) {
-            if (result[key]) {
-              if (Array.isArray(result[key])) result[key].push(value);
-              else result[key] = [result[key], value];
-            } else result[key] = value;
-          }
-          return result;
-        },
-        header: (name) => req.headers.get(name),
-        json: () => req.json(),
-        text: () => req.text(),
-        arrayBuffer: () => req.arrayBuffer(),
-        parseBody: async () => {
-          const contentType = req.headers.get('Content-Type') || '';
-          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;
-            return result;
-          }
-          return req.text();
-        },
-      },
-      text: (body, status = 200, headers = {}) => {
-        const h = { 'Content-Type': 'text/plain', ...headers };
-        return new Response(body, { status, headers: h });
-      },
-      json: (data, status = 200) => new Response(JSON.stringify(data), { status, headers: { 'Content-Type': 'application/json' } }),
-      html: (body, status = 200) => {
-        const rendered = typeof body === 'object' ? __renderJsx__(body) : body;
-        return new Response(rendered, { status, headers: { 'Content-Type': 'text/html' } });
-      },
-      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 }),
-      stream: (callback) => {
-        const { readable, writable } = new TransformStream();
-        const writer = writable.getWriter();
-        const streamApi = {
-          write: async (chunk) => {
-            const data = typeof chunk === 'string' ? new TextEncoder().encode(chunk) : chunk;
-            await writer.write(data);
-          },
-          close: async () => await writer.close(),
-          pipe: async (rs) => {
-            const reader = rs.getReader();
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) break;
-              await writer.write(value);
-            }
-            await writer.close();
-          }
-        };
-        Promise.resolve(callback(streamApi)).then(() => writer.close()).catch(() => writer.close());
-        return new Response(readable, { headers: { 'Content-Type': 'text/html; charset=utf-8' } });
-      },
-      status: (code) => {
-        const ctx = createContext(req, pathParams, store);
-        const originalJson = ctx.json;
-        const originalText = ctx.text;
-        const originalHtml = ctx.html;
-        ctx.json = (data) => originalJson(data, code);
-        ctx.text = (body) => originalText(body, code);
-        ctx.html = (body) => originalHtml(body, code);
-        return ctx;
-      },
-      header: (name, value) => {
-        store._headers = store._headers || {};
-        store._headers[name] = value;
-      },
-      set: (key, value) => { store[key] = value; },
-      get: (key) => store[key],
-    };
-  };
-
-  const addRoute = (method, path, ...handlers) => {
-    const { regex, params } = parsePattern(path);
-    routes.push({ method: method.toUpperCase(), pattern: path, regex, params, handlers });
-  };
-
-  const handleRequest = async (req) => {
-    const url = new URL(req.url, 'http://localhost');
-    const path = url.pathname;
-    const method = req.method;
-    const store = {};
-
-    let matchedRoute = null;
-    let routeParams = {};
-    for (const route of routes) {
-      if (route.method !== method && route.method !== 'ALL') continue;
-      const match = path.match(route.regex);
-      if (match) {
-        matchedRoute = route;
-        routeParams = match.groups || {};
-        break;
-      }
-    }
-
-    const matchingMiddleware = middleware.filter(mw => {
-      const prefix = mw.prefix.replace('/*', '').replace('*', '');
-      return path.startsWith(prefix) || prefix === '';
-    });
-
-    let chainResponse = null;
-
-    const executeChain = async (index) => {
-      if (index < matchingMiddleware.length) {
-        const mw = matchingMiddleware[index];
-        const ctx = createContext(req, routeParams, store);
-        const next = async () => {
-          const downstreamResult = await executeChain(index + 1);
-          if (downstreamResult) chainResponse = downstreamResult;
-          return downstreamResult;
-        };
-        const result = await mw.handler(ctx, next);
-        if (result) return result;
-        return chainResponse;
-      }
-
-      if (!matchedRoute) {
-        if (notFoundHandler) {
-          const ctx = createContext(req, {}, store);
-          return notFoundHandler(ctx);
-        }
-        return new Response('Not Found', { status: 404 });
-      }
-
-      const ctx = createContext(req, routeParams, store);
-      for (let i = 0; i < matchedRoute.handlers.length; i++) {
-        const handler = matchedRoute.handlers[i];
-        const isLast = i === matchedRoute.handlers.length - 1;
-        let nextCalled = false;
-        const next = async () => { nextCalled = true; };
-        const result = await handler(ctx, next);
-        if (result) return result;
-        if (!isLast && !nextCalled) break;
-      }
-      return null;
-    };
-
-    const applyHeaders = (response) => {
-      if (store._headers && response instanceof Response) {
-        for (const [name, value] of Object.entries(store._headers)) {
-          response.headers.set(name, value);
-        }
-      }
-      return response;
-    };
-
-    try {
-      const result = await executeChain(0);
-      if (result) return applyHeaders(result);
-      if (notFoundHandler) {
-        const ctx = createContext(req, {}, store);
-        return applyHeaders(notFoundHandler(ctx));
-      }
-      return new Response('Not Found', { status: 404 });
-    } catch (err) {
-      if (errorHandler) {
-        const ctx = createContext(req, {}, store);
-        return applyHeaders(errorHandler(err, ctx));
-      }
-      throw err;
-    }
-  };
-
-  const appObj = {
-    get: (path, ...handlers) => addRoute('GET', path, ...handlers),
-    post: (path, ...handlers) => addRoute('POST', path, ...handlers),
-    put: (path, ...handlers) => addRoute('PUT', path, ...handlers),
-    delete: (path, ...handlers) => addRoute('DELETE', path, ...handlers),
-    patch: (path, ...handlers) => addRoute('PATCH', path, ...handlers),
-    all: (path, ...handlers) => addRoute('ALL', path, ...handlers),
-    use: (pathOrHandler, handler) => {
-      const path = typeof pathOrHandler === 'string' ? pathOrHandler : '/*';
-      const h = typeof pathOrHandler === 'function' ? pathOrHandler : handler;
-      const { regex, params } = parsePattern(path);
-      middleware.push({ prefix: path, regex, handler: h });
-    },
-    route: (basePath, subApp) => {
-      for (const route of subApp._routes || []) {
-        addRoute(route.method, basePath + route.pattern, ...route.handlers);
-      }
-    },
-    basePath: (prefix) => {
-      const subApp = {
-        get: (path, ...handlers) => { addRoute('GET', prefix + path, ...handlers); return subApp; },
-        post: (path, ...handlers) => { addRoute('POST', prefix + path, ...handlers); return subApp; },
-        put: (path, ...handlers) => { addRoute('PUT', prefix + path, ...handlers); return subApp; },
-        delete: (path, ...handlers) => { addRoute('DELETE', prefix + path, ...handlers); return subApp; },
-        patch: (path, ...handlers) => { addRoute('PATCH', prefix + path, ...handlers); return subApp; },
-        all: (path, ...handlers) => { addRoute('ALL', prefix + path, ...handlers); return subApp; },
-        basePath: (subPrefix) => appObj.basePath(prefix + subPrefix),
-        _routes: routes,
-      };
-      return subApp;
-    },
-    notFound: (handler) => { notFoundHandler = handler; },
-    onError: (handler) => { errorHandler = handler; },
-    request: async (path, options = {}) => {
-      const url = path.startsWith('http') ? path : 'http://localhost' + path;
-      const req = new Request(url, {
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        body: options.body,
-      });
-      return handleRequest(req);
-    },
-    fetch: handleRequest,
-    _routes: routes,
-  };
-  return appObj;
-};
-
-const app = __createHonoApp__();
-`
-}
-
-function getMdxRenderingTemplate(): string {
-  return `
-// ============================================================
-// MDX Rendering Utilities
-// ============================================================
-
-const __extractFrontmatter__ = (content) => {
-  const match = content.match(/^---\\n([\\s\\S]*?)\\n---\\n?([\\s\\S]*)$/);
-  if (!match) return { frontmatter: {}, body: content };
-  try {
-    const fm = {};
-    match[1].split('\\n').forEach(line => {
-      const [key, ...vals] = line.split(':');
-      if (key && vals.length) fm[key.trim()] = vals.join(':').trim();
-    });
-    return { frontmatter: fm, body: match[2] };
-  } catch {
-    return { frontmatter: {}, body: content };
-  }
-};
-
-const render = {
-  markdown: (content, options = {}) => {
-    const { frontmatter, body } = __extractFrontmatter__(content);
-    if (options.includeFrontmatter) return content;
-    return body.trim();
-  },
-  toc: (content) => {
-    const { body } = __extractFrontmatter__(content);
-    const headings = [];
-    const regex = /^(#{1,6})\\s+(.+)$/gm;
-    let match;
-    while ((match = regex.exec(body)) !== null) {
-      headings.push({
-        level: match[1].length,
-        text: match[2].trim(),
-        slug: match[2].trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')
-      });
-    }
-    return headings;
-  },
-  html: (content) => {
-    const { body } = __extractFrontmatter__(content);
-    return body
-      .replace(/^### (.+)$/gm, '<h3>$1</h3>')
-      .replace(/^## (.+)$/gm, '<h2>$1</h2>')
-      .replace(/^# (.+)$/gm, '<h1>$1</h1>')
-      .replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>')
-      .replace(/\\*(.+?)\\*/g, '<em>$1</em>')
-      .replace(/\\[(.+?)\\]\\((.+?)\\)/g, '<a href="$2">$1</a>')
-      .replace(/^- (.+)$/gm, '<li>$1</li>')
-      .replace(/(<li>.*<\\/li>\\n?)+/g, '<ul>$&</ul>')
-      .replace(/^\\n+|\\n+$/g, '');
-  }
-};
-
-// React-like hooks stubs
-let __hook_state__ = [];
-let __hook_index__ = 0;
-
-const useState = (initial) => {
-  const idx = __hook_index__++;
-  if (__hook_state__[idx] === undefined) __hook_state__[idx] = initial;
-  const setState = (newVal) => {
-    __hook_state__[idx] = typeof newVal === 'function' ? newVal(__hook_state__[idx]) : newVal;
-  };
-  return [__hook_state__[idx], setState];
-};
-
-const useEffect = (fn, deps) => { /* No-op in server context */ };
-const useRef = (initial) => ({ current: initial });
-const useMemo = (fn, deps) => fn();
-const useCallback = (fn, deps) => fn;
-const Suspense = ({ children, fallback }) => children;
-
-const renderToStream = async (element, stream) => {
-  const html = __renderJsx__(element);
-  await stream.write(html);
-};
-
-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;
-    }
-    return result;
-  },
-  json: JSON.stringify,
-  parse: JSON.parse
-};
-
-Object.defineProperty(Function.prototype, 'isClient', {
-  get: function() { return __isClientComponent__(this); },
-  configurable: true,
-  enumerable: false
-});
-
-const parseUrl = (urlString) => {
-  try {
-    const url = new URL(urlString);
-    const pathParts = url.pathname.split('/').filter(Boolean);
-    return {
-      protocol: url.protocol.replace(':', ''),
-      host: url.host,
-      pathname: url.pathname,
-      path: pathParts,
-      search: url.search,
-      hash: url.hash,
-      origin: url.origin
-    };
-  } catch {
-    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)
-// ============================================================
-
-const __event_handlers__ = new Map();
-const __schedule_handlers__ = [];
-const __workflow_history__ = [];
-
-const __KNOWN_PATTERNS__ = {
-  second: '* * * * * *', minute: '* * * * *', hour: '0 * * * *',
-  day: '0 0 * * *', week: '0 0 * * 0', month: '0 0 1 * *', year: '0 0 1 1 *',
-  Monday: '0 0 * * 1', Tuesday: '0 0 * * 2', Wednesday: '0 0 * * 3',
-  Thursday: '0 0 * * 4', Friday: '0 0 * * 5', Saturday: '0 0 * * 6', Sunday: '0 0 * * 0',
-  weekday: '0 0 * * 1-5', weekend: '0 0 * * 0,6', midnight: '0 0 * * *', noon: '0 12 * * *'
-};
-
-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 },
-  at12pm: { hour: 12, minute: 0 }, atnoon: { hour: 12, minute: 0 }, at1pm: { hour: 13, minute: 0 },
-  at2pm: { hour: 14, minute: 0 }, at3pm: { hour: 15, minute: 0 }, at4pm: { hour: 16, minute: 0 },
-  at5pm: { hour: 17, minute: 0 }, at6pm: { hour: 18, minute: 0 }, at7pm: { hour: 19, minute: 0 },
-  at8pm: { hour: 20, minute: 0 }, at9pm: { hour: 21, minute: 0 }, atmidnight: { hour: 0, minute: 0 }
-};
-
-const __parseEvent__ = (event) => {
-  const parts = event.split('.');
-  if (parts.length !== 2) return null;
-  return { noun: parts[0], event: parts[1] };
-};
-
-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() });
-};
-
-const __registerScheduleHandler__ = (interval, handler) => {
-  __schedule_handlers__.push({ interval, handler, source: handler.toString() });
-};
-
-const on = new Proxy(function(event, filterOrHandler, handler) {
-  if (typeof event === 'string') {
-    const actualHandler = typeof filterOrHandler === 'function' ? filterOrHandler : handler;
-    const filter = typeof filterOrHandler === 'object' ? filterOrHandler : null;
-    const key = event;
-    if (!__event_handlers__.has(key)) __event_handlers__.set(key, []);
-    __event_handlers__.get(key).push({ handler: actualHandler, filter, source: actualHandler.toString() });
-    return {
-      off: () => {
-        const handlers = __event_handlers__.get(key);
-        if (handlers) {
-          const idx = handlers.findIndex(h => h.handler === actualHandler);
-          if (idx > -1) handlers.splice(idx, 1);
-        }
-      }
-    };
-  }
-}, {
-  get: (target, prop) => {
-    if (prop === 'once') {
-      return (event, handler) => {
-        const wrapper = async (data, $) => {
-          const key = event;
-          const handlers = __event_handlers__.get(key);
-          if (handlers) {
-            const idx = handlers.findIndex(h => h.handler === wrapper);
-            if (idx > -1) handlers.splice(idx, 1);
-          }
-          return handler(data, $);
-        };
-        const key = event;
-        if (!__event_handlers__.has(key)) __event_handlers__.set(key, []);
-        __event_handlers__.get(key).push({ handler: wrapper, source: handler.toString() });
-        return { off: () => {} };
-      };
-    }
-    const noun = String(prop);
-    return new Proxy({}, {
-      get: (_, eventName) => (handler) => {
-        const key = noun + '.' + String(eventName);
-        __registerEventHandler__(noun, String(eventName), handler);
-        return {
-          off: () => {
-            const handlers = __event_handlers__.get(key);
-            if (handlers) {
-              const idx = handlers.findIndex(h => h.handler === handler);
-              if (idx > -1) handlers.splice(idx, 1);
-            }
-          },
-          unsubscribe: () => {
-            const handlers = __event_handlers__.get(key);
-            if (handlers) {
-              const idx = handlers.findIndex(h => h.handler === handler);
-              if (idx > -1) handlers.splice(idx, 1);
-            }
-          }
-        };
-      }
-    });
-  },
-  apply: (target, thisArg, args) => target(...args)
-});
-
-const __parseDuration__ = (str) => {
-  if (!str || typeof str !== 'string') return null;
-  const match = str.match(/^(\\d+)(ms|s|m|h|d|w)?$/);
-  if (!match) return null;
-  const value = parseInt(match[1], 10);
-  const unit = match[2] || 'ms';
-  switch (unit) {
-    case 'ms': return value;
-    case 's': return value * 1000;
-    case 'm': return value * 60 * 1000;
-    case 'h': return value * 60 * 60 * 1000;
-    case 'd': return value * 24 * 60 * 60 * 1000;
-    case 'w': return value * 7 * 24 * 60 * 60 * 1000;
-    default: return value;
-  }
-};
-
-const __isCronExpression__ = (str) => {
-  if (!str || typeof str !== 'string') return false;
-  const parts = str.trim().split(/\\s+/);
-  return parts.length >= 5 && parts.length <= 6;
-};
-
-const __schedule_timers__ = [];
-
-const every = new Proxy(function(intervalOrName, handlerOrCronOrOptions, handlerArg) {
-  let name = null;
-  let interval = null;
-  let handler = null;
-  let options = {};
-
-  if (typeof handlerOrCronOrOptions === 'function') {
-    interval = intervalOrName;
-    handler = handlerOrCronOrOptions;
-  } else if (typeof handlerArg === 'function') {
-    name = intervalOrName;
-    if (typeof handlerOrCronOrOptions === 'string') {
-      interval = handlerOrCronOrOptions;
-    } else {
-      options = handlerOrCronOrOptions || {};
-      interval = options.interval;
-    }
-    handler = handlerArg;
-  }
-
-  const isCron = __isCronExpression__(interval);
-  const durationMs = isCron ? null : __parseDuration__(interval);
-
-  let stopped = false;
-  let timer = null;
-
-  const job = {
-    name: name || interval,
-    cron: isCron ? interval : null,
-    stopped: false,
-    stop: () => {
-      stopped = true;
-      job.stopped = true;
-      if (timer) clearInterval(timer);
-    },
-    next: () => new Date(Date.now() + (durationMs || 60000))
-  };
-
-  if (durationMs) {
-    if (options.immediate) Promise.resolve().then(() => handler());
-    timer = setInterval(async () => {
-      if (stopped) return;
-      if (options.until && options.until()) { job.stop(); return; }
-      try { await handler(); } catch (e) { console.error('[every] Handler error:', e); }
-    }, durationMs);
-    __schedule_timers__.push(timer);
-  }
-
-  __registerScheduleHandler__({
-    type: isCron ? 'cron' : 'duration',
-    expression: isCron ? interval : null,
-    ms: durationMs,
-    natural: name || interval
-  }, handler);
-
-  return job;
-}, {
-  get: (target, prop) => {
-    const propStr = String(prop);
-    const pattern = __KNOWN_PATTERNS__[propStr];
-    if (pattern) {
-      const result = (handler) => {
-        __registerScheduleHandler__({ type: 'cron', expression: pattern, natural: propStr }, handler);
-        return { stop: () => {}, cancel: () => {}, name: propStr, cron: pattern, stopped: false };
-      };
-      return new Proxy(result, {
-        get: (_, timeKey) => {
-          const time = __TIME_PATTERNS__[String(timeKey)];
-          if (time) {
-            const parts = pattern.split(' ');
-            parts[0] = String(time.minute);
-            parts[1] = String(time.hour);
-            const cron = parts.join(' ');
-            return (handler) => {
-              __registerScheduleHandler__({ type: 'cron', expression: cron, natural: propStr + '.' + String(timeKey) }, handler);
-              return { stop: () => {}, cancel: () => {}, name: propStr + '.' + String(timeKey), cron, stopped: false };
-            };
-          }
-          return undefined;
-        },
-        apply: (_, __, args) => {
-          __registerScheduleHandler__({ type: 'cron', expression: pattern, natural: propStr }, args[0]);
-          return { stop: () => {}, cancel: () => {}, name: propStr, cron: pattern, stopped: false };
-        }
-      });
-    }
-    const pluralUnits = { seconds: 'second', minutes: 'minute', hours: 'hour', days: 'day', weeks: 'week' };
-    if (pluralUnits[propStr]) {
-      return (value) => (handler) => {
-        __registerScheduleHandler__({ type: pluralUnits[propStr], value, natural: value + ' ' + propStr }, handler);
-        return { stop: () => {}, cancel: () => {}, name: value + ' ' + propStr, stopped: false };
-      };
-    }
-    return undefined;
-  },
-  apply: (target, thisArg, args) => target(...args)
-});
-
-const send = async (event, data, options = {}) => {
-  const eventId = __generateId__();
-  const timestamp = Date.now();
-  const eventObj = { id: eventId, type: event, data, timestamp, correlationId: options.correlationId };
-  __workflow_history__.push({ type: 'event', name: event, data, timestamp });
-
-  if (options.delay) {
-    const delayMs = typeof options.delay === 'string' ? __parseDuration__(options.delay) : options.delay;
-    if (delayMs) await new Promise(r => setTimeout(r, delayMs));
-  }
-
-  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) {
-        if (h.filter?.channel && h.filter.channel !== options.channel) continue;
-        if (h.filter?.where) {
-          let match = true;
-          for (const [k, v] of Object.entries(h.filter.where)) {
-            if (data[k] !== v) { match = false; break; }
-          }
-          if (!match) continue;
-        }
-        matchingHandlers.push(h);
-      }
-    }
-  }
-
-  if (options.wait && matchingHandlers.length > 0) {
-    let response = null;
-    const reply = (data) => { response = { data }; };
-    await matchingHandlers[0].handler({ type: event, data, correlationId: options.correlationId }, reply);
-    return response || eventObj;
-  }
-
-  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); }
-  }));
-
-  return eventObj;
-};
-
-send.broadcast = async (event, data) => send(event, data);
-
-const delay = (ms) => {
-  if (typeof ms === 'string') ms = __parseDuration__(ms) || 0;
-  return new Promise(r => setTimeout(r, ms));
-};
-
-const decide = (subject) => {
-  const conditions = [];
-  let defaultValue = null;
-
-  const chain = {
-    when: (conditionOrFn, result) => {
-      conditions.push({ condition: conditionOrFn, result });
-      return chain;
-    },
-    otherwise: (result) => {
-      defaultValue = result;
-      for (const { condition, result } of conditions) {
-        let matches = false;
-        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];
-            if (typeof value === 'object' && value !== null) {
-              for (const [op, opVal] of Object.entries(value)) {
-                switch (op) {
-                  case '$gte': if (!(subjectValue >= opVal)) matches = false; break;
-                  case '$gt': if (!(subjectValue > opVal)) matches = false; break;
-                  case '$lte': if (!(subjectValue <= opVal)) matches = false; break;
-                  case '$lt': if (!(subjectValue < opVal)) matches = false; break;
-                  case '$ne': if (subjectValue === opVal) matches = false; break;
-                  default: if (subjectValue !== value) matches = false;
-                }
-              }
-            } else if (subjectValue !== value) matches = false;
-            if (!matches) break;
-          }
-        }
-        if (matches) return typeof result === 'function' ? result() : result;
-      }
-      return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
-    }
-  };
-  return chain;
-};
-
-decide.async = (subject) => {
-  const conditions = [];
-  const chain = {
-    when: (conditionFn, result) => {
-      conditions.push({ condition: conditionFn, result });
-      return chain;
-    },
-    otherwise: async (defaultResult) => {
-      for (const { condition, result } of conditions) {
-        const matches = await condition(subject);
-        if (matches) return result;
-      }
-      return defaultResult;
-    }
-  };
-  return chain;
-};
-
-const __tracked_events__ = [];
-const track = async (event, data, metadata = {}) => {
-  const entry = { type: event, data, metadata, timestamp: Date.now(), userId: metadata.userId };
-  __tracked_events__.push(entry);
-  return entry;
-};
-
-track.user = async (userId, event, data) => {
-  const entry = { type: event, data, userId, timestamp: Date.now() };
-  __tracked_events__.push(entry);
-  return entry;
-};
-
-track.query = async (options = {}) => {
-  let results = [...__tracked_events__];
-  if (options.type) results = results.filter(e => e.type === options.type);
-  if (options.userId) results = results.filter(e => e.userId === options.userId);
-  if (options['data.buttonId']) results = results.filter(e => e.data?.buttonId === options['data.buttonId']);
-  if (options.orderBy) {
-    results.sort((a, b) => {
-      const aVal = a[options.orderBy];
-      const bVal = b[options.orderBy];
-      return options.order === 'desc' ? bVal - aVal : aVal - bVal;
-    });
-  }
-  if (options.limit) results = results.slice(0, options.limit);
-  return results;
-};
-
-track.funnel = async (steps, options = {}) => {
-  const events = await track.query(options);
-  const completed = steps.every(step => events.some(e => e.type === step));
-  return {
-    steps: steps.map(step => ({ step, completed: events.some(e => e.type === step) })),
-    completed,
-    conversionRate: completed ? 1 : 0
-  };
-};
-
-track.aggregate = async (event, options = {}) => {
-  const events = __tracked_events__.filter(e => e.type === event);
-  const groups = {};
-  for (const e of events) {
-    const key = options.groupBy ? e.data[options.groupBy] : '_all';
-    if (!groups[key]) groups[key] = { sum: 0, count: 0, values: [] };
-    groups[key].count++;
-    if (options.sum) groups[key].sum += e.data[options.sum] || 0;
-    groups[key].values.push(e);
-  }
-  return groups;
-};
-
-track.timeseries = async (event, options = {}) => {
-  const events = __tracked_events__.filter(e => e.type === event);
-  return events.map(e => ({
-    timestamp: e.timestamp,
-    value: options.field ? e.data[options.field] : 1
-  }));
-};
-
-const experiment = (name) => {
-  const variants = [];
-  let eligibilityFn = null;
-  const overrides = new Map();
-  let rolloutConfig = null;
-
-  const exp = {
-    variant: (variantName, config, options = {}) => {
-      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; },
-    assign: (userId) => {
-      if (overrides.has(userId)) {
-        const overrideVariant = variants.find(v => v.name === overrides.get(userId));
-        if (overrideVariant) return { name: overrideVariant.name, ...overrideVariant.config };
-      }
-      if (eligibilityFn && typeof userId === 'object' && !eligibilityFn(userId)) {
-        return variants[0] ? { name: variants[0].name, ...variants[0].config } : {};
-      }
-      const userIdStr = typeof userId === 'object' ? userId.id || JSON.stringify(userId) : String(userId);
-      let hash = 0;
-      for (let i = 0; i < userIdStr.length; i++) {
-        hash = ((hash << 5) - hash) + userIdStr.charCodeAt(i);
-        hash = hash & hash;
-      }
-      const normalized = Math.abs(hash % 100) / 100;
-      if (rolloutConfig && normalized < rolloutConfig.percentage) {
-        const rolloutVariant = variants.find(v => v.name === rolloutConfig.variant);
-        if (rolloutVariant) return { name: rolloutVariant.name, ...rolloutVariant.config };
-      }
-      const totalWeight = variants.reduce((sum, v) => sum + v.weight, 0);
-      let cumulative = 0;
-      for (const v of variants) {
-        cumulative += v.weight / totalWeight;
-        if (normalized < cumulative) return { name: v.name, ...v.config };
-      }
-      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 }); }
-    },
-    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 e of exposures) {
-        const variantName = exp.assign(e.data.userId).name;
-        if (result[variantName]) result[variantName].exposures++;
-      }
-      for (const e of conversions) {
-        const variantName = exp.assign(e.data.userId).name;
-        if (result[variantName]) result[variantName].conversions++;
-      }
-      return result;
-    }
-  };
-  return exp;
-};
-
-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, $);
-};
-
-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, $);
-};
-
-const __queues__ = new Map();
-const __queue_stats__ = new Map();
-const queue = (name) => {
-  if (!__queues__.has(name)) {
-    __queues__.set(name, []);
-    __queue_stats__.set(name, { added: 0, processed: 0, failed: 0, retried: 0 });
-  }
-  const q = __queues__.get(name);
-  const stats = __queue_stats__.get(name);
-  return {
-    add: async (item, options = {}) => {
-      const job = { id: __generateId__(), item, options, addedAt: new Date(), priority: options.priority || 'normal', attempts: 0 };
-      q.push(job);
-      stats.added++;
-      return job;
-    },
-    process: async (handler) => {
-      while (q.length) {
-        const job = q.shift();
-        try {
-          job.attempts++;
-          await handler(job.item);
-          stats.processed++;
-        } catch (e) {
-          stats.failed++;
-          if (job.attempts < (job.options.maxRetries || 3)) {
-            q.push(job);
-            stats.retried++;
-          }
-        }
-      }
-    },
-    processBatch: async (handler, batchSize = 10) => {
-      const batch = q.splice(0, batchSize);
-      if (batch.length === 0) return;
-      try {
-        await handler(batch.map(j => j.item));
-        stats.processed += batch.length;
-      } catch (e) {
-        stats.failed += batch.length;
-        for (const job of batch) {
-          if (job.attempts < (job.options.maxRetries || 3)) {
-            job.attempts++;
-            q.push(job);
-            stats.retried++;
-          }
-        }
-      }
-    },
-    size: () => q.length,
-    clear: () => { q.length = 0; },
-    stats: () => ({ ...stats, pending: q.length }),
-    peek: (n = 1) => q.slice(0, n).map(j => j.item),
-    getByPriority: (priority) => q.filter(j => j.priority === priority).map(j => j.item)
-  };
-};
-
-const __actors__ = new Map();
-const actor = (type) => ({
-  register: (id, state = {}) => {
-    const key = type + ':' + id;
-    __actors__.set(key, { id, type, state, createdAt: new Date() });
-    return __actors__.get(key);
-  },
-  get: (id) => __actors__.get(type + ':' + id),
-  send: async (id, message) => {
-    const a = __actors__.get(type + ':' + id);
-    if (!a) throw new Error('Actor not found: ' + type + ':' + id);
-    return { delivered: true };
-  }
-});
-
-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()
-    };
-    __actions__.set(id, action);
-    return action;
-  },
-  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);
-    action.status = 'active';
-    action.startedAt = new Date();
-    action.updatedAt = new Date();
-    return action;
-  },
-  async complete(id, result = {}) {
-    const action = __actions__.get(id);
-    if (!action) throw new Error('Action not found: ' + id);
-    action.status = 'completed';
-    action.result = result;
-    action.completedAt = new Date();
-    action.updatedAt = new Date();
-    return action;
-  },
-  async fail(id, error) {
-    const action = __actions__.get(id);
-    if (!action) throw new Error('Action not found: ' + id);
-    action.status = 'failed';
-    action.error = error;
-    action.failedAt = new Date();
-    action.updatedAt = new Date();
-    return action;
-  },
-  async list(options = {}) {
-    let results = Array.from(__actions__.values());
-    if (options.status) results = results.filter(a => a.status === options.status);
-    if (options.actor) results = results.filter(a => a.actor === options.actor);
-    if (options.limit) results = results.slice(0, options.limit);
-    return results;
-  },
-  async retry(id) {
-    const action = __actions__.get(id);
-    if (!action) throw new Error('Action not found: ' + id);
-    action.status = 'pending';
-    action.retryCount = (action.retryCount || 0) + 1;
-    action.updatedAt = new Date();
-    return action;
-  },
-  async cancel(id) {
-    const action = __actions__.get(id);
-    if (!action) throw new Error('Action not found: ' + id);
-    action.status = 'cancelled';
-    action.cancelledAt = new Date();
-    action.updatedAt = new Date();
-    return action;
-  }
-};
-
-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()
-    };
-    __artifacts__.set(id, artifact);
-    return artifact;
-  },
-  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);
-    if (options.limit) results = results.slice(0, options.limit);
-    return results;
-  }
-};
-
-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()
-    };
-    __events__.push(event);
-    return event;
-  },
-  async list(options = {}) {
-    let results = [...__events__];
-    if (options.type) results = results.filter(e => e.type === options.type);
-    if (options.subject) results = results.filter(e => e.subject === options.subject);
-    if (options.limit) results = results.slice(0, options.limit);
-    return results;
-  },
-  async query(options = {}) {
-    let results = [...__events__];
-    if (options.type) results = results.filter(e => e.type === options.type);
-    if (options.subject) results = results.filter(e => e.subject === options.subject);
-    if (options.actor) results = results.filter(e => e.metadata?.actor === options.actor);
-    if (options.from) results = results.filter(e => new Date(e.timestamp) >= new Date(options.from));
-    if (options.to) results = results.filter(e => new Date(e.timestamp) <= new Date(options.to));
-    if (options.orderBy === 'timestamp') {
-      results.sort((a, b) => options.order === 'desc' ? b.timestamp - a.timestamp : a.timestamp - b.timestamp);
-    }
-    if (options.limit) results = results.slice(0, options.limit);
-    return results;
-  },
-  async replay(handler, options = {}) {
-    const evts = await events.list(options);
-    for (const evt of evts) await handler(evt);
-  },
-  subscribe(type, handler) {
-    on(type, handler);
-    return { unsubscribe: () => {} };
-  },
-  async emit(type, data, metadata = {}) {
-    const event = await events.record({ type, data, metadata });
-    await send(type, data);
-    return event;
-  }
-};
-
-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 };
-  const [, frontmatter, body] = frontmatterMatch;
-  const data = {};
-  let currentKey = null;
-  let inArray = false;
-  const lines = frontmatter.split('\\n');
-  for (const line of lines) {
-    const keyMatch = line.match(/^(\\w+):\\s*(.*)$/);
-    if (keyMatch) {
-      currentKey = keyMatch[1];
-      const value = keyMatch[2].trim();
-      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) {
-        if (!Array.isArray(data[currentKey])) data[currentKey] = [];
-        data[currentKey].push(itemMatch[1].trim());
-      }
-    }
-  }
-  return { data, content: body.trim(), type: data.$type || data['@type'] || null, id: data.$id || data['@id'] || null };
-};
-
-const stringify = (doc) => {
-  const lines = ['---'];
-  if (doc.type) lines.push('$type: ' + doc.type);
-  if (doc.id) lines.push('$id: ' + doc.id);
-  for (const [key, value] of Object.entries(doc.data || {})) {
-    if (Array.isArray(value)) {
-      lines.push(key + ':');
-      for (const item of value) lines.push('  - ' + item);
-    } else lines.push(key + ': ' + value);
-  }
-  lines.push('---');
-  if (doc.content) lines.push('', doc.content);
-  return lines.join('\\n');
-};
-
-const toAst = (doc) => {
-  const children = [];
-  const lines = (doc.content || '').split('\\n');
-  for (const line of lines) {
-    if (line.startsWith('# ')) children.push({ type: 'heading', depth: 1, text: line.slice(2) });
-    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)] });
-    } 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 });
-  }
-  return { type: 'root', children };
-};
-
-const renderMarkdown = (doc, options = {}) => {
-  let result = '';
-  if (options.includeFrontmatter && doc.data && Object.keys(doc.data).length > 0) {
-    result += '---\\n';
-    if (doc.type) result += '$type: ' + doc.type + '\\n';
-    for (const [key, value] of Object.entries(doc.data)) {
-      if (Array.isArray(value)) {
-        result += key + ':\\n';
-        for (const item of value) result += '  - ' + item + '\\n';
-      } else result += key + ': ' + value + '\\n';
-    }
-    result += '---\\n';
-  }
-  result += doc.content || '';
-  return result;
-};
-
-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'];
-  for (const name of componentNames) {
-    components[name] = (props) => createElement(name.toLowerCase() === 'hero' ? 'header' : 'section', { 'data-component': name, ...props });
-  }
-  return components;
-};
-
-const getComponentNames = () => ['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'];
-
-const getComponentMeta = (name) => ({
-  category: ['Hero', 'Features', 'Pricing', 'CTA', 'Testimonials'].includes(name) ? 'landing' : 'ui',
-  requiredProps: name === 'Hero' ? ['title'] : [],
-  related: name === 'Hero' ? ['CTA', 'Features'] : []
-});
-
-const getComponentsByCategory = (category) => {
-  if (category === 'landing') return ['Hero', 'Features', 'Pricing', 'CTA', 'Testimonials'];
-  return ['Card', 'Button', 'Input', 'Form'];
-};
-
-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() });
-  return tests;
-};
-
-const parseMeta = (meta) => {
-  const result = {};
-  const parts = meta.split(/\\s+/);
-  for (const part of parts) {
-    if (part.includes('=')) {
-      const [key, value] = part.split('=');
-      result[key] = value;
-    } else result[part] = true;
-  }
-  return result;
-};
-
-const createElement = (type, props, ...children) => ({ type, props: props || {}, children });
-
-const extractLinks = (content) => {
-  const links = [];
-  const regex = /\\[([^\\]]+)\\]\\(([^)]+)\\)/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) links.push({ text: match[1], url: match[2] });
-  return links;
-};
-
-const extractRelationships = (doc) => {
-  const relationships = [];
-  const url = doc.id || doc.url;
-  if (!url) return relationships;
-  const links = extractLinks(doc.content || '');
-  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 });
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (typeof item === 'string' && (item.startsWith('http') || item.startsWith('/'))) {
-          relationships.push({ from: url, to: item, type: key });
-        }
-      }
-    }
-  }
-  return relationships;
-};
-
-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;
-  return null;
-};
-`
-}
-
-function getContextObjectTemplate(): string {
-  return `
-// Context object ($) - unified SDK context (aligned with ai-workflows WorkflowContext)
-const $ = {
-  ns: __SDK_CONFIG__.ns,
-  db,
-  ai,
-  on,
-  every,
-  send,
-  do: __doEvent__,
-  try: __tryEvent__,
-  queue,
-  actor,
-  actions,
-  artifacts,
-  events,
-  decide,
-  track,
-  experiment,
-  delay,
-  state: {},
-  history: __workflow_history__,
-  user: { id: 'test-user', name: 'Test User', role: 'admin' },
-  request: { method: 'GET', path: '/', headers: {}, body: null },
-  env: { NODE_ENV: 'test' },
-  config: {},
-  context: {},
-  meta: {},
-  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,
-  async scope(overrides, fn) {
-    const prev = { ns: $.ns, user: $.user, state: { ...$.state } };
-    Object.assign($, overrides);
-    try { return await fn(); }
-    finally { Object.assign($, prev); }
-  },
-  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
-const api = {};
-const search = __db_core__.search.bind(__db_core__);
-`
-}
-
-// 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)
-// ============================================================
-
-const __SDK_CONFIG__ = {
-  rpcUrl: '${rpcUrl}',
-  token: '${token}',
-  ns: '${ns}'
-};
-
-// HTTP RPC client
-const __rpc__ = {
-  async do(path, ...args) {
-    const headers = { 'Content-Type': 'application/json' };
-    if (__SDK_CONFIG__.token) {
-      headers['Authorization'] = 'Bearer ' + __SDK_CONFIG__.token;
-    }
-
-    const serializedArgs = args.map(arg => {
-      if (typeof arg === 'function') {
-        return { __fn: arg.toString().replace(/"/g, "'") };
-      }
-      return arg;
-    });
-
-    const response = await fetch(__SDK_CONFIG__.rpcUrl + '/rpc', {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ method: 'do', path, args: serializedArgs })
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || 'RPC error: ' + response.statusText);
-    }
-
-    return response.json();
-  }
-};
-
-const __userDefinitions__ = new Map();
-
-const __createProxy__ = (path = '') => {
-  const localStore = new Map();
-
-  const proxy = new Proxy(() => {}, {
-    get: (target, prop, receiver) => {
-      if (prop === 'toJSON') {
-        const obj = { __rpcPath: path };
-        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;
-          }
-        }
-        return () => obj;
-      }
-      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;
-      if (prop === 'should') {
-        const obj = {};
-        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 (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);
-
-      if (localStore.has(String(prop))) return localStore.get(String(prop));
-      if (__userDefinitions__.has(fullPath)) return __userDefinitions__.get(fullPath);
-
-      return __createProxy__(fullPath);
-    },
-
-    set: (_, prop, value) => {
-      const fullPath = path ? path + '.' + String(prop) : String(prop);
-      localStore.set(String(prop), value);
-      __userDefinitions__.set(fullPath, value);
-      return true;
-    },
-
-    apply: (_, __, args) => {
-      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);
-    },
-
-    ownKeys: () => {
-      const keys = [];
-      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);
-          if (localKey && !keys.includes(localKey)) keys.push(localKey);
-        }
-      }
-      return keys;
-    },
-
-    getOwnPropertyDescriptor: (_, prop) => {
-      const fullPath = path ? path + '.' + String(prop) : String(prop);
-      if (localStore.has(String(prop)) || __userDefinitions__.has(fullPath)) {
-        return { configurable: true, enumerable: true, writable: true };
-      }
-      return undefined;
-    }
-  });
-
-  return proxy;
-};
-
-const $ = __createProxy__();
-const db = $.db;
-const ai = $.ai;
-const api = $.api;
-const on = $.on;
-const send = $.send;
-const search = $.search;
-const track = $.track;
-const every = $.every;
-const decide = $.decide;
-
-$.ns = __SDK_CONFIG__.ns;
-$.user = { id: 'anonymous', name: 'Anonymous', role: 'guest' };
-$.request = { method: 'GET', path: '/', headers: {}, body: null };
-$.env = typeof process !== 'undefined' ? (process.env || {}) : {};
-$.config = {};
-$.context = {};
-$.meta = {};
-`
-}