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

package/bin/cli.js

@@ -24,8 +24,7 @@ import { loadConfig } from "@b9g/platform/config";
 
 // src/esbuild/watcher.ts
 import * as ESBuild from "esbuild";
-import { existsSync as existsSync2 } from "fs";
-import { resolve, join as join2, dirname as dirname3 } from "path";
+import { resolve, join as join3 } from "path";
 import { mkdir } from "fs/promises";
 import { assetsPlugin } from "@b9g/assets/plugin";
 
@@ -36,8 +35,8 @@ import { pathToFileURL } from "url";
 function importMetaPlugin() {
   return {
     name: "import-meta-transform",
-    setup(build2) {
-      build2.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
+    setup(build3) {
+      build3.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
         if (args.path.includes("node_modules")) {
           return null;
         }
@@ -168,7 +167,12 @@ async function loadJSXConfig(projectRoot) {
           ...tsOptions
         };
       }
-    } catch {
+    } catch (err) {
+      if (!(err instanceof SyntaxError) || !/^(Unexpected token|Expected|JSON)/i.test(
+        String(err.message)
+      )) {
+        throw err;
+      }
     }
   }
   return { ...CRANK_JSX_DEFAULTS };
@@ -191,19 +195,43 @@ function applyJSXOptions(buildOptions, jsxOptions) {
   }
 }
 
-// src/esbuild/watcher.ts
-import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["watcher"]);
-function findProjectRoot() {
-  let dir = process.cwd();
+// src/utils/project.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
   while (dir !== dirname3(dir)) {
     if (existsSync2(join2(dir, "package.json"))) {
       return dir;
     }
     dir = dirname3(dir);
   }
-  return process.cwd();
+  return startDir;
+}
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== dirname3(dir)) {
+    const packageJsonPath = join2(dir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (packageJson.workspaces) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = dirname3(dir);
+  }
+  return null;
 }
