@b9g/shovel 0.2.0-beta.7 → 0.2.0-beta.8

package/README.md

@@ -29,7 +29,7 @@ Shovel implements web platform APIs that server-side JavaScript is missing:
 |-----|----------|--------------|
 | `fetch` event | [Service Workers](https://w3c.github.io/ServiceWorker/) | Request handling |
 | `self.caches` | [Cache API](https://w3c.github.io/ServiceWorker/#cache-interface) | Response caching |
-| `self.buckets` | [FileSystemDirectoryHandle](https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle) | Storage (local, S3, R2) |
+| `self.buckets` | [FileSystem API](https://fs.spec.whatwg.org/) | Storage (local, S3, R2) |
 | `self.cookieStore` | [Cookie Store API](https://wicg.github.io/cookie-store/) | Cookie management |
 | `URLPattern` | [URLPattern](https://urlpattern.spec.whatwg.org/) | Route matching (100% WPT) |
 | `AsyncContext.Variable` | [TC39 Stage 2](https://github.com/tc39/proposal-async-context) | Request-scoped state |

package/bin/cli.js

@@ -20,11 +20,12 @@ var DEFAULTS = {
 import { configure, getConsoleSink, getLogger as getLogger2 } from "@logtape/logtape";
 import { AsyncContext } from "@b9g/async-context";
 import * as Platform from "@b9g/platform";
+import { loadConfig } from "@b9g/platform/config";
 
 // src/esbuild/watcher.ts
 import * as ESBuild from "esbuild";
-import { existsSync } from "fs";
-import { resolve, join, dirname as dirname2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { resolve, join as join2, dirname as dirname3 } from "path";
 import { mkdir } from "fs/promises";
 import { assetsPlugin } from "@b9g/assets/plugin";
 
@@ -77,16 +78,129 @@ function importMetaPlugin() {
   };
 }
 
+// src/esbuild/jsx-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join, dirname as dirname2 } from "path";
+import { existsSync } from "fs";
+var CRANK_JSX_DEFAULTS = {
+  jsx: "automatic",
+  jsxImportSource: "@b9g/crank"
+};
+async function findTsConfig(startDir) {
+  let dir = startDir;
+  while (dir !== dirname2(dir)) {
+    const tsconfigPath = join(dir, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      return tsconfigPath;
+    }
+    dir = dirname2(dir);
+  }
+  return null;
+}
+async function parseTsConfig(tsconfigPath) {
+  const content = await readFile2(tsconfigPath, "utf8");
+  const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const config = JSON.parse(stripped);
+  if (config.extends) {
+    const baseDir = dirname2(tsconfigPath);
+    let extendsPath = config.extends;
+    if (extendsPath.startsWith(".")) {
+      extendsPath = join(baseDir, extendsPath);
+    } else {
+      extendsPath = join(baseDir, "node_modules", extendsPath);
+    }
+    if (!extendsPath.endsWith(".json")) {
+      extendsPath += ".json";
+    }
+    if (existsSync(extendsPath)) {
+      const baseConfig = await parseTsConfig(extendsPath);
+      return {
+        ...baseConfig,
+        ...config,
+        compilerOptions: {
+          ...baseConfig.compilerOptions,
+          ...config.compilerOptions
+        }
+      };
+    }
+  }
+  return config;
+}
+function mapTsConfigToEsbuild(compilerOptions) {
+  const options = {};
+  if (compilerOptions.jsx) {
+    switch (compilerOptions.jsx) {
+      case "react":
+      case "react-native":
+        options.jsx = "transform";
+        break;
+      case "react-jsx":
+      case "react-jsxdev":
+        options.jsx = "automatic";
+        break;
+      case "preserve":
+        options.jsx = "preserve";
+        break;
+    }
+  }
+  if (compilerOptions.jsxFactory) {
+    options.jsxFactory = compilerOptions.jsxFactory;
+  }
+  if (compilerOptions.jsxFragmentFactory) {
+    options.jsxFragment = compilerOptions.jsxFragmentFactory;
+  }
+  if (compilerOptions.jsxImportSource) {
+    options.jsxImportSource = compilerOptions.jsxImportSource;
+  }
+  return options;
+}
+async function loadJSXConfig(projectRoot) {
+  const tsconfigPath = await findTsConfig(projectRoot);
+  if (tsconfigPath) {
+    try {
+      const config = await parseTsConfig(tsconfigPath);
+      const compilerOptions = config.compilerOptions || {};
+      const hasJsxConfig = compilerOptions.jsx || compilerOptions.jsxFactory || compilerOptions.jsxFragmentFactory || compilerOptions.jsxImportSource;
+      if (hasJsxConfig) {
+        const tsOptions = mapTsConfigToEsbuild(compilerOptions);
+        return {
+          ...CRANK_JSX_DEFAULTS,
+          ...tsOptions
+        };
+      }
+    } catch {
+    }
+  }
+  return { ...CRANK_JSX_DEFAULTS };
+}
+function applyJSXOptions(buildOptions, jsxOptions) {
+  if (jsxOptions.jsx) {
+    buildOptions.jsx = jsxOptions.jsx;
+  }
+  if (jsxOptions.jsxFactory) {
+    buildOptions.jsxFactory = jsxOptions.jsxFactory;
+  }
+  if (jsxOptions.jsxFragment) {
+    buildOptions.jsxFragment = jsxOptions.jsxFragment;
+  }
+  if (jsxOptions.jsxImportSource) {
+    buildOptions.jsxImportSource = jsxOptions.jsxImportSource;
+  }
+  if (jsxOptions.jsxSideEffects !== void 0) {
+    buildOptions.jsxSideEffects = jsxOptions.jsxSideEffects;
+  }
+}
+
 // src/esbuild/watcher.ts
 import { getLogger } from "@logtape/logtape";
 var logger = getLogger(["watcher"]);
 function findProjectRoot() {
   let dir = process.cwd();
-  while (dir !== dirname2(dir)) {
-    if (existsSync(join(dir, "package.json"))) {
+  while (dir !== dirname3(dir)) {
+    if (existsSync2(join2(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname2(dir);
+    dir = dirname3(dir);
   }
   return process.cwd();
 }
@@ -110,12 +224,13 @@ var Watcher = class {
   async start() {
     const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
     const outputDir = resolve(this.#projectRoot, this.#options.outDir);
-    await mkdir(join(outputDir, "server"), { recursive: true });
-    await mkdir(join(outputDir, "static"), { recursive: true });
+    await mkdir(join2(outputDir, "server"), { recursive: true });
+    await mkdir(join2(outputDir, "static"), { recursive: true });
+    const jsxOptions = await loadJSXConfig(this.#projectRoot);
     const initialBuildPromise = new Promise((resolve3) => {
       this.#initialBuildResolve = resolve3;
     });
-    this.#ctx = await ESBuild.context({
+    const buildOptions = {
       entryPoints: [entryPath],
       bundle: true,
       format: "esm",
@@ -128,7 +243,13 @@ var Watcher = class {
       plugins: [
         importMetaPlugin(),
         assetsPlugin({
-          outDir: outputDir
+          outDir: outputDir,
+          clientBuild: {
+            jsx: jsxOptions.jsx,
+            jsxFactory: jsxOptions.jsxFactory,
+            jsxFragment: jsxOptions.jsxFragment,
+            jsxImportSource: jsxOptions.jsxImportSource
+          }
         }),
         // Plugin to detect build completion (works with watch mode)
         {
@@ -152,7 +273,7 @@ var Watcher = class {
               if (success) {
                 logger.info("Build complete", { entrypoint: outputPath });
               } else {
-                logger.error("Build errors", { errors: result.errors });
+                logger.error("Build errors: {errors}", { errors: result.errors });
               }
               this.#currentEntrypoint = outputPath;
               if (!this.#initialBuildComplete) {
@@ -168,7 +289,9 @@ var Watcher = class {
       sourcemap: "inline",
       minify: false,
       treeShaking: true
-    });
+    };
+    applyJSXOptions(buildOptions, jsxOptions);
+    this.#ctx = await ESBuild.context(buildOptions);
     logger.info("Starting esbuild watch mode");
     await this.#ctx.watch();
     return initialBuildPromise;
@@ -206,8 +329,9 @@ await configure({
 var logger2 = getLogger2(["cli"]);
 async function developCommand(entrypoint, options) {
   try {
-    const platformName = Platform.resolvePlatform(options);
-    const workerCount = getWorkerCount(options);
+    const config = loadConfig(process.cwd());
+    const platformName = Platform.resolvePlatform({ ...options, config });
+    const workerCount = getWorkerCount(options, config);
     if (options.verbose) {
       Platform.displayPlatformInfo(platformName);
       logger2.info("Worker configuration", { workerCount });
@@ -273,13 +397,16 @@ async function developCommand(entrypoint, options) {
     process.exit(1);
   }
 }
-function getWorkerCount(options) {
+function getWorkerCount(options, config) {
   if (options.workers) {
     return parseInt(options.workers);
   }
   if (process.env.WORKER_COUNT) {
     return parseInt(process.env.WORKER_COUNT);
   }
+  if (config?.workers) {
+    return config.workers;
+  }
   return DEFAULTS.WORKERS;
 }
 
@@ -314,10 +441,7 @@ async function activateCommand(entrypoint, options) {
     await serviceWorker.dispose();
     await platformInstance.dispose();
   } catch (error) {
-    logger3.error("ServiceWorker activation failed", { error: error.message });
-    if (options.verbose) {
-      logger3.error("Stack trace", { stack: error.stack });
-    }
+    logger3.error("ServiceWorker activation failed: {error}", { error });
     process.exit(1);
   }
 }
@@ -344,12 +468,14 @@ async function infoCommand() {
 
 // src/commands/build.ts
 import * as ESBuild2 from "esbuild";
-import { resolve as resolve2, join as join2, dirname as dirname3 } from "path";
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { resolve as resolve2, join as join3, dirname as dirname4 } from "path";
+import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
 import { fileURLToPath } from "url";
 import { assetsPlugin as assetsPlugin2 } from "@b9g/assets/plugin";
 import { configure as configure2, getConsoleSink as getConsoleSink2, getLogger as getLogger5 } from "@logtape/logtape";
 import { AsyncContext as AsyncContext2 } from "@b9g/async-context";
+import * as Platform3 from "@b9g/platform";
+import { loadConfig as loadConfig2 } from "@b9g/platform/config";
 await configure2({
   reset: true,
   contextLocalStorage: new AsyncContext2.Variable(),
@@ -401,7 +527,7 @@ async function buildForProduction({
   if (verbose) {
     logger5.info("Built app to", { outputDir: buildContext.outputDir });
     logger5.info("Server files", { dir: buildContext.serverDir });
-    logger5.info("Static files", { dir: join2(buildContext.outputDir, "static") });
+    logger5.info("Static files", { dir: join3(buildContext.outputDir, "static") });
   }
 }
 async function initializeBuild({
@@ -425,7 +551,7 @@ async function initializeBuild({
   const entryPath = resolve2(entrypoint);
   const outputDir = resolve2(outDir);
   try {
-    const stats = await readFile2(entryPath, "utf8");
+    const stats = await readFile3(entryPath, "utf8");
     if (stats.length === 0) {
       logger5.warn("Entry point is empty", { entryPath });
     }
@@ -447,8 +573,8 @@ async function initializeBuild({
   }
   try {
     await mkdir2(outputDir, { recursive: true });
-    await mkdir2(join2(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
-    await mkdir2(join2(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
+    await mkdir2(join3(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
+    await mkdir2(join3(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
   } catch (error) {
     throw new Error(
       `Failed to create output directory structure: ${error.message}`
@@ -457,7 +583,7 @@ async function initializeBuild({
   return {
     entryPath,
     outputDir,
-    serverDir: join2(outputDir, BUILD_STRUCTURE.serverDir),
+    serverDir: join3(outputDir, BUILD_STRUCTURE.serverDir),
     workspaceRoot,
     platform,
     verbose,
@@ -466,37 +592,37 @@ async function initializeBuild({
 }
 async function findWorkspaceRoot() {
   let workspaceRoot = process.cwd();
-  while (workspaceRoot !== dirname3(workspaceRoot)) {
+  while (workspaceRoot !== dirname4(workspaceRoot)) {
     try {
       const packageJSON = JSON.parse(
-        await readFile2(resolve2(workspaceRoot, "package.json"), "utf8")
+        await readFile3(resolve2(workspaceRoot, "package.json"), "utf8")
       );
       if (packageJSON.workspaces) {
         return workspaceRoot;
       }
     } catch {
     }
-    workspaceRoot = dirname3(workspaceRoot);
+    workspaceRoot = dirname4(workspaceRoot);
   }
   return workspaceRoot;
 }
 async function findShovelPackageRoot() {
-  let currentDir = dirname3(fileURLToPath(import.meta.url));
+  let currentDir = dirname4(fileURLToPath(import.meta.url));
   let packageRoot = currentDir;
-  while (packageRoot !== dirname3(packageRoot)) {
+  while (packageRoot !== dirname4(packageRoot)) {
     try {
-      const packageJSONPath = join2(packageRoot, "package.json");
-      const content = await readFile2(packageJSONPath, "utf8");
+      const packageJSONPath = join3(packageRoot, "package.json");
+      const content = await readFile3(packageJSONPath, "utf8");
       const pkg2 = JSON.parse(content);
       if (pkg2.name === "@b9g/shovel" || pkg2.name === "shovel") {
         if (packageRoot.endsWith("/dist") || packageRoot.endsWith("\\dist")) {
-          return dirname3(packageRoot);
+          return dirname4(packageRoot);
         }
         return packageRoot;
       }
     } catch {
     }
-    packageRoot = dirname3(packageRoot);
+    packageRoot = dirname4(packageRoot);
   }
   return currentDir;
 }
@@ -509,6 +635,7 @@ async function createBuildConfig({
   workerCount
 }) {
   const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
+  const jsxOptions = await loadJSXConfig(workspaceRoot || dirname4(entryPath));
   try {
     const virtualEntry = await createVirtualEntry(
       entryPath,
@@ -524,19 +651,25 @@ async function createBuildConfig({
         format: BUILD_DEFAULTS.format,
         target: BUILD_DEFAULTS.target,
         platform: "node",
-        outfile: join2(serverDir, "server.js"),
-        absWorkingDir: workspaceRoot || dirname3(entryPath),
+        outfile: join3(serverDir, "server.js"),
+        absWorkingDir: workspaceRoot || dirname4(entryPath),
         mainFields: ["module", "main"],
         conditions: ["import", "module"],
         // Allow user code to import @b9g packages from shovel's packages directory
         nodePaths: [
-          join2(shovelRoot, "packages"),
-          join2(shovelRoot, "node_modules")
+          join3(shovelRoot, "packages"),
+          join3(shovelRoot, "node_modules")
         ],
         plugins: [
           importMetaPlugin(),
           assetsPlugin2({
-            outDir: outputDir
+            outDir: outputDir,
+            clientBuild: {
+              jsx: jsxOptions.jsx,
+              jsxFactory: jsxOptions.jsxFactory,
+              jsxFragment: jsxOptions.jsxFragment,
+              jsxImportSource: jsxOptions.jsxImportSource
+            }
           })
         ],
         metafile: true,
@@ -548,12 +681,13 @@ async function createBuildConfig({
         define: platform === "node" ? { "import.meta.env": "process.env" } : {},
         external
       };
+      applyJSXOptions(userBuildConfig, jsxOptions);
       await ESBuild2.build(userBuildConfig);
-      const runtimeSourcePath = join2(
+      const runtimeSourcePath = join3(
         shovelRoot,
         "packages/platform/dist/src/runtime.js"
       );
-      const workerDestPath = join2(serverDir, "worker.js");
+      const workerDestPath = join3(serverDir, "worker.js");
       try {
         await ESBuild2.build({
           entryPoints: [runtimeSourcePath],
@@ -565,7 +699,7 @@ async function createBuildConfig({
           external: ["node:*"]
         });
       } catch (error) {
-        const installedRuntimePath = join2(
+        const installedRuntimePath = join3(
           shovelRoot,
           "node_modules/@b9g/platform/dist/src/runtime.js"
         );
@@ -593,17 +727,23 @@ async function createBuildConfig({
       platform: isCloudflare ? "browser" : "node",
       // Cloudflare: single-file architecture (server.js contains everything)
       // Node/Bun: multi-file architecture (index.js is entry, server.js is user code)
-      outfile: join2(
+      outfile: join3(
         serverDir,
         isCloudflare ? "server.js" : BUILD_DEFAULTS.outputFile
       ),
-      absWorkingDir: workspaceRoot || dirname3(entryPath),
+      absWorkingDir: workspaceRoot || dirname4(entryPath),
       mainFields: ["module", "main"],
       conditions: ["import", "module"],
       plugins: isCloudflare ? [
         importMetaPlugin(),
         assetsPlugin2({
-          outDir: outputDir
+          outDir: outputDir,
+          clientBuild: {
+            jsx: jsxOptions.jsx,
+            jsxFactory: jsxOptions.jsxFactory,
+            jsxFragment: jsxOptions.jsxFragment,
+            jsxImportSource: jsxOptions.jsxImportSource
+          }
         })
       ] : [],
       // Assets already handled in user code build
@@ -617,6 +757,7 @@ async function createBuildConfig({
       external
     };
     if (isCloudflare) {
+      applyJSXOptions(buildConfig, jsxOptions);
       await configureCloudflareTarget(buildConfig);
     }
     return buildConfig;
@@ -642,22 +783,22 @@ import "${userEntryPath}";
   return await createWorkerEntry(userEntryPath, workerCount, platform);
 }
 async function createWorkerEntry(userEntryPath, workerCount, platform) {
-  let currentDir = dirname3(fileURLToPath(import.meta.url));
+  let currentDir = dirname4(fileURLToPath(import.meta.url));
   let packageRoot = currentDir;
-  while (packageRoot !== dirname3(packageRoot)) {
+  while (packageRoot !== dirname4(packageRoot)) {
     try {
-      const packageJSONPath = join2(packageRoot, "package.json");
-      await readFile2(packageJSONPath, "utf8");
+      const packageJSONPath = join3(packageRoot, "package.json");
+      await readFile3(packageJSONPath, "utf8");
       break;
     } catch {
-      packageRoot = dirname3(packageRoot);
+      packageRoot = dirname4(packageRoot);
     }
   }
-  let templatePath = join2(packageRoot, "src/worker-entry.ts");
+  let templatePath = join3(packageRoot, "src/worker-entry.ts");
   try {
-    await readFile2(templatePath, "utf8");
+    await readFile3(templatePath, "utf8");
   } catch {
-    templatePath = join2(packageRoot, "src/worker-entry.js");
+    templatePath = join3(packageRoot, "src/worker-entry.js");
   }
   const transpileResult = await ESBuild2.build({
     entryPoints: [templatePath],
@@ -680,21 +821,21 @@ async function logBundleAnalysis(metafile) {
     const analysis = await ESBuild2.analyzeMetafile(metafile);
     logger5.info(analysis, {});
   } catch (error) {
-    logger5.warn("Failed to analyze bundle", { error: error.message });
+    logger5.warn("Failed to analyze bundle: {error}", { error });
   }
 }
 async function generatePackageJSON({ serverDir, platform, verbose, entryPath }) {
-  const entryDir = dirname3(entryPath);
+  const entryDir = dirname4(entryPath);
   const sourcePackageJsonPath = resolve2(entryDir, "package.json");
   try {
-    const packageJSONContent = await readFile2(sourcePackageJsonPath, "utf8");
+    const packageJSONContent = await readFile3(sourcePackageJsonPath, "utf8");
     try {
       JSON.parse(packageJSONContent);
     } catch (parseError) {
       throw new Error(`Invalid package.json format: ${parseError.message}`);
     }
     await writeFile(
-      join2(serverDir, "package.json"),
+      join3(serverDir, "package.json"),
       packageJSONContent,
       "utf8"
     );
@@ -703,12 +844,12 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
     }
   } catch (error) {
     if (verbose) {
-      logger5.warn("Could not copy package.json", { error: error.message });
+      logger5.warn("Could not copy package.json: {error}", { error });
     }
     try {
       const generatedPackageJson = await generateExecutablePackageJSON(platform);
       await writeFile(
-        join2(serverDir, "package.json"),
+        join3(serverDir, "package.json"),
         JSON.stringify(generatedPackageJson, null, 2),
         "utf8"
       );
@@ -720,10 +861,7 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
       }
     } catch (generateError) {
       if (verbose) {
-        logger5.warn("Could not generate package.json", {
-          error: generateError.message
-        });
-        logger5.warn("Generation error details", { error: generateError });
+        logger5.warn("Could not generate package.json: {error}", { error: generateError });
       }
     }
   }
@@ -760,12 +898,14 @@ async function generateExecutablePackageJSON(platform) {
   return packageJSON;
 }
 async function buildCommand(entrypoint, options) {
+  const config = loadConfig2(process.cwd());
+  const platform = Platform3.resolvePlatform({ ...options, config });
   await buildForProduction({
     entrypoint,
     outDir: "dist",
     verbose: options.verbose || false,
-    platform: options.platform || "node",
-    workerCount: options.workers ? parseInt(options.workers, 10) : 1
+    platform,
+    workerCount: options.workers ? parseInt(options.workers, 10) : config.workers
   });
   process.exit(0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/shovel",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.8",
   "description": "ServiceWorker-first universal deployment platform. Write ServiceWorker apps once, deploy anywhere (Node/Bun/Cloudflare). Registry-based multi-app orchestration.",
   "license": "MIT",
   "bin": {
@@ -10,7 +10,7 @@
     "create": "bin/create.js"
   },
   "dependencies": {
-    "@b9g/async-context": "^0.1.1",
+    "@b9g/async-context": "^0.1.2",
     "@clack/prompts": "^0.7.0",
     "@logtape/logtape": "^1.2.0",
     "commander": "^13.1.0",
@@ -21,30 +21,30 @@
     "source-map": "^0.7.4"
   },
   "devDependencies": {
-    "@b9g/assets": "^0.1.13",
-    "@b9g/cache": "^0.1.4",
+    "@b9g/assets": "^0.1.14",
+    "@b9g/cache": "^0.1.5",
     "@b9g/crank": "^0.7.2",
-    "@b9g/filesystem": "^0.1.6",
-    "@b9g/http-errors": "^0.1.5",
+    "@b9g/filesystem": "^0.1.7",
+    "@b9g/http-errors": "^0.1.6",
     "@b9g/libuild": "^0.1.17",
-    "@b9g/platform": "^0.1.10",
-    "@b9g/platform-bun": "^0.1.8",
-    "@b9g/platform-cloudflare": "^0.1.7",
-    "@b9g/platform-node": "^0.1.10",
-    "@b9g/router": "^0.1.8",
+    "@b9g/platform": "^0.1.11",
+    "@b9g/platform-bun": "^0.1.9",
+    "@b9g/platform-cloudflare": "^0.1.8",
+    "@b9g/platform-node": "^0.1.11",
+    "@b9g/router": "^0.1.9",
     "@types/bun": "^1.2.2",
     "mitata": "^1.0.34",
     "typescript": "^5.7.3"
   },
   "peerDependencies": {
-    "@b9g/node-webworker": "^0.1.3",
-    "@b9g/platform": "^0.1.10",
-    "@b9g/platform-node": "^0.1.10",
-    "@b9g/platform-cloudflare": "^0.1.7",
-    "@b9g/platform-bun": "^0.1.8",
-    "@b9g/cache": "^0.1.4",
-    "@b9g/filesystem": "^0.1.6",
-    "@b9g/http-errors": "^0.1.5"
+    "@b9g/node-webworker": "^0.1.4",
+    "@b9g/platform": "^0.1.11",
+    "@b9g/platform-node": "^0.1.11",
+    "@b9g/platform-cloudflare": "^0.1.8",
+    "@b9g/platform-bun": "^0.1.9",
+    "@b9g/cache": "^0.1.5",
+    "@b9g/filesystem": "^0.1.7",
+    "@b9g/http-errors": "^0.1.6"
   },
   "peerDependenciesMeta": {
     "@b9g/platform": {