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

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,11 @@ 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 { resolve, join as join3 } from "path";
 import { mkdir } from "fs/promises";
 import { assetsPlugin } from "@b9g/assets/plugin";
 
@@ -35,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;
         }
@@ -77,19 +77,161 @@ function importMetaPlugin() {
   };
 }
 
-// src/esbuild/watcher.ts
-import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["watcher"]);
-function findProjectRoot() {
-  let dir = process.cwd();
+// 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)) {
-    if (existsSync(join(dir, "package.json"))) {
-      return dir;
+    const tsconfigPath = join(dir, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      return tsconfigPath;
     }
     dir = dirname2(dir);
   }
-  return process.cwd();
+  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 (err) {
+      if (!(err instanceof SyntaxError) || !/^(Unexpected token|Expected|JSON)/i.test(
+        String(err.message)
+      )) {
+        throw err;
+      }
+    }
+  }
+  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/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 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;
@@ -110,12 +252,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 });
-    const initialBuildPromise = new Promise((resolve3) => {
-      this.#initialBuildResolve = resolve3;
+    await mkdir(join3(outputDir, "server"), { recursive: true });
+    await mkdir(join3(outputDir, "static"), { recursive: true });
+    const jsxOptions = await loadJSXConfig(this.#projectRoot);
+    const initialBuildPromise = new Promise((resolve4) => {
+      this.#initialBuildResolve = resolve4;
     });
-    this.#ctx = await ESBuild.context({
+    const buildOptions = {
       entryPoints: [entryPath],
       bundle: true,
       format: "esm",
@@ -128,19 +271,43 @@ 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)
         {
           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);
@@ -152,7 +319,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 +335,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,21 +375,18 @@ await configure({
 var logger2 = getLogger2(["cli"]);
 async function developCommand(entrypoint, options) {
   try {
-    const platformName = Platform.resolvePlatform(options);
-    const workerCount = getWorkerCount(options);
+    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;
@@ -228,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 });
@@ -273,40 +440,44 @@ 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;
 }
 
 // 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",
       {}
@@ -314,13 +485,50 @@ 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);
   }
 }
+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);
@@ -343,13 +551,15 @@ 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 * 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";
+import { loadConfig as loadConfig2 } from "@b9g/platform/config";
 await configure2({
   reset: true,
   contextLocalStorage: new AsyncContext2.Variable(),
@@ -363,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",
@@ -390,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);
   }