+function getNodeModulesPath(startDir) {
+  return join2(findProjectRoot(startDir), "node_modules");
+}
+
+// src/esbuild/watcher.ts
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["watcher"]);
 var Watcher = class {
   #options;
   #ctx;
@@ -224,11 +252,11 @@ var Watcher = class {
   async start() {
     const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
     const outputDir = resolve(this.#projectRoot, this.#options.outDir);
-    await mkdir(join2(outputDir, "server"), { recursive: true });
-    await mkdir(join2(outputDir, "static"), { recursive: true });
+    await mkdir(join3(outputDir, "server"), { recursive: true });
+    await mkdir(join3(outputDir, "static"), { recursive: true });
     const jsxOptions = await loadJSXConfig(this.#projectRoot);
-    const initialBuildPromise = new Promise((resolve3) => {
-      this.#initialBuildResolve = resolve3;
+    const initialBuildPromise = new Promise((resolve4) => {
+      this.#initialBuildResolve = resolve4;
     });
     const buildOptions = {
       entryPoints: [entryPath],
@@ -254,14 +282,32 @@ var Watcher = class {
         // Plugin to detect build completion (works with watch mode)
         {
           name: "build-notify",
-          setup: (build2) => {
-            build2.onStart(() => {
+          setup: (build3) => {
+            build3.onStart(() => {
               logger.info("Building", {
                 entrypoint: this.#options.entrypoint
               });
             });
-            build2.onEnd(async (result) => {
-              const success = result.errors.length === 0;
+            build3.onEnd(async (result) => {
+              let success = result.errors.length === 0;
+              const dynamicImportWarnings = (result.warnings || []).filter(
+                (w) => w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")
+              );
+              if (dynamicImportWarnings.length > 0) {
+                success = false;
+                for (const warning of dynamicImportWarnings) {
+                  const loc = warning.location;
+                  const file = loc?.file || "unknown";
+                  const line = loc?.line || "?";
+                  logger.error(
+                    "Non-analyzable dynamic import at {file}:{line}: {text}",
+                    { file, line, text: warning.text }
+                  );
+                }
+                logger.error(
+                  "Dynamic imports must use literal strings, not variables. For config-driven providers, ensure they are registered in shovel.json."
+                );
+              }
               let outputPath = "";
               if (result.metafile) {
                 const outputs = Object.keys(result.metafile.outputs);
@@ -329,22 +375,18 @@ await configure({
 var logger2 = getLogger2(["cli"]);
 async function developCommand(entrypoint, options) {
   try {
-    const config = loadConfig(process.cwd());
+    const projectRoot = findProjectRoot();
+    const config = loadConfig(projectRoot);
     const platformName = Platform.resolvePlatform({ ...options, config });
     const workerCount = getWorkerCount(options, config);
     if (options.verbose) {
       Platform.displayPlatformInfo(platformName);
       logger2.info("Worker configuration", { workerCount });
     }
-    const platformConfig = {
-      hotReload: true,
+    const platformInstance = await Platform.createPlatform(platformName, {
       port: parseInt(options.port) || DEFAULTS.SERVER.PORT,
       host: options.host || DEFAULTS.SERVER.HOST
-    };
-    const platformInstance = await Platform.createPlatform(
-      platformName,
-      platformConfig
-    );
+    });
     logger2.info("Starting development server", {});
     logger2.info("Workers", { workerCount });
     let serviceWorker;
@@ -352,6 +394,7 @@ async function developCommand(entrypoint, options) {
     const watcher = new Watcher({
       entrypoint,
       outDir,
+      config,
       onBuild: async (success, builtEntrypoint2) => {
         if (success && serviceWorker) {
           logger2.info("Reloading Workers", { entrypoint: builtEntrypoint2 });
@@ -413,27 +456,28 @@ function getWorkerCount(options, config) {
 // src/commands/activate.ts
 import { getLogger as getLogger3 } from "@logtape/logtape";
 import * as Platform2 from "@b9g/platform";
+import * as ESBuild2 from "esbuild";
+import { resolve as resolve2, join as join4 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+import { assetsPlugin as assetsPlugin2 } from "@b9g/assets/plugin";
 var logger3 = getLogger3(["cli"]);
 async function activateCommand(entrypoint, options) {
   try {
     const platformName = Platform2.resolvePlatform(options);
     const workerCount = getWorkerCount2(options);
-    if (options.verbose) {
-      Platform2.displayPlatformInfo(platformName);
-      logger3.info("Worker configuration", { workerCount });
-    }
-    const platformConfig = {
-      hotReload: false
-    };
-    const platformInstance = await Platform2.createPlatform(
-      platformName,
-      platformConfig
-    );
+    logger3.debug("Platform: {platform}", { platform: platformName });
+    logger3.debug("Worker count: {workerCount}", { workerCount });
+    logger3.info("Building ServiceWorker for activation");
+    const builtEntrypoint = await buildForActivate(entrypoint);
+    const platformInstance = await Platform2.createPlatform(platformName);
     logger3.info("Activating ServiceWorker", {});
-    const serviceWorker = await platformInstance.loadServiceWorker(entrypoint, {
-      hotReload: false,
-      workerCount
-    });
+    const serviceWorker = await platformInstance.loadServiceWorker(
+      builtEntrypoint,
+      {
+        hotReload: false,
+        workerCount
+      }
+    );
     logger3.info(
       "ServiceWorker activated - check dist/ for generated content",
       {}
@@ -445,6 +489,46 @@ async function activateCommand(entrypoint, options) {
     process.exit(1);
   }
 }
+async function buildForActivate(entrypoint) {
+  const entryPath = resolve2(entrypoint);
+  const outputDir = resolve2("dist");
+  const serverDir = join4(outputDir, "server");
+  await mkdir2(serverDir, { recursive: true });
+  await mkdir2(join4(outputDir, "static"), { recursive: true });
+  const projectRoot = findProjectRoot();
+  const jsxOptions = await loadJSXConfig(projectRoot);
+  const outfile = join4(serverDir, "server.js");
+  const buildConfig = {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: "esm",
+    target: "es2022",
+    platform: "node",
+    outfile,
+    absWorkingDir: projectRoot,
+    mainFields: ["module", "main"],
+    conditions: ["import", "module"],
+    nodePaths: [getNodeModulesPath()],
+    plugins: [
+      importMetaPlugin(),
+      assetsPlugin2({
+        outDir: outputDir,
+        clientBuild: {
+          jsx: jsxOptions.jsx,
+          jsxFactory: jsxOptions.jsxFactory,
+          jsxFragment: jsxOptions.jsxFragment,
+          jsxImportSource: jsxOptions.jsxImportSource
+        }
+      })
+    ],
+    external: ["node:*"]
+  };
+  applyJSXOptions(buildConfig, jsxOptions);
+  logger3.debug("Building entrypoint: {entryPath}", { entryPath, outfile });
+  await ESBuild2.build(buildConfig);
+  logger3.debug("Build complete: {outfile}", { outfile });
+  return outfile;
+}
 function getWorkerCount2(options) {
   if (options.workers) {
     return parseInt(options.workers);
@@ -467,11 +551,11 @@ async function infoCommand() {
 }
 
 // src/commands/build.ts
-import * as ESBuild2 from "esbuild";
-import { resolve as resolve2, join as join3, dirname as dirname4 } from "path";
-import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
+import * as ESBuild3 from "esbuild";
+import { resolve as resolve3, join as join5, dirname as dirname4 } from "path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile } from "fs/promises";
 import { fileURLToPath } from "url";
-import { assetsPlugin as assetsPlugin2 } from "@b9g/assets/plugin";
+import { assetsPlugin as assetsPlugin3 } 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";
@@ -489,6 +573,26 @@ await configure2({
   ]
 });
 var logger5 = getLogger5(["cli"]);
+function validateDynamicImports(result, context2) {
+  const dynamicImportWarnings = (result.warnings || []).filter(
+    (w) => w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")
+  );
+  if (dynamicImportWarnings.length > 0) {
+    const locations = dynamicImportWarnings.map((w) => {
+      const loc = w.location;
+      const file = loc?.file || "unknown";
+      const line = loc?.line || "?";
+      return `  ${file}:${line} - ${w.text}`;
+    }).join("\n");
+    throw new Error(
+      `Build failed (${context2}): Non-analyzable dynamic imports found:
+${locations}
+
+Dynamic imports must use literal strings, not variables.
+For config-driven providers, ensure they are registered in shovel.json.`
+    );
+  }
+}
 var BUILD_DEFAULTS = {
   format: "esm",
   target: "es2022",
@@ -516,7 +620,8 @@ async function buildForProduction({
     workerCount
   });
   const buildConfig = await createBuildConfig(buildContext);
-  const result = await ESBuild2.build(buildConfig);
+  const result = await ESBuild3.build(buildConfig);
+  validateDynamicImports(result, "main bundle");
   if (verbose && result.metafile) {
     await logBundleAnalysis(result.metafile);
   }
@@ -527,7 +632,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: join3(buildContext.outputDir, "static") });
+    logger5.info("Static files", { dir: join5(buildContext.outputDir, "static") });
   }
 }
 async function initializeBuild({
@@ -548,8 +653,8 @@ async function initializeBuild({
     logger5.info("Output:", { dir: outDir });
     logger5.info("Target platform:", { platform });
   }
-  const entryPath = resolve2(entrypoint);
-  const outputDir = resolve2(outDir);
+  const entryPath = resolve3(entrypoint);
+  const outputDir = resolve3(outDir);
   try {
     const stats = await readFile3(entryPath, "utf8");
     if (stats.length === 0) {
@@ -564,17 +669,17 @@ async function initializeBuild({
       `Invalid platform: ${platform}. Valid platforms: ${validPlatforms.join(", ")}`
     );
   }
-  const workspaceRoot = await findWorkspaceRoot();
+  const projectRoot = findProjectRoot();
   if (verbose) {
     logger5.info("Entry:", { entryPath });
     logger5.info("Output:", { outputDir });
     logger5.info("Target platform:", { platform });
-    logger5.info("Workspace root:", { workspaceRoot });
+    logger5.info("Project root:", { projectRoot });
   }
   try {
-    await mkdir2(outputDir, { recursive: true });
-    await mkdir2(join3(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
-    await mkdir2(join3(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
+    await mkdir3(outputDir, { recursive: true });
+    await mkdir3(join5(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
+    await mkdir3(join5(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
   } catch (error) {
     throw new Error(
       `Failed to create output directory structure: ${error.message}`
@@ -583,59 +688,23 @@ async function initializeBuild({
   return {
     entryPath,
     outputDir,
-    serverDir: join3(outputDir, BUILD_STRUCTURE.serverDir),
-    workspaceRoot,
+    serverDir: join5(outputDir, BUILD_STRUCTURE.serverDir),
+    projectRoot,
     platform,
     verbose,
     workerCount
   };
 }
-async function findWorkspaceRoot() {
-  let workspaceRoot = process.cwd();
-  while (workspaceRoot !== dirname4(workspaceRoot)) {
-    try {
-      const packageJSON = JSON.parse(
-        await readFile3(resolve2(workspaceRoot, "package.json"), "utf8")
-      );
-      if (packageJSON.workspaces) {
-        return workspaceRoot;
-      }
-    } catch {
-    }
-    workspaceRoot = dirname4(workspaceRoot);
-  }
-  return workspaceRoot;
-}
-async function findShovelPackageRoot() {
-  let currentDir = dirname4(fileURLToPath(import.meta.url));
-  let packageRoot = currentDir;
-  while (packageRoot !== dirname4(packageRoot)) {
-    try {
-      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 dirname4(packageRoot);
-        }
-        return packageRoot;
-      }
-    } catch {
-    }
-    packageRoot = dirname4(packageRoot);
-  }
-  return currentDir;
-}
 async function createBuildConfig({
   entryPath,
   outputDir,
   serverDir,
-  workspaceRoot,
+  projectRoot,
   platform,
   workerCount
 }) {
   const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
-  const jsxOptions = await loadJSXConfig(workspaceRoot || dirname4(entryPath));
+  const jsxOptions = await loadJSXConfig(projectRoot || dirname4(entryPath));
   try {
     const virtualEntry = await createVirtualEntry(
       entryPath,
@@ -643,7 +712,6 @@ async function createBuildConfig({
       workerCount
     );
     const external = ["node:*"];
-    const shovelRoot = await findShovelPackageRoot();
     if (!isCloudflare) {
       const userBuildConfig = {
         entryPoints: [entryPath],
@@ -651,18 +719,15 @@ async function createBuildConfig({
         format: BUILD_DEFAULTS.format,
         target: BUILD_DEFAULTS.target,
         platform: "node",
-        outfile: join3(serverDir, "server.js"),
-        absWorkingDir: workspaceRoot || dirname4(entryPath),
+        outfile: join5(serverDir, "server.js"),
+        absWorkingDir: projectRoot,
         mainFields: ["module", "main"],
         conditions: ["import", "module"],
-        // Allow user code to import @b9g packages from shovel's packages directory
-        nodePaths: [
-          join3(shovelRoot, "packages"),
-          join3(shovelRoot, "node_modules")
-        ],
+        // Resolve packages from the user's project node_modules
+        nodePaths: [getNodeModulesPath()],
         plugins: [
           importMetaPlugin(),
-          assetsPlugin2({
+          assetsPlugin3({
             outDir: outputDir,
             clientBuild: {
               jsx: jsxOptions.jsx,
@@ -682,43 +747,28 @@ async function createBuildConfig({
         external
       };
       applyJSXOptions(userBuildConfig, jsxOptions);
-      await ESBuild2.build(userBuildConfig);
-      const runtimeSourcePath = join3(
-        shovelRoot,
-        "packages/platform/dist/src/runtime.js"
+      const userBuildResult = await ESBuild3.build(userBuildConfig);
+      validateDynamicImports(userBuildResult, "user code");
+      const runtimeSourcePath = join5(
+        getNodeModulesPath(),
+        "@b9g/platform/dist/src/runtime.js"
       );
-      const workerDestPath = join3(serverDir, "worker.js");
-      try {
-        await ESBuild2.build({
-          entryPoints: [runtimeSourcePath],
-          bundle: true,
-          format: "esm",
-          target: "es2022",
-          platform: "node",
-          outfile: workerDestPath,
-          external: ["node:*"]
-        });
-      } catch (error) {
-        const installedRuntimePath = join3(
-          shovelRoot,
-          "node_modules/@b9g/platform/dist/src/runtime.js"
-        );
-        await ESBuild2.build({
-          entryPoints: [installedRuntimePath],
-          bundle: true,
-          format: "esm",
-          target: "es2022",
-          platform: "node",
-          outfile: workerDestPath,
-          external: ["node:*"]
-        });
-      }
+      const workerDestPath = join5(serverDir, "worker.js");
+      await ESBuild3.build({
+        entryPoints: [runtimeSourcePath],
+        bundle: true,
+        format: "esm",
+        target: "es2022",
+        platform: "node",
+        outfile: workerDestPath,
+        external: ["node:*"]
+      });
     }
     const buildConfig = {
       stdin: {
         contents: virtualEntry,
-        resolveDir: shovelRoot,
-        // Use Shovel root to resolve @b9g packages
+        resolveDir: projectRoot,
+        // Resolve packages from user's project
         sourcefile: "virtual-entry.js"
       },
       bundle: true,
@@ -727,16 +777,18 @@ 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: join3(
+      outfile: join5(
         serverDir,
         isCloudflare ? "server.js" : BUILD_DEFAULTS.outputFile
       ),
-      absWorkingDir: workspaceRoot || dirname4(entryPath),
+      absWorkingDir: projectRoot,
       mainFields: ["module", "main"],
       conditions: ["import", "module"],
+      // Resolve packages from the user's project node_modules
+      nodePaths: [getNodeModulesPath()],
       plugins: isCloudflare ? [
         importMetaPlugin(),
-        assetsPlugin2({
+        assetsPlugin3({
           outDir: outputDir,
           clientBuild: {
             jsx: jsxOptions.jsx,
@@ -775,32 +827,37 @@ async function configureCloudflareTarget(buildConfig) {
 async function createVirtualEntry(userEntryPath, platform, workerCount = 1) {
   const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
   if (isCloudflare) {
-    return `
-// Import user's ServiceWorker code
+    return `// Import user's ServiceWorker code
 import "${userEntryPath}";
 `;
   }
-  return await createWorkerEntry(userEntryPath, workerCount, platform);
+  return createWorkerEntry(userEntryPath, workerCount, platform);
 }
 async function createWorkerEntry(userEntryPath, workerCount, platform) {
   let currentDir = dirname4(fileURLToPath(import.meta.url));
   let packageRoot = currentDir;
   while (packageRoot !== dirname4(packageRoot)) {
     try {
-      const packageJSONPath = join3(packageRoot, "package.json");
+      const packageJSONPath = join5(packageRoot, "package.json");
       await readFile3(packageJSONPath, "utf8");
       break;
-    } catch {
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
       packageRoot = dirname4(packageRoot);
     }
   }
-  let templatePath = join3(packageRoot, "src/worker-entry.ts");
+  let templatePath = join5(packageRoot, "src/worker-entry.ts");
   try {
     await readFile3(templatePath, "utf8");
-  } catch {
-    templatePath = join3(packageRoot, "src/worker-entry.js");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+    templatePath = join5(packageRoot, "src/worker-entry.js");
   }
-  const transpileResult = await ESBuild2.build({
+  const transpileResult = await ESBuild3.build({
     entryPoints: [templatePath],
     bundle: false,
     // Just transpile - bundling happens in final build
@@ -818,7 +875,7 @@ async function createWorkerEntry(userEntryPath, workerCount, platform) {
 async function logBundleAnalysis(metafile) {
   try {
     logger5.info("Bundle analysis:", {});
-    const analysis = await ESBuild2.analyzeMetafile(metafile);
+    const analysis = await ESBuild3.analyzeMetafile(metafile);
     logger5.info(analysis, {});
   } catch (error) {
     logger5.warn("Failed to analyze bundle: {error}", { error });
@@ -826,7 +883,7 @@ async function logBundleAnalysis(metafile) {
 }
 async function generatePackageJSON({ serverDir, platform, verbose, entryPath }) {
   const entryDir = dirname4(entryPath);
-  const sourcePackageJsonPath = resolve2(entryDir, "package.json");
+  const sourcePackageJsonPath = resolve3(entryDir, "package.json");
   try {
     const packageJSONContent = await readFile3(sourcePackageJsonPath, "utf8");
     try {
@@ -835,7 +892,7 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
       throw new Error(`Invalid package.json format: ${parseError.message}`);
     }
     await writeFile(
-      join3(serverDir, "package.json"),
+      join5(serverDir, "package.json"),
       packageJSONContent,
       "utf8"
     );
@@ -849,7 +906,7 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
     try {
       const generatedPackageJson = await generateExecutablePackageJSON(platform);
       await writeFile(
-        join3(serverDir, "package.json"),
+        join5(serverDir, "package.json"),
         JSON.stringify(generatedPackageJson, null, 2),
         "utf8"
       );
@@ -861,7 +918,9 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
       }
     } catch (generateError) {
       if (verbose) {
-        logger5.warn("Could not generate package.json: {error}", { error: generateError });
+        logger5.warn("Could not generate package.json: {error}", {
+          error: generateError
+        });
       }
     }
   }
@@ -874,8 +933,7 @@ async function generateExecutablePackageJSON(platform) {
     private: true,
     dependencies: {}
   };
-  const workspaceRoot = await findWorkspaceRoot();
-  const isWorkspaceEnvironment = workspaceRoot !== null;
+  const isWorkspaceEnvironment = findWorkspaceRoot() !== null;
   if (isWorkspaceEnvironment) {
     packageJSON.dependencies = {};
   } else {
@@ -898,7 +956,8 @@ async function generateExecutablePackageJSON(platform) {
   return packageJSON;
 }
 async function buildCommand(entrypoint, options) {
-  const config = loadConfig2(process.cwd());
+  const projectRoot = findProjectRoot();
+  const config = loadConfig2(projectRoot);
   const platform = Platform3.resolvePlatform({ ...options, config });
   await buildForProduction({
     entrypoint,

package/bin/create.js

@@ -8,7 +8,7 @@ import picocolors from "picocolors";
 import { mkdir, writeFile } from "fs/promises";
 import { join, resolve } from "path";
 import { existsSync } from "fs";
-var { cyan, green, yellow: _yellow, red, dim, bold } = picocolors;
+var { cyan, green, red, dim, bold } = picocolors;
 async function main() {
   console.info("");
   intro(cyan("\u{1F680} Create Shovel App"));
@@ -200,28 +200,49 @@ function getRequestInfo(request: Request) {
 
 async function parseBody(request: Request) {
   const contentType = request.headers.get('content-type') || '';
-  
+
   if (contentType.includes('application/json')) {
     try {
       return await request.json();
-    } catch {
+    } catch (err) {
+      // Only ignore JSON parse errors, rethrow others
+      if (
+        !(err instanceof SyntaxError) ||
+        !/^(Unexpected token|Expected|JSON)/i.test(String(err.message))
+      ) {
+        throw err;
+      }
       return null;
     }
   }
-  
+
   if (contentType.includes('application/x-www-form-urlencoded')) {
     try {
       const formData = await request.formData();
       return Object.fromEntries(formData.entries());
-    } catch {
+    } catch (err) {
+      // Only ignore form data parse errors, rethrow others
+      if (
+        !(err instanceof TypeError) ||
+        !String(err.message).includes('FormData')
+      ) {
+        throw err;
+      }
       return null;
     }
   }
-  
+
   try {
     const text = await request.text();
     return text || null;
-  } catch {
+  } catch (err) {
+    // Only ignore body already consumed errors, rethrow others
+    if (
+      !(err instanceof TypeError) ||
+      !String(err.message).includes('body')
+    ) {
+      throw err;
+    }
     return null;
   }
 }
@@ -237,28 +258,49 @@ function getRequestInfo(request) {
 
 async function parseBody(request) {
   const contentType = request.headers.get('content-type') || '';
-  
+
   if (contentType.includes('application/json')) {
     try {
       return await request.json();
-    } catch {
+    } catch (err) {
+      // Only ignore JSON parse errors, rethrow others
+      if (
+        !(err instanceof SyntaxError) ||
+        !/^(Unexpected token|Expected|JSON)/i.test(String(err.message))
+      ) {
+        throw err;
+      }
       return null;
     }
   }
-  
+
   if (contentType.includes('application/x-www-form-urlencoded')) {
     try {
       const formData = await request.formData();
       return Object.fromEntries(formData.entries());
-    } catch {
+    } catch (err) {
+      // Only ignore form data parse errors, rethrow others
+      if (
+        !(err instanceof TypeError) ||
+        !String(err.message).includes('FormData')
+      ) {
+        throw err;
+      }
       return null;
     }
   }
-  
+
   try {
     const text = await request.text();
     return text || null;
-  } catch {
+  } catch (err) {
+    // Only ignore body already consumed errors, rethrow others
+    if (
+      !(err instanceof TypeError) ||
+      !String(err.message).includes('body')
+    ) {
+      throw err;
+    }
     return null;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/shovel",
-  "version": "0.2.0-beta.8",
+  "version": "0.2.0-beta.9",
   "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.2",
+    "@b9g/async-context": "^0.1.4",
     "@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.14",
+    "@b9g/assets": "^0.1.15",
     "@b9g/cache": "^0.1.5",
     "@b9g/crank": "^0.7.2",
     "@b9g/filesystem": "^0.1.7",
-    "@b9g/http-errors": "^0.1.6",
+    "@b9g/http-errors": "^0.1.5",
     "@b9g/libuild": "^0.1.17",
     "@b9g/platform": "^0.1.11",
     "@b9g/platform-bun": "^0.1.9",
-    "@b9g/platform-cloudflare": "^0.1.8",
+    "@b9g/platform-cloudflare": "^0.1.9",
     "@b9g/platform-node": "^0.1.11",
-    "@b9g/router": "^0.1.9",
+    "@b9g/router": "^0.1.10",
     "@types/bun": "^1.2.2",
     "mitata": "^1.0.34",
     "typescript": "^5.7.3"
   },
   "peerDependencies": {
-    "@b9g/node-webworker": "^0.1.4",
+    "@b9g/node-webworker": "^0.1.3",
     "@b9g/platform": "^0.1.11",
     "@b9g/platform-node": "^0.1.11",
-    "@b9g/platform-cloudflare": "^0.1.8",
+    "@b9g/platform-cloudflare": "^0.1.9",
     "@b9g/platform-bun": "^0.1.9",
     "@b9g/cache": "^0.1.5",
     "@b9g/filesystem": "^0.1.7",
-    "@b9g/http-errors": "^0.1.6"
+    "@b9g/http-errors": "^0.1.5"
   },
   "peerDependenciesMeta": {
     "@b9g/platform": {