@aprovan/patchwork-compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,1859 @@
+// src/compiler.ts
+import * as esbuild from "esbuild-wasm";
+
+// 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
+import { z } from "zod";
+var PlatformSchema = z.enum(["browser", "cli"]);
+var EsbuildConfigSchema = z.object({
+  target: z.string().optional(),
+  format: z.enum(["esm", "cjs", "iife"]).optional(),
+  jsx: z.enum(["automatic", "transform", "preserve"]).optional(),
+  jsxFactory: z.string().optional(),
+  jsxFragment: z.string().optional()
+}).strict().optional();
+var FrameworkConfigSchema = z.object({
+  // Map of package names to window global names (e.g., { react: 'React' })
+  globals: z.record(z.string(), z.string()).optional(),
+  // CDN URLs to preload before widget execution
+  preload: z.array(z.string()).optional(),
+  // Dependency version overrides for CDN packages (e.g., { react: '18' })
+  deps: z.record(z.string(), z.string()).optional()
+}).strict().optional();
+var AliasesSchema = z.record(z.string(), z.string()).optional();
+var DependenciesSchema = z.record(z.string(), z.string()).optional();
+var ImageConfigSchema = z.object({
+  platform: PlatformSchema,
+  dependencies: DependenciesSchema,
+  esbuild: EsbuildConfigSchema,
+  framework: FrameworkConfigSchema,
+  aliases: AliasesSchema
+}).strict();
+var InputSpecSchema = z.object({
+  type: z.enum(["string", "number", "boolean", "object", "array"]),
+  default: z.unknown().optional(),
+  required: z.boolean().optional(),
+  description: z.string().optional()
+});
+var ManifestSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  platform: PlatformSchema,
+  image: z.string(),
+  inputs: z.record(z.string(), InputSpecSchema).optional(),
+  services: z.array(z.string()).optional(),
+  packages: z.record(z.string(), z.string()).optional()
+});
+var CompileOptionsSchema = z.object({
+  typescript: z.boolean().optional()
+}).strict().optional();
+var MountModeSchema = z.enum(["embedded", "iframe"]);
+var MountOptionsSchema = z.object({
+  target: z.custom((v) => v instanceof HTMLElement, {
+    message: "Expected HTMLElement"
+  }),
+  mode: MountModeSchema,
+  sandbox: z.array(z.string()).optional(),
+  inputs: z.record(z.string(), 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: dirname2, join } = await import("path");
+    const require2 = createRequire(import.meta.url);
+    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 = dirname2(packageJsonPath);
+    if (packageJson.main) {
+      try {
+        const mainPath = join(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 exports = {
+    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 exports[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 module = await import(
+      /* webpackIgnore: true */
+      scriptUrl
+    );
+    if (image?.mount) {
+      const result = await image.mount(module, container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module.mount === "function") {
+      const result = await module.mount(container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module.render === "function") {
+      const result = await module.render(container, inputs);
+      if (typeof result === "function") {
+        moduleCleanup = result;
+      }
+    } else if (typeof module.default === "function") {
+      const Component = module.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/store.ts
+var VFSStore = class {
+  constructor(backend, root = "") {
+    this.backend = backend;
+    this.root = root;
+  }
+  key(path) {
+    return this.root ? `${this.root}/${path}` : path;
+  }
+  async getFile(path) {
+    const content = await this.backend.get(this.key(path));
+    if (!content) return null;
+    return { path, content };
+  }
+  async putFile(file) {
+    await this.backend.put(this.key(file.path), file.content);
+  }
+  async deleteFile(path) {
+    await this.backend.delete(this.key(path));
+  }
+  async listFiles(prefix) {
+    const fullPrefix = prefix ? this.key(prefix) : this.root;
+    const paths = await this.backend.list(fullPrefix);
+    return paths.map((p) => this.root ? p.slice(this.root.length + 1) : p);
+  }
+  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 file = await this.getFile(path);
+        if (file) files.set(path.slice(id.length + 1), file);
+      })
+    );
+    return { id, entry: resolveEntry(files), files };
+  }
+  async saveProject(project) {
+    await Promise.all(
+      Array.from(project.files.values()).map(
+        (file) => this.putFile({ ...file, path: `${project.id}/${file.path}` })
+      )
+    );
+  }
+};
+
+// src/vfs/backends/indexeddb.ts
+var DB_NAME = "patchwork-vfs";
+var STORE_NAME = "files";
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, 1);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = () => {
+      request.result.createObjectStore(STORE_NAME);
+    };
+  });
+}
+function withStore(mode, fn) {
+  return openDB().then(
+    (db) => new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, mode);
+      const store = tx.objectStore(STORE_NAME);
+      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}:${path}`;
+  }
+  async get(path) {
+    const result = await withStore(
+      "readonly",
+      (store) => store.get(this.key(path))
+    );
+    return result ?? null;
+  }
+  async put(path, content) {
+    await withStore("readwrite", (store) => store.put(content, this.key(path)));
+  }
+  async delete(path) {
+    await withStore("readwrite", (store) => store.delete(this.key(path)));
+  }
+  async list(prefix) {
+    const keyPrefix = prefix ? this.key(prefix) : this.key("");
+    const allKeys = await withStore("readonly", (store) => store.getAllKeys());
+    return allKeys.filter((k) => k.startsWith(keyPrefix)).map((k) => k.slice(this.prefix.length + 1));
+  }
+  async exists(path) {
+    return await this.get(path) !== null;
+  }
+};
+
+// src/vfs/backends/local-fs.ts
+var LocalFSBackend = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async get(path) {
+    const res = await fetch(`${this.config.baseUrl}/${path}`);
+    if (!res.ok) return null;
+    return res.text();
+  }
+  async put(path, content) {
+    await fetch(`${this.config.baseUrl}/${path}`, {
+      method: "PUT",
+      body: content
+    });
+  }
+  async delete(path) {
+    await fetch(`${this.config.baseUrl}/${path}`, { method: "DELETE" });
+  }
+  async list(prefix) {
+    const url = prefix ? `${this.config.baseUrl}?prefix=${encodeURIComponent(prefix)}` : this.config.baseUrl;
+    const res = await fetch(url);
+    return res.json();
+  }
+  async exists(path) {
+    const res = await fetch(`${this.config.baseUrl}/${path}`, {
+      method: "HEAD"
+    });
+    return res.ok;
+  }
+};
+
+// src/vfs/backends/s3.ts
+var S3Backend = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get baseUrl() {
+    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com`;
+  }
+  key(path) {
+    return this.config.prefix ? `${this.config.prefix}/${path}` : path;
+  }
+  async get(path) {
+    const res = await fetch(`${this.baseUrl}/${this.key(path)}`);
+    if (!res.ok) return null;
+    return res.text();
+  }
+  async put(path, content) {
+    await fetch(`${this.baseUrl}/${this.key(path)}`, {
+      method: "PUT",
+      body: content,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+  async delete(path) {
+    await fetch(`${this.baseUrl}/${this.key(path)}`, { method: "DELETE" });
+  }
+  async list(prefix) {
+    const listPrefix = prefix ? this.key(prefix) : this.config.prefix || "";
+    const res = await fetch(
+      `${this.baseUrl}?list-type=2&prefix=${encodeURIComponent(listPrefix)}`
+    );
+    const xml = await res.text();
+    return this.parseListResponse(xml);
+  }
+  async exists(path) {
+    const res = await fetch(`${this.baseUrl}/${this.key(path)}`, {
+      method: "HEAD"
+    });
+    return res.ok;
+  }
+  parseListResponse(xml) {
+    const matches = xml.matchAll(/<Key>([^<]+)<\/Key>/g);
+    const prefixLen = this.config.prefix ? this.config.prefix.length + 1 : 0;
+    return Array.from(matches, (m) => (m[1] ?? "").slice(prefixLen));
+  }
+};
+export {
+  CompileOptionsSchema,
+  DEFAULT_CLI_IMAGE_CONFIG,
+  DEFAULT_IMAGE_CONFIG,
+  DEV_SANDBOX,
+  EsbuildConfigSchema,
+  ImageConfigSchema,
+  ImageRegistry,
+  IndexedDBBackend,
+  InputSpecSchema,
+  LocalFSBackend,
+  ManifestSchema,
+  MountModeSchema,
+  MountOptionsSchema,
+  ParentBridge,
+  PlatformSchema,
+  S3Backend,
+  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.js.map