@chee/patchwork-bundles 0.0.1

package/.claude/settings.local.json

@@ -0,0 +1,17 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:www.npmjs.com)",
+      "WebSearch",
+      "Bash(find:*)",
+      "WebFetch(domain:registry.npmjs.org)",
+      "Bash(pnpm --version:*)",
+      "Bash(npx pnpm@next-11:*)",
+      "Bash(npm view:*)",
+      "Bash(ls:*)",
+      "Bash(echo:*)",
+      "Bash(pnpm test:*)",
+      "Bash(node -e:*)"
+    ]
+  }
+}

package/dist/esbuild.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => import("unplugin").EsbuildPlugin;
+export default _default;

package/dist/esbuild.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.esbuild;

package/dist/farm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => JsPlugin;
+export default _default;

package/dist/farm.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.farm;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { type PatchworkBundleOptions } from "./types.js";
+export declare const patchworkBundles: import("unplugin").UnpluginInstance<PatchworkBundleOptions | undefined, boolean>;
+export default patchworkBundles;
+export type { PatchworkBundleOptions } from "./types.js";

package/dist/index.js

@@ -0,0 +1,54 @@
+import { createUnplugin } from "unplugin";
+import { resolve } from "node:path";
+import { readPackageJson, parseBareSpecifier, isBareSpecifier, resolveDepEntryPoint, } from "./utils.js";
+import { getImportableUrlFromAutomergeUrl } from "@inkandswitch/patchwork-filesystem";
+import externals from "@inkandswitch/patchwork-bootloader/externals";
+import { resolveOptions } from "./types.js";
+export const patchworkBundles = createUnplugin((rawOptions) => {
+    const options = resolveOptions(rawOptions);
+    let deps;
+    return {
+        name: "patchwork-bundles",
+        enforce: "pre",
+        buildStart() {
+            const pkgPath = resolve(process.cwd(), options.packageJsonPath);
+            const pkgJson = readPackageJson(pkgPath);
+            deps = pkgJson.dependencies ?? {};
+        },
+        resolveId(id) {
+            if (!isBareSpecifier(id))
+                return undefined;
+            // Bootloader externals — always external (served via importmap)
+            if (externals.includes(id)) {
+                return { id, external: true };
+            }
+            const { pkgName, subpath } = parseBareSpecifier(id);
+            if (pkgName !== id && externals.includes(pkgName)) {
+                return { id, external: true };
+            }
+            const version = deps[pkgName];
+            if (!version)
+                return undefined;
+            // Automerge deps — rewrite to service worker URLs
+            if (version.startsWith("automerge:")) {
+                if (options.rewrite.automerge === "patchwork") {
+                    const entryPoint = resolveDepEntryPoint(pkgName, subpath);
+                    const url = getImportableUrlFromAutomergeUrl(version, entryPoint);
+                    return { id: url, external: true };
+                }
+                return undefined;
+            }
+            // npm fallback — optionally rewrite to esm.sh
+            if (options.rewrite.npm === "esm.sh") {
+                const cleanVersion = version.replace(/^[\^~>=<\s]+/, "");
+                const esmId = subpath === "." ? pkgName : id;
+                return {
+                    id: `https://esm.sh/${esmId}@${cleanVersion}`,
+                    external: true,
+                };
+            }
+            return undefined;
+        },
+    };
+});
+export default patchworkBundles;

package/dist/rollup.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => import("rollup").Plugin<any> | import("rollup").Plugin<any>[];
+export default _default;

package/dist/rollup.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.rollup;

package/dist/rspack.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => RspackPluginInstance;
+export default _default;

package/dist/rspack.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.rspack;

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+export interface PatchworkBundleOptions {
+    /** Path to the project's package.json. Default: "./package.json" relative to cwd */
+    packageJsonPath?: string;
+    rewrite?: {
+        /**
+         * How to handle dependencies with `automerge:` version specifiers.
+         * - `"patchwork"` (default): rewrite bare imports to service-worker URLs
+         *   (`/{encodeURIComponent("automerge:docid")}/resolved/entry.js`),
+         *   resolving through the dep's package.json exports with the `"patchwork"` condition.
+         * - `"bundle"`: include the dependency code in the bundle normally.
+         */
+        automerge?: "patchwork" | "bundle";
+        /**
+         * How to handle npm dependencies (deps that aren't `automerge:` URLs
+         * and aren't in the bootloader externals list).
+         * - `"bundle"` (default): bundle them normally.
+         * - `"esm.sh"`: rewrite to `https://esm.sh/<pkg>@<version>` external URLs.
+         */
+        npm?: "esm.sh" | "bundle";
+    };
+}
+export interface ResolvedOptions {
+    packageJsonPath: string;
+    rewrite: {
+        automerge: "patchwork" | "bundle";
+        npm: "esm.sh" | "bundle";
+    };
+}
+export declare function resolveOptions(raw?: PatchworkBundleOptions): ResolvedOptions;

