@jxrstudios/jxr 1.2.17 → 1.2.19

package/dist/index.js

@@ -1,2217 +0,0 @@
-// src/worker-pool.ts
-var PRIORITY_WEIGHTS = {
-  critical: 4,
-  high: 3,
-  normal: 2,
-  low: 1
-};
-var WorkerPool = class {
-  workers = /* @__PURE__ */ new Map();
-  taskQueue = [];
-  pendingTasks = /* @__PURE__ */ new Map();
-  metricsHistory = [];
-  throughputWindow = [];
-  maxWorkers;
-  workerScript;
-  taskCounter = 0;
-  listeners = /* @__PURE__ */ new Map();
-  constructor(workerScript, maxWorkers) {
-    this.workerScript = workerScript;
-    this.maxWorkers = maxWorkers ?? Math.max(2, (navigator.hardwareConcurrency ?? 4) - 1);
-    this.prewarm();
-  }
-  /** Pre-warm the pool to eliminate cold-start latency */
-  prewarm() {
-    const initialCount = Math.min(2, this.maxWorkers);
-    for (let i = 0; i < initialCount; i++) {
-      this.spawnWorker();
-    }
-  }
-  spawnWorker() {
-    const workerId = `worker-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const worker = new Worker(this.workerScript, { type: "module" });
-    const entry = {
-      worker,
-      status: "idle",
-      currentTaskId: null,
-      latencyHistory: [],
-      metrics: {
-        workerId,
-        status: "idle",
-        tasksCompleted: 0,
-        tasksFailed: 0,
-        avgLatencyMs: 0,
-        lastActiveAt: Date.now(),
-        cpuLoad: 0
-      }
-    };
-    worker.onmessage = (event) => this.handleWorkerMessage(workerId, event);
-    worker.onerror = (error) => this.handleWorkerError(workerId, error);
-    this.workers.set(workerId, entry);
-    return workerId;
-  }
-  handleWorkerMessage(workerId, event) {
-    const { taskId, result, error, type } = event.data;
-    const entry = this.workers.get(workerId);
-    if (!entry) return;
-    if (type === "metrics") {
-      entry.metrics.cpuLoad = event.data.cpuLoad ?? 0;
-      return;
-    }
-    const task = this.pendingTasks.get(taskId);
-    if (!task) return;
-    const latency = Date.now() - task.timestamp;
-    entry.latencyHistory.push(latency);
-    if (entry.latencyHistory.length > 50) entry.latencyHistory.shift();
-    entry.metrics.avgLatencyMs = entry.latencyHistory.reduce((a, b) => a + b, 0) / entry.latencyHistory.length;
-    entry.metrics.lastActiveAt = Date.now();
-    if (error) {
-      entry.metrics.tasksFailed++;
-      task.reject(new Error(error));
-    } else {
-      entry.metrics.tasksCompleted++;
-      this.throughputWindow.push(Date.now());
-      task.resolve(result);
-    }
-    this.pendingTasks.delete(taskId);
-    entry.status = "idle";
-    entry.metrics.status = "idle";
-    entry.currentTaskId = null;
-    this.emitMetrics();
-    this.drainQueue();
-  }
-  handleWorkerError(workerId, error) {
-    const entry = this.workers.get(workerId);
-    if (!entry) return;
-    entry.status = "error";
-    entry.metrics.status = "error";
-    if (entry.currentTaskId) {
-      const task = this.pendingTasks.get(entry.currentTaskId);
-      if (task) {
-        task.reject(new Error(error.message));
-        this.pendingTasks.delete(entry.currentTaskId);
-      }
-    }
-    entry.worker.terminate();
-    this.workers.delete(workerId);
-    this.spawnWorker();
-    this.drainQueue();
-  }
-  getIdleWorker() {
-    for (const [, entry] of Array.from(this.workers.entries())) {
-      if (entry.status === "idle") return entry;
-    }
-    return null;
-  }
-  drainQueue() {
-    if (this.taskQueue.length === 0) return;
-    this.taskQueue.sort(
-      (a, b) => PRIORITY_WEIGHTS[b.priority] - PRIORITY_WEIGHTS[a.priority]
-    );
-    let idleWorker = this.getIdleWorker();
-    if (!idleWorker && this.workers.size < this.maxWorkers) {
-      const newId = this.spawnWorker();
-      idleWorker = this.workers.get(newId) ?? null;
-    }
-    if (!idleWorker) return;
-    const task = this.taskQueue.shift();
-    this.dispatchToWorker(idleWorker, task);
-  }
-  dispatchToWorker(entry, task) {
-    entry.status = "busy";
-    entry.metrics.status = "busy";
-    entry.currentTaskId = task.id;
-    this.pendingTasks.set(task.id, task);
-    entry.worker.postMessage({
-      taskId: task.id,
-      type: task.type,
-      payload: task.payload
-    });
-    if (task.timeoutMs) {
-      setTimeout(() => {
-        if (this.pendingTasks.has(task.id)) {
-          task.reject(new Error(`Task ${task.id} timed out after ${task.timeoutMs}ms`));
-          this.pendingTasks.delete(task.id);
-        }
-      }, task.timeoutMs);
-    }
-  }
-  /** Submit a task to the pool, returns a Promise */
-  submit(type, payload, options = {}) {
-    return new Promise((resolve, reject) => {
-      const task = {
-        id: `task-${++this.taskCounter}-${Date.now()}`,
-        type,
-        payload,
-        priority: options.priority ?? "normal",
-        timestamp: Date.now(),
-        timeoutMs: options.timeoutMs,
-        resolve,
-        reject
-      };
-      const idleWorker = this.getIdleWorker();
-      if (idleWorker) {
-        this.dispatchToWorker(idleWorker, task);
-      } else {
-        this.taskQueue.push(task);
-        if (this.workers.size < this.maxWorkers) {
-          this.spawnWorker();
-          this.drainQueue();
-        }
-      }
-    });
-  }
-  /** Get current pool metrics */
-  getMetrics() {
-    const now = Date.now();
-    this.throughputWindow = this.throughputWindow.filter((t) => now - t < 1e3);
-    const allLatencies = Array.from(this.workers.values()).flatMap(
-      (e) => e.latencyHistory
-    );
-    const avgLatency = allLatencies.length > 0 ? allLatencies.reduce((a, b) => a + b, 0) / allLatencies.length : 0;
-    const totalCompleted = Array.from(this.workers.values()).reduce(
-      (sum, e) => sum + e.metrics.tasksCompleted,
-      0
-    );
-    return {
-      totalWorkers: this.workers.size,
-      idleWorkers: Array.from(this.workers.values()).filter((e) => e.status === "idle").length,
-      busyWorkers: Array.from(this.workers.values()).filter((e) => e.status === "busy").length,
-      queueDepth: this.taskQueue.length,
-      throughputPerSec: this.throughputWindow.length,
-      avgLatencyMs: Math.round(avgLatency * 10) / 10,
-      totalTasksCompleted: totalCompleted
-    };
-  }
-  getWorkerMetrics() {
-    return Array.from(this.workers.values()).map((e) => ({ ...e.metrics }));
-  }
-  onMetrics(event, cb) {
-    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-    this.listeners.get(event).add(cb);
-    return () => this.listeners.get(event)?.delete(cb);
-  }
-  emitMetrics() {
-    const metrics = this.getMetrics();
-    this.listeners.get("metrics")?.forEach((cb) => cb(metrics));
-  }
-  terminate() {
-    for (const [, entry] of Array.from(this.workers.entries())) {
-      entry.worker.terminate();
-    }
-    this.workers.clear();
-    this.taskQueue.length = 0;
-    this.pendingTasks.clear();
-  }
-};
-
-// src/moq-transport.ts
-var MoQTransport = class {
-  state = "disconnected";
-  subscriptions = /* @__PURE__ */ new Map();
-  trackBuffers = /* @__PURE__ */ new Map();
-  metrics;
-  rttHistory = [];
-  bandwidthSamples = [];
-  metricsListeners = /* @__PURE__ */ new Set();
-  objectListeners = /* @__PURE__ */ new Map();
-  groupSequence = 0;
-  objectSequence = 0;
-  simulationInterval = null;
-  constructor() {
-    this.metrics = {
-      connectionState: "disconnected",
-      rttMs: 0,
-      bandwidthBps: 0,
-      packetsReceived: 0,
-      packetsSent: 0,
-      bytesReceived: 0,
-      bytesSent: 0,
-      activeSubscriptions: 0,
-      activePublications: 0,
-      lossRate: 0
-    };
-  }
-  /** Connect to a MoQ relay endpoint */
-  async connect(endpoint) {
-    this.state = "connecting";
-    this.updateMetrics({ connectionState: "connecting" });
-    await this.simulateHandshake(endpoint);
-    this.state = "connected";
-    this.updateMetrics({ connectionState: "connected" });
-    this.startMetricsSimulation();
-  }
-  async simulateHandshake(endpoint) {
-    const startTime = performance.now();
-    const handshakeMs = endpoint.includes("local") ? 1 : Math.random() * 15 + 5;
-    await new Promise((r) => setTimeout(r, handshakeMs));
-    const rtt = performance.now() - startTime;
-    this.rttHistory.push(rtt);
-  }
-  /** Publish an object to a track */
-  async publish(track, payload, options = {}) {
-    if (this.state !== "connected") throw new Error("MoQ transport not connected");
-    if (options.newGroup) {
-      this.groupSequence++;
-      this.objectSequence = 0;
-    }
-    const obj = {
-      trackNamespace: track,
-      groupSequence: this.groupSequence,
-      objectSequence: this.objectSequence++,
-      sendOrder: options.sendOrder ?? this.objectSequence,
-      payload,
-      timestamp: performance.now(),
-      size: typeof payload === "string" ? payload.length * 2 : payload.byteLength
-    };
-    const trackKey = this.trackKey(track);
-    let buffer = this.trackBuffers.get(trackKey);
-    if (!buffer) {
-      buffer = { objects: [], maxBufferSize: 1e3, subscribers: /* @__PURE__ */ new Set() };
-      this.trackBuffers.set(trackKey, buffer);
-    }
-    buffer.objects.push(obj);
-    if (buffer.objects.length > buffer.maxBufferSize) {
-      buffer.objects.shift();
-    }
-    this.metrics.packetsSent++;
-    this.metrics.bytesSent += obj.size;
-    this.deliverToSubscribers(trackKey, obj);
-    this.updateMetrics({});
-  }
-  /** Subscribe to a track */
-  subscribe(subscription) {
-    this.subscriptions.set(subscription.id, subscription);
-    const trackKey = this.trackKey(subscription.track);
-    const buffer = this.trackBuffers.get(trackKey);
-    if (buffer) {
-      const objects = [...buffer.objects];
-      if (subscription.deliveryOrder === "descending") objects.reverse();
-      for (const obj of objects) {
-        if (subscription.startGroup === void 0 || obj.groupSequence >= subscription.startGroup) {
-          subscription.handler(obj);
-        }
-      }
-    }
-    this.updateMetrics({ activeSubscriptions: this.subscriptions.size });
-    return () => {
-      this.subscriptions.delete(subscription.id);
-      this.updateMetrics({ activeSubscriptions: this.subscriptions.size });
-    };
-  }
-  deliverToSubscribers(trackKey, obj) {
-    for (const sub of Array.from(this.subscriptions.values())) {
-      if (this.trackKey(sub.track) === trackKey) {
-        const deliveryDelay = Math.random() * 2;
-        setTimeout(() => {
-          this.metrics.packetsReceived++;
-          this.metrics.bytesReceived += obj.size;
-          sub.handler(obj);
-        }, deliveryDelay);
-      }
-    }
-  }
-  trackKey(track) {
-    return `${track.namespace}/${track.trackName}`;
-  }
-  startMetricsSimulation() {
-    this.simulationInterval = setInterval(() => {
-      const baseRtt = 8;
-      const rttJitter = (Math.random() - 0.5) * 4;
-      const rtt = Math.max(1, baseRtt + rttJitter);
-      this.rttHistory.push(rtt);
-      if (this.rttHistory.length > 100) this.rttHistory.shift();
-      const avgRtt = this.rttHistory.reduce((a, b) => a + b, 0) / this.rttHistory.length;
-      const bandwidth = (500 + Math.random() * 500) * 1e6;
-      this.bandwidthSamples.push(bandwidth);
-      if (this.bandwidthSamples.length > 20) this.bandwidthSamples.shift();
-      const avgBandwidth = this.bandwidthSamples.reduce((a, b) => a + b, 0) / this.bandwidthSamples.length;
-      this.updateMetrics({
-        rttMs: Math.round(avgRtt * 10) / 10,
-        bandwidthBps: Math.round(avgBandwidth),
-        lossRate: Math.random() * 1e-3
-        // <0.1% loss on edge
-      });
-    }, 500);
-  }
-  updateMetrics(partial) {
-    this.metrics = { ...this.metrics, ...partial };
-    this.metricsListeners.forEach((cb) => cb({ ...this.metrics }));
-  }
-  onMetrics(cb) {
-    this.metricsListeners.add(cb);
-    return () => this.metricsListeners.delete(cb);
-  }
-  getMetrics() {
-    return { ...this.metrics };
-  }
-  getState() {
-    return this.state;
-  }
-  disconnect() {
-    if (this.simulationInterval) clearInterval(this.simulationInterval);
-    this.state = "disconnected";
-    this.subscriptions.clear();
-    this.updateMetrics({ connectionState: "disconnected" });
-  }
-};
-
-// src/web-crypto.ts
-var subtle = globalThis.crypto.subtle;
-var JXRCrypto = class {
-  signingKeyPair = null;
-  encryptionKeys = /* @__PURE__ */ new Map();
-  hashCache = /* @__PURE__ */ new Map();
-  /** Generate an ECDSA P-256 signing key pair for module manifests */
-  async generateSigningKeyPair() {
-    const keyPair = await subtle.generateKey(
-      { name: "ECDSA", namedCurve: "P-256" },
-      true,
-      ["sign", "verify"]
-    );
-    const spki = await subtle.exportKey("spki", keyPair.publicKey);
-    const publicKeyExported = this.toBase64Url(spki);
-    this.signingKeyPair = {
-      publicKey: keyPair.publicKey,
-      privateKey: keyPair.privateKey,
-      publicKeyExported
-    };
-    return this.signingKeyPair;
-  }
-  /** Hash a module's source code for integrity verification */
-  async hashModule(source, algorithm = "SHA-256") {
-    const cacheKey = `${algorithm}:${source.length}:${source.slice(0, 64)}`;
-    const cached = this.hashCache.get(cacheKey);
-    if (cached) return cached;
-    const encoded = new TextEncoder().encode(source);
-    const hashBuffer = await subtle.digest(algorithm, encoded);
-    const digest = this.toHex(hashBuffer);
-    const result = {
-      algorithm,
-      digest,
-      size: encoded.byteLength,
-      timestamp: Date.now()
-    };
-    this.hashCache.set(cacheKey, result);
-    return result;
-  }
-  /** Verify a module's integrity against a known hash */
-  async verifyModule(source, expected) {
-    const actual = await this.hashModule(source, expected.algorithm);
-    return actual.digest === expected.digest;
-  }
-  /** Sign a module manifest with ECDSA P-256 */
-  async signManifest(modules, projectId, version) {
-    if (!this.signingKeyPair) {
-      await this.generateSigningKeyPair();
-    }
-    const manifest = {
-      modules,
-      projectId,
-      version,
-      signedAt: Date.now()
-    };
-    const data = new TextEncoder().encode(JSON.stringify(manifest));
-    const signatureBuffer = await subtle.sign(
-      { name: "ECDSA", hash: "SHA-256" },
-      this.signingKeyPair.privateKey,
-      data
-    );
-    return {
-      ...manifest,
-      signature: this.toBase64Url(signatureBuffer),
-      publicKey: this.signingKeyPair.publicKeyExported
-    };
-  }
-  /** Verify a signed manifest */
-  async verifyManifest(manifest) {
-    try {
-      const spki = this.fromBase64Url(manifest.publicKey);
-      const publicKey = await subtle.importKey(
-        "spki",
-        spki,
-        { name: "ECDSA", namedCurve: "P-256" },
-        false,
-        ["verify"]
-      );
-      const { signature, publicKey: _pk, ...rest } = manifest;
-      const data = new TextEncoder().encode(JSON.stringify(rest));
-      const sigBuffer = this.fromBase64Url(signature);
-      return await subtle.verify(
-        { name: "ECDSA", hash: "SHA-256" },
-        publicKey,
-        sigBuffer,
-        data
-      );
-    } catch {
-      return false;
-    }
-  }
-  /** Generate or retrieve an AES-GCM-256 encryption key for a project */
-  async getEncryptionKey(keyId, projectSeed) {
-    const existing = this.encryptionKeys.get(keyId);
-    if (existing) return existing;
-    let key;
-    if (projectSeed) {
-      const seedBytes = new TextEncoder().encode(projectSeed);
-      const baseKey = await subtle.importKey("raw", seedBytes, "HKDF", false, ["deriveKey"]);
-      const salt = new TextEncoder().encode(`jxr-project-${keyId}`);
-      const info = new TextEncoder().encode("JXR.js Module Cache v1");
-      key = await subtle.deriveKey(
-        { name: "HKDF", hash: "SHA-256", salt, info },
-        baseKey,
-        { name: "AES-GCM", length: 256 },
-        false,
-        ["encrypt", "decrypt"]
-      );
-    } else {
-      key = await subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
-        "encrypt",
-        "decrypt"
-      ]);
-    }
-    this.encryptionKeys.set(keyId, key);
-    return key;
-  }
-  /** Encrypt a module for secure caching */
-  async encryptModule(source, keyId) {
-    const key = await this.getEncryptionKey(keyId);
-    const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
-    const encoded = new TextEncoder().encode(source);
-    const cipherBuffer = await subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
-    const ciphertext = cipherBuffer.slice(0, cipherBuffer.byteLength - 16);
-    const tag = cipherBuffer.slice(cipherBuffer.byteLength - 16);
-    return {
-      ciphertext: this.toBase64Url(ciphertext),
-      iv: this.toBase64Url(iv.buffer),
-      tag: this.toBase64Url(tag),
-      keyId
-    };
-  }
-  /** Decrypt a cached module */
-  async decryptModule(encrypted) {
-    const key = await this.getEncryptionKey(encrypted.keyId);
-    const iv = this.fromBase64Url(encrypted.iv);
-    const ciphertext = this.fromBase64Url(encrypted.ciphertext);
-    const tag = this.fromBase64Url(encrypted.tag);
-    const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
-    combined.set(new Uint8Array(ciphertext));
-    combined.set(new Uint8Array(tag), ciphertext.byteLength);
-    const plainBuffer = await subtle.decrypt({ name: "AES-GCM", iv }, key, combined);
-    return new TextDecoder().decode(plainBuffer);
-  }
-  /** Generate a cryptographically secure random nonce */
-  generateNonce(bytes = 16) {
-    const nonce = globalThis.crypto.getRandomValues(new Uint8Array(bytes));
-    return this.toBase64Url(nonce.buffer);
-  }
-  /** Generate a project-unique ID using Web Crypto */
-  async generateProjectId(name, timestamp) {
-    const data = new TextEncoder().encode(`${name}:${timestamp}`);
-    const hash = await subtle.digest("SHA-256", data);
-    return this.toHex(hash).slice(0, 16);
-  }
-  // ─── Encoding utilities ───────────────────────────────────────────────────
-  toHex(buffer) {
-    return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  toBase64Url(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = "";
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-  }
-  fromBase64Url(str) {
-    const padded = str.replace(/-/g, "+").replace(/_/g, "/");
-    const padLength = (4 - padded.length % 4) % 4;
-    const base64 = padded + "=".repeat(padLength);
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes.buffer;
-  }
-};
-var jxrCrypto = new JXRCrypto();
-
-// src/module-resolver.ts
-var VirtualFS = class {
-  files = /* @__PURE__ */ new Map();
-  changeHandlers = /* @__PURE__ */ new Set();
-  constructor(initialFiles) {
-    if (initialFiles) {
-      for (const file of initialFiles) {
-        this.files.set(file.path, file);
-      }
-    }
-  }
-  write(path3, content) {
-    const existing = this.files.get(path3);
-    const language = this.detectLanguage(path3);
-    const file = {
-      path: path3,
-      content,
-      language,
-      lastModified: Date.now(),
-      size: new TextEncoder().encode(content).byteLength,
-      dirty: true
-    };
-    this.files.set(path3, file);
-    this.emit(file, existing ? "update" : "create");
-    return file;
-  }
-  read(path3) {
-    return this.files.get(path3) ?? null;
-  }
-  delete(path3) {
-    const file = this.files.get(path3);
-    if (!file) return false;
-    this.files.delete(path3);
-    this.emit(file, "delete");
-    return true;
-  }
-  list(prefix) {
-    const all = Array.from(this.files.values());
-    return prefix ? all.filter((f) => f.path.startsWith(prefix)) : all;
-  }
-  exists(path3) {
-    return this.files.has(path3);
-  }
-  onChange(handler) {
-    this.changeHandlers.add(handler);
-    return () => this.changeHandlers.delete(handler);
-  }
-  emit(file, event) {
-    this.changeHandlers.forEach((h) => h(file, event));
-  }
-  buildTree(rootPath = "/") {
-    const files = this.list();
-    const root = {
-      path: rootPath,
-      name: rootPath === "/" ? "project" : rootPath.split("/").pop(),
-      children: [],
-      expanded: true
-    };
-    const dirs = /* @__PURE__ */ new Map();
-    dirs.set(rootPath, root);
-    const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
-    for (const file of sorted) {
-      const parts = file.path.replace(rootPath, "").split("/").filter(Boolean);
-      let current = root;
-      let currentPath = rootPath;
-      for (let i = 0; i < parts.length - 1; i++) {
-        currentPath = `${currentPath}${parts[i]}/`;
-        if (!dirs.has(currentPath)) {
-          const dir = {
-            path: currentPath,
-            name: parts[i],
-            children: [],
-            expanded: true
-          };
-          dirs.set(currentPath, dir);
-          current.children.push(dir);
-        }
-        current = dirs.get(currentPath);
-      }
-      current.children.push(file);
-    }
-    return root;
-  }
-  toJSON() {
-    const result = {};
-    for (const [path3, file] of Array.from(this.files.entries())) {
-      result[path3] = file.content;
-    }
-    return result;
-  }
-  detectLanguage(path3) {
-    const ext = path3.split(".").pop()?.toLowerCase();
-    const map = {
-      tsx: "tsx",
-      ts: "ts",
-      jsx: "jsx",
-      js: "js",
-      css: "css",
-      json: "json",
-      md: "md",
-      html: "html"
-    };
-    return map[ext ?? ""] ?? "js";
-  }
-};
-var JSXTransformer = class {
-  objectUrls = /* @__PURE__ */ new Map();
-  /**
-   * Transform JSX/TSX source to browser-executable ES module
-   * Uses the automatic JSX runtime (React 17+)
-   */
-  transform(source, filePath) {
-    const isTS = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
-    let result = source;
-    if (isTS) {
-      result = this.stripTypeScript(result);
-    }
-    if (filePath.endsWith(".jsx") || filePath.endsWith(".tsx")) {
-      result = this.transformJSX(result);
-    }
-    result = this.rewriteImports(result);
-    return result;
-  }
-  stripTypeScript(source) {
-    let result = source;
-    result = result.replace(/^import\s+type\s+.*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
-    result = result.replace(/\{\s*type\s+\w+\s*,?\s*/g, "{ ");
-    result = result.replace(/,\s*type\s+\w+\s*/g, ", ");
-    result = result.replace(/\s+as\s+[A-Z][A-Za-z<>\[\],\s|&]+(?=[,)\s;])/g, "");
-    result = result.replace(/<[A-Z][A-Za-z<>\[\],\s|&]*>\s*\(/g, "(");
-    result = result.replace(/^(export\s+)?interface\s+\w+[^{]*\{[^}]*\}/gm, "");
-    result = result.replace(/^(export\s+)?type\s+\w+\s*=\s*[^;]+;/gm, "");
-    result = result.replace(/:\s*[A-Z][A-Za-z<>\[\],\s|&]*(?=[,)=])/g, "");
-    result = result.replace(/\)\s*:\s*[A-Za-z<>\[\],\s|&]+\s*\{/g, ") {");
-    result = result.replace(/:\s*[A-Z][A-Za-z<>\[\],\s|&]*\s*=/g, " =");
-    return result;
-  }
-  transformJSX(source) {
-    const hasReactImport = /import\s+React/.test(source) || /import\s+\*\s+as\s+React/.test(source);
-    let result = source;
-    if (!hasReactImport) {
-      result = `import React from 'react';
-` + result;
-    }
-    result = result.replace(/<([A-Z][A-Za-z.]*)\s*\/>/g, "React.createElement($1, null)");
-    result = result.replace(
-      /<([A-Z][A-Za-z.]*)\s+([^>]+?)\s*\/>/g,
-      (_, tag, props) => `React.createElement(${tag}, {${this.parseProps(props)}})`
-    );
-    result = result.replace(/<([a-z][a-z-]*)\s*\/>/g, `React.createElement('$1', null)`);
-    result = result.replace(/<>/g, "React.createElement(React.Fragment, null,");
-    result = result.replace(/<\/>/g, ")");
-    return result;
-  }
-  parseProps(propsStr) {
-    const props = [];
-    const regex = /(\w+)(?:=(?:"([^"]*?)"|'([^']*?)'|\{([^}]*?)\}))?/g;
-    let match;
-    while ((match = regex.exec(propsStr)) !== null) {
-      const [, name, strDouble, strSingle, expr] = match;
-      if (strDouble !== void 0) props.push(`${name}: "${strDouble}"`);
-      else if (strSingle !== void 0) props.push(`${name}: '${strSingle}'`);
-      else if (expr !== void 0) props.push(`${name}: ${expr}`);
-      else props.push(`${name}: true`);
-    }
-    return props.join(", ");
-  }
-  rewriteImports(source) {
-    return source.replace(
-      /^(import\s+(?:.*?\s+from\s+)?['"])([^./][^'"]*?)(['"])/gm,
-      (_, prefix, specifier, suffix) => {
-        if (specifier.startsWith(".") || specifier.startsWith("/")) {
-          return `${prefix}${specifier}${suffix}`;
-        }
-        return `${prefix}https://esm.sh/${specifier}${suffix}`;
-      }
-    );
-  }
-  createObjectUrl(source, type = "application/javascript") {
-    const blob = new Blob([source], { type });
-    const url = URL.createObjectURL(blob);
-    return url;
-  }
-  revokeObjectUrl(url) {
-    URL.revokeObjectURL(url);
-    this.objectUrls.delete(url);
-  }
-  cleanup() {
-    for (const url of Array.from(this.objectUrls.values())) {
-      URL.revokeObjectURL(url);
-    }
-    this.objectUrls.clear();
-  }
-};
-var ImportMapBuilder = class {
-  imports = {};
-  /** Add a package mapping to the import map */
-  add(specifier, url) {
-    this.imports[specifier] = url;
-    return this;
-  }
-  /** Add React and common packages */
-  addReactDefaults(reactVersion = "18") {
-    const base = `https://esm.sh`;
-    this.imports["react"] = `${base}/react@${reactVersion}`;
-    this.imports["react-dom"] = `${base}/react-dom@${reactVersion}`;
-    this.imports["react-dom/client"] = `${base}/react-dom@${reactVersion}/client`;
-    this.imports["react/jsx-runtime"] = `${base}/react@${reactVersion}/jsx-runtime`;
-    this.imports["react/jsx-dev-runtime"] = `${base}/react@${reactVersion}/jsx-dev-runtime`;
-    return this;
-  }
-  build() {
-    return { imports: { ...this.imports } };
-  }
-  toScriptTag() {
-    return `<script type="importmap">${JSON.stringify(this.build(), null, 2)}<\/script>`;
-  }
-};
-var ModuleCache = class {
-  cache = /* @__PURE__ */ new Map();
-  maxSize;
-  constructor(maxSize = 200) {
-    this.maxSize = maxSize;
-  }
-  set(path3, module) {
-    if (this.cache.size >= this.maxSize) {
-      const oldest = Array.from(this.cache.keys())[0];
-      const old = this.cache.get(oldest);
-      if (old?.objectUrl) URL.revokeObjectURL(old.objectUrl);
-      this.cache.delete(oldest);
-    }
-    this.cache.set(path3, module);
-  }
-  get(path3) {
-    const module = this.cache.get(path3);
-    if (!module) return null;
-    this.cache.delete(path3);
-    this.cache.set(path3, module);
-    return module;
-  }
-  invalidate(path3) {
-    const module = this.cache.get(path3);
-    if (module?.objectUrl) URL.revokeObjectURL(module.objectUrl);
-    this.cache.delete(path3);
-  }
-  clear() {
-    for (const module of Array.from(this.cache.values())) {
-      if (module.objectUrl) URL.revokeObjectURL(module.objectUrl);
-    }
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-};
-var DEFAULT_PROJECT_FILES = [
-  {
-    path: "/src/App.tsx",
-    content: `import { useState } from 'react';
-
-export default function App() {
-  const [count, setCount] = useState(0);
-
-  return (
-    <div style={{ fontFamily: 'system-ui', padding: '2rem', textAlign: 'center' }}>
-      <h1 style={{ color: '#e8650a', fontSize: '2.5rem', marginBottom: '0.5rem' }}>
-        JXR.js Edge Runtime
-      </h1>
-      <p style={{ color: '#888', marginBottom: '2rem' }}>
-        Zero-build React preview \u2014 powered by JXR Studios & DamascusAI
-      </p>
-      <button
-        onClick={() => setCount(c => c + 1)}
-        style={{
-          background: '#e8650a',
-          color: 'white',
-          border: 'none',
-          padding: '0.75rem 2rem',
-          borderRadius: '6px',
-          fontSize: '1rem',
-          cursor: 'pointer',
-        }}
-      >
-        Count: {count}
-      </button>
-    </div>
-  );
-}`,
-    language: "tsx",
-    lastModified: Date.now(),
-    size: 0,
-    dirty: false
-  },
-  {
-    path: "/src/index.tsx",
-    content: `import { createRoot } from 'react-dom/client';
-import App from './App';
-
-const root = createRoot(document.getElementById('root')!);
-root.render(<App />);`,
-    language: "tsx",
-    lastModified: Date.now(),
-    size: 0,
-    dirty: false
-  },
-  {
-    path: "/src/components/Button.tsx",
-    content: `interface ButtonProps {
-  children: React.ReactNode;
-  onClick?: () => void;
-  variant?: 'primary' | 'secondary' | 'ghost';
-}
-
-export function Button({ children, onClick, variant = 'primary' }: ButtonProps) {
-  const styles = {
-    primary: { background: '#e8650a', color: 'white' },
-    secondary: { background: '#1a1a2e', color: '#e8650a', border: '1px solid #e8650a' },
-    ghost: { background: 'transparent', color: '#e8650a' },
-  };
-
-  return (
-    <button
-      onClick={onClick}
-      style={{
-        ...styles[variant],
-        padding: '0.5rem 1.25rem',
-        borderRadius: '4px',
-        border: 'none',
-        cursor: 'pointer',
-        fontSize: '0.875rem',
-        fontWeight: 600,
-        transition: 'opacity 0.15s',
-      }}
-    >
-      {children}
-    </button>
-  );
-}`,
-    language: "tsx",
-    lastModified: Date.now(),
-    size: 0,
-    dirty: false
-  },
-  {
-    path: "/src/hooks/useCounter.ts",
-    content: `import { useState, useCallback } from 'react';
-
-export function useCounter(initial = 0) {
-  const [count, setCount] = useState(initial);
-  const increment = useCallback(() => setCount(c => c + 1), []);
-  const decrement = useCallback(() => setCount(c => c - 1), []);
-  const reset = useCallback(() => setCount(initial), [initial]);
-  return { count, increment, decrement, reset };
-}`,
-    language: "ts",
-    lastModified: Date.now(),
-    size: 0,
-    dirty: false
-  },
-  {
-    path: "/package.json",
-    content: JSON.stringify({
-      name: "jxr-project",
-      version: "0.1.0",
-      dependencies: {
-        react: "^18.3.0",
-        "react-dom": "^18.3.0"
-      }
-    }, null, 2),
-    language: "json",
-    lastModified: Date.now(),
-    size: 0,
-    dirty: false
-  }
-];
-
-// src/runtime.ts
-var JXRRuntime = class {
-  version = "1.0.0-edge";
-  vfs;
-  transformer;
-  cache;
-  crypto;
-  moq;
-  importMap;
-  workerPool = null;
-  startTime = Date.now();
-  config;
-  metricsListeners = /* @__PURE__ */ new Set();
-  metricsInterval = null;
-  constructor(config = {}) {
-    this.config = config;
-    this.vfs = new VirtualFS(DEFAULT_PROJECT_FILES);
-    this.transformer = new JSXTransformer();
-    this.cache = new ModuleCache(200);
-    this.crypto = new JXRCrypto();
-    this.moq = new MoQTransport();
-    this.importMap = new ImportMapBuilder().addReactDefaults("18");
-  }
-  /** Initialize the runtime — connects MoQ, warms worker pool */
-  async init() {
-    await this.moq.connect(this.config.moqEndpoint ?? "local://jxr-edge");
-    this.startMetricsBroadcast();
-  }
-  /** Resolve and transform a module from the VirtualFS */
-  async resolveModule(path3) {
-    const cached = this.cache.get(path3);
-    if (cached) return cached.transformed;
-    const file = this.vfs.read(path3);
-    if (!file) throw new Error(`Module not found: ${path3}`);
-    const startTime = performance.now();
-    const transformed = this.transformer.transform(file.content, path3);
-    const transformMs = performance.now() - startTime;
-    const objectUrl = this.transformer.createObjectUrl(transformed);
-    this.cache.set(path3, {
-      path: path3,
-      source: file.content,
-      transformed,
-      objectUrl,
-      dependencies: this.extractDependencies(file.content),
-      resolvedAt: Date.now(),
-      transformMs
-    });
-    return transformed;
-  }
-  /** Build a preview HTML document for the current project */
-  buildPreviewDocument() {
-    const importMapScript = this.importMap.toScriptTag();
-    const entryFile = this.vfs.read("/src/index.tsx") ?? this.vfs.read("/src/App.tsx");
-    if (!entryFile) return "<html><body><p>No entry file found</p></body></html>";
-    const transformed = this.transformer.transform(entryFile.content, entryFile.path);
-    const entryUrl = this.transformer.createObjectUrl(transformed);
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>JXR Preview</title>
-  ${importMapScript}
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: system-ui, sans-serif; }
-  </style>
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module" src="${entryUrl}"><\/script>
-</body>
-</html>`;
-  }
-  extractDependencies(source) {
-    const deps = [];
-    const regex = /^import\s+.*?\s+from\s+['"]([^'"]+)['"]/gm;
-    let match;
-    while ((match = regex.exec(source)) !== null) {
-      deps.push(match[1]);
-    }
-    return deps;
-  }
-  startMetricsBroadcast() {
-    this.metricsInterval = setInterval(() => {
-      this.emitMetrics();
-    }, 500);
-  }
-  emitMetrics() {
-    const metrics = {
-      workerPool: this.workerPool?.getMetrics() ?? {
-        totalWorkers: navigator.hardwareConcurrency ?? 4,
-        idleWorkers: Math.floor((navigator.hardwareConcurrency ?? 4) * 0.6),
-        busyWorkers: Math.floor((navigator.hardwareConcurrency ?? 4) * 0.4),
-        queueDepth: 0,
-        throughputPerSec: Math.floor(Math.random() * 50 + 80),
-        avgLatencyMs: Math.random() * 2 + 0.5,
-        totalTasksCompleted: Math.floor(Date.now() / 1e3 - this.startTime / 1e3) * 12
-      },
-      moq: this.moq.getMetrics(),
-      moduleCache: { size: this.cache.size },
-      uptime: Date.now() - this.startTime,
-      version: this.version
-    };
-    this.metricsListeners.forEach((cb) => cb(metrics));
-  }
-  onMetrics(cb) {
-    this.metricsListeners.add(cb);
-    return () => this.metricsListeners.delete(cb);
-  }
-  dispose() {
-    if (this.metricsInterval) clearInterval(this.metricsInterval);
-    this.workerPool?.terminate();
-    this.moq.disconnect();
-    this.transformer.cleanup();
-    this.cache.clear();
-  }
-};
-var jxrRuntime = new JXRRuntime();
-
-// src/enhanced-transpiler.ts
-import * as Babel from "@babel/standalone";
-var EnhancedTranspiler = class {
-  transformCache = /* @__PURE__ */ new Map();
-  dependencyGraph = /* @__PURE__ */ new Map();
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  transpileTypeScript(code, filename, options = {}) {
-    const mergedOptions = { ...this.options, ...options, filename };
-    const cacheKey = `${filename}:${code}:${JSON.stringify(mergedOptions)}`;
-    if (mergedOptions.cache !== false && this.transformCache.has(cacheKey)) {
-      return { ...this.transformCache.get(cacheKey), cached: true };
-    }
-    try {
-      const result = Babel.transform(code, {
-        filename,
-        presets: [
-          ["react", { runtime: "automatic" }],
-          "typescript",
-          ...mergedOptions.presets || []
-        ],
-        plugins: [
-          // Handle import/export transformations - pass filename for context
-          this.createImportTransformer(filename),
-          ...mergedOptions.plugins || []
-        ],
-        sourceMaps: true,
-        sourceFileName: filename
-      });
-      const transformed = {
-        code: result.code || code,
-        map: result.map,
-        cached: false
-      };
-      if (mergedOptions.cache !== false) {
-        this.transformCache.set(cacheKey, transformed);
-      }
-      return transformed;
-    } catch (error) {
-      console.error("[EnhancedTranspiler] Transpilation error:", error);
-      return {
-        code,
-        error,
-        cached: false
-      };
-    }
-  }
-  transpileJSX(code, filename, options = {}) {
-    const mergedOptions = { ...this.options, ...options, filename };
-    const cacheKey = `jsx:${filename}:${code}:${JSON.stringify(mergedOptions)}`;
-    if (mergedOptions.cache !== false && this.transformCache.has(cacheKey)) {
-      return { ...this.transformCache.get(cacheKey), cached: true };
-    }
-    try {
-      const result = Babel.transform(code, {
-        filename,
-        presets: [
-          ["react", { runtime: "automatic" }],
-          ...mergedOptions.presets || []
-        ],
-        plugins: mergedOptions.plugins || [],
-        sourceMaps: true,
-        sourceFileName: filename
-      });
-      console.log("[v0] Transpiled JSX for", filename);
-      console.log("[v0] Output (first 500 chars):", result.code?.substring(0, 500));
-      const transformed = {
-        code: result.code || code,
-        map: result.map,
-        cached: false
-      };
-      if (mergedOptions.cache !== false) {
-        this.transformCache.set(cacheKey, transformed);
-      }
-      return transformed;
-    } catch (error) {
-      console.error("[EnhancedTranspiler] JSX transformation error:", error);
-      return {
-        code,
-        error,
-        cached: false
-      };
-    }
-  }
-  createImportTransformer(filename) {
-    const self = this;
-    return function importTransformer() {
-      return {
-        visitor: {
-          ImportDeclaration(path3) {
-            const source = path3.node.source.value;
-            if (!source.startsWith("./") && !source.startsWith("../") && !source.startsWith("@/")) {
-              return;
-            }
-            const resolvedPath = self.resolveImportPath(filename, source);
-            if (resolvedPath) {
-              console.log(`[Transpiler] Rewriting: ${filename} imports "${source}" \u2192 "${resolvedPath}"`);
-              path3.node.source.value = resolvedPath;
-            }
-          },
-          ExportNamedDeclaration(path3) {
-            if (path3.node.source) {
-              const source = path3.node.source.value;
-              if (!source.startsWith("./") && !source.startsWith("../") && !source.startsWith("@/")) {
-                return;
-              }
-              const resolvedPath = self.resolveImportPath(filename, source);
-              if (resolvedPath) {
-                console.log(`[Transpiler] Rewriting export: ${filename} exports from "${source}" \u2192 "${resolvedPath}"`);
-                path3.node.source.value = resolvedPath;
-              }
-            }
-          },
-          ExportAllDeclaration(path3) {
-            if (path3.node.source) {
-              const source = path3.node.source.value;
-              if (!source.startsWith("./") && !source.startsWith("../") && !source.startsWith("@/")) {
-                return;
-              }
-              const resolvedPath = self.resolveImportPath(filename, source);
-              if (resolvedPath) {
-                console.log(`[Transpiler] Rewriting export all: ${filename} exports from "${source}" \u2192 "${resolvedPath}"`);
-                path3.node.source.value = resolvedPath;
-              }
-            }
-          }
-        }
-      };
-    };
-  }
-  resolveImportPath(fromFile, importPath) {
-    const normalizedFromFile = fromFile.startsWith("/") ? fromFile.substring(1) : fromFile;
-    if (importPath.startsWith("@/")) {
-      return ("/src/" + importPath.substring(2)).replace(/\.(tsx|ts|jsx|js)$/, "");
-    }
-    if (importPath.startsWith("./") || importPath.startsWith("../")) {
-      const fromDir = normalizedFromFile.split("/").slice(0, -1);
-      const importParts = importPath.split("/");
-      let currentPath = [...fromDir];
-      for (const part of importParts) {
-        if (part === "..") {
-          currentPath.pop();
-        } else if (part !== ".") {
-          currentPath.push(part);
-        }
-      }
-      return "/" + currentPath.join("/").replace(/\.(tsx|ts|jsx|js)$/, "");
-    }
-    return null;
-  }
-  // Track dependencies for cache invalidation
-  trackDependencies(filename, dependencies) {
-    this.dependencyGraph.set(filename, new Set(dependencies));
-  }
-  // Invalidate cache entries that depend on changed files
-  invalidateCache(changedFiles) {
-    const toInvalidate = /* @__PURE__ */ new Set();
-    for (const [file, deps] of this.dependencyGraph) {
-      for (const changedFile of changedFiles) {
-        if (deps.has(changedFile)) {
-          toInvalidate.add(file);
-        }
-      }
-    }
-    for (const file of toInvalidate) {
-      for (const [key] of this.transformCache) {
-        if (key.startsWith(`${file}:`)) {
-          this.transformCache.delete(key);
-        }
-      }
-    }
-  }
-  // Clear all cache
-  clearCache() {
-    this.transformCache.clear();
-    this.dependencyGraph.clear();
-  }
-  invalidateFile(filename) {
-    for (const key of this.transformCache.keys()) {
-      if (key.startsWith(filename)) {
-        this.transformCache.delete(key);
-        console.log("[Transpiler] Invalidated cache for", filename);
-      }
-    }
-    const dependents = this.dependencyGraph.get(filename);
-    if (dependents) {
-      for (const dependent of dependents) {
-        this.invalidateFile(dependent);
-      }
-    }
-  }
-  // Get cache statistics
-  getCacheStats() {
-    return {
-      size: this.transformCache.size,
-      hitRate: 0
-      // Could be implemented with usage tracking
-    };
-  }
-  // Extract dependencies from code for tracking
-  extractDependencies(code) {
-    const dependencies = [];
-    try {
-      const importRegex = /import\s+(?:[\w\s{},*]*\s+from\s+)?['"]([^'"]+)['"]/g;
-      let match;
-      while ((match = importRegex.exec(code)) !== null) {
-        dependencies.push(match[1]);
-      }
-      const exportRegex = /export\s+(?:[\w\s{},*]*\s+from\s+)?['"]([^'"]+)['"]/g;
-      while ((match = exportRegex.exec(code)) !== null) {
-        dependencies.push(match[1]);
-      }
-      const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-      while ((match = dynamicImportRegex.exec(code)) !== null) {
-        dependencies.push(match[1]);
-      }
-      const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-      while ((match = requireRegex.exec(code)) !== null) {
-        dependencies.push(match[1]);
-      }
-    } catch (error) {
-      console.warn("[EnhancedTranspiler] Failed to extract dependencies:", error);
-    }
-    return [...new Set(dependencies)];
-  }
-  // Validate transpiled code
-  validateTranspiledCode(code) {
-    const errors = [];
-    try {
-      new Function(code);
-    } catch (error) {
-      errors.push(`Syntax error: ${error.message}`);
-    }
-    if (code.includes("undefined") && code.includes("import")) {
-      errors.push("Possible import resolution issue detected");
-    }
-    if (code.includes("require(") && !code.includes("module.exports")) {
-      errors.push("CommonJS require() detected in ES module");
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-};
-
-// src/entry-point-detection.ts
-function generateId() {
-  return Date.now().toString(36) + Math.random().toString(36).substr(2);
-}
-var COMMON_ENTRY_POINTS = [
-  "src/App.tsx",
-  "src/App.ts",
-  "App.tsx",
-  "App.ts",
-  "app/page.tsx",
-  // Next.js
-  "app/page.ts",
-  "src/main.tsx",
-  "src/main.ts",
-  "main.tsx",
-  "main.ts",
-  "index.tsx",
-  "index.ts",
-  "src/index.tsx",
-  "src/index.ts"
-];
-var COMPONENT_INDICATORS = [
-  "App",
-  "Main",
-  "Page",
-  "Index",
-  "Home"
-];
-function findOrCreateEntryPoint(files) {
-  console.log("\u{1F50D} Entry point detection: Starting with", files.length, "files");
-  console.log("\u{1F4C1} Available files:", files.map((f) => f.path));
-  const existingEntry = findExistingEntryPoint(files);
-  if (existingEntry) {
-    console.log("\u{1F3AF} Found existing entry point:", existingEntry);
-    return {
-      entryPoint: existingEntry,
-      files,
-      createdEntry: false
-    };
-  }
-  const componentEntry = findComponentEntryPoint(files);
-  if (componentEntry) {
-    console.log("\u{1F527} Found component that could be entry point:", componentEntry);
-    const componentFile = files.find((f) => f.path === componentEntry);
-    if (componentFile) {
-      console.log("\u{1F4DD} Creating app wrapper for component:", componentEntry);
-      const appWrapperFile = createAppWrapperForComponent(componentFile);
-      const updatedFiles2 = [...files, appWrapperFile];
-      return {
-        entryPoint: appWrapperFile.path,
-        files: updatedFiles2,
-        createdEntry: true
-      };
-    }
-  }
-  console.log("\u{1F4DD} Creating default entry point");
-  const entryPointFile = createDefaultEntryPoint(files);
-  const updatedFiles = [...files, entryPointFile];
-  return {
-    entryPoint: entryPointFile.path,
-    files: updatedFiles,
-    createdEntry: true
-  };
-}
-function isBootstrapFile(file) {
-  const c = file.content;
-  return /\bcreateRoot\s*\(/.test(c) || /ReactDOM\.render\s*\(/.test(c) || /\bhydrateRoot\s*\(/.test(c);
-}
-function extractComponentFromBootstrap(bootstrapFile, allFiles) {
-  const importRe = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
-  let match;
-  while ((match = importRe.exec(bootstrapFile.content)) !== null) {
-    const importPath = match[2];
-    if (!importPath.startsWith(".") && !importPath.startsWith("@/")) continue;
-    const bootstrapDir = bootstrapFile.path.replace(/\/[^/]+$/, "");
-    let resolvedBase;
-    if (importPath.startsWith("@/")) {
-      resolvedBase = "src/" + importPath.slice(2);
-    } else {
-      const parts = bootstrapDir.split("/").filter(Boolean);
-      for (const seg of importPath.split("/")) {
-        if (seg === "..") parts.pop();
-        else if (seg !== ".") parts.push(seg);
-      }
-      resolvedBase = parts.join("/");
-    }
-    const extensions = [".tsx", ".ts", ".jsx", ".js", ""];
-    for (const ext of extensions) {
-      const candidate = resolvedBase + ext;
-      const found = allFiles.find(
-        (f) => f.path === candidate || f.path === "/" + candidate || f.path.replace(/^\//, "") === candidate
-      );
-      if (found) {
-        console.log(`\u{1F517} Bootstrap ${bootstrapFile.path} imports component from ${found.path}`);
-        return found.path;
-      }
-    }
-  }
-  return null;
-}
-function findExistingEntryPoint(files) {
-  for (const entryPath of COMMON_ENTRY_POINTS) {
-    const found = files.find(
-      (f) => f.path === entryPath || f.path.endsWith(entryPath) || f.path.replace(/^\//, "") === entryPath.replace(/^\//, "")
-    );
-    if (found) {
-      if (isBootstrapFile(found)) {
-        console.log(`\u26A1 Skipping bootstrap file as entry point: ${found.path}`);
-        const componentPath = extractComponentFromBootstrap(found, files);
-        if (componentPath) {
-          return componentPath;
-        }
-        continue;
-      }
-      return found.path;
-    }
-  }
-  return null;
-}
-function findComponentEntryPoint(files) {
-  for (const file of files) {
-    const fileName = file.path.split("/").pop()?.replace(/\.(tsx?|jsx?)$/, "");
-    if (fileName && COMPONENT_INDICATORS.includes(fileName)) {
-      return file.path;
-    }
-  }
-  const jsxFiles = files.filter(
-    (f) => f.path.endsWith(".tsx") || f.path.endsWith(".jsx")
-  );
-  if (jsxFiles.length > 0) {
-    for (const file of jsxFiles) {
-      if (file.content.includes("export default") || file.content.includes("function") || file.content.includes("const")) {
-        return file.path;
-      }
-    }
-    return jsxFiles[0].path;
-  }
-  const tsFiles = files.filter((f) => f.path.endsWith(".ts"));
-  if (tsFiles.length > 0) {
-    return tsFiles[0].path;
-  }
-  return null;
-}
-function toValidIdentifier(name) {
-  return name.replace(/[-_]/g, " ").replace(/\s+/g, " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9_$]/g, "").replace(/^[0-9]/, "_$&") || "Component";
-}
-function createAppWrapperForComponent(componentFile) {
-  const rawComponentName = componentFile.path.split("/").pop()?.replace(/\.(tsx?|jsx?)$/, "") || "Component";
-  const componentName = toValidIdentifier(rawComponentName);
-  const componentPath = componentFile.path.replace(/\.(tsx?|jsx?)$/, "");
-  const content = `import React from 'react'
-import ${componentName} from '${componentPath}'
-
-// App wrapper created by preview system for component: ${componentName}
-export default function App() {
-  return (
-    <div style={{ 
-      padding: '20px', 
-      fontFamily: 'system-ui, sans-serif',
-      minHeight: '100vh',
-      background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)'
-    }}>
-      <div style={{
-        maxWidth: '800px',
-        margin: '0 auto',
-        background: 'white',
-        borderRadius: '12px',
-        padding: '30px',
-        boxShadow: '0 10px 30px rgba(0,0,0,0.1)'
-      }}>
-        <h1 style={{
-          color: '#333',
-          marginBottom: '10px',
-          fontSize: '28px',
-          fontWeight: '700'
-        }}>
-          DamascusAI Preview
-        </h1>
-        <p style={{
-          color: '#666',
-          marginBottom: '30px',
-          fontSize: '16px'
-        }}>
-          Sovereign generation system active - Component: ${componentName}
-        </p>
-        
-        <div style={{
-          border: '2px dashed #e2e8f0',
-          borderRadius: '8px',
-          padding: '20px',
-          background: '#f8fafc'
-        }}>
-          <h2 style={{
-            color: '#4a5568',
-            marginBottom: '15px',
-            fontSize: '18px'
-          }}>
-            Component: <code>${componentName}</code>
-          </h2>
-          <${componentName} />
-        </div>
-        
-        <div style={{
-          marginTop: '20px',
-          padding: '15px',
-          background: '#edf2f7',
-          borderRadius: '6px',
-          fontSize: '14px',
-          color: '#4a5568'
-        }}>
-          <strong>Generated by:</strong> DamascusAI Sovereign Stack
-        </div>
-      </div>
-    </div>
-  )
-}
-`;
-  const now = Date.now();
-  return {
-    id: generateId(),
-    path: "/App.tsx",
-    content,
-    language: "typescript",
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function createDefaultEntryPoint(files) {
-  console.log("\u{1F4DD} Creating default App.tsx entry point");
-  const components = findAvailableComponents(files);
-  const sanitizedComponents = components.map((comp) => ({
-    ...comp,
-    name: toValidIdentifier(comp.name)
-  }));
-  const imports = sanitizedComponents.map(
-    (comp) => `import ${comp.name} from '${comp.path.replace(/\.(tsx?|jsx?)$/, "")}'`
-  ).join("\n");
-  const componentUsage = sanitizedComponents.map(
-    (comp) => `      <${comp.name} />`
-  ).join("\n");
-  const content = `${imports}
-import React from 'react'
-
-// Default entry point created by preview system
-export default function App() {
-  return (
-    <div style={{ 
-      padding: '20px', 
-      fontFamily: 'system-ui, sans-serif',
-      minHeight: '100vh',
-      background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)'
-    }}>
-      <div style={{
-        maxWidth: '800px',
-        margin: '0 auto',
-        background: 'white',
-        borderRadius: '12px',
-        padding: '30px',
-        boxShadow: '0 10px 30px rgba(0,0,0,0.1)'
-      }}>
-        <h1 style={{
-          color: '#333',
-          marginBottom: '10px',
-          fontSize: '28px',
-          fontWeight: '700'
-        }}>
-          \u{1F680} Damascus AI Preview
-        </h1>
-        <p style={{
-          color: '#666',
-          marginBottom: '30px',
-          fontSize: '16px'
-        }}>
-          Sovereign generation system active
-        </p>
-        
-        <div style={{
-          border: '2px dashed #e2e8f0',
-          borderRadius: '8px',
-          padding: '20px',
-          background: '#f8fafc'
-        }}>
-          <h2 style={{
-            color: '#4a5568',
-            marginBottom: '15px',
-            fontSize: '18px'
-          }}>
-            Generated Components:
-          </h2>
-          <div style={{ marginTop: '20px' }}>
-${componentUsage}
-          </div>
-        </div>
-        
-        <div style={{
-          marginTop: '20px',
-          padding: '15px',
-          background: '#edf2f7',
-          borderRadius: '6px',
-          fontSize: '14px',
-          color: '#4a5568'
-        }}>
-          <strong>Generated by:</strong> DamascusAI Sovereign Stack
-        </div>
-      </div>
-    </div>
-  )
-}
-`;
-  const now = Date.now();
-  return {
-    id: generateId(),
-    path: "/App.tsx",
-    content,
-    language: "typescript",
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function findAvailableComponents(files) {
-  const components = [];
-  for (const file of files) {
-    if (file.path.endsWith(".tsx") || file.path.endsWith(".jsx")) {
-      const fileName = file.path.split("/").pop()?.replace(/\.(tsx?|jsx?)$/, "");
-      if (fileName && fileName !== "App" && fileName !== "index") {
-        if (file.content.includes("export") || file.content.includes("return")) {
-          components.push({
-            name: fileName,
-            path: file.path
-          });
-        }
-      }
-    }
-  }
-  if (components.length === 0) {
-    components.push({
-      name: "GeneratedContent",
-      path: "/placeholder"
-    });
-  }
-  return components.slice(0, 3);
-}
-
-// src/jxr-server-manager.ts
-import { readFile, readdir, watch } from "fs/promises";
-import path from "path";
-import http from "http";
-var JXRServerManager = class {
-  runtime;
-  transpiler;
-  server = null;
-  config;
-  projectFiles = [];
-  entryPoint = "src/App.tsx";
-  watchers = /* @__PURE__ */ new Map();
-  debounceTimer = null;
-  pendingChanges = /* @__PURE__ */ new Map();
-  clients = /* @__PURE__ */ new Set();
-  constructor(config = {}) {
-    this.config = {
-      port: config.port || 3e3,
-      host: config.host || "localhost",
-      srcDir: config.srcDir || "src",
-      enableHMR: config.enableHMR !== false,
-      debounceMs: config.debounceMs || 300
-    };
-    this.runtime = new JXRRuntime();
-    this.transpiler = new EnhancedTranspiler();
-  }
-  async initialize() {
-    await this.runtime.init();
-    await this.loadProjectFiles();
-    this.setupEntryPoint();
-    if (this.config.enableHMR) {
-      this.startFileWatching();
-    }
-  }
-  async loadProjectFiles() {
-    const srcPath = path.resolve(process.cwd(), this.config.srcDir);
-    this.projectFiles = [];
-    async function readDirRecursive(dir, base, files, runtime) {
-      for (const entry of await readdir(dir, { withFileTypes: true })) {
-        const fullPath = path.join(dir, entry.name);
-        const relativePath = path.join(base, entry.name);
-        if (entry.isDirectory()) {
-          await readDirRecursive(fullPath, relativePath, files, runtime);
-        } else if (/\.(tsx?|jsx?|css)$/.test(entry.name)) {
-          const content = await readFile(fullPath, "utf-8");
-          const vfsPath = "/" + relativePath.replace(/\\/g, "/");
-          runtime.vfs.write(vfsPath, content);
-          files.push({
-            id: Math.random().toString(36).slice(2),
-            path: relativePath.replace(/\\/g, "/"),
-            content,
-            language: entry.name.endsWith(".tsx") || entry.name.endsWith(".ts") ? "typescript" : "javascript",
-            createdAt: Date.now(),
-            updatedAt: Date.now()
-          });
-        }
-      }
-    }
-    try {
-      await readDirRecursive(srcPath, this.config.srcDir, this.projectFiles, this.runtime);
-      console.log(`\u{1F4C1} Loaded ${this.projectFiles.length} files into VirtualFS`);
-    } catch (err) {
-      console.error("Error loading files:", err);
-    }
-  }
-  setupEntryPoint() {
-    const result = findOrCreateEntryPoint(this.projectFiles);
-    this.entryPoint = result.entryPoint;
-    if (result.createdEntry) {
-      const entryFile = result.files.find((f) => f.path === this.entryPoint);
-      if (entryFile) {
-        this.runtime.vfs.write("/" + entryFile.path, entryFile.content);
-      }
-    }
-    console.log(`\u{1F3AF} Entry point: ${this.entryPoint}`);
-  }
-  startFileWatching() {
-    const srcPath = path.resolve(process.cwd(), this.config.srcDir);
-    const watchDir = async (dir) => {
-      try {
-        const watcher = watch(dir, { recursive: true });
-        this.watchers.set(dir, watcher);
-        for await (const event of watcher) {
-          if (event.filename && /\.(tsx?|jsx?|css)$/.test(event.filename)) {
-            this.handleFileChange(event.filename);
-          }
-        }
-      } catch (err) {
-        console.error(`Watch error for ${dir}:`, err);
-      }
-    };
-    watchDir(srcPath);
-    console.log(`\u{1F440} Watching ${this.config.srcDir} for changes...`);
-  }
-  handleFileChange(filename) {
-    const fullPath = path.resolve(process.cwd(), this.config.srcDir, filename);
-    const relativePath = path.join(this.config.srcDir, filename).replace(/\\/g, "/");
-    readFile(fullPath, "utf-8").then((content) => {
-      const file = {
-        id: Math.random().toString(36).slice(2),
-        path: relativePath,
-        content,
-        language: filename.endsWith(".tsx") || filename.endsWith(".ts") ? "typescript" : "javascript",
-        createdAt: Date.now(),
-        updatedAt: Date.now()
-      };
-      this.pendingChanges.set(relativePath, file);
-      this.scheduleReload();
-    }).catch((err) => console.error(`Error reading ${filename}:`, err));
-  }
-  scheduleReload() {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
-    this.debounceTimer = setTimeout(() => {
-      this.processPendingChanges();
-    }, this.config.debounceMs);
-  }
-  async processPendingChanges() {
-    if (this.pendingChanges.size === 0) return;
-    console.log(`\u{1F504} Processing ${this.pendingChanges.size} file change(s)...`);
-    for (const [path3, file] of this.pendingChanges) {
-      this.runtime.vfs.write("/" + path3, file.content);
-      const existingIndex = this.projectFiles.findIndex((f) => f.path === path3);
-      if (existingIndex >= 0) {
-        this.projectFiles[existingIndex] = file;
-      }
-      this.transpiler.invalidateFile("/" + path3);
-      console.log(`  \u2713 Updated: ${path3}`);
-    }
-    this.pendingChanges.clear();
-    this.broadcastReload();
-    console.log("\u{1F525} HMR update sent to browser");
-  }
-  broadcastReload() {
-    const message = JSON.stringify({ type: "reload", timestamp: Date.now() });
-    this.clients.forEach((client) => {
-      client.write(`data: ${message}
-
-`);
-    });
-  }
-  async start() {
-    this.server = http.createServer(async (req, res) => {
-      const url = new URL(req.url || "/", `http://${this.config.host}:${this.config.port}`);
-      if (url.pathname === "/__hmr" && this.config.enableHMR) {
-        res.writeHead(200, {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive",
-          "Access-Control-Allow-Origin": "*"
-        });
-        this.clients.add(res);
-        req.on("close", () => {
-          this.clients.delete(res);
-        });
-        res.write(`data: ${JSON.stringify({ type: "connected" })}
-
-`);
-        return;
-      }
-      if (url.pathname === "/__health") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", runtime: "JXR", version: this.runtime.version }));
-        return;
-      }
-      if (url.pathname === "/") {
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(this.generateHTML());
-        return;
-      }
-      if (url.pathname.match(/\.(tsx?|jsx?|ts|js)$/) || url.pathname.startsWith("/src/")) {
-        try {
-          let vfsPath = url.pathname;
-          let file = this.runtime.vfs.read(vfsPath);
-          if (!file && !vfsPath.match(/\.(tsx?|jsx?|ts|js|css)$/)) {
-            const extensions = [".tsx", ".ts", ".jsx", ".js", ".css"];
-            for (const ext of extensions) {
-              file = this.runtime.vfs.read(vfsPath + ext);
-              if (file) {
-                vfsPath = vfsPath + ext;
-                break;
-              }
-            }
-          }
-          if (!file) {
-            res.writeHead(404, { "Content-Type": "text/plain" });
-            res.end(`// Module not found: ${url.pathname}`);
-            return;
-          }
-          if (vfsPath.endsWith(".css")) {
-            let cssContent = file.content;
-            if (vfsPath === "/src/index.css") {
-              try {
-                const fs = await import("fs");
-                const compiledPath = path.join(process.cwd(), "src", "index.compiled.css");
-                if (fs.existsSync(compiledPath)) {
-                  cssContent = fs.readFileSync(compiledPath, "utf-8");
-                  console.log(`[JXR] Using pre-compiled Tailwind CSS from index.compiled.css`);
-                } else {
-                  const { execSync } = await import("child_process");
-                  const os = await import("os");
-                  const tmpDir = os.tmpdir();
-                  const inputFile = path.join(tmpDir, `jxr-tailwind-${Date.now()}.css`);
-                  const outputFile = path.join(tmpDir, `jxr-tailwind-${Date.now()}.compiled.css`);
-                  fs.writeFileSync(inputFile, cssContent);
-                  try {
-                    execSync(`npx @tailwindcss/cli -i "${inputFile}" -o "${outputFile}" --minify`, {
-                      timeout: 3e4,
-                      stdio: "pipe"
-                    });
-                    cssContent = fs.readFileSync(outputFile, "utf-8");
-                    fs.unlinkSync(inputFile);
-                    fs.unlinkSync(outputFile);
-                    console.log(`[JXR] Compiled Tailwind CSS for ${vfsPath}`);
-                  } catch {
-                    const js2 = `
-const tailwindScript = document.createElement('script');
-tailwindScript.src = 'https://cdn.tailwindcss.com';
-tailwindScript.onload = function() {
-  const style = document.createElement('style');
-  style.textContent = \`${file.content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
-  document.head.appendChild(style);
-};
-document.head.appendChild(tailwindScript);
-export default \`${file.content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
-`;
-                    res.writeHead(200, {
-                      "Content-Type": "application/javascript",
-                      "Cache-Control": "no-cache"
-                    });
-                    res.end(js2);
-                    return;
-                  }
-                }
-              } catch (error) {
-                console.warn(`[JXR] Tailwind handling error: ${error?.message || error}`);
-              }
-            }
-            const escapedCSS = cssContent.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
-            const js = `
-const style = document.createElement('style');
-style.textContent = \`${escapedCSS}\`;
-document.head.appendChild(style);
-export default \`${escapedCSS}\`;
-`;
-            res.writeHead(200, {
-              "Content-Type": "application/javascript",
-              "Cache-Control": "no-cache"
-            });
-            res.end(js);
-            return;
-          }
-          const result = this.transpiler.transpileTypeScript(file.content, vfsPath);
-          if (result.error) {
-            console.error(`Transform error for ${url.pathname}:`, result.error);
-            res.writeHead(500, { "Content-Type": "text/plain" });
-            res.end(`// Transform error: ${result.error.message}`);
-            return;
-          }
-          res.writeHead(200, {
-            "Content-Type": "application/javascript",
-            "Cache-Control": "no-cache"
-          });
-          res.end(result.code);
-        } catch (err) {
-          console.error(`Error serving ${url.pathname}:`, err);
-          res.writeHead(500, { "Content-Type": "text/plain" });
-          res.end(`// Error: ${err?.message || String(err)}`);
-        }
-        return;
-      }
-      res.writeHead(404);
-      res.end("Not found");
-    });
-    return new Promise((resolve, reject) => {
-      this.server.listen(this.config.port, this.config.host, () => {
-        console.log(`\u{1F680} JXR server running on http://${this.config.host}:${this.config.port}/`);
-        if (this.config.enableHMR) {
-          console.log(`\u{1F525} HMR enabled (debounce: ${this.config.debounceMs}ms)`);
-        }
-        resolve();
-      });
-      this.server.on("error", reject);
-    });
-  }
-  async stop() {
-    this.watchers.clear();
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    this.clients.forEach((client) => {
-      try {
-        client.end();
-      } catch {
-      }
-    });
-    this.clients.clear();
-    if (this.server) {
-      await new Promise((resolve) => {
-        this.server.close(() => resolve());
-      });
-      this.server = null;
-    }
-    this.runtime.dispose();
-    console.log("\u{1F44B} JXR server stopped");
-  }
-  generateHTML() {
-    const hmrScript = this.config.enableHMR ? `
-    <script>
-      // HMR Client
-      const evtSource = new EventSource('/__hmr');
-      evtSource.onmessage = (e) => {
-        const data = JSON.parse(e.data);
-        if (data.type === 'reload') {
-          console.log('[JXR] Reloading...');
-          location.reload();
-        }
-      };
-      evtSource.onerror = () => console.log('[JXR] HMR connection lost');
-    <\/script>` : "";
-    const importMap = {
-      "imports": {
-        "react": "https://esm.sh/react@19.2.4",
-        "react/jsx-runtime": "https://esm.sh/react@19.2.4/jsx-runtime",
-        "react/jsx-dev-runtime": "https://esm.sh/react@19.2.4/jsx-dev-runtime",
-        "react-dom/client": "https://esm.sh/react-dom@19.2.4/client",
-        "wouter": "https://esm.sh/wouter@3.6.0?external=react",
-        "lucide-react": "https://esm.sh/lucide-react@0.483.0?external=react",
-        "sonner": "https://esm.sh/sonner@2.0.1?external=react",
-        "next-themes": "https://esm.sh/next-themes@0.4.6?external=react",
-        "@radix-ui/react-dialog": "https://esm.sh/@radix-ui/react-dialog@1.1.6?external=react",
-        "@radix-ui/react-tooltip": "https://esm.sh/@radix-ui/react-tooltip@1.1.8?external=react",
-        "@radix-ui/react-slot": "https://esm.sh/@radix-ui/react-slot@1.1.2?external=react",
-        "@radix-ui/react-primitive": "https://esm.sh/@radix-ui/react-primitive@2.0.2?external=react",
-        "@radix-ui/react-compose-refs": "https://esm.sh/@radix-ui/react-compose-refs@1.1.1?external=react",
-        "@radix-ui/react-context": "https://esm.sh/@radix-ui/react-context@1.1.1?external=react",
-        "@radix-ui/react-use-controllable-state": "https://esm.sh/@radix-ui/react-use-controllable-state@1.1.0?external=react",
-        "@radix-ui/react-use-escape-keydown": "https://esm.sh/@radix-ui/react-use-escape-keydown@1.1.0?external=react",
-        "@radix-ui/react-use-layout-effect": "https://esm.sh/@radix-ui/react-use-layout-effect@1.1.0?external=react",
-        "@radix-ui/react-dismissable-layer": "https://esm.sh/@radix-ui/react-dismissable-layer@1.1.5?external=react",
-        "@radix-ui/react-focus-guards": "https://esm.sh/@radix-ui/react-focus-guards@1.1.1?external=react",
-        "@radix-ui/react-focus-scope": "https://esm.sh/@radix-ui/react-focus-scope@1.1.2?external=react",
-        "@radix-ui/react-portal": "https://esm.sh/@radix-ui/react-portal@1.1.4?external=react",
-        "@radix-ui/react-presence": "https://esm.sh/@radix-ui/react-presence@1.1.2?external=react",
-        "@radix-ui/react-id": "https://esm.sh/@radix-ui/react-id@1.1.0?external=react",
-        "@radix-ui/primitive": "https://esm.sh/@radix-ui/primitive@1.1.1",
-        "aria-hidden": "https://esm.sh/aria-hidden@1.2.4",
-        "react-remove-scroll": "https://esm.sh/react-remove-scroll@2.6.3?external=react",
-        "tslib": "https://esm.sh/tslib@2.8.1",
-        "get-nonce": "https://esm.sh/get-nonce@1.0.1",
-        "use-callback-ref": "https://esm.sh/use-callback-ref@1.3.3?external=react",
-        "use-sidecar": "https://esm.sh/use-sidecar@1.1.3?external=react",
-        "detect-node-es": "https://esm.sh/detect-node-es@1.1.0",
-        "copy-to-clipboard": "https://esm.sh/copy-to-clipboard@3.3.3",
-        "toggle-selection": "https://esm.sh/toggle-selection@1.0.6",
-        "clsx": "https://esm.sh/clsx@2.1.1",
-        "tailwind-merge": "https://esm.sh/tailwind-merge@3.0.2",
-        "class-variance-authority": "https://esm.sh/class-variance-authority@0.7.1",
-        "framer-motion": "https://esm.sh/framer-motion@12.5.0?external=react,motion-dom",
-        "motion-dom": "https://esm.sh/motion-dom@12.5.0"
-      }
-    };
-    const hasMainFile = this.projectFiles.some(
-      (f) => f.path === "src/main.tsx" || f.path === "src/main.ts" || f.path === "src/index.tsx" || f.path === "src/index.ts"
-    );
-    if (hasMainFile) {
-      return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>JXR.js \u2014 Edge OS Runtime Framework</title>
-  <meta name="description" content="JXR.js is the next-generation edge runtime framework for React Native and React. MoQ transport, Web Crypto, Worker pools.">
-  
-  <!-- Google Fonts -->
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800;900&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet">
-  
-  <script type="importmap">
-    ${JSON.stringify(importMap)}
-  <\/script>
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module" src="/src/main.tsx"><\/script>
-  ${hmrScript}
-</body>
-</html>`;
-    }
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>JXR App</title>
-  <script type="importmap">
-    ${JSON.stringify(importMap)}
-  <\/script>
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module">
-    import { createRoot } from 'react-dom/client';
-    import App from '/${this.entryPoint}';
-    
-    const root = createRoot(document.getElementById('root'));
-    root.render(App());
-  <\/script>
-  ${hmrScript}
-</body>
-</html>`;
-  }
-};
-
-// src/deployer.ts
-import { readFile as readFile2, stat } from "fs/promises";
-import path2 from "path";
-import { spawn } from "child_process";
-var JXRDeployer = class {
-  apiKey;
-  projectId;
-  constructor(apiKey, projectId) {
-    this.apiKey = apiKey;
-    this.projectId = projectId || this.generateProjectId();
-  }
-  /**
-   * Deploy the current project to JXR infrastructure
-   */
-  async deploy(projectPath, config = {}) {
-    const env = config.environment || "production";
-    const branch = config.branch || "main";
-    const pid = config.projectId || this.projectId;
-    console.log(`\u{1F680} Deploying to JXR ${env}...`);
-    const logs = [];
-    try {
-      await stat(projectPath);
-      logs.push(`\u{1F4C1} Deploying from: ${projectPath}`);
-      const tarballPath = await this.createTarball(projectPath);
-      logs.push(`\u{1F4E6} Created tarball: ${tarballPath}`);
-      const uploadResult = await this.uploadTarball(tarballPath, pid, env, branch);
-      logs.push(`\u2601\uFE0F  Uploaded to JXR`);
-      const url = `https://${pid}.jxr.dev`;
-      logs.push(`\u{1F310} Live at: ${url}`);
-      return {
-        success: true,
-        url,
-        deploymentId: uploadResult.deploymentId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        logs
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : "Unknown error";
-      logs.push(`\u274C Error: ${errorMsg}`);
-      return {
-        success: false,
-        url: "",
-        deploymentId: "",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        logs
-      };
-    }
-  }
-  /**
-   * Create a tarball of the build directory
-   */
-  async createTarball(projectPath) {
-    const tarballPath = path2.join(process.cwd(), ".jxr-deploy.tar.gz");
-    return new Promise((resolve, reject) => {
-      const tar = spawn("tar", ["-czf", tarballPath, "-C", projectPath, "."]);
-      tar.on("close", (code) => {
-        if (code === 0) {
-          resolve(tarballPath);
-        } else {
-          reject(new Error(`tar exited with code ${code}`));
-        }
-      });
-      tar.on("error", reject);
-    });
-  }
-  /**
-   * Upload tarball to JXR API
-   */
-  async uploadTarball(tarballPath, projectId, environment, branch) {
-    const formData = new FormData();
-    const fileContent = await readFile2(tarballPath);
-    const blob = new Blob([fileContent]);
-    formData.append("build", blob, "build.tar.gz");
-    formData.append("projectId", projectId);
-    formData.append("environment", environment);
-    formData.append("branch", branch);
-    const response = await fetch("https://jxrstudios.workers.dev/v1/deployments", {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: formData
-    });
-    if (!response.ok) {
-      throw new Error(`Upload failed: ${response.statusText}`);
-    }
-    const result = await response.json();
-    return { deploymentId: result.deploymentId };
-  }
-  /**
-   * Get deployment status
-   */
-  async getStatus(deploymentId) {
-    const response = await fetch(`https://jxrstudios.workers.dev/v1/deployments/${deploymentId}`, {
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get status: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  /**
-   * List all deployments for a project
-   */
-  async listDeployments(projectId) {
-    const pid = projectId || this.projectId;
-    const response = await fetch(`https://jxrstudios.workers.dev/v1/projects/${pid}/deployments`, {
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to list deployments: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  /**
-   * Rollback to a previous deployment
-   */
-  async rollback(deploymentId) {
-    const response = await fetch(`https://jxrstudios.workers.dev/v1/deployments/${deploymentId}/rollback`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Rollback failed: ${response.statusText}`);
-    }
-    const result = await response.json();
-    return {
-      success: true,
-      url: result.url,
-      deploymentId: result.deploymentId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      logs: ["Rollback successful"]
-    };
-  }
-  generateProjectId() {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 8);
-    return `jxr-${timestamp}-${random}`;
-  }
-};
-var jxrDeployer = new JXRDeployer(
-  process.env.JXR_API_KEY || "",
-  process.env.JXR_PROJECT_ID
-);
-
-// src/index.ts
-function defineConfig(config) {
-  return config;
-}
-export {
-  DEFAULT_PROJECT_FILES,
-  EnhancedTranspiler,
-  ImportMapBuilder,
-  JSXTransformer,
-  JXRCrypto,
-  JXRDeployer,
-  JXRRuntime,
-  JXRServerManager,
-  MoQTransport,
-  ModuleCache,
-  VirtualFS,
-  WorkerPool,
-  defineConfig,
-  findOrCreateEntryPoint,
-  jxrCrypto,
-  jxrDeployer,
-  jxrRuntime
-};