@aprovan/patchwork-compiler 0.1.0 → 0.1.2-dev.6bd527d

package/dist/index.cjs

@@ -0,0 +1,2822 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompileOptionsSchema: () => CompileOptionsSchema,
+  DEFAULT_CLI_IMAGE_CONFIG: () => DEFAULT_CLI_IMAGE_CONFIG,
+  DEFAULT_IMAGE_CONFIG: () => DEFAULT_IMAGE_CONFIG,
+  DEV_SANDBOX: () => DEV_SANDBOX,
+  EsbuildConfigSchema: () => EsbuildConfigSchema,
+  HttpBackend: () => HttpBackend,
+  ImageConfigSchema: () => ImageConfigSchema,
+  ImageRegistry: () => ImageRegistry,
+  IndexedDBBackend: () => IndexedDBBackend,
+  InputSpecSchema: () => InputSpecSchema,
+  ManifestSchema: () => ManifestSchema,
+  MountModeSchema: () => MountModeSchema,
+  MountOptionsSchema: () => MountOptionsSchema,
+  ParentBridge: () => ParentBridge,
+  PlatformSchema: () => PlatformSchema,
+  VFSStore: () => VFSStore,
+  cdnTransformPlugin: () => cdnTransformPlugin,
+  createCompiler: () => createCompiler,
+  createFieldAccessProxy: () => createFieldAccessProxy,
+  createHttpServiceProxy: () => createHttpServiceProxy,
+  createIframeServiceProxy: () => createIframeServiceProxy,
+  createImageRegistry: () => createImageRegistry,
+  createProjectFromFiles: () => createProjectFromFiles,
+  createSingleFileProject: () => createSingleFileProject,
+  detectMainFile: () => detectMainFile,
+  disposeIframeBridge: () => disposeIframeBridge,
+  extractNamespaces: () => extractNamespaces,
+  fetchPackageJson: () => fetchPackageJson,
+  generateIframeBridgeScript: () => generateIframeBridgeScript,
+  generateImportMap: () => generateImportMap,
+  generateNamespaceGlobals: () => generateNamespaceGlobals,
+  getCdnBaseUrl: () => getCdnBaseUrl,
+  getImageRegistry: () => getImageRegistry,
+  injectNamespaceGlobals: () => injectNamespaceGlobals,
+  loadImage: () => loadImage,
+  mountEmbedded: () => mountEmbedded,
+  mountIframe: () => mountIframe,
+  parseImageConfig: () => parseImageConfig,
+  parseImageSpec: () => parseImageSpec,
+  parseManifest: () => parseManifest,
+  reloadEmbedded: () => reloadEmbedded,
+  reloadIframe: () => reloadIframe,
+  removeNamespaceGlobals: () => removeNamespaceGlobals,
+  resolveEntry: () => resolveEntry,
+  safeParseImageConfig: () => safeParseImageConfig,
+  safeParseManifest: () => safeParseManifest,
+  setCdnBaseUrl: () => setCdnBaseUrl,
+  vfsPlugin: () => vfsPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/compiler.ts
+var esbuild = __toESM(require("esbuild-wasm"), 1);
+
+// src/vfs/project.ts
+function createProjectFromFiles(files, id = crypto.randomUUID()) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    fileMap.set(file.path, file);
+  }
+  return { id, entry: resolveEntry(fileMap), files: fileMap };
+}
+function resolveEntry(files) {
+  const paths = Array.from(files.keys());
+  const mainFile = paths.find((p) => /\bmain\.(tsx?|jsx?)$/.test(p));
+  if (mainFile) return mainFile;
+  const indexFile = paths.find((p) => /\bindex\.(tsx?|jsx?)$/.test(p));
+  if (indexFile) return indexFile;
+  const firstTsx = paths.find((p) => /\.(tsx|jsx)$/.test(p));
+  if (firstTsx) return firstTsx;
+  return paths[0] || "main.tsx";
+}
+function detectMainFile(language) {
+  switch (language) {
+    case "tsx":
+    case "typescript":
+      return "main.tsx";
+    case "jsx":
+    case "javascript":
+      return "main.jsx";
+    case "ts":
+      return "main.ts";
+    case "js":
+      return "main.js";
+    default:
+      return "main.tsx";
+  }
+}
+function createSingleFileProject(content, entry = "main.tsx", id = "inline") {
+  return {
+    id,
+    entry,
+    files: /* @__PURE__ */ new Map([[entry, { path: entry, content }]])
+  };
+}
+
+// src/schemas.ts
+var import_zod = require("zod");
+var PlatformSchema = import_zod.z.enum(["browser", "cli"]);
+var EsbuildConfigSchema = import_zod.z.object({
+  target: import_zod.z.string().optional(),
+  format: import_zod.z.enum(["esm", "cjs", "iife"]).optional(),
+  jsx: import_zod.z.enum(["automatic", "transform", "preserve"]).optional(),
+  jsxFactory: import_zod.z.string().optional(),
+  jsxFragment: import_zod.z.string().optional()
+}).strict().optional();
+var FrameworkConfigSchema = import_zod.z.object({
+  // Map of package names to window global names (e.g., { react: 'React' })
+  globals: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  // CDN URLs to preload before widget execution
+  preload: import_zod.z.array(import_zod.z.string()).optional(),
+  // Dependency version overrides for CDN packages (e.g., { react: '18' })
+  deps: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+}).strict().optional();
+var AliasesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional();
+var DependenciesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional();
+var ImageConfigSchema = import_zod.z.object({
+  platform: PlatformSchema,
+  dependencies: DependenciesSchema,
+  esbuild: EsbuildConfigSchema,
+  framework: FrameworkConfigSchema,
+  aliases: AliasesSchema
+}).strict();
+var InputSpecSchema = import_zod.z.object({
+  type: import_zod.z.enum(["string", "number", "boolean", "object", "array"]),
+  default: import_zod.z.unknown().optional(),
+  required: import_zod.z.boolean().optional(),
+  description: import_zod.z.string().optional()
+});
+var ManifestSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  version: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  platform: PlatformSchema,
+  image: import_zod.z.string(),
+  inputs: import_zod.z.record(import_zod.z.string(), InputSpecSchema).optional(),
+  services: import_zod.z.array(import_zod.z.string()).optional(),
+  packages: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+});
+var CompileOptionsSchema = import_zod.z.object({
+  typescript: import_zod.z.boolean().optional()
+}).strict().optional();
+var MountModeSchema = import_zod.z.enum(["embedded", "iframe"]);
+var MountOptionsSchema = import_zod.z.object({
+  target: import_zod.z.custom((v) => v instanceof HTMLElement, {
+    message: "Expected HTMLElement"
+  }),
+  mode: MountModeSchema,
+  sandbox: import_zod.z.array(import_zod.z.string()).optional(),
+  inputs: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+function parseImageConfig(data) {
+  return ImageConfigSchema.parse(data);
+}
+function safeParseImageConfig(data) {
+  const result = ImageConfigSchema.safeParse(data);
+  return result.success ? result.data : null;
+}
+function parseManifest(data) {
+  return ManifestSchema.parse(data);
+}
+function safeParseManifest(data) {
+  const result = ManifestSchema.safeParse(data);
+  return result.success ? result.data : null;
+}
+var DEFAULT_IMAGE_CONFIG = {
+  platform: "browser",
+  esbuild: {
+    target: "es2020",
+    format: "esm",
+    jsx: "automatic"
+  },
+  framework: {}
+};
+var DEFAULT_CLI_IMAGE_CONFIG = {
+  platform: "cli",
+  esbuild: {
+    target: "node20",
+    format: "esm",
+    jsx: "automatic"
+  }
+};
+
+// src/images/loader.ts
+var DEFAULT_CDN_BASE = "https://esm.sh";
+var cdnBaseUrl = DEFAULT_CDN_BASE;
+function setCdnBaseUrl(url) {
+  cdnBaseUrl = url;
+}
+function getCdnBaseUrl() {
+  return cdnBaseUrl;
+}
+function parseImageSpec(spec) {
+  if (spec.startsWith("@")) {
+    const parts = spec.split("/");
+    if (parts.length >= 2) {
+      const scope = parts[0];
+      const nameAndVersion = parts.slice(1).join("/");
+      const atIndex2 = nameAndVersion.lastIndexOf("@");
+      if (atIndex2 > 0) {
+        return {
+          name: `${scope}/${nameAndVersion.slice(0, atIndex2)}`,
+          version: nameAndVersion.slice(atIndex2 + 1)
+        };
+      }
+      return { name: `${scope}/${nameAndVersion}` };
+    }
+  }
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex > 0) {
+    return {
+      name: spec.slice(0, atIndex),
+      version: spec.slice(atIndex + 1)
+    };
+  }
+  return { name: spec };
+}
+async function fetchPackageJson(packageName, version) {
+  const versionSuffix = version ? `@${version}` : "";
+  const url = `${cdnBaseUrl}/${packageName}${versionSuffix}/package.json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch package.json for ${packageName}: ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function loadLocalImage(name) {
+  if (typeof globalThis.require === "undefined" && typeof process === "undefined") {
+    return null;
+  }
+  try {
+    const { createRequire } = await import("module");
+    const { readFile } = await import("fs/promises");
+    const { dirname: dirname3, join: join2 } = await import("path");
+    const require2 = createRequire(importMetaUrl);
+    let packageJsonPath;
+    try {
+      packageJsonPath = require2.resolve(`${name}/package.json`);
+    } catch {
+      return null;
+    }
+    const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    const config = safeParseImageConfig(packageJson.patchwork) || DEFAULT_IMAGE_CONFIG;
+    let setup;
+    let mount;
+    const packageDir = dirname3(packageJsonPath);
+    if (packageJson.main) {
+      try {
+        const mainPath = join2(packageDir, packageJson.main);
+        const imageModule = await import(
+          /* webpackIgnore: true */
+          /* @vite-ignore */
+          mainPath
+        );
+        if (typeof imageModule.setup === "function") {
+          setup = imageModule.setup;
+        }
+        if (typeof imageModule.mount === "function") {
+          mount = imageModule.mount;
+        }
+      } catch {
+      }
+    }
+    return {
+      name: packageJson.name,
+      version: packageJson.version,
+      config,
+      dependencies: packageJson.dependencies || {},
+      setup,
+      mount
+    };
+  } catch {
+    return null;
+  }
+}
+async function loadImage(spec) {
+  const { name, version } = parseImageSpec(spec);
+  const localImage = await loadLocalImage(name);
+  if (localImage) {
+    return localImage;
+  }
+  const packageJson = await fetchPackageJson(name, version);
+  const config = safeParseImageConfig(packageJson.patchwork) || DEFAULT_IMAGE_CONFIG;
+  let setup;
+  let mount;
+  let moduleUrl;
+  if (packageJson.main && typeof window !== "undefined") {
+    try {
+      const versionSuffix = version ? `@${version}` : "";
+      const mainEntry = packageJson.main.startsWith("./") ? packageJson.main.slice(2) : packageJson.main;
+      const importUrl = `${cdnBaseUrl}/${name}${versionSuffix}/${mainEntry}`;
+      moduleUrl = importUrl;
+      const imageModule = await import(
+        /* @vite-ignore */
+        importUrl
+      );
+      if (typeof imageModule.setup === "function") {
+        setup = imageModule.setup;
+      }
+      if (typeof imageModule.mount === "function") {
+        mount = imageModule.mount;
+      }
+    } catch (err) {
+      console.error("[patchwork-compiler] Failed to load image module:", err);
+    }
+  }
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+    moduleUrl,
+    config,
+    dependencies: packageJson.dependencies || {},
+    setup,
+    mount
+  };
+}
+
+// src/images/registry.ts
+var ImageRegistry = class {
+  images = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Map();
+  /**
+   * Get a loaded image by spec
+   */
+  get(spec) {
+    const { name } = parseImageSpec(spec);
+    return this.images.get(name);
+  }
+  /**
+   * Check if an image is loaded
+   */
+  has(spec) {
+    const { name } = parseImageSpec(spec);
+    return this.images.has(name);
+  }
+  /**
+   * Load an image (or return cached)
+   */
+  async load(spec) {
+    const { name } = parseImageSpec(spec);
+    const cached = this.images.get(name);
+    if (cached) {
+      return cached;
+    }
+    const inProgress = this.loading.get(name);
+    if (inProgress) {
+      return inProgress;
+    }
+    const loadPromise = loadImage(spec).then((image) => {
+      this.images.set(name, image);
+      this.loading.delete(name);
+      return image;
+    });
+    this.loading.set(name, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * Preload an image
+   */
+  async preload(spec) {
+    await this.load(spec);
+  }
+  /**
+   * Clear a specific image from cache
+   */
+  clear(spec) {
+    const { name } = parseImageSpec(spec);
+    this.images.delete(name);
+    this.loading.delete(name);
+  }
+  /**
+   * Clear all cached images
+   */
+  clearAll() {
+    this.images.clear();
+    this.loading.clear();
+  }
+  /**
+   * Get all loaded image names
+   */
+  getLoadedNames() {
+    return Array.from(this.images.keys());
+  }
+};
+var globalRegistry = null;
+function getImageRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new ImageRegistry();
+  }
+  return globalRegistry;
+}
+function createImageRegistry() {
+  return new ImageRegistry();
+}
+
+// src/transforms/cdn.ts
+var DEFAULT_CDN_BASE2 = "https://esm.sh";
+var cdnBaseUrl2 = DEFAULT_CDN_BASE2;
+function setCdnBaseUrl2(url) {
+  cdnBaseUrl2 = url;
+}
+var EXTERNAL_PACKAGES = /* @__PURE__ */ new Set(["react", "react-dom", "ink"]);
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "buffer",
+  "child_process",
+  "cluster",
+  "crypto",
+  "dgram",
+  "dns",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "querystring",
+  "readline",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib"
+]);
+function toEsmShUrl(packageName, version, subpath, deps) {
+  let url = `${cdnBaseUrl2}/${packageName}`;
+  if (version) {
+    url += `@${version}`;
+  }
+  if (subpath) {
+    url += `/${subpath}`;
+  }
+  if (deps && Object.keys(deps).length > 0) {
+    const depsStr = Object.entries(deps).map(([name, ver]) => `${name}@${ver}`).join(",");
+    url += `?deps=${depsStr}`;
+  }
+  return url;
+}
+function isBareImport(path) {
+  if (path.startsWith(".") || path.startsWith("/") || path.startsWith("http://") || path.startsWith("https://")) {
+    return false;
+  }
+  return true;
+}
+function parseImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    const parts2 = importPath.split("/");
+    if (parts2.length >= 2) {
+      const packageName2 = `${parts2[0]}/${parts2[1]}`;
+      const subpath2 = parts2.slice(2).join("/");
+      return { packageName: packageName2, subpath: subpath2 || void 0 };
+    }
+  }
+  const parts = importPath.split("/");
+  const packageName = parts[0];
+  const subpath = parts.slice(1).join("/");
+  return { packageName, subpath: subpath || void 0 };
+}
+function matchAlias(importPath, aliases) {
+  for (const [pattern, target] of Object.entries(aliases)) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      if (importPath === prefix || importPath.startsWith(prefix + "/")) {
+        return target;
+      }
+    }
+    if (importPath === pattern) {
+      return target;
+    }
+  }
+  return null;
+}
+function cdnTransformPlugin(options = {}) {
+  const {
+    packages = {},
+    external = [],
+    bundle = false,
+    globals = {},
+    deps = {},
+    aliases = {}
+  } = options;
+  const externalSet = /* @__PURE__ */ new Set([...EXTERNAL_PACKAGES, ...external]);
+  const globalsSet = new Set(Object.keys(globals));
+  return {
+    name: "cdn-transform",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        const aliasTarget = matchAlias(args.path, aliases);
+        if (aliasTarget) {
+          const { packageName, subpath } = parseImportPath(aliasTarget);
+          if (globalsSet.has(packageName)) {
+            return {
+              path: aliasTarget,
+              namespace: "global-inject"
+            };
+          }
+          const version = packages[packageName];
+          let url = toEsmShUrl(
+            packageName,
+            version,
+            subpath,
+            Object.keys(deps).length > 0 ? deps : void 0
+          );
+          if (bundle) {
+            url += url.includes("?") ? "&bundle" : "?bundle";
+          }
+          return {
+            path: url,
+            external: true
+          };
+        }
+        return null;
+      });
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        if (!isBareImport(args.path)) {
+          return null;
+        }
+        const { packageName } = parseImportPath(args.path);
+        if (globalsSet.has(packageName)) {
+          return {
+            path: args.path,
+            namespace: "global-inject"
+          };
+        }
+        return null;
+      });
+      build2.onLoad({ filter: /.*/, namespace: "global-inject" }, (args) => {
+        const { packageName, subpath } = parseImportPath(args.path);
+        const globalName = globals[packageName];
+        if (!globalName) return null;
+        if (subpath) {
+          return {
+            contents: `export * from '${packageName}'; export { default } from '${packageName}';`,
+            loader: "js"
+          };
+        }
+        const contents = `
+const mod = window.${globalName};
+export default mod;
+// Re-export all properties as named exports
+const { ${getCommonExports(packageName).join(", ")} } = mod;
+export { ${getCommonExports(packageName).join(", ")} };
+`;
+        return {
+          contents,
+          loader: "js"
+        };
+      });
+      build2.onResolve({ filter: /.*/ }, (args) => {
+        if (!isBareImport(args.path)) {
+          return null;
+        }
+        if (NODE_BUILTINS.has(args.path)) {
+          return { external: true };
+        }
+        const { packageName, subpath } = parseImportPath(args.path);
+        if (globalsSet.has(packageName)) {
+          return null;
+        }
+        if (externalSet.has(packageName)) {
+          return { external: true };
+        }
+        const version = packages[packageName];
+        let url = toEsmShUrl(
+          packageName,
+          version,
+          subpath,
+          Object.keys(deps).length > 0 ? deps : void 0
+        );
+        if (bundle) {
+          url += url.includes("?") ? "&bundle" : "?bundle";
+        }
+        return {
+          path: url,
+          external: true
+        };
+      });
+    }
+  };
+}
+function getCommonExports(packageName) {
+  const exports2 = {
+    react: [
+      "useState",
+      "useEffect",
+      "useCallback",
+      "useMemo",
+      "useRef",
+      "useContext",
+      "useReducer",
+      "useLayoutEffect",
+      "useId",
+      "createContext",
+      "createElement",
+      "cloneElement",
+      "createRef",
+      "forwardRef",
+      "lazy",
+      "memo",
+      "Fragment",
+      "Suspense",
+      "StrictMode",
+      "Component",
+      "PureComponent",
+      "Children",
+      "isValidElement"
+    ],
+    "react-dom": [
+      "createPortal",
+      "flushSync",
+      "render",
+      "hydrate",
+      "unmountComponentAtNode"
+    ]
+  };
+  return exports2[packageName] || [];
+}
+function generateImportMap(packages) {
+  const imports = {};
+  for (const [name, version] of Object.entries(packages)) {
+    imports[name] = toEsmShUrl(name, version);
+  }
+  return imports;
+}
+
+// src/transforms/vfs.ts
+function dirname(path) {
+  const idx = path.lastIndexOf("/");
+  return idx === -1 ? "." : path.slice(0, idx) || ".";
+}
+function normalizePath(path) {
+  const parts = [];
+  for (const segment of path.split("/")) {
+    if (segment === "..") parts.pop();
+    else if (segment && segment !== ".") parts.push(segment);
+  }
+  return parts.join("/");
+}
+function inferLoader(path, language) {
+  if (language) {
+    switch (language) {
+      case "typescript":
+      case "ts":
+        return "ts";
+      case "tsx":
+        return "tsx";
+      case "javascript":
+      case "js":
+        return "js";
+      case "jsx":
+        return "jsx";
+      case "json":
+        return "json";
+      case "css":
+        return "css";
+    }
+  }
+  const ext = path.split(".").pop();
+  switch (ext) {
+    case "ts":
+      return "ts";
+    case "tsx":
+      return "tsx";
+    case "js":
+      return "js";
+    case "jsx":
+      return "jsx";
+    case "json":
+      return "json";
+    case "css":
+      return "css";
+    default:
+      return "tsx";
+  }
+}
+function normalizeVFSPath(path) {
+  if (path.startsWith("@/")) {
+    return path.slice(2);
+  }
+  return path;
+}
+function resolveRelativePath(importer, target) {
+  const importerDir = dirname(normalizeVFSPath(importer));
+  const combined = importerDir === "." ? target : `${importerDir}/${target}`;
+  return normalizePath(combined);
+}
+function matchAlias2(importPath, aliases) {
+  if (!aliases) return null;
+  for (const [pattern, target] of Object.entries(aliases)) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      if (importPath === prefix || importPath.startsWith(prefix + "/")) {
+        return target;
+      }
+    }
+    if (importPath === pattern) {
+      return target;
+    }
+  }
+  return null;
+}
+function findFile(project, path) {
+  if (project.files.has(path)) return path;
+  const extensions = [".tsx", ".ts", ".jsx", ".js", ".json"];
+  for (const ext of extensions) {
+    if (project.files.has(path + ext)) return path + ext;
+  }
+  for (const ext of extensions) {
+    const indexPath = `${path}/index${ext}`;
+    if (project.files.has(indexPath)) return indexPath;
+  }
+  return null;
+}
+function vfsPlugin(project, options = {}) {
+  return {
+    name: "patchwork-vfs",
+    setup(build2) {
+      build2.onResolve({ filter: /^@\// }, (args) => {
+        const aliased = matchAlias2(args.path, options.aliases);
+        if (aliased) return null;
+        return { path: args.path, namespace: "vfs" };
+      });
+      build2.onResolve({ filter: /^\./ }, (args) => {
+        if (args.namespace !== "vfs") return null;
+        const resolved = resolveRelativePath(args.importer, args.path);
+        return { path: resolved, namespace: "vfs" };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "vfs" }, (args) => {
+        const normalPath = normalizeVFSPath(args.path);
+        const filePath = findFile(project, normalPath);
+        if (!filePath) {
+          throw new Error(`File not found in VFS: ${args.path}`);
+        }
+        const file = project.files.get(filePath);
+        return {
+          contents: file.content,
+          loader: inferLoader(filePath, file.language)
+        };
+      });
+    }
+  };
+}
+
+// src/mount/bridge.ts
+function generateMessageId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function createHttpServiceProxy(proxyUrl) {
+  return {
+    async call(namespace, procedure, args) {
+      const url = `${proxyUrl}/${namespace}/${procedure}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ args: args[0] ?? {} })
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Service call failed: ${response.status} ${response.statusText}`
+        );
+      }
+      const result = await response.json();
+      return result;
+    }
+  };
+}
+function createFieldAccessProxy(namespace, handler) {
+  function createNestedProxy(path) {
+    const fn = (...args) => handler(namespace, path, ...args);
+    return new Proxy(fn, {
+      get(_, nestedName) {
+        if (typeof nestedName === "symbol") return void 0;
+        const newPath = path ? `${path}.${nestedName}` : nestedName;
+        return createNestedProxy(newPath);
+      }
+    });
+  }
+  return new Proxy(
+    {},
+    {
+      get(_, fieldName) {
+        if (typeof fieldName === "symbol") return void 0;
+        return createNestedProxy(fieldName);
+      }
+    }
+  );
+}
+function generateNamespaceGlobals(services, proxy) {
+  const namespaces = {};
+  const uniqueNamespaces = extractNamespaces(services);
+  for (const namespace of uniqueNamespaces) {
+    namespaces[namespace] = createFieldAccessProxy(
+      namespace,
+      (ns, method, ...args) => proxy.call(ns, method, args)
+    );
+  }
+  return namespaces;
+}
+function injectNamespaceGlobals(target, namespaces) {
+  for (const [name, value] of Object.entries(namespaces)) {
+    target[name] = value;
+  }
+}
+function removeNamespaceGlobals(target, namespaceNames) {
+  for (const name of namespaceNames) {
+    delete target[name];
+  }
+}
+function extractNamespaces(services) {
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const service of services) {
+    const parts = service.split(".");
+    if (parts[0]) {
+      namespaces.add(parts[0]);
+    }
+  }
+  return Array.from(namespaces);
+}
+var ParentBridge = class {
+  proxy;
+  pendingCalls = /* @__PURE__ */ new Map();
+  iframes = /* @__PURE__ */ new Set();
+  messageHandler;
+  constructor(proxy) {
+    this.proxy = proxy;
+    this.messageHandler = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.messageHandler);
+    }
+  }
+  /**
+   * Register an iframe to receive messages from
+   */
+  registerIframe(iframe) {
+    this.iframes.add(iframe);
+  }
+  /**
+   * Unregister an iframe
+   */
+  unregisterIframe(iframe) {
+    this.iframes.delete(iframe);
+  }
+  /**
+   * Handle incoming messages from iframes
+   */
+  async handleMessage(event) {
+    const sourceIframe = Array.from(this.iframes).find(
+      (iframe) => iframe.contentWindow === event.source
+    );
+    if (!sourceIframe) {
+      return;
+    }
+    const message = event.data;
+    if (!message || typeof message !== "object") return;
+    if (message.type === "service-call") {
+      const payload = message.payload;
+      try {
+        const result = await this.proxy.call(
+          payload.namespace,
+          payload.procedure,
+          payload.args
+        );
+        const response = {
+          type: "service-result",
+          id: message.id,
+          payload: { result }
+        };
+        sourceIframe.contentWindow?.postMessage(response, "*");
+      } catch (error) {
+        const response = {
+          type: "service-result",
+          id: message.id,
+          payload: {
+            error: error instanceof Error ? error.message : String(error)
+          }
+        };
+        sourceIframe.contentWindow?.postMessage(response, "*");
+      }
+    }
+  }
+  /**
+   * Dispose the bridge
+   */
+  dispose() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.messageHandler);
+    }
+    this.iframes.clear();
+    this.pendingCalls.clear();
+  }
+};
+function createIframeServiceProxy() {
+  const pendingCalls = /* @__PURE__ */ new Map();
+  if (typeof window !== "undefined") {
+    window.addEventListener("message", (event) => {
+      const message = event.data;
+      if (!message || typeof message !== "object") return;
+      if (message.type === "service-result") {
+        const pending = pendingCalls.get(message.id);
+        if (pending) {
+          pendingCalls.delete(message.id);
+          const payload = message.payload;
+          if (payload.error) {
+            pending.reject(new Error(payload.error));
+          } else {
+            pending.resolve(payload.result);
+          }
+        }
+      }
+    });
+  }
+  return {
+    call(namespace, procedure, args) {
+      return new Promise((resolve, reject) => {
+        const id = generateMessageId();
+        pendingCalls.set(id, { resolve, reject });
+        const message = {
+          type: "service-call",
+          id,
+          payload: { namespace, procedure, args }
+        };
+        window.parent.postMessage(message, "*");
+        setTimeout(() => {
+          if (pendingCalls.has(id)) {
+            pendingCalls.delete(id);
+            reject(
+              new Error(`Service call timeout: ${namespace}.${procedure}`)
+            );
+          }
+        }, 3e4);
+      });
+    }
+  };
+}
+function generateIframeBridgeScript(services) {
+  const uniqueNamespaces = extractNamespaces(services);
+  const namespaceAssignments = uniqueNamespaces.map((ns) => `window.${ns} = createNamespaceProxy('${ns}');`).join("\n  ");
+  return `
+(function() {
+  const pendingCalls = new Map();
+
+  window.addEventListener('message', function(event) {
+    const message = event.data;
+    if (!message || typeof message !== 'object') return;
+
+    if (message.type === 'service-result') {
+      const pending = pendingCalls.get(message.id);
+      if (pending) {
+        pendingCalls.delete(message.id);
+        if (message.payload.error) {
+          pending.reject(new Error(message.payload.error));
+        } else {
+          pending.resolve(message.payload.result);
+        }
+      }
+    }
+  });
+
+  function proxyCall(namespace, procedure, args) {
+    return new Promise(function(resolve, reject) {
+      const id = Date.now() + '-' + Math.random().toString(36).slice(2, 11);
+      pendingCalls.set(id, { resolve: resolve, reject: reject });
+
+      window.parent.postMessage({
+        type: 'service-call',
+        id: id,
+        payload: { namespace: namespace, procedure: procedure, args: args }
+      }, '*');
+
+      setTimeout(function() {
+        if (pendingCalls.has(id)) {
+          pendingCalls.delete(id);
+          reject(new Error('Service call timeout: ' + namespace + '.' + procedure));
+        }
+      }, 30000);
+    });
+  }
+
+  // Create a dynamic proxy for a namespace that supports arbitrary nested method calls
+  function createNamespaceProxy(namespace) {
+    function createNestedProxy(path) {
+      var fn = function() {
+        return proxyCall(namespace, path, Array.prototype.slice.call(arguments));
+      };
+
+      return new Proxy(fn, {
+        get: function(_, nestedName) {
+          if (typeof nestedName === 'symbol') return undefined;
+          var newPath = path ? path + '.' + nestedName : nestedName;
+          return createNestedProxy(newPath);
+        }
+      });
+    }
+
+    return new Proxy({}, {
+      get: function(_, fieldName) {
+        if (typeof fieldName === 'symbol') return undefined;
+        return createNestedProxy(fieldName);
+      }
+    });
+  }
+
+  ${namespaceAssignments}
+})();
+`;
+}
+
+// src/mount/embedded.ts
+var mountCounter = 0;
+var importMapInjected = false;
+function injectImportMap(globals, preloadUrls, deps) {
+  if (importMapInjected) return;
+  const existingMap = document.querySelector('script[type="importmap"]');
+  if (existingMap) {
+    importMapInjected = true;
+    return;
+  }
+  const imports = {};
+  const packageNames = Object.keys(globals);
+  packageNames.forEach((pkgName, index) => {
+    if (preloadUrls[index]) {
+      imports[pkgName] = preloadUrls[index];
+    } else if (deps?.[pkgName]) {
+      imports[pkgName] = `https://esm.sh/${pkgName}@${deps[pkgName]}`;
+    } else {
+      imports[pkgName] = `https://esm.sh/${pkgName}`;
+    }
+  });
+  if (imports["react-dom"]) {
+    imports["react-dom/client"] = imports["react-dom"];
+  }
+  const script = document.createElement("script");
+  script.type = "importmap";
+  script.textContent = JSON.stringify({ imports }, null, 2);
+  document.head.insertBefore(script, document.head.firstChild);
+  importMapInjected = true;
+}
+function generateMountId() {
+  return `pw-mount-${Date.now()}-${++mountCounter}`;
+}
+function pickCreateElement(globals) {
+  for (const obj of globals) {
+    const ce = obj?.createElement;
+    if (typeof ce === "function") return ce;
+    const def = obj?.default;
+    if (def && typeof def.createElement === "function") {
+      return def.createElement;
+    }
+  }
+  return null;
+}
+function pickRenderer(globals) {
+  for (const obj of globals) {
+    if (obj && typeof obj.createRoot === "function") {
+      return { kind: "root", createRoot: obj.createRoot };
+    }
+    if (obj && typeof obj.render === "function") {
+      return { kind: "render", render: obj.render };
+    }
+    const def = obj?.default;
+    if (def && typeof def.createRoot === "function") {
+      return { kind: "root", createRoot: def.createRoot };
+    }
+    if (def && typeof def.render === "function") {
+      return { kind: "render", render: def.render };
+    }
+  }
+  return null;
+}
+async function mountEmbedded(widget, options, image, proxy) {
+  const { target, inputs = {} } = options;
+  const mountId = generateMountId();
+  const container = document.createElement("div");
+  container.id = mountId;
+  container.className = "patchwork-widget patchwork-embedded";
+  target.appendChild(container);
+  if (image?.setup) {
+    await image.setup(container);
+  }
+  if (image?.css) {
+    const style = document.createElement("style");
+    style.id = `${mountId}-style`;
+    style.textContent = image.css;
+    document.head.appendChild(style);
+  }
+  const services = widget.manifest.services || [];
+  const namespaceNames = extractNamespaces(services);
+  const namespaces = generateNamespaceGlobals(services, proxy);
+  injectNamespaceGlobals(window, namespaces);
+  const frameworkConfig = image?.config?.framework || {};
+  const preloadUrls = frameworkConfig.preload || [];
+  const globalMapping = frameworkConfig.globals || {};
+  const deps = frameworkConfig.deps || {};
+  injectImportMap(globalMapping, preloadUrls, deps);
+  const preloadedModules = await Promise.all(
+    preloadUrls.map(
+      (url) => import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        url
+      )
+    )
+  );
+  const win = window;
+  const globalNames = Object.values(globalMapping);
+  preloadedModules.forEach((mod, index) => {
+    if (globalNames[index]) {
+      const name = globalNames[index];
+      win[name] = mod;
+    }
+  });
+  const blob = new Blob([widget.code], { type: "application/javascript" });
+  const scriptUrl = URL.createObjectURL(blob);
+  let moduleCleanup;
+  const globalObjects = globalNames.map((n) => win[n]).filter(Boolean);
+  try {
+    const module2 = await import(
+      /* webpackIgnore: true */
+      scriptUrl
+    );
+    if (image?.mount) {
+      const result = await image.mount(module2, container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module2.mount === "function") {
+      const result = await module2.mount(container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module2.render === "function") {
+      const result = await module2.render(container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module2.default === "function") {
+      const Component = module2.default;
+      const createElement = pickCreateElement(globalObjects);
+      const renderer = pickRenderer(globalObjects);
+      if (createElement && renderer?.kind === "root") {
+        const root = renderer.createRoot(container);
+        root.render(createElement(Component, inputs));
+        if (typeof root.unmount === "function") {
+          moduleCleanup = () => root.unmount();
+        }
+      } else if (createElement && renderer?.kind === "render") {
+        renderer.render(createElement(Component, inputs), container);
+      } else {
+        const result = Component(inputs);
+        if (result instanceof HTMLElement) {
+          container.appendChild(result);
+        } else if (typeof result === "string") {
+          container.innerHTML = result;
+        }
+      }
+    }
+  } finally {
+    URL.revokeObjectURL(scriptUrl);
+  }
+  const unmount = () => {
+    if (moduleCleanup) {
+      moduleCleanup();
+    }
+    removeNamespaceGlobals(window, namespaceNames);
+    const style = document.getElementById(`${mountId}-style`);
+    if (style) {
+      style.remove();
+    }
+    container.remove();
+  };
+  return {
+    id: mountId,
+    widget,
+    mode: "embedded",
+    target,
+    inputs,
+    unmount
+  };
+}
+async function reloadEmbedded(mounted, widget, image, proxy) {
+  mounted.unmount();
+  return mountEmbedded(
+    widget,
+    { target: mounted.target, mode: "embedded", inputs: mounted.inputs },
+    image,
+    proxy
+  );
+}
+
+// src/mount/iframe.ts
+var mountCounter2 = 0;
+var sharedBridge = null;
+function getParentBridge(proxy) {
+  if (!sharedBridge) {
+    sharedBridge = new ParentBridge(proxy);
+  }
+  return sharedBridge;
+}
+function generateMountId2() {
+  return `pw-iframe-${Date.now()}-${++mountCounter2}`;
+}
+var DEFAULT_SANDBOX = ["allow-scripts"];
+var DEV_SANDBOX = ["allow-scripts", "allow-same-origin"];
+function generateIframeContent(image, inputs, services, baseUrl) {
+  const bridgeScript = generateIframeBridgeScript(services);
+  const packages = {
+    ...image?.dependencies || {}
+  };
+  const importMap = generateImportMap(packages);
+  const css = image?.css || "";
+  const frameworkConfig = image?.config?.framework || {};
+  const preloadUrls = frameworkConfig.preload || [];
+  const globals = frameworkConfig.globals || {};
+  const globalNames = Object.values(globals);
+  const imageModuleUrl = image?.moduleUrl || "";
+  const mountScript = `
+    // Run image setup inside the iframe (styling/runtime)
+    const imageModuleUrl = ${JSON.stringify(imageModuleUrl)};
+
+    // Preload framework modules declared by the image (if any)
+    const preloadUrls = ${JSON.stringify(preloadUrls)};
+    const globalNames = ${JSON.stringify(globalNames)};
+    for (let i = 0; i < preloadUrls.length; i++) {
+      const url = preloadUrls[i];
+      const name = globalNames[i];
+      if (!url || !name) continue;
+      try {
+        const mod = await import(/* webpackIgnore: true */ url);
+        window[name] = mod;
+      } catch (e) {
+        console.error('[patchwork-iframe] Failed to preload:', url, e);
+      }
+    }
+
+    const root = document.getElementById('root');
+    const inputs = window.__PATCHWORK_INPUTS__ || {};
+
+    if (imageModuleUrl && root) {
+      try {
+        const img = await import(/* webpackIgnore: true */ imageModuleUrl);
+        if (typeof img?.setup === 'function') {
+          await img.setup(root);
+        }
+      } catch (e) {
+        console.error('[patchwork-iframe] Failed to run image setup:', e);
+      }
+    }
+
+    function pickCreateElement(globals) {
+      for (const obj of globals) {
+        if (obj && typeof obj.createElement === 'function') return obj.createElement.bind(obj);
+        if (obj?.default && typeof obj.default.createElement === 'function') return obj.default.createElement.bind(obj.default);
+      }
+      return null;
+    }
+
+    function pickRenderer(globals) {
+      for (const obj of globals) {
+        if (obj && typeof obj.createRoot === 'function') {
+          return {
+            kind: 'root',
+            createRoot: obj.createRoot.bind(obj),
+          };
+        }
+        if (obj && typeof obj.render === 'function') {
+          return {
+            kind: 'render',
+            render: obj.render.bind(obj),
+          };
+        }
+        if (obj?.default && typeof obj.default.createRoot === 'function') {
+          return {
+            kind: 'root',
+            createRoot: obj.default.createRoot.bind(obj.default),
+          };
+        }
+        if (obj?.default && typeof obj.default.render === 'function') {
+          return {
+            kind: 'render',
+            render: obj.default.render.bind(obj.default),
+          };
+        }
+      }
+      return null;
+    }
+
+    function getGlobalsFromConfig() {
+      const names = ${JSON.stringify(globalNames)};
+      return names.map((n) => window[n]).filter(Boolean);
+    }
+
+    async function mountModule(mod) {
+      if (!root) throw new Error('No #root element');
+
+      if (typeof mod?.mount === 'function') {
+        const cleanup = await mod.mount(root, inputs);
+        if (typeof cleanup === 'function') window.__PATCHWORK_CLEANUP__ = cleanup;
+        return;
+      }
+
+      if (typeof mod?.render === 'function') {
+        const cleanup = await mod.render(root, inputs);
+        if (typeof cleanup === 'function') window.__PATCHWORK_CLEANUP__ = cleanup;
+        return;
+      }
+
+      const Component = mod?.default;
+      if (typeof Component !== 'function') {
+        root.textContent = 'Widget did not export a default component.';
+        return;
+      }
+
+      const globals = getGlobalsFromConfig();
+      const createElement = pickCreateElement(globals);
+      const renderer = pickRenderer(globals);
+
+      if (createElement && renderer?.kind === 'root') {
+        const r = renderer.createRoot(root);
+        r.render(createElement(Component, inputs));
+        if (typeof r.unmount === 'function') window.__PATCHWORK_CLEANUP__ = () => r.unmount();
+        return;
+      }
+
+      if (createElement && renderer?.kind === 'render') {
+        renderer.render(createElement(Component, inputs), root);
+        return;
+      }
+
+      const result = Component(inputs);
+      if (result instanceof HTMLElement) {
+        root.appendChild(result);
+        return;
+      }
+      if (typeof result === 'string') {
+        root.innerHTML = result;
+        return;
+      }
+
+      root.textContent = 'No framework renderer available for this widget.';
+    }
+
+    // Wait for widget code via postMessage (more efficient than inline in srcdoc)
+    // We convert relative URLs to absolute so they work inside blob URL context
+    window.addEventListener('message', async function handleWidgetCode(event) {
+      if (!event.data || event.data.type !== 'widget-code') return;
+      window.removeEventListener('message', handleWidgetCode);
+      
+      const widgetCode = event.data.code;
+      const origin = event.data.origin || ''; // Parent sends the origin
+      
+      // Convert relative URLs (starting with /) to absolute URLs
+      // This is necessary because blob: URLs can't resolve relative imports
+      // and srcdoc iframes have null origin
+      const absoluteCode = widgetCode.replace(
+        /from\\s*["'](\\/[^"']+)["']/g,
+        (_, path) => 'from "' + origin + path + '"'
+      ).replace(
+        /import\\s*["'](\\/[^"']+)["']/g,
+        (_, path) => 'import "' + origin + path + '"'
+      );
+      
+      const blob = new Blob([absoluteCode], { type: 'application/javascript' });
+      const url = URL.createObjectURL(blob);
+      
+      try {
+        const mod = await import(/* webpackIgnore: true */ url);
+        await mountModule(mod);
+        window.parent.postMessage({ type: 'widget-mounted' }, '*');
+      } catch (e) {
+        console.error('[patchwork-iframe] Failed to mount widget:', e);
+        window.parent.postMessage({ type: 'widget-error', error: e.message }, '*');
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    });
+
+    // Signal ready to receive widget code
+    window.parent.postMessage({ type: 'widget-ready' }, '*');
+
+    // Set up ResizeObserver to report body size changes to parent
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const { width, height } = entry.contentRect;
+        window.parent.postMessage({ 
+          type: 'widget-resize', 
+          width: Math.ceil(width), 
+          height: Math.ceil(height) 
+        }, '*');
+      }
+    });
+    resizeObserver.observe(document.body);
+  `;
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <base href="${baseUrl}">
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, -apple-system, sans-serif; }
+    ${css}
+  </style>
+  <script type="importmap">
+    ${JSON.stringify({ imports: importMap }, null, 2)}
+  </script>
+</head>
+<body>
+  <div id="root"></div>
+
+  <!-- Service Bridge -->
+  <script>
+    ${bridgeScript}
+  </script>
+
+  <!-- Widget Inputs -->
+  <script>
+    window.__PATCHWORK_INPUTS__ = ${JSON.stringify(inputs)};
+  </script>
+
+  <script type="module">
+    ${mountScript}
+  </script>
+</body>
+</html>`;
+}
+async function mountIframe(widget, options, image, proxy) {
+  const { target, sandbox = DEFAULT_SANDBOX, inputs = {} } = options;
+  const mountId = generateMountId2();
+  const iframe = document.createElement("iframe");
+  iframe.id = mountId;
+  iframe.className = "patchwork-widget patchwork-iframe";
+  iframe.style.cssText = "width: 100%; border: none; overflow: hidden;";
+  iframe.sandbox.add(...sandbox);
+  const bridge = getParentBridge(proxy);
+  bridge.registerIframe(iframe);
+  const services = widget.manifest.services || [];
+  const baseUrl = typeof window !== "undefined" ? window.location.origin : "";
+  const content = generateIframeContent(image, inputs, services, baseUrl);
+  iframe.srcdoc = content;
+  target.appendChild(iframe);
+  const handleResize = (event) => {
+    if (event.source !== iframe.contentWindow) return;
+    if (event.data?.type === "widget-resize") {
+      const { height } = event.data;
+      if (typeof height === "number" && height > 0) {
+        iframe.style.height = `${height}px`;
+      }
+    }
+  };
+  window.addEventListener("message", handleResize);
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Iframe mount timeout"));
+    }, 3e4);
+    const handleMessage = (event) => {
+      if (event.source !== iframe.contentWindow) return;
+      if (event.data?.type === "widget-ready") {
+        iframe.contentWindow?.postMessage(
+          { type: "widget-code", code: widget.code, origin: baseUrl },
+          "*"
+        );
+      } else if (event.data?.type === "widget-mounted") {
+        cleanup();
+        resolve();
+      } else if (event.data?.type === "widget-error") {
+        cleanup();
+        reject(new Error(event.data.error || "Widget mount failed"));
+      }
+    };
+    const cleanup = () => {
+      clearTimeout(timeout);
+      window.removeEventListener("message", handleMessage);
+    };
+    window.addEventListener("message", handleMessage);
+  });
+  const unmount = () => {
+    window.removeEventListener("message", handleResize);
+    bridge.unregisterIframe(iframe);
+    iframe.remove();
+  };
+  return {
+    id: mountId,
+    widget,
+    mode: "iframe",
+    target,
+    iframe,
+    inputs,
+    sandbox,
+    unmount
+  };
+}
+async function reloadIframe(mounted, widget, image, proxy) {
+  mounted.unmount();
+  return mountIframe(
+    widget,
+    {
+      target: mounted.target,
+      mode: "iframe",
+      sandbox: mounted.sandbox,
+      inputs: mounted.inputs
+    },
+    image,
+    proxy
+  );
+}
+function disposeIframeBridge() {
+  if (sharedBridge) {
+    sharedBridge.dispose();
+    sharedBridge = null;
+  }
+}
+
+// src/compiler.ts
+var esbuildInitialized = false;
+var esbuildInitPromise = null;
+async function initEsbuild() {
+  if (esbuildInitialized) return;
+  if (esbuildInitPromise) return esbuildInitPromise;
+  esbuildInitPromise = (async () => {
+    try {
+      await esbuild.initialize({
+        wasmURL: "https://unpkg.com/esbuild-wasm/esbuild.wasm"
+      });
+      esbuildInitialized = true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("initialized")) {
+        esbuildInitialized = true;
+      } else {
+        throw error;
+      }
+    }
+  })();
+  return esbuildInitPromise;
+}
+function hashContent(content) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  let hash = 0;
+  for (let i = 0; i < data.length; i++) {
+    hash = (hash << 5) - hash + (data[i] ?? 0) | 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+async function createCompiler(options) {
+  await initEsbuild();
+  const { image: imageSpec, proxyUrl, cdnBaseUrl: cdnBaseUrl3, widgetCdnBaseUrl } = options;
+  if (cdnBaseUrl3) {
+    setCdnBaseUrl(cdnBaseUrl3);
+  }
+  if (widgetCdnBaseUrl) {
+    setCdnBaseUrl2(widgetCdnBaseUrl);
+  } else if (cdnBaseUrl3) {
+    setCdnBaseUrl2(cdnBaseUrl3);
+  }
+  const registry = getImageRegistry();
+  await registry.preload(imageSpec);
+  const proxy = createHttpServiceProxy(proxyUrl);
+  return new PatchworkCompiler(proxy, registry);
+}
+var PatchworkCompiler = class {
+  proxy;
+  registry;
+  constructor(proxy, registry) {
+    this.proxy = proxy;
+    this.registry = registry;
+  }
+  /**
+   * Pre-load an image package
+   */
+  async preloadImage(spec) {
+    await this.registry.preload(spec);
+  }
+  /**
+   * Check if an image is loaded
+   */
+  isImageLoaded(spec) {
+    return this.registry.has(spec);
+  }
+  /**
+   * Compile widget source to ESM
+   */
+  async compile(source, manifest, _options = {}) {
+    const project = typeof source === "string" ? createSingleFileProject(source) : source;
+    const entryExt = project.entry.split(".").pop();
+    const loader = entryExt === "ts" || entryExt === "tsx" ? "tsx" : "jsx";
+    const image = this.registry.get(manifest.image) || null;
+    const esbuildConfig = image?.config.esbuild || {};
+    const frameworkConfig = image?.config.framework || {};
+    const target = esbuildConfig.target || "es2020";
+    const format = esbuildConfig.format || "esm";
+    const jsx = esbuildConfig.jsx ?? "automatic";
+    const packages = {
+      ...image?.dependencies || {},
+      ...manifest.packages || {}
+    };
+    const globals = frameworkConfig.globals || {};
+    const deps = frameworkConfig.deps || {};
+    const aliases = image?.config.aliases || {};
+    const entryFile = project.files.get(project.entry);
+    if (!entryFile) {
+      throw new Error(`Entry file not found: ${project.entry}`);
+    }
+    const result = await esbuild.build({
+      stdin: {
+        contents: entryFile.content,
+        loader,
+        sourcefile: project.entry
+      },
+      bundle: true,
+      format,
+      target,
+      platform: manifest.platform === "cli" ? "node" : "browser",
+      jsx,
+      ...esbuildConfig.jsxFactory ? { jsxFactory: esbuildConfig.jsxFactory } : {},
+      ...esbuildConfig.jsxFragment ? { jsxFragment: esbuildConfig.jsxFragment } : {},
+      write: false,
+      sourcemap: "inline",
+      plugins: [
+        vfsPlugin(project, { aliases }),
+        cdnTransformPlugin({
+          packages,
+          globals,
+          deps,
+          aliases
+        })
+      ]
+    });
+    const code = result.outputFiles?.[0]?.text || "";
+    const hash = hashContent(code);
+    return {
+      code,
+      hash,
+      manifest
+    };
+  }
+  /**
+   * Mount a compiled widget to the DOM
+   */
+  async mount(widget, options) {
+    const image = this.registry.get(widget.manifest.image) || null;
+    if (options.mode === "iframe") {
+      return mountIframe(widget, options, image, this.proxy);
+    }
+    return mountEmbedded(widget, options, image, this.proxy);
+  }
+  /**
+   * Unmount a mounted widget
+   */
+  unmount(mounted) {
+    mounted.unmount();
+  }
+  /**
+   * Hot reload a mounted widget
+   */
+  async reload(mounted, source, manifest) {
+    const widget = await this.compile(source, manifest);
+    const image = this.registry.get(widget.manifest.image) || null;
+    if (mounted.mode === "iframe") {
+      await reloadIframe(mounted, widget, image, this.proxy);
+    } else {
+      await reloadEmbedded(mounted, widget, image, this.proxy);
+    }
+  }
+};
+
+// src/vfs/core/utils.ts
+function createFileStats(size, mtime, isDir = false) {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function createDirEntry(name, isDir) {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function normalizePath2(path) {
+  return path.replace(/\/+/g, "/").replace(/^\/|\/$/g, "");
+}
+function dirname2(path) {
+  const normalized = normalizePath2(path);
+  const lastSlash = normalized.lastIndexOf("/");
+  return lastSlash === -1 ? "" : normalized.slice(0, lastSlash);
+}
+function join(...parts) {
+  return normalizePath2(parts.filter(Boolean).join("/"));
+}
+
+// src/vfs/backends/memory.ts
+var MemoryBackend = class {
+  files = /* @__PURE__ */ new Map();
+  dirs = /* @__PURE__ */ new Set([""]);
+  watchers = /* @__PURE__ */ new Map();
+  async readFile(path) {
+    const entry = this.files.get(normalizePath2(path));
+    if (!entry) throw new Error(`ENOENT: ${path}`);
+    return entry.content;
+  }
+  async writeFile(path, content) {
+    const normalized = normalizePath2(path);
+    const dir = dirname2(normalized);
+    if (dir && !this.dirs.has(dir)) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const isNew = !this.files.has(normalized);
+    this.files.set(normalized, { content, mtime: /* @__PURE__ */ new Date() });
+    this.emit(isNew ? "create" : "update", normalized);
+  }
+  async unlink(path) {
+    const normalized = normalizePath2(path);
+    if (!this.files.delete(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    this.emit("delete", normalized);
+  }
+  async stat(path) {
+    const normalized = normalizePath2(path);
+    const entry = this.files.get(normalized);
+    if (entry) {
+      return createFileStats(entry.content.length, entry.mtime, false);
+    }
+    if (this.dirs.has(normalized)) {
+      return createFileStats(0, /* @__PURE__ */ new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+  async mkdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (this.dirs.has(normalized)) return;
+    const parent = dirname2(normalized);
+    if (parent && !this.dirs.has(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    this.dirs.add(normalized);
+  }
+  async readdir(path) {
+    const normalized = normalizePath2(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = normalized ? `${normalized}/` : "";
+    const entries = /* @__PURE__ */ new Map();
+    for (const filePath of this.files.keys()) {
+      if (filePath.startsWith(prefix)) {
+        const rest = filePath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, false);
+      }
+    }
+    for (const dirPath of this.dirs) {
+      if (dirPath.startsWith(prefix) && dirPath !== normalized) {
+        const rest = dirPath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, true);
+      }
+    }
+    return Array.from(entries).map(
+      ([name, isDir]) => createDirEntry(name, isDir)
+    );
+  }
+  async rmdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = `${normalized}/`;
+    const hasChildren = [...this.files.keys()].some((p) => p.startsWith(prefix)) || [...this.dirs].some((d) => d.startsWith(prefix));
+    if (hasChildren && !options?.recursive) {
+      throw new Error(`ENOTEMPTY: ${path}`);
+    }
+    if (options?.recursive) {
+      for (const filePath of this.files.keys()) {
+        if (filePath.startsWith(prefix)) {
+          this.files.delete(filePath);
+          this.emit("delete", filePath);
+        }
+      }
+      for (const dirPath of this.dirs) {
+        if (dirPath.startsWith(prefix)) {
+          this.dirs.delete(dirPath);
+        }
+      }
+    }
+    this.dirs.delete(normalized);
+  }
+  async exists(path) {
+    const normalized = normalizePath2(path);
+    return this.files.has(normalized) || this.dirs.has(normalized);
+  }
+  watch(path, callback) {
+    const normalized = normalizePath2(path);
+    let callbacks = this.watchers.get(normalized);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.watchers.set(normalized, callbacks);
+    }
+    callbacks.add(callback);
+    return () => callbacks.delete(callback);
+  }
+  emit(event, path) {
+    let current = path;
+    while (true) {
+      const callbacks = this.watchers.get(current);
+      if (callbacks) {
+        for (const cb of callbacks) cb(event, path);
+      }
+      if (!current) break;
+      current = dirname2(current);
+    }
+  }
+};
+
+// src/vfs/core/virtual-fs.ts
+var VirtualFS = class {
+  changes = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  backend;
+  constructor(backend) {
+    this.backend = backend ?? new MemoryBackend();
+  }
+  async readFile(path, encoding) {
+    return this.backend.readFile(path, encoding);
+  }
+  async writeFile(path, content) {
+    const existed = await this.backend.exists(path);
+    await this.backend.writeFile(path, content);
+    this.recordChange(path, existed ? "update" : "create");
+  }
+  async applyRemoteFile(path, content) {
+    await this.backend.writeFile(path, content);
+  }
+  async applyRemoteDelete(path) {
+    try {
+      if (await this.backend.exists(path)) {
+        await this.backend.unlink(path);
+      }
+    } catch {
+      return;
+    }
+  }
+  async unlink(path) {
+    await this.backend.unlink(path);
+    this.recordChange(path, "delete");
+  }
+  async stat(path) {
+    return this.backend.stat(path);
+  }
+  async mkdir(path, options) {
+    return this.backend.mkdir(path, options);
+  }
+  async readdir(path) {
+    return this.backend.readdir(path);
+  }
+  async rmdir(path, options) {
+    return this.backend.rmdir(path, options);
+  }
+  async exists(path) {
+    return this.backend.exists(path);
+  }
+  watch(path, callback) {
+    if (this.backend.watch) {
+      return this.backend.watch(path, callback);
+    }
+    return () => {
+    };
+  }
+  /**
+   * Get all pending changes since last sync
+   */
+  getChanges() {
+    return Array.from(this.changes.values());
+  }
+  /**
+   * Clear change tracking (after successful sync)
+   */
+  clearChanges() {
+    this.changes.clear();
+  }
+  /**
+   * Mark specific paths as synced
+   */
+  markSynced(paths) {
+    for (const path of paths) {
+      this.changes.delete(path);
+    }
+  }
+  /**
+   * Subscribe to change events
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  recordChange(path, type) {
+    const record = { path, type, mtime: /* @__PURE__ */ new Date() };
+    this.changes.set(path, record);
+    for (const listener of this.listeners) {
+      listener(record);
+    }
+  }
+};
+
+// src/vfs/sync/differ.ts
+function hashContent2(content) {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i += 1) {
+    hash ^= content.charCodeAt(i);
+    hash = hash + (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+async function readChecksum(provider, path) {
+  try {
+    const content = await provider.readFile(path);
+    return hashContent2(content);
+  } catch {
+    return void 0;
+  }
+}
+async function readChecksums(local, localPath, remote, remotePath) {
+  const [localChecksum, remoteChecksum] = await Promise.all([
+    readChecksum(local, localPath),
+    readChecksum(remote, remotePath)
+  ]);
+  return { local: localChecksum, remote: remoteChecksum };
+}
+
+// src/vfs/sync/resolver.ts
+function resolveConflict(input) {
+  if (input.remoteMtime <= input.changeMtime) return null;
+  if (input.localChecksum && input.remoteChecksum && input.localChecksum === input.remoteChecksum) {
+    return null;
+  }
+  const conflict = {
+    path: input.path,
+    localMtime: input.changeMtime,
+    remoteMtime: input.remoteMtime
+  };
+  switch (input.strategy) {
+    case "local-wins":
+      conflict.resolved = "local";
+      break;
+    case "remote-wins":
+      conflict.resolved = "remote";
+      break;
+    case "newest-wins":
+      conflict.resolved = input.remoteMtime > input.changeMtime ? "remote" : "local";
+      break;
+    case "manual":
+      break;
+  }
+  return conflict;
+}
+
+// src/vfs/sync/engine.ts
+var SyncEngineImpl = class {
+  constructor(local, remote, config = {}) {
+    this.local = local;
+    this.remote = remote;
+    this.conflictStrategy = config.conflictStrategy ?? "local-wins";
+    this.basePath = config.basePath ?? "";
+    this.startRemoteWatch();
+  }
+  status = "idle";
+  intervalId;
+  listeners = /* @__PURE__ */ new Map();
+  conflictStrategy;
+  basePath;
+  async sync() {
+    if (this.status === "syncing") {
+      return { pushed: 0, pulled: 0, conflicts: [] };
+    }
+    this.setStatus("syncing");
+    const result = { pushed: 0, pulled: 0, conflicts: [] };
+    try {
+      const localChanges = this.local.getChanges();
+      const localChangeMap = new Map(
+        localChanges.map((change) => [change.path, change])
+      );
+      const syncedPaths = [];
+      const remoteFiles = await this.listFiles(this.remote, this.basePath);
+      const localFiles = await this.listFiles(this.local, "");
+      const remoteLocalPaths = new Set(
+        remoteFiles.map((path) => this.localPath(path))
+      );
+      for (const remotePath of remoteFiles) {
+        const localPath = this.localPath(remotePath);
+        const localChange = localChangeMap.get(localPath);
+        if (localChange) {
+          const conflict = await this.checkConflict(localChange, remotePath);
+          if (conflict) {
+            result.conflicts.push(conflict);
+            this.emit("conflict", conflict);
+            if (conflict.resolved === "remote") {
+              if (await this.pullRemoteFile(localPath, remotePath)) {
+                result.pulled++;
+                this.emit("change", {
+                  path: localPath,
+                  type: "update",
+                  mtime: /* @__PURE__ */ new Date()
+                });
+              }
+              syncedPaths.push(localPath);
+            }
+          }
+          continue;
+        }
+        if (await this.pullRemoteFile(localPath, remotePath)) {
+          result.pulled++;
+          this.emit("change", {
+            path: localPath,
+            type: "update",
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      for (const localPath of localFiles) {
+        if (remoteLocalPaths.has(localPath)) continue;
+        if (localChangeMap.has(localPath)) continue;
+        await this.local.applyRemoteDelete(localPath);
+        result.pulled++;
+        this.emit("change", {
+          path: localPath,
+          type: "delete",
+          mtime: /* @__PURE__ */ new Date()
+        });
+      }
+      for (const change of localChanges) {
+        if (syncedPaths.includes(change.path)) continue;
+        const remotePath = this.remotePath(change.path);
+        try {
+          const conflict = await this.checkConflict(change, remotePath);
+          if (conflict) {
+            result.conflicts.push(conflict);
+            this.emit("conflict", conflict);
+            if (conflict.resolved === "remote") {
+              if (await this.pullRemoteFile(change.path, remotePath)) {
+                result.pulled++;
+                this.emit("change", {
+                  path: change.path,
+                  type: "update",
+                  mtime: /* @__PURE__ */ new Date()
+                });
+              }
+              syncedPaths.push(change.path);
+            }
+            if (conflict.resolved !== "local") continue;
+          }
+          if (change.type === "delete") {
+            if (await this.remote.exists(remotePath)) {
+              await this.remote.unlink(remotePath);
+            }
+            result.pushed++;
+            syncedPaths.push(change.path);
+            this.emit("change", change);
+            continue;
+          }
+          const content = await this.local.readFile(change.path);
+          await this.remote.writeFile(remotePath, content);
+          result.pushed++;
+          syncedPaths.push(change.path);
+          this.emit("change", change);
+        } catch (err) {
+          this.emit(
+            "error",
+            err instanceof Error ? err : new Error(String(err))
+          );
+        }
+      }
+      if (syncedPaths.length > 0) {
+        this.local.markSynced(syncedPaths);
+      }
+      this.setStatus("idle");
+    } catch (err) {
+      this.setStatus("error");
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+    return result;
+  }
+  startAutoSync(intervalMs) {
+    this.stopAutoSync();
+    this.intervalId = setInterval(() => this.sync(), intervalMs);
+  }
+  stopAutoSync() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  on(event, callback) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(callback);
+    return () => set.delete(callback);
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (set) {
+      for (const cb of set) cb(data);
+    }
+  }
+  setStatus(status) {
+    this.status = status;
+    this.emit("status", status);
+  }
+  remotePath(localPath) {
+    return this.basePath ? join(this.basePath, localPath) : localPath;
+  }
+  localPath(remotePath) {
+    if (!this.basePath) return normalizePath2(remotePath);
+    const normalized = normalizePath2(remotePath);
+    const base = normalizePath2(this.basePath);
+    if (normalized === base) return "";
+    if (normalized.startsWith(`${base}/`)) {
+      return normalized.slice(base.length + 1);
+    }
+    return normalized;
+  }
+  async listFiles(provider, basePath) {
+    const normalized = normalizePath2(basePath);
+    let entries = [];
+    try {
+      entries = await provider.readdir(normalized);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      const entryPath = normalized ? `${normalized}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        results.push(...await this.listFiles(provider, entryPath));
+      } else {
+        results.push(entryPath);
+      }
+    }
+    return results;
+  }
+  async pullRemoteFile(localPath, remotePath) {
+    let localContent = null;
+    try {
+      if (await this.local.exists(localPath)) {
+        localContent = await this.local.readFile(localPath);
+      }
+    } catch {
+      localContent = null;
+    }
+    const remoteContent = await this.remote.readFile(remotePath);
+    if (localContent === remoteContent) return false;
+    await this.local.applyRemoteFile(localPath, remoteContent);
+    return true;
+  }
+  startRemoteWatch() {
+    if (!this.remote.watch) return;
+    this.remote.watch(this.basePath, (event, path) => {
+      void this.handleRemoteEvent(event, path);
+    });
+  }
+  async handleRemoteEvent(event, remotePath) {
+    const localPath = this.localPath(remotePath);
+    const localChange = this.local.getChanges().find((change) => change.path === localPath);
+    if (localChange) {
+      const conflict = await this.checkRemoteEventConflict(
+        localChange,
+        remotePath,
+        event
+      );
+      if (conflict) {
+        this.emit("conflict", conflict);
+        if (conflict.resolved === "remote") {
+          await this.applyRemoteEvent(event, localPath, remotePath);
+          this.local.markSynced([localPath]);
+          this.emit("change", {
+            path: localPath,
+            type: event,
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+        return;
+      }
+      return;
+    }
+    try {
+      await this.applyRemoteEvent(event, localPath, remotePath);
+      this.emit("change", {
+        path: localPath,
+        type: event,
+        mtime: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  async checkConflict(change, remotePath) {
+    try {
+      const remoteStat = await this.remote.stat(remotePath);
+      if (remoteStat.mtime <= change.mtime) return null;
+      const checksums = await readChecksums(
+        this.local,
+        change.path,
+        this.remote,
+        remotePath
+      );
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: remoteStat.mtime,
+        localChecksum: checksums.local,
+        remoteChecksum: checksums.remote,
+        strategy: this.conflictStrategy
+      });
+    } catch {
+      return null;
+    }
+  }
+  async checkRemoteEventConflict(change, remotePath, event) {
+    if (event === "delete") {
+      if (change.type === "delete") return null;
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: /* @__PURE__ */ new Date(),
+        strategy: this.conflictStrategy
+      });
+    }
+    try {
+      const remoteStat = await this.remote.stat(remotePath);
+      if (remoteStat.mtime <= change.mtime) return null;
+      const checksums = await readChecksums(
+        this.local,
+        change.path,
+        this.remote,
+        remotePath
+      );
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: remoteStat.mtime,
+        localChecksum: checksums.local,
+        remoteChecksum: checksums.remote,
+        strategy: this.conflictStrategy
+      });
+    } catch {
+      return null;
+    }
+  }
+  async applyRemoteEvent(event, localPath, remotePath) {
+    if (event === "delete") {
+      await this.local.applyRemoteDelete(localPath);
+      return;
+    }
+    const content = await this.remote.readFile(remotePath);
+    await this.local.applyRemoteFile(localPath, content);
+  }
+};
+
+// src/vfs/backends/indexeddb.ts
+var DB_NAME = "patchwork-vfs";
+var DB_VERSION = 2;
+var FILES_STORE = "files";
+var DIRS_STORE = "dirs";
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = (event) => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(FILES_STORE)) {
+        db.createObjectStore(FILES_STORE);
+      }
+      if (!db.objectStoreNames.contains(DIRS_STORE)) {
+        db.createObjectStore(DIRS_STORE);
+      }
+    };
+  });
+}
+function withStore(storeName, mode, fn) {
+  return openDB().then(
+    (db) => new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, mode);
+      const store = tx.objectStore(storeName);
+      const request = fn(store);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    })
+  );
+}
+var IndexedDBBackend = class {
+  constructor(prefix = "vfs") {
+    this.prefix = prefix;
+  }
+  key(path) {
+    return `${this.prefix}:${normalizePath2(path)}`;
+  }
+  async readFile(path) {
+    const record = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.get(this.key(path))
+    );
+    if (!record) throw new Error(`ENOENT: ${path}`);
+    return record.content;
+  }
+  async writeFile(path, content) {
+    const dir = dirname2(normalizePath2(path));
+    if (dir && !await this.dirExists(dir)) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const record = { content, mtime: Date.now() };
+    await withStore(
+      FILES_STORE,
+      "readwrite",
+      (store) => store.put(record, this.key(path))
+    );
+  }
+  async unlink(path) {
+    await withStore(
+      FILES_STORE,
+      "readwrite",
+      (store) => store.delete(this.key(path))
+    );
+  }
+  async stat(path) {
+    const normalized = normalizePath2(path);
+    const record = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.get(this.key(normalized))
+    );
+    if (record) {
+      return createFileStats(
+        record.content.length,
+        new Date(record.mtime),
+        false
+      );
+    }
+    if (await this.dirExists(normalized)) {
+      return createFileStats(0, /* @__PURE__ */ new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+  async mkdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (await this.dirExists(normalized)) return;
+    const parent = dirname2(normalized);
+    if (parent && !await this.dirExists(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    await withStore(
+      DIRS_STORE,
+      "readwrite",
+      (store) => store.put(Date.now(), this.key(normalized))
+    );
+  }
+  async readdir(path) {
+    const normalized = normalizePath2(path);
+    if (normalized && !await this.dirExists(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = normalized ? `${this.key(normalized)}/` : `${this.prefix}:`;
+    const entries = /* @__PURE__ */ new Map();
+    const fileKeys = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.getAllKeys()
+    );
+    for (const key of fileKeys) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name && !rest.includes("/")) entries.set(name, false);
+      }
+    }
+    const dirKeys = await withStore(
+      DIRS_STORE,
+      "readonly",
+      (store) => store.getAllKeys()
+    );
+    for (const key of dirKeys) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name && !rest.includes("/")) entries.set(name, true);
+      }
+    }
+    return Array.from(entries).map(
+      ([name, isDir]) => createDirEntry(name, isDir)
+    );
+  }
+  async rmdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (!await this.dirExists(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = `${this.key(normalized)}/`;
+    if (options?.recursive) {
+      const fileKeys = await withStore(
+        FILES_STORE,
+        "readonly",
+        (store) => store.getAllKeys()
+      );
+      for (const key of fileKeys) {
+        if (key.startsWith(prefix)) {
+          await withStore(
+            FILES_STORE,
+            "readwrite",
+            (store) => store.delete(key)
+          );
+        }
+      }
+      const dirKeys = await withStore(
+        DIRS_STORE,
+        "readonly",
+        (store) => store.getAllKeys()
+      );
+      for (const key of dirKeys) {
+        if (key.startsWith(prefix)) {
+          await withStore(
+            DIRS_STORE,
+            "readwrite",
+            (store) => store.delete(key)
+          );
+        }
+      }
+    }
+    await withStore(
+      DIRS_STORE,
+      "readwrite",
+      (store) => store.delete(this.key(normalized))
+    );
+  }
+  async exists(path) {
+    const normalized = normalizePath2(path);
+    const record = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.get(this.key(normalized))
+    );
+    if (record) return true;
+    return this.dirExists(normalized);
+  }
+  async dirExists(path) {
+    if (!path) return true;
+    const result = await withStore(
+      DIRS_STORE,
+      "readonly",
+      (store) => store.get(this.key(path))
+    );
+    return result !== void 0;
+  }
+};
+
+// src/vfs/backends/http.ts
+var HttpBackend = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async readFile(path) {
+    const res = await fetch(this.url(path));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    return res.text();
+  }
+  async writeFile(path, content) {
+    const res = await fetch(this.url(path), {
+      method: "PUT",
+      body: content,
+      headers: { "Content-Type": "text/plain" }
+    });
+    if (!res.ok) throw new Error(`Failed to write: ${path}`);
+  }
+  async unlink(path) {
+    const res = await fetch(this.url(path), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to delete: ${path}`);
+  }
+  async stat(path) {
+    const res = await fetch(this.url(path, { stat: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const data = await res.json();
+    return createFileStats(data.size, new Date(data.mtime), data.isDirectory);
+  }
+  async mkdir(path, options) {
+    const params = { mkdir: "true" };
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "POST" });
+    if (!res.ok) throw new Error(`Failed to mkdir: ${path}`);
+  }
+  async readdir(path) {
+    const res = await fetch(this.url(path, { readdir: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const entries = await res.json();
+    return entries.map((e) => createDirEntry(e.name, e.isDirectory));
+  }
+  async rmdir(path, options) {
+    const params = {};
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to rmdir: ${path}`);
+  }
+  async exists(path) {
+    const res = await fetch(this.url(path), { method: "HEAD" });
+    return res.ok;
+  }
+  watch(path, callback) {
+    const controller = new AbortController();
+    this.startWatch(path, callback, controller.signal);
+    return () => controller.abort();
+  }
+  async startWatch(path, callback, signal) {
+    try {
+      const res = await fetch(this.url("", { watch: path }), { signal });
+      if (!res.ok) return;
+      const reader = res.body?.getReader();
+      if (!reader) return;
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              callback(event.type, event.path);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  url(path, params) {
+    const baseUrl = this.config.baseUrl.replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    const base = cleanPath ? `${baseUrl}/${cleanPath}` : baseUrl;
+    if (!params) return base;
+    const query = new URLSearchParams(params).toString();
+    return `${base}?${query}`;
+  }
+};
+
+// src/vfs/store.ts
+var VFSStore = class {
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.root = options.root ?? "";
+    if (options.sync) {
+      this.local = new VirtualFS();
+      this.syncEngine = new SyncEngineImpl(this.local, this.provider, {
+        conflictStrategy: options.conflictStrategy,
+        basePath: this.root
+      });
+      if (options.autoSyncIntervalMs) {
+        this.syncEngine.startAutoSync(options.autoSyncIntervalMs);
+      }
+    }
+  }
+  local;
+  syncEngine;
+  root;
+  async readFile(path, encoding) {
+    if (this.local) {
+      try {
+        return await this.local.readFile(path, encoding);
+      } catch {
+        const content = await this.provider.readFile(
+          this.remotePath(path),
+          encoding
+        );
+        await this.local.applyRemoteFile(path, content);
+        return content;
+      }
+    }
+    return this.provider.readFile(this.remotePath(path), encoding);
+  }
+  async writeFile(path, content) {
+    if (this.local) {
+      await this.local.writeFile(path, content);
+      return;
+    }
+    await this.provider.writeFile(this.remotePath(path), content);
+  }
+  async unlink(path) {
+    if (this.local) {
+      await this.local.unlink(path);
+      return;
+    }
+    await this.provider.unlink(this.remotePath(path));
+  }
+  async stat(path) {
+    if (this.local) {
+      try {
+        return await this.local.stat(path);
+      } catch {
+        return this.provider.stat(this.remotePath(path));
+      }
+    }
+    return this.provider.stat(this.remotePath(path));
+  }
+  async mkdir(path, options) {
+    if (this.local) {
+      await this.local.mkdir(path, options);
+    }
+    await this.provider.mkdir(this.remotePath(path), options);
+  }
+  async readdir(path) {
+    if (this.local) {
+      try {
+        return await this.local.readdir(path);
+      } catch {
+        return this.provider.readdir(this.remotePath(path));
+      }
+    }
+    return this.provider.readdir(this.remotePath(path));
+  }
+  async rmdir(path, options) {
+    if (this.local) {
+      await this.local.rmdir(path, options);
+    }
+    await this.provider.rmdir(this.remotePath(path), options);
+  }
+  async exists(path) {
+    if (this.local) {
+      if (await this.local.exists(path)) return true;
+      return this.provider.exists(this.remotePath(path));
+    }
+    return this.provider.exists(this.remotePath(path));
+  }
+  async listFiles(prefix = "") {
+    return this.walkFiles(prefix);
+  }
+  async loadProject(id) {
+    const paths = await this.listFiles(id);
+    if (paths.length === 0) return null;
+    const files = /* @__PURE__ */ new Map();
+    await Promise.all(
+      paths.map(async (path) => {
+        const content = await this.provider.readFile(this.remotePath(path));
+        const relative = path.slice(id.length + 1);
+        files.set(relative, { path: relative, content });
+        if (this.local) {
+          await this.local.applyRemoteFile(path, content);
+        }
+      })
+    );
+    return { id, entry: resolveEntry(files), files };
+  }
+  async saveProject(project) {
+    if (this.local) {
+      await Promise.all(
+        Array.from(project.files.values()).map(
+          (file) => this.local.writeFile(`${project.id}/${file.path}`, file.content)
+        )
+      );
+      await this.sync();
+      return;
+    }
+    await Promise.all(
+      Array.from(project.files.values()).map(
+        (file) => this.provider.writeFile(
+          this.remotePath(`${project.id}/${file.path}`),
+          file.content
+        )
+      )
+    );
+  }
+  async sync() {
+    if (!this.syncEngine) {
+      return { pushed: 0, pulled: 0, conflicts: [] };
+    }
+    return this.syncEngine.sync();
+  }
+  on(event, callback) {
+    if (!this.syncEngine) return () => {
+    };
+    return this.syncEngine.on(event, callback);
+  }
+  remotePath(path) {
+    return this.root ? join(this.root, path) : path;
+  }
+  async walkFiles(prefix) {
+    const results = [];
+    const normalized = prefix ? prefix.replace(/^\/+/g, "") : "";
+    let entries = [];
+    try {
+      entries = await this.provider.readdir(this.remotePath(normalized));
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const entryPath = normalized ? `${normalized}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        results.push(...await this.walkFiles(entryPath));
+      } else {
+        results.push(entryPath);
+      }
+    }
+    return results;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompileOptionsSchema,
+  DEFAULT_CLI_IMAGE_CONFIG,
+  DEFAULT_IMAGE_CONFIG,
+  DEV_SANDBOX,
+  EsbuildConfigSchema,
+  HttpBackend,
+  ImageConfigSchema,
+  ImageRegistry,
+  IndexedDBBackend,
+  InputSpecSchema,
+  ManifestSchema,
+  MountModeSchema,
+  MountOptionsSchema,
+  ParentBridge,
+  PlatformSchema,
+  VFSStore,
+  cdnTransformPlugin,
+  createCompiler,
+  createFieldAccessProxy,
+  createHttpServiceProxy,
+  createIframeServiceProxy,
+  createImageRegistry,
+  createProjectFromFiles,
+  createSingleFileProject,
+  detectMainFile,
+  disposeIframeBridge,
+  extractNamespaces,
+  fetchPackageJson,
+  generateIframeBridgeScript,
+  generateImportMap,
+  generateNamespaceGlobals,
+  getCdnBaseUrl,
+  getImageRegistry,
+  injectNamespaceGlobals,
+  loadImage,
+  mountEmbedded,
+  mountIframe,
+  parseImageConfig,
+  parseImageSpec,
+  parseManifest,
+  reloadEmbedded,
+  reloadIframe,
+  removeNamespaceGlobals,
+  resolveEntry,
+  safeParseImageConfig,
+  safeParseManifest,
+  setCdnBaseUrl,
+  vfsPlugin
+});
+//# sourceMappingURL=index.cjs.map