package/dist/types.js

@@ -0,0 +1,9 @@
+export function resolveOptions(raw) {
+    return {
+        packageJsonPath: raw?.packageJsonPath ?? "./package.json",
+        rewrite: {
+            automerge: raw?.rewrite?.automerge ?? "patchwork",
+            npm: raw?.rewrite?.npm ?? "bundle",
+        },
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Read and parse a package.json file.
+ */
+export declare function readPackageJson(path: string): Record<string, any>;
+/**
+ * Parse a bare import specifier into package name and subpath.
+ *
+ * - `"abc"` → `{ pkgName: "abc", subpath: "." }`
+ * - `"abc/utils"` → `{ pkgName: "abc", subpath: "./utils" }`
+ * - `"@scope/pkg"` → `{ pkgName: "@scope/pkg", subpath: "." }`
+ * - `"@scope/pkg/utils"` → `{ pkgName: "@scope/pkg", subpath: "./utils" }`
+ */
+export declare function parseBareSpecifier(id: string): {
+    pkgName: string;
+    subpath: string;
+};
+/**
+ * Returns true if the specifier is a bare import (not relative, absolute,
+ * or a protocol URL).
+ */
+export declare function isBareSpecifier(id: string): boolean;
+/**
+ * Resolve a dependency's entry point by reading its package.json from
+ * `node_modules/` and resolving through its `exports` field.
+ *
+ * Returns the resolved path relative to the package root (e.g. `"./dist/index.js"`),
+ * or the subpath itself if resolution fails.
+ */
+export declare function resolveDepEntryPoint(pkgName: string, subpath?: string, conditions?: string[]): string;

package/dist/utils.js

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { resolve as resolveExports } from "resolve.exports";
+/**
+ * Read and parse a package.json file.
+ */
+export function readPackageJson(path) {
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+/**
+ * Parse a bare import specifier into package name and subpath.
+ *
+ * - `"abc"` → `{ pkgName: "abc", subpath: "." }`
+ * - `"abc/utils"` → `{ pkgName: "abc", subpath: "./utils" }`
+ * - `"@scope/pkg"` → `{ pkgName: "@scope/pkg", subpath: "." }`
+ * - `"@scope/pkg/utils"` → `{ pkgName: "@scope/pkg", subpath: "./utils" }`
+ */
+export function parseBareSpecifier(id) {
+    const firstSlash = id.indexOf("/");
+    const isScoped = id.startsWith("@");
+    if (isScoped) {
+        const secondSlash = id.indexOf("/", firstSlash + 1);
+        if (secondSlash === -1) {
+            return { pkgName: id, subpath: "." };
+        }
+        return {
+            pkgName: id.slice(0, secondSlash),
+            subpath: "./" + id.slice(secondSlash + 1),
+        };
+    }
+    if (firstSlash === -1) {
+        return { pkgName: id, subpath: "." };
+    }
+    return {
+        pkgName: id.slice(0, firstSlash),
+        subpath: "./" + id.slice(firstSlash + 1),
+    };
+}
+/**
+ * Returns true if the specifier is a bare import (not relative, absolute,
+ * or a protocol URL).
+ */
+export function isBareSpecifier(id) {
+    return (id.length > 0 &&
+        !id.startsWith(".") &&
+        !id.startsWith("/") &&
+        !id.includes(":"));
+}
+/**
+ * Resolve a dependency's entry point by reading its package.json from
+ * `node_modules/` and resolving through its `exports` field.
+ *
+ * Returns the resolved path relative to the package root (e.g. `"./dist/index.js"`),
+ * or the subpath itself if resolution fails.
+ */
+export function resolveDepEntryPoint(pkgName, subpath = ".", conditions = ["patchwork", "browser", "import"]) {
+    try {
+        const depPkgJsonPath = resolvePath(process.cwd(), "node_modules", pkgName, "package.json");
+        const depPkgJson = readPackageJson(depPkgJsonPath);
+        const resolved = resolveExports(depPkgJson, subpath, { conditions });
+        if (resolved && resolved[0]) {
+            return resolved[0];
+        }
+        // Fallback to "main" for root export
+        if (subpath === "." && typeof depPkgJson.main === "string") {
+            return depPkgJson.main;
+        }
+    }
+    catch {
+        // If we can't read the dep's package.json, just pass through the subpath
+    }
+    return subpath;
+}

package/dist/vite.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+export default _default;

package/dist/vite.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.vite;

package/dist/webpack.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options?: import("./types.js").PatchworkBundleOptions | undefined) => WebpackPluginInstance;
+export default _default;

package/dist/webpack.js

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.webpack;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@chee/patchwork-bundles",
+  "version": "0.0.1",
+  "type": "module",
+  "author": "Ink & Switch",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./vite": {
+      "import": "./dist/vite.js",
+      "types": "./dist/vite.d.ts"
+    },
+    "./esbuild": {
+      "import": "./dist/esbuild.js",
+      "types": "./dist/esbuild.d.ts"
+    },
+    "./webpack": {
+      "import": "./dist/webpack.js",
+      "types": "./dist/webpack.d.ts"
+    },
+    "./rollup": {
+      "import": "./dist/rollup.js",
+      "types": "./dist/rollup.d.ts"
+    },
+    "./rspack": {
+      "import": "./dist/rspack.js",
+      "types": "./dist/rspack.d.ts"
+    },
+    "./farm": {
+      "import": "./dist/farm.js",
+      "types": "./dist/farm.d.ts"
+    }
+  },
+  "dependencies": {
+    "@automerge/automerge-repo": "2.6.0-subduction.15",
+    "resolve.exports": "^2.0.3",
+    "unplugin": "^2.3.0",
+    "@inkandswitch/patchwork-bootloader": "^0.0.5",
+    "@inkandswitch/patchwork-filesystem": "^0.0.4"
+  },
+  "devDependencies": {
+    "esbuild": "^0.23.1",
+    "vite": "^7.1.9",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --preserveWatchOutput",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/esbuild.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.esbuild;

package/src/farm.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.farm;

package/src/index.ts

@@ -0,0 +1,76 @@
+import { createUnplugin } from "unplugin";
+import { resolve } from "node:path";
+import {
+  readPackageJson,
+  parseBareSpecifier,
+  isBareSpecifier,
+  resolveDepEntryPoint,
+} from "./utils.js";
+import { getImportableUrlFromAutomergeUrl } from "@inkandswitch/patchwork-filesystem";
+import externals from "@inkandswitch/patchwork-bootloader/externals";
+import type { AutomergeUrl } from "@automerge/automerge-repo";
+import { resolveOptions, type PatchworkBundleOptions } from "./types.js";
+
+export const patchworkBundles = createUnplugin(
+  (rawOptions?: PatchworkBundleOptions) => {
+    const options = resolveOptions(rawOptions);
+    let deps: Record<string, string>;
+
+    return {
+      name: "patchwork-bundles",
+      enforce: "pre",
+
+      buildStart() {
+        const pkgPath = resolve(process.cwd(), options.packageJsonPath);
+        const pkgJson = readPackageJson(pkgPath);
+        deps = pkgJson.dependencies ?? {};
+      },
+
+      resolveId(id: string) {
+        if (!isBareSpecifier(id)) return undefined;
+
+        // Bootloader externals — always external (served via importmap)
+        if (externals.includes(id)) {
+          return { id, external: true };
+        }
+
+        const { pkgName, subpath } = parseBareSpecifier(id);
+
+        if (pkgName !== id && externals.includes(pkgName)) {
+          return { id, external: true };
+        }
+
+        const version = deps[pkgName];
+        if (!version) return undefined;
+
+        // Automerge deps — rewrite to service worker URLs
+        if (version.startsWith("automerge:")) {
+          if (options.rewrite.automerge === "patchwork") {
+            const entryPoint = resolveDepEntryPoint(pkgName, subpath);
+            const url = getImportableUrlFromAutomergeUrl(
+              version as AutomergeUrl,
+              entryPoint
+            );
+            return { id: url, external: true };
+          }
+          return undefined;
+        }
+
+        // npm fallback — optionally rewrite to esm.sh
+        if (options.rewrite.npm === "esm.sh") {
+          const cleanVersion = version.replace(/^[\^~>=<\s]+/, "");
+          const esmId = subpath === "." ? pkgName : id;
+          return {
+            id: `https://esm.sh/${esmId}@${cleanVersion}`,
+            external: true,
+          };
+        }
+
+        return undefined;
+      },
+    };
+  }
+);
+
+export default patchworkBundles;
+export type { PatchworkBundleOptions } from "./types.js";

package/src/rollup.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.rollup;

package/src/rspack.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.rspack;

package/src/types.ts

@@ -0,0 +1,41 @@
+export interface PatchworkBundleOptions {
+  /** Path to the project's package.json. Default: "./package.json" relative to cwd */
+  packageJsonPath?: string;
+
+  rewrite?: {
+    /**
+     * How to handle dependencies with `automerge:` version specifiers.
+     * - `"patchwork"` (default): rewrite bare imports to service-worker URLs
+     *   (`/{encodeURIComponent("automerge:docid")}/resolved/entry.js`),
+     *   resolving through the dep's package.json exports with the `"patchwork"` condition.
+     * - `"bundle"`: include the dependency code in the bundle normally.
+     */
+    automerge?: "patchwork" | "bundle";
+
+    /**
+     * How to handle npm dependencies (deps that aren't `automerge:` URLs
+     * and aren't in the bootloader externals list).
+     * - `"bundle"` (default): bundle them normally.
+     * - `"esm.sh"`: rewrite to `https://esm.sh/<pkg>@<version>` external URLs.
+     */
+    npm?: "esm.sh" | "bundle";
+  };
+}
+
+export interface ResolvedOptions {
+  packageJsonPath: string;
+  rewrite: {
+    automerge: "patchwork" | "bundle";
+    npm: "esm.sh" | "bundle";
+  };
+}
+
+export function resolveOptions(raw?: PatchworkBundleOptions): ResolvedOptions {
+  return {
+    packageJsonPath: raw?.packageJsonPath ?? "./package.json",
+    rewrite: {
+      automerge: raw?.rewrite?.automerge ?? "patchwork",
+      npm: raw?.rewrite?.npm ?? "bundle",
+    },
+  };
+}

package/src/utils.ts

@@ -0,0 +1,96 @@
+import { readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { resolve as resolveExports } from "resolve.exports";
+
+/**
+ * Read and parse a package.json file.
+ */
+export function readPackageJson(path: string): Record<string, any> {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+
+/**
+ * Parse a bare import specifier into package name and subpath.
+ *
+ * - `"abc"` → `{ pkgName: "abc", subpath: "." }`
+ * - `"abc/utils"` → `{ pkgName: "abc", subpath: "./utils" }`
+ * - `"@scope/pkg"` → `{ pkgName: "@scope/pkg", subpath: "." }`
+ * - `"@scope/pkg/utils"` → `{ pkgName: "@scope/pkg", subpath: "./utils" }`
+ */
+export function parseBareSpecifier(id: string): {
+  pkgName: string;
+  subpath: string;
+} {
+  const firstSlash = id.indexOf("/");
+  const isScoped = id.startsWith("@");
+
+  if (isScoped) {
+    const secondSlash = id.indexOf("/", firstSlash + 1);
+    if (secondSlash === -1) {
+      return { pkgName: id, subpath: "." };
+    }
+    return {
+      pkgName: id.slice(0, secondSlash),
+      subpath: "./" + id.slice(secondSlash + 1),
+    };
+  }
+
+  if (firstSlash === -1) {
+    return { pkgName: id, subpath: "." };
+  }
+
+  return {
+    pkgName: id.slice(0, firstSlash),
+    subpath: "./" + id.slice(firstSlash + 1),
+  };
+}
+
+/**
+ * Returns true if the specifier is a bare import (not relative, absolute,
+ * or a protocol URL).
+ */
+export function isBareSpecifier(id: string): boolean {
+  return (
+    id.length > 0 &&
+    !id.startsWith(".") &&
+    !id.startsWith("/") &&
+    !id.includes(":")
+  );
+}
+
+/**
+ * Resolve a dependency's entry point by reading its package.json from
+ * `node_modules/` and resolving through its `exports` field.
+ *
+ * Returns the resolved path relative to the package root (e.g. `"./dist/index.js"`),
+ * or the subpath itself if resolution fails.
+ */
+export function resolveDepEntryPoint(
+  pkgName: string,
+  subpath: string = ".",
+  conditions: string[] = ["patchwork", "browser", "import"]
+): string {
+  try {
+    const depPkgJsonPath = resolvePath(
+      process.cwd(),
+      "node_modules",
+      pkgName,
+      "package.json"
+    );
+    const depPkgJson = readPackageJson(depPkgJsonPath);
+
+    const resolved = resolveExports(depPkgJson, subpath, { conditions });
+    if (resolved && resolved[0]) {
+      return resolved[0];
+    }
+
+    // Fallback to "main" for root export
+    if (subpath === "." && typeof depPkgJson.main === "string") {
+      return depPkgJson.main;
+    }
+  } catch {
+    // If we can't read the dep's package.json, just pass through the subpath
+  }
+
+  return subpath;
+}

package/src/vite.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.vite;

package/src/webpack.ts

@@ -0,0 +1,2 @@
+import { patchworkBundles } from "./index.js";
+export default patchworkBundles.webpack;

package/test/integration.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { build as viteBuild } from "vite";
+import * as esbuild from "esbuild";
+
+const AUTOMERGE_URL = "automerge:kFcrzeDmr5zXE1jShvxUPsoToAN";
+const ENCODED_URL = encodeURIComponent(AUTOMERGE_URL);
+
+describe("patchwork-bundles integration", () => {
+  let tmpDir: string;
+  let originalCwd: string;
+
+  beforeAll(async () => {
+    originalCwd = process.cwd();
+    tmpDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), "patchwork-bundles-test-")
+    );
+
+    // Phase 1: set up project with pnpm-plugin-patchwork as a configDependency
+    await fs.writeFile(
+      path.join(tmpDir, "package.json"),
+      JSON.stringify(
+        {
+          name: "test-patchwork-bundles",
+          version: "0.0.0",
+          type: "module",
+          dependencies: {
+            "my-sideboard-tool": AUTOMERGE_URL,
+            "solid-js": "^1.9.9",
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    // stub workspace packages that the automerge doc depends on via workspace:^
+    const bootloaderDir = path.join(tmpDir, "packages/patchwork-bootloader");
+    await fs.mkdir(bootloaderDir, { recursive: true });
+    await fs.writeFile(
+      path.join(bootloaderDir, "package.json"),
+      JSON.stringify({
+        name: "@inkandswitch/patchwork-bootloader",
+        version: "0.0.1",
+        type: "module",
+        exports: { "./externals": { import: "./externals.js" } },
+      })
+    );
+    await fs.writeFile(
+      path.join(bootloaderDir, "externals.js"),
+      `const externals = [\n  "solid-js",\n  "solid-js/web",\n  "solid-js/html",\n  "solid-js/store",\n  "solid-js/jsx-runtime",\n  "solid-js/h"\n];\nexport default externals;\n`
+    );
+
+    const elementsDir = path.join(tmpDir, "packages/patchwork-elements");
+    await fs.mkdir(elementsDir, { recursive: true });
+    await fs.writeFile(
+      path.join(elementsDir, "package.json"),
+      JSON.stringify({
+        name: "@inkandswitch/patchwork-elements",
+        version: "0.0.1",
+        type: "module",
+      })
+    );
+
+    await fs.writeFile(
+      path.join(tmpDir, "pnpm-workspace.yaml"),
+      [
+        "packages:",
+        '  - "packages/*"',
+        "configDependencies:",
+        '  pnpm-plugin-patchwork: "0.1.0"',
+        "",
+      ].join("\n")
+    );
+
+    // .npmrc — avoid strict peer deps issues
+    await fs.writeFile(
+      path.join(tmpDir, ".npmrc"),
+      "strict-peer-dependencies=false\nauto-install-peers=true\n"
+    );
+
+    // install — plugin resolves automerge: deps automatically
+    // filter out parent pnpm's npm_config_* env vars to avoid contamination
+    const cleanEnv = Object.fromEntries(
+      Object.entries(process.env).filter(
+        ([k]) => !k.startsWith("npm_")
+      )
+    );
+    execSync("npx pnpm@next-11 install --no-frozen-lockfile", {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 120_000,
+      env: {
+        ...cleanEnv,
+        PATCHWORK_SYNC_SERVER: "wss://sync3.automerge.org",
+      },
+    });
+
+    // Phase 2: write source file
+    const srcDir = path.join(tmpDir, "src");
+    await fs.mkdir(srcDir, { recursive: true });
+    await fs.writeFile(
+      path.join(srcDir, "index.ts"),
+      [
+        `import { createSignal } from "solid-js";`,
+        `import * as sideboard from "my-sideboard-tool";`,
+        `console.log(createSignal, sideboard);`,
+        "",
+      ].join("\n")
+    );
+
+    process.chdir(tmpDir);
+  }, 180_000);
+
+  afterAll(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  describe("pnpm plugin installed my-sideboard-tool from automerge", () => {
+    it("has a package.json with the sideboard package name", async () => {
+      const pkgPath = path.join(
+        tmpDir,
+        "node_modules/my-sideboard-tool/package.json"
+      );
+      const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+      expect(pkg.name).toBe("@chee/patchwork-sideboard");
+    });
+
+    it("has an exports field with a patchwork condition", async () => {
+      const pkgPath = path.join(
+        tmpDir,
+        "node_modules/my-sideboard-tool/package.json"
+      );
+      const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+      expect(pkg.exports).toBeDefined();
+      expect(pkg.exports["."]).toBeDefined();
+      expect(pkg.exports["."].patchwork).toBeDefined();
+    });
+
+    it("contains actual dist files from the automerge document", async () => {
+      const distDir = path.join(tmpDir, "node_modules/my-sideboard-tool/dist");
+      const files = await fs.readdir(distDir);
+      expect(files.length).toBeGreaterThan(0);
+      // should have js output
+      expect(files.some((f) => f.endsWith(".js"))).toBe(true);
+    });
+  });
+
+  describe("vite build", () => {
+    let output: string;
+
+    beforeAll(async () => {
+      // Determine what entry point the plugin will resolve to
+      const pluginPath = path.resolve(originalCwd, "dist/vite.js");
+      const { default: vitePlugin } = await import(pluginPath);
+
+      const result = await viteBuild({
+        root: tmpDir,
+        logLevel: "silent",
+        build: {
+          lib: {
+            entry: path.join(tmpDir, "src/index.ts"),
+            formats: ["es"],
+            fileName: "index",
+          },
+          outDir: path.join(tmpDir, "dist-vite"),
+          write: true,
+          minify: false,
+        },
+        plugins: [vitePlugin()],
+      });
+
+      // vite 7 outputs .js, older versions output .mjs
+      const mjs = path.join(tmpDir, "dist-vite/index.mjs");
+      const js = path.join(tmpDir, "dist-vite/index.js");
+      output = await fs.readFile(
+        await fs.access(mjs).then(() => mjs, () => js),
+        "utf-8"
+      );
+    }, 60_000);
+
+    it("rewrites automerge dep to service-worker URL", () => {
+      expect(output).toContain(ENCODED_URL);
+      // Should be an import from /<encoded-url>/...
+      expect(output).toMatch(new RegExp(`from ["']/${ENCODED_URL}/`));
+    });
+
+    it("externalizes solid-js", () => {
+      expect(output).toMatch(/from ["']solid-js["']/);
+      // if solid-js were inlined, the output would be thousands of lines
+      const lines = output.split("\n").length;
+      expect(lines).toBeLessThan(20);
+    });
+
+    it("does not contain bundled automerge dep code", () => {
+      // The automerge dep should be external, not inlined
+      expect(output).not.toContain("my-sideboard-tool");
+    });
+  });
+
+  describe("esbuild build", () => {
+    let output: string;
+
+    beforeAll(async () => {
+      const pluginPath = path.resolve(originalCwd, "dist/esbuild.js");
+      const { default: esbuildPlugin } = await import(pluginPath);
+
+      await esbuild.build({
+        entryPoints: [path.join(tmpDir, "src/index.ts")],
+        bundle: true,
+        format: "esm",
+        outfile: path.join(tmpDir, "dist-esbuild/index.js"),
+        plugins: [esbuildPlugin()],
+        logLevel: "silent",
+      });
+
+      output = await fs.readFile(
+        path.join(tmpDir, "dist-esbuild/index.js"),
+        "utf-8"
+      );
+    }, 60_000);
+
+    it("rewrites automerge dep to service-worker URL", () => {
+      expect(output).toContain(ENCODED_URL);
+      expect(output).toMatch(new RegExp(`from ["']/${ENCODED_URL}/`));
+    });
+
+    it("externalizes solid-js", () => {
+      expect(output).toMatch(/from ["']solid-js["']/);
+      // if solid-js were inlined, the output would be thousands of lines
+      const lines = output.split("\n").length;
+      expect(lines).toBeLessThan(20);
+    });
+
+    it("does not contain bundled automerge dep code", () => {
+      expect(output).not.toContain("my-sideboard-tool");
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["test/**/*.{test,spec}.ts"],
+    testTimeout: 180_000,
+  },
+});