@@ -401,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: join2(buildContext.outputDir, "static") });
+    logger5.info("Static files", { dir: join5(buildContext.outputDir, "static") });
   }
 }
 async function initializeBuild({
@@ -422,10 +653,10 @@ 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 readFile2(entryPath, "utf8");
+    const stats = await readFile3(entryPath, "utf8");
     if (stats.length === 0) {
       logger5.warn("Entry point is empty", { entryPath });
     }
@@ -438,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(join2(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
-    await mkdir2(join2(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}`
@@ -457,58 +688,23 @@ async function initializeBuild({
   return {
     entryPath,
     outputDir,
-    serverDir: join2(outputDir, BUILD_STRUCTURE.serverDir),
-    workspaceRoot,
+    serverDir: join5(outputDir, BUILD_STRUCTURE.serverDir),
+    projectRoot,
     platform,
     verbose,
     workerCount
   };
 }
-async function findWorkspaceRoot() {
-  let workspaceRoot = process.cwd();
-  while (workspaceRoot !== dirname3(workspaceRoot)) {
-    try {
-      const packageJSON = JSON.parse(
-        await readFile2(resolve2(workspaceRoot, "package.json"), "utf8")
-      );
-      if (packageJSON.workspaces) {
-        return workspaceRoot;
-      }
-    } catch {
-    }
-    workspaceRoot = dirname3(workspaceRoot);
-  }
-  return workspaceRoot;
-}
-async function findShovelPackageRoot() {
-  let currentDir = dirname3(fileURLToPath(import.meta.url));
-  let packageRoot = currentDir;
-  while (packageRoot !== dirname3(packageRoot)) {
-    try {
-      const packageJSONPath = join2(packageRoot, "package.json");
-      const content = await readFile2(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 packageRoot;
-      }
-    } catch {
-    }
-    packageRoot = dirname3(packageRoot);
-  }
-  return currentDir;
-}
 async function createBuildConfig({
   entryPath,
   outputDir,
   serverDir,
-  workspaceRoot,
+  projectRoot,
   platform,
   workerCount
 }) {
   const isCloudflare = platform === "cloudflare" || platform === "cloudflare-workers";
+  const jsxOptions = await loadJSXConfig(projectRoot || dirname4(entryPath));
   try {
     const virtualEntry = await createVirtualEntry(
       entryPath,
@@ -516,7 +712,6 @@ async function createBuildConfig({
       workerCount
     );
     const external = ["node:*"];
-    const shovelRoot = await findShovelPackageRoot();
     if (!isCloudflare) {
       const userBuildConfig = {
         entryPoints: [entryPath],
@@ -524,19 +719,22 @@ async function createBuildConfig({
         format: BUILD_DEFAULTS.format,
         target: BUILD_DEFAULTS.target,
         platform: "node",
-        outfile: join2(serverDir, "server.js"),
-        absWorkingDir: workspaceRoot || dirname3(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: [
-          join2(shovelRoot, "packages"),
-          join2(shovelRoot, "node_modules")
-        ],
+        // Resolve packages from the user's project node_modules
+        nodePaths: [getNodeModulesPath()],
         plugins: [
           importMetaPlugin(),
-          assetsPlugin2({
-            outDir: outputDir
+          assetsPlugin3({
+            outDir: outputDir,
+            clientBuild: {
+              jsx: jsxOptions.jsx,
+              jsxFactory: jsxOptions.jsxFactory,
+              jsxFragment: jsxOptions.jsxFragment,
+              jsxImportSource: jsxOptions.jsxImportSource
+            }
           })
         ],
         metafile: true,
@@ -548,43 +746,29 @@ async function createBuildConfig({
         define: platform === "node" ? { "import.meta.env": "process.env" } : {},
         external
       };
-      await ESBuild2.build(userBuildConfig);
-      const runtimeSourcePath = join2(
-        shovelRoot,
-        "packages/platform/dist/src/runtime.js"
+      applyJSXOptions(userBuildConfig, jsxOptions);
+      const userBuildResult = await ESBuild3.build(userBuildConfig);
+      validateDynamicImports(userBuildResult, "user code");
+      const runtimeSourcePath = join5(
+        getNodeModulesPath(),
+        "@b9g/platform/dist/src/runtime.js"
       );
-      const workerDestPath = join2(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 = join2(
-          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,
@@ -593,17 +777,25 @@ 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: join5(
         serverDir,
         isCloudflare ? "server.js" : BUILD_DEFAULTS.outputFile
       ),
-      absWorkingDir: workspaceRoot || dirname3(entryPath),
+      absWorkingDir: projectRoot,
       mainFields: ["module", "main"],
       conditions: ["import", "module"],
+      // Resolve packages from the user's project node_modules
+      nodePaths: [getNodeModulesPath()],
       plugins: isCloudflare ? [
         importMetaPlugin(),
-        assetsPlugin2({
-          outDir: outputDir
+        assetsPlugin3({
+          outDir: outputDir,
+          clientBuild: {
+            jsx: jsxOptions.jsx,
+            jsxFactory: jsxOptions.jsxFactory,
+            jsxFragment: jsxOptions.jsxFragment,
+            jsxImportSource: jsxOptions.jsxImportSource
+          }
         })
       ] : [],
       // Assets already handled in user code build
@@ -617,6 +809,7 @@ async function createBuildConfig({
       external
     };
     if (isCloudflare) {
+      applyJSXOptions(buildConfig, jsxOptions);
       await configureCloudflareTarget(buildConfig);
     }
     return buildConfig;
@@ -634,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 = 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 = join5(packageRoot, "package.json");
+      await readFile3(packageJSONPath, "utf8");
       break;
-    } catch {
-      packageRoot = dirname3(packageRoot);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+      packageRoot = dirname4(packageRoot);
     }
   }
-  let templatePath = join2(packageRoot, "src/worker-entry.ts");
+  let templatePath = join5(packageRoot, "src/worker-entry.ts");
   try {
-    await readFile2(templatePath, "utf8");
-  } catch {
-    templatePath = join2(packageRoot, "src/worker-entry.js");
+    await readFile3(templatePath, "utf8");
+  } 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
@@ -677,24 +875,24 @@ 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.message });
+    logger5.warn("Failed to analyze bundle: {error}", { error });
   }
 }
 async function generatePackageJSON({ serverDir, platform, verbose, entryPath }) {
-  const entryDir = dirname3(entryPath);
-  const sourcePackageJsonPath = resolve2(entryDir, "package.json");
+  const entryDir = dirname4(entryPath);
+  const sourcePackageJsonPath = resolve3(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"),
+      join5(serverDir, "package.json"),
       packageJSONContent,
       "utf8"
     );
@@ -703,12 +901,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"),
+        join5(serverDir, "package.json"),
         JSON.stringify(generatedPackageJson, null, 2),
         "utf8"
       );
@@ -720,10 +918,9 @@ async function generatePackageJSON({ serverDir, platform, verbose, entryPath })
       }
     } catch (generateError) {
       if (verbose) {
-        logger5.warn("Could not generate package.json", {
-          error: generateError.message
+        logger5.warn("Could not generate package.json: {error}", {
+          error: generateError
         });
-        logger5.warn("Generation error details", { error: generateError });
       }
     }
   }
@@ -736,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 {
@@ -760,12 +956,15 @@ async function generateExecutablePackageJSON(platform) {
   return packageJSON;
 }
 async function buildCommand(entrypoint, options) {
+  const projectRoot = findProjectRoot();
+  const config = loadConfig2(projectRoot);
+  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/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.7",
+  "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.1",
+    "@b9g/async-context": "^0.1.4",
     "@clack/prompts": "^0.7.0",
     "@logtape/logtape": "^1.2.0",
     "commander": "^13.1.0",
@@ -21,29 +21,29 @@
     "source-map": "^0.7.4"
   },
   "devDependencies": {
-    "@b9g/assets": "^0.1.13",
-    "@b9g/cache": "^0.1.4",
+    "@b9g/assets": "^0.1.15",
+    "@b9g/cache": "^0.1.5",
     "@b9g/crank": "^0.7.2",
-    "@b9g/filesystem": "^0.1.6",
+    "@b9g/filesystem": "^0.1.7",
     "@b9g/http-errors": "^0.1.5",
     "@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.9",
+    "@b9g/platform-node": "^0.1.11",
+    "@b9g/router": "^0.1.10",
     "@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/platform": "^0.1.11",
+    "@b9g/platform-node": "^0.1.11",
+    "@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.5"
   },
   "peerDependenciesMeta": {