@dxos/app-framework 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/dist/plugin/node-esm/index.mjs

@@ -0,0 +1,730 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/vite-plugin/composer-plugin.ts
+import cssInjectedByJs from "vite-plugin-css-injected-by-js";
+
+// src/vite-plugin/manifest.ts
+var MANIFEST_ASSET_NAME = "manifest.json";
+var serializeManifest = (meta, { moduleFile }) => JSON.stringify({
+  ...meta,
+  moduleFile
+}, null, 2);
+
+// src/vite-plugin/packages.ts
+var THIRD_PARTY_SHARED_PACKAGES = [
+  "@effect-atom/atom",
+  "@effect-atom/atom-react",
+  "@effect/platform",
+  "effect",
+  "lit",
+  "react",
+  "react-dom",
+  "solid-js"
+];
+var DEFAULT_PACKAGES = [
+  // packages/common
+  "@dxos/async",
+  "@dxos/codec-protobuf",
+  "@dxos/context",
+  "@dxos/crypto",
+  "@dxos/debug",
+  "@dxos/display-name",
+  "@dxos/effect",
+  "@dxos/effect-atom-solid",
+  "@dxos/errors",
+  "@dxos/feed-store",
+  "@dxos/graph",
+  "@dxos/hypercore",
+  "@dxos/invariant",
+  "@dxos/keyboard",
+  "@dxos/keys",
+  "@dxos/kv-store",
+  "@dxos/log",
+  "@dxos/merkle-search-tree",
+  "@dxos/random",
+  "@dxos/random-access-storage",
+  "@dxos/timeframe",
+  "@dxos/tracing",
+  "@dxos/util",
+  "@dxos/web-context",
+  "@dxos/web-context-react",
+  "@dxos/web-context-solid",
+  // packages/core/echo
+  "@dxos/echo",
+  "@dxos/echo-atom",
+  "@dxos/echo-db",
+  "@dxos/echo-pipeline",
+  "@dxos/echo-protocol",
+  "@dxos/echo-query",
+  "@dxos/echo-react",
+  "@dxos/echo-solid",
+  "@dxos/feed",
+  "@dxos/index-core",
+  // packages/core/halo
+  "@dxos/credentials",
+  "@dxos/keyring",
+  // packages/core/mesh
+  "@dxos/edge-client",
+  "@dxos/messaging",
+  "@dxos/network-manager",
+  "@dxos/rpc",
+  "@dxos/rpc-tunnel",
+  "@dxos/teleport",
+  "@dxos/teleport-extension-automerge-replicator",
+  "@dxos/teleport-extension-gossip",
+  "@dxos/teleport-extension-object-sync",
+  "@dxos/teleport-extension-replicator",
+  "@dxos/websocket-rpc",
+  // packages/core
+  "@dxos/ai",
+  "@dxos/assistant",
+  "@dxos/assistant-toolkit",
+  "@dxos/blueprints",
+  "@dxos/compute",
+  "@dxos/conductor",
+  "@dxos/functions",
+  "@dxos/functions-runtime",
+  "@dxos/mcp-client",
+  "@dxos/operation",
+  "@dxos/protocols",
+  // packages/devtools
+  "@dxos/devtools",
+  // packages/sdk
+  "@dxos/app-framework",
+  "@dxos/app-graph",
+  "@dxos/app-solid",
+  "@dxos/app-toolkit",
+  "@dxos/client",
+  "@dxos/client-protocol",
+  "@dxos/client-services",
+  "@dxos/config",
+  "@dxos/migrations",
+  "@dxos/observability",
+  "@dxos/react-client",
+  "@dxos/react-edge-client",
+  "@dxos/schema",
+  "@dxos/types",
+  // packages/ui
+  "@dxos/lit-grid",
+  "@dxos/lit-ui",
+  "@dxos/react-hooks",
+  "@dxos/react-ui",
+  "@dxos/react-ui-attention",
+  "@dxos/react-ui-board",
+  "@dxos/react-ui-calendar",
+  "@dxos/react-ui-canvas",
+  "@dxos/react-ui-canvas-compute",
+  "@dxos/react-ui-canvas-editor",
+  "@dxos/react-ui-chat",
+  "@dxos/react-ui-components",
+  "@dxos/react-ui-dnd",
+  "@dxos/react-ui-editor",
+  "@dxos/react-ui-form",
+  "@dxos/react-ui-gameboard",
+  "@dxos/react-ui-geo",
+  "@dxos/react-ui-graph",
+  "@dxos/react-ui-grid",
+  "@dxos/react-ui-list",
+  "@dxos/react-ui-markdown",
+  "@dxos/react-ui-masonry",
+  "@dxos/react-ui-menu",
+  "@dxos/react-ui-mosaic",
+  "@dxos/react-ui-pickers",
+  "@dxos/react-ui-search",
+  "@dxos/react-ui-sfx",
+  "@dxos/react-ui-stack",
+  "@dxos/react-ui-syntax-highlighter",
+  "@dxos/react-ui-table",
+  "@dxos/react-ui-tabs",
+  "@dxos/react-ui-text-tooltip",
+  "@dxos/react-ui-thread",
+  "@dxos/solid-ui",
+  "@dxos/solid-ui-geo",
+  "@dxos/ui",
+  "@dxos/ui-editor",
+  "@dxos/ui-theme",
+  "@dxos/ui-types",
+  // third-party
+  ...THIRD_PARTY_SHARED_PACKAGES
+];
+var isSharedPackage = (id) => DEFAULT_PACKAGES.some((pkg) => id === pkg || id.startsWith(`${pkg}/`));
+
+// src/vite-plugin/composer-plugin.ts
+var JSX_DEV_RUNTIME = "react/jsx-dev-runtime";
+var DEFAULT_MODULE_FILE = "plugin.mjs";
+var isExternal = (id) => id !== JSX_DEV_RUNTIME && isSharedPackage(id);
+var REQUIRE_SHIM_BANNER = [
+  "// --- composer-plugin: CJS require shim ---",
+  "// See @dxos/app-framework/vite-plugin/composer-plugin.ts for rationale.",
+  "import * as __composerReact from 'react';",
+  "import * as __composerReactDom from 'react-dom';",
+  "import * as __composerReactJsxRuntime from 'react/jsx-runtime';",
+  "const __composerRequireShim = new Map([",
+  "  ['react', __composerReact.default ?? __composerReact],",
+  "  ['react-dom', __composerReactDom.default ?? __composerReactDom],",
+  "  ['react/jsx-runtime', __composerReactJsxRuntime],",
+  "]);",
+  "// Module-local binding: rolldown's CJS fallback does a `typeof require` check",
+  "// and uses whichever `require` is in lexical scope. Declaring this as `const`",
+  "// (instead of `globalThis.require ??=`) keeps each bundle's shim isolated from",
+  "// the host page and from other plugins sharing the window.",
+  "const require = (id) => {",
+  "  if (__composerRequireShim.has(id)) return __composerRequireShim.get(id);",
+  "  throw new Error('composer-plugin: unsupported CJS require at runtime: ' + id);",
+  "};",
+  "// --- end CJS require shim ---"
+].join("\n");
+var composerPlugin = (options) => {
+  const entry = options?.entry ?? "src/plugin.tsx";
+  const port = options?.port ?? 3967;
+  const moduleFile = options?.moduleFile ?? DEFAULT_MODULE_FILE;
+  const meta = options?.meta;
+  const resolved = /* @__PURE__ */ new Set();
+  let base = "/";
+  const plugins = [
+    // Inline every imported stylesheet into the bundled module. Each community plugin
+    // is distributed as a single GitHub Release asset (per {@link moduleFile}); a sibling
+    // `.css` file would silently be dropped at runtime because Composer only fetches the
+    // module URL the registry advertises.
+    // TODO(wittjosiah): Once the registry supports multi-asset releases, move CSS (and
+    // fonts/images/wasm) back to sibling assets so plugins don't ship stylesheets inside
+    // their JS bundle.
+    ...cssInjectedByJs(),
+    // Configure vite for library-mode builds with externalized deps.
+    {
+      name: "composer-plugin",
+      config: () => ({
+        server: {
+          port,
+          // Allow the Composer host (different origin) to dynamically import plugin modules.
+          cors: true
+        },
+        preview: {
+          port
+        },
+        build: {
+          sourcemap: true,
+          // Transitively-bundled WASM modules (automerge, tiktoken, …) emit top-level
+          // await; `esnext` lets rolldown pass that through without an explicit polyfill.
+          target: "esnext",
+          lib: {
+            entry,
+            formats: [
+              "es"
+            ],
+            fileName: () => moduleFile
+          },
+          // Inline every asset as a data URL. GitHub Releases sign each asset with a
+          // per-file URL, so sibling-file imports from the plugin module can't resolve.
+          // TODO(wittjosiah): Drop once the registry can serve multi-asset releases and
+          // plugins can ship fonts/images/wasm as siblings of plugin.mjs.
+          assetsInlineLimit: () => true,
+          rolldownOptions: {
+            external: (id) => isExternal(id),
+            output: {
+              // Produce a single bundle per plugin for GitHub Release distribution.
+              // TODO(wittjosiah): Drop once the registry can serve multi-asset releases.
+              inlineDynamicImports: true,
+              // Install the CJS require shim at the top of plugin.mjs so transitively
+              // bundled CJS helpers (that call `require('react')` et al. at runtime) can
+              // resolve against the host-provided externals instead of throwing.
+              banner: REQUIRE_SHIM_BANNER
+            }
+          }
+        }
+      })
+    },
+    // Dev-time externalization.
+    // Vite's dev server doesn't use rollup externals, so we need to handle it manually.
+    // We intercept imports of shared deps at resolve time, mark them external, and then
+    // strip the `/@id/` prefix that Vite's import analysis injects for external modules.
+    {
+      name: "composer-plugin:externalize",
+      enforce: "pre",
+      apply: "serve",
+      // Exclude shared packages from Vite's dependency pre-bundling.
+      config: () => ({
+        optimizeDeps: {
+          exclude: DEFAULT_PACKAGES
+        }
+      }),
+      // Mark shared deps as external so Vite doesn't try to bundle them.
+      resolveId: (id) => {
+        if (isExternal(id)) {
+          resolved.add(id);
+          return {
+            id,
+            external: true
+          };
+        }
+      },
+      // Return a stub for any externalized module that Vite tries to load directly.
+      load: (id) => {
+        if (resolved.has(id)) {
+          return {
+            code: "export default {};"
+          };
+        }
+      },
+      // After all plugins are resolved, inject a late-stage transform plugin that strips
+      // the `/@id/` prefix from externalized bare specifiers in the output.
+      // This must run after Vite's internal import analysis which rewrites bare specifiers.
+      configResolved: (config) => {
+        base = config.base ?? "/";
+        config.plugins.push({
+          name: "composer-plugin:strip-prefix",
+          transform: (code) => {
+            if (resolved.size === 0) {
+              return;
+            }
+            const escaped = [
+              ...resolved
+            ].map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+            const pattern = new RegExp(`${base}@id/(${escaped})`, "g");
+            if (pattern.test(code)) {
+              return code.replace(pattern, (_, dep) => dep);
+            }
+          }
+        });
+      }
+    },
+    // JSX dev runtime shim.
+    // React refresh (used by @vitejs/plugin-react) imports from `react/jsx-dev-runtime`,
+    // but the externalized React only exposes `react/jsx-runtime`. This virtual module
+    // bridges the gap by re-exporting jsx-runtime's functions under jsx-dev-runtime's API.
+    {
+      name: "composer-plugin:jsx-dev-shim",
+      enforce: "pre",
+      apply: "serve",
+      resolveId: (id) => id === JSX_DEV_RUNTIME ? `\0${JSX_DEV_RUNTIME}` : void 0,
+      load: (id) => id === `\0${JSX_DEV_RUNTIME}` ? [
+        'import { jsx, jsxs, Fragment } from "react/jsx-runtime";',
+        "export { Fragment };",
+        "export function jsxDEV(type, props, key, isStaticChildren) {",
+        "  return isStaticChildren ? jsxs(type, props, key) : jsx(type, props, key);",
+        "}"
+      ].join("\n") : void 0
+    },
+    // React Refresh preamble stub.
+    //
+    // @vitejs/plugin-react's JSX transform prepends a runtime check to every module:
+    //   if (!window.$RefreshReg$) throw new Error("@vitejs/plugin-react can't detect preamble…");
+    // In a normal single-origin app, vite injects a `<script type="module">` preamble
+    // into `index.html` that sets up `$RefreshReg$` / `$RefreshSig$` on `window` before any
+    // app code runs. When a community plugin is dev-served at its own origin and then
+    // dynamic-imported into the Composer host at a different origin, the host's window
+    // never receives that preamble, so every JSX module throws on first import.
+    //
+    // Inject a no-op refresh shim on the host's window from the plugin's entrypoint: fast-
+    // refresh itself doesn't work cross-origin anyway, so silencing the check lets the
+    // plugin load and ordinary page reloads take care of picking up edits. Production
+    // builds are untouched (`apply: 'serve'`).
+    {
+      name: "composer-plugin:react-refresh-shim",
+      enforce: "pre",
+      apply: "serve",
+      transform(code, id) {
+        if (!id.endsWith(entry.replace(/^\.?\//, "/"))) {
+          return;
+        }
+        const shim = [
+          "// composer-plugin: no-op React Refresh shim so cross-origin plugin modules",
+          "// don't throw the @vitejs/plugin-react preamble check at dynamic-import time.",
+          'if (typeof window !== "undefined") {',
+          "  window.$RefreshReg$ = window.$RefreshReg$ || (() => {});",
+          "  window.$RefreshSig$ = window.$RefreshSig$ || (() => (type) => type);",
+          "  window.__vite_plugin_react_preamble_installed__ = true;",
+          "}",
+          ""
+        ].join("\n");
+        return {
+          code: shim + code,
+          map: null
+        };
+      }
+    }
+  ];
+  if (meta) {
+    plugins.push({
+      name: "composer-plugin:emit-manifest",
+      apply: "build",
+      generateBundle() {
+        this.emitFile({
+          type: "asset",
+          fileName: MANIFEST_ASSET_NAME,
+          source: serializeManifest(meta, {
+            moduleFile
+          })
+        });
+      }
+    });
+  }
+  return plugins;
+};
+
+// src/vite-plugin/import-map-plugin.ts
+import { init as initCjsLexer, parse as parseCjs } from "cjs-module-lexer";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { createRequire as nodeCreateRequire } from "node:module";
+import path from "node:path";
+var require2 = nodeCreateRequire(import.meta.url);
+var trimQueryString = (id) => id.replace(/\?.*$/, "");
+var resolvedIdIsEsmModule = (resolvedId) => {
+  const file = trimQueryString(resolvedId);
+  if (file.endsWith(".mjs") || file.endsWith(".mts")) {
+    return true;
+  }
+  if (file.endsWith(".cjs") || file.endsWith(".cts")) {
+    return false;
+  }
+  let directory = path.dirname(file);
+  while (directory !== path.dirname(directory)) {
+    const packageJsonPath = path.join(directory, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return pkg.type === "module";
+      } catch {
+        return false;
+      }
+    }
+    directory = path.dirname(directory);
+  }
+  return false;
+};
+var findPackageJsonPath = (resolvedId, packageName) => {
+  let directory = path.dirname(trimQueryString(resolvedId));
+  while (directory !== path.dirname(directory)) {
+    const packageJsonPath = path.join(directory, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (packageJson.name === packageName) {
+          return packageJsonPath;
+        }
+      } catch {
+      }
+    }
+    directory = path.dirname(directory);
+  }
+  return void 0;
+};
+var resolvePackageJsonPath = (packageName) => {
+  try {
+    return findPackageJsonPath(require2.resolve(packageName), packageName);
+  } catch {
+    return void 0;
+  }
+};
+var resolvePackageJsonPathViaContext = async (ctx, packageName) => {
+  try {
+    const resolved = await ctx.resolve(packageName);
+    if (resolved) {
+      const viaResolved = findPackageJsonPath(resolved.id, packageName);
+      if (viaResolved) {
+        return viaResolved;
+      }
+    }
+  } catch {
+  }
+  return resolvePackageJsonPath(packageName);
+};
+var importMapExcludedSubpaths = {
+  "@dxos/app-framework": /* @__PURE__ */ new Set([
+    "vite-plugin"
+  ]),
+  // `@dxos/lit-grid/testing` re-exports a playwright page-object manager and pulls
+  // `@playwright/test` (and transitive playwright-core) into the browser bundle.
+  "@dxos/lit-grid": /* @__PURE__ */ new Set([
+    "testing"
+  ]),
+  "@dxos/react-ui-mosaic": /* @__PURE__ */ new Set([
+    "playwright"
+  ]),
+  "@dxos/react-ui-stack": /* @__PURE__ */ new Set([
+    "playwright"
+  ]),
+  "@dxos/react-ui-table": /* @__PURE__ */ new Set([
+    "playwright"
+  ]),
+  "@dxos/ui-theme": /* @__PURE__ */ new Set([
+    "plugin"
+  ]),
+  // `solid-js/web/storage` is a server-only helper that pulls
+  // `node:async_hooks` (AsyncLocalStorage) and has no browser shim. Client
+  // code imports `solid-js`, `solid-js/store`, and `solid-js/web` only.
+  "solid-js": /* @__PURE__ */ new Set([
+    "web/storage"
+  ])
+};
+var GLOBALLY_EXCLUDED_SUBPATHS = /* @__PURE__ */ new Set([
+  "playwright",
+  "testing"
+]);
+var BUILD_TOOL_SUBPATH = /^(vite-plugin|esbuild-plugin|rollup-plugin|plugin)$/;
+var ASSET_SUBPATH = /\.(css|pcss|scss|sass|less|json|node|wasm|html|svg|png|jpe?g|gif|webp|ico)$/;
+var isAssetSubpath = (specifier) => ASSET_SUBPATH.test(specifier);
+var walkDirectoryForExtension = (baseDir, extension) => {
+  if (!existsSync(baseDir)) {
+    return [];
+  }
+  const results = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(full);
+      } else if (entry.endsWith(extension)) {
+        results.push(path.relative(baseDir, full).slice(0, -extension.length));
+      }
+    }
+  };
+  walk(baseDir);
+  return results;
+};
+var pickPatternTarget = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    const preferred = obj.browser ?? obj.import ?? obj.default ?? obj.module;
+    return typeof preferred === "string" ? preferred : void 0;
+  }
+  return void 0;
+};
+var expandWildcardExport = (packageName, packageJsonDir, exportKey, exportValue) => {
+  const target = pickPatternTarget(exportValue);
+  if (!target || !target.includes("*")) {
+    return [];
+  }
+  const keyStarIndex = exportKey.indexOf("*");
+  const targetStarIndex = target.indexOf("*");
+  if (keyStarIndex === -1 || targetStarIndex === -1) {
+    return [];
+  }
+  const keyPrefix = exportKey.slice(2, keyStarIndex);
+  const targetPrefix = target.slice(2, targetStarIndex);
+  const targetSuffix = target.slice(targetStarIndex + 1);
+  const baseDir = path.resolve(packageJsonDir, targetPrefix);
+  const files = walkDirectoryForExtension(baseDir, targetSuffix || ".js");
+  return files.map((relativeNoExt) => `${packageName}/${keyPrefix}${relativeNoExt}`);
+};
+var getPackageEntrypoints = (packageName, packageJsonPath) => {
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  const exportsField = packageJson.exports;
+  if (!exportsField || typeof exportsField === "string" || Array.isArray(exportsField)) {
+    return [
+      packageName
+    ];
+  }
+  const exportKeys = Object.keys(exportsField);
+  if (!exportKeys.some((key) => key.startsWith("."))) {
+    return [
+      packageName
+    ];
+  }
+  const excluded = importMapExcludedSubpaths[packageName];
+  const packageJsonDir = path.dirname(packageJsonPath);
+  const modules = exportKeys.flatMap((key) => {
+    if (key === ".") {
+      return [
+        packageName
+      ];
+    }
+    if (!key.startsWith("./") || key === "./package.json") {
+      return [];
+    }
+    if (key.endsWith(".d.ts")) {
+      return [];
+    }
+    if (key.includes("*")) {
+      return expandWildcardExport(packageName, packageJsonDir, key, exportsField[key]);
+    }
+    const subpath = key.slice(2);
+    if (excluded?.has(subpath) || GLOBALLY_EXCLUDED_SUBPATHS.has(subpath) || BUILD_TOOL_SUBPATH.test(subpath)) {
+      return [];
+    }
+    return [
+      `${packageName}/${subpath}`
+    ];
+  });
+  return modules.length > 0 ? modules : [
+    packageName
+  ];
+};
+var getCjsNamedExports = (filePath, seen = /* @__PURE__ */ new Set()) => {
+  const normalized = trimQueryString(filePath);
+  if (seen.has(normalized)) {
+    return [];
+  }
+  seen.add(normalized);
+  try {
+    const source = readFileSync(normalized, "utf8");
+    const { exports: directExports, reexports } = parseCjs(source);
+    const reexportedNames = reexports.flatMap((reexport) => {
+      const resolved = path.resolve(path.dirname(normalized), reexport);
+      const candidates = [
+        resolved,
+        `${resolved}.js`,
+        `${resolved}.cjs`
+      ];
+      const found = candidates.find((candidate) => existsSync(candidate));
+      return found ? getCjsNamedExports(found, seen) : [];
+    });
+    return [
+      .../* @__PURE__ */ new Set([
+        ...directExports,
+        ...reexportedNames
+      ])
+    ].filter((name) => name !== "default" && name !== "__esModule");
+  } catch {
+    return [];
+  }
+};
+var importMapPlugin = (options) => {
+  const packages = options?.packages ?? DEFAULT_PACKAGES;
+  const WRAPPER_PREFIX = "\0import-map:";
+  const chunkRefIds = {};
+  const resolvedIds = {};
+  let imports = {};
+  let modules = [];
+  let importMapIsDev = false;
+  let base = "/";
+  return [
+    // Phase 1: Resolve all package entrypoints and emit chunks (or record dev paths).
+    {
+      name: "import-map:get-chunk-ref-ids",
+      configResolved(config) {
+        base = config.base ?? "/";
+      },
+      async buildStart() {
+        importMapIsDev = this.environment.mode === "dev";
+        await initCjsLexer();
+        modules = [
+          ...new Set((await Promise.all(packages.map(async (packageName) => {
+            const packageJsonPath = await resolvePackageJsonPathViaContext(this, packageName);
+            if (!packageJsonPath) {
+              this.warn(`Unable to locate package.json for import map package: ${packageName}`);
+              return [
+                packageName
+              ];
+            }
+            return getPackageEntrypoints(packageName, packageJsonPath);
+          }))).flat())
+        ];
+        for (const specifier of modules) {
+          if (isAssetSubpath(specifier)) {
+            imports[specifier] = "data:text/javascript;charset=utf-8,export%20%7B%7D%3B";
+            continue;
+          }
+          const resolved = await this.resolve(specifier);
+          if (!resolved) {
+            this.warn(`Import map: unable to resolve "${specifier}"; omitting from import map.`);
+            continue;
+          }
+          if (importMapIsDev) {
+            const filePath = trimQueryString(resolved.id);
+            imports[specifier] = filePath.startsWith("/") ? `/@fs${filePath}` : filePath;
+          } else {
+            resolvedIds[specifier] = resolved.id;
+            chunkRefIds[specifier] = this.emitFile({
+              type: "chunk",
+              id: `${WRAPPER_PREFIX}${specifier}`,
+              preserveSignature: "strict"
+            });
+          }
+        }
+      },
+      // Intercept virtual wrapper IDs so Rollup doesn't try to resolve them as files.
+      resolveId(id) {
+        if (id.startsWith(WRAPPER_PREFIX)) {
+          return id;
+        }
+      },
+      // Generate the source for each virtual wrapper module.
+      // For CJS packages, explicitly re-export named exports (discovered via static analysis)
+      // because Rollup's `export *` interop doesn't preserve them for CJS.
+      load(id) {
+        if (!id.startsWith(WRAPPER_PREFIX)) {
+          return;
+        }
+        const specifier = id.slice(WRAPPER_PREFIX.length);
+        const resolvedId = resolvedIds[specifier];
+        if (!resolvedId) {
+          return `export * from ${JSON.stringify(specifier)};
+`;
+        }
+        const filePath = trimQueryString(resolvedId);
+        const isCjs = filePath.endsWith(".cjs") || !filePath.endsWith(".mjs") && !resolvedIdIsEsmModule(filePath);
+        if (isCjs) {
+          const named = getCjsNamedExports(filePath);
+          if (named.length > 0) {
+            return `export { default, ${named.join(", ")} } from ${JSON.stringify(specifier)};
+`;
+          }
+        }
+        return `export * from ${JSON.stringify(specifier)};
+`;
+      },
+      // After bundling, map each specifier to the URL of its emitted chunk. Preserves
+      // asset-subpath entries already written to `imports` during `buildStart` (those
+      // use an inline data URL rather than an emitted chunk).
+      generateBundle() {
+        if (importMapIsDev) {
+          return;
+        }
+        imports = {
+          ...imports,
+          ...Object.fromEntries(modules.filter((specifier) => chunkRefIds[specifier] !== void 0).map((specifier) => [
+            specifier,
+            `${base}${this.getFileName(chunkRefIds[specifier])}`
+          ]))
+        };
+      }
+    },
+    // Phase 2: Inject the import map into the HTML as a <script type="importmap"> tag.
+    {
+      name: "import-map:transform-index-html",
+      enforce: "post",
+      transformIndexHtml(html) {
+        const tags = [
+          {
+            tag: "script",
+            attrs: {
+              type: "importmap"
+            },
+            children: JSON.stringify({
+              imports
+            }, null, 2)
+          }
+        ];
+        return {
+          html,
+          tags
+        };
+      }
+    }
+  ];
+};
+export {
+  DEFAULT_PACKAGES,
+  MANIFEST_ASSET_NAME,
+  composerPlugin,
+  importMapPlugin,
+  isSharedPackage,
+  serializeManifest
+};
+//# sourceMappingURL=index.mjs.map