@b9g/shovel 0.2.0-beta.2 → 0.2.0-beta.21

package/src/_chunks/chunk-VWH6D26D.js

@@ -0,0 +1,1062 @@
+import {
+  findProjectRoot,
+  generateConfigModule,
+  generateStorageTypes,
+  getNodeModulesPath,
+  loadRawConfig
+} from "./chunk-PTLNYIRW.js";
+
+// src/utils/bundler.ts
+import * as ESBuild2 from "esbuild";
+import { builtinModules, createRequire } from "node:module";
+import { resolve, join as join4, dirname as dirname4, basename as basename2, relative as relative2 } from "path";
+import { mkdir } from "fs/promises";
+import { watch, existsSync as existsSync3 } from "fs";
+import { getLogger as getLogger2 } from "@logtape/logtape";
+
+// src/plugins/assets.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { createHash } from "crypto";
+import { join, basename, extname, relative, dirname } from "path";
+import mime from "mime";
+import * as ESBuild from "esbuild";
+import { getLogger } from "@logtape/logtape";
+import { NodeModulesPolyfillPlugin } from "@esbuild-plugins/node-modules-polyfill";
+import { NodeGlobalsPolyfillPlugin } from "@esbuild-plugins/node-globals-polyfill";
+var TRANSPILABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".mts",
+  ".cts"
+]);
+var CSS_EXTENSIONS = /* @__PURE__ */ new Set([".css"]);
+var logger = getLogger(["shovel"]);
+var DEFAULT_CONFIG = {
+  outDir: "dist",
+  clientBuild: {}
+};
+var HASH_LENGTH = 16;
+function mergeConfig(userConfig = {}) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig
+  };
+}
+function normalizePath(basePath) {
+  if (!basePath.startsWith("/")) {
+    basePath = "/" + basePath;
+  }
+  if (!basePath.endsWith("/")) {
+    basePath = basePath + "/";
+  }
+  return basePath;
+}
+function assetsPlugin(options = {}) {
+  const config = mergeConfig(options);
+  const manifest = {
+    assets: {},
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    config: {
+      outDir: config.outDir
+    }
+  };
+  const contexts = /* @__PURE__ */ new Map();
+  return {
+    name: "shovel-assets",
+    setup(build2) {
+      build2.onResolve({ filter: /.*/ }, (_args) => {
+        return null;
+      });
+      async function getContext(absPath, buildOptions) {
+        let ctx = contexts.get(absPath);
+        if (!ctx) {
+          ctx = await ESBuild.context(buildOptions);
+          contexts.set(absPath, ctx);
+        }
+        return ctx;
+      }
+      build2.onLoad({ filter: /.*/ }, async (args) => {
+        if (!args.with?.assetBase || typeof args.with.assetBase !== "string") {
+          return null;
+        }
+        try {
+          const ext = extname(args.path);
+          const name = basename(args.path, ext);
+          const wantsCSS = args.with.type === "css";
+          const needsTranspilation = TRANSPILABLE_EXTENSIONS.has(ext);
+          const needsCSSBundling = CSS_EXTENSIONS.has(ext);
+          if (wantsCSS && !needsTranspilation) {
+            return {
+              errors: [
+                {
+                  text: `type: "css" can only be used with transpilable files (.ts, .tsx, .jsx, etc.), not ${ext}`
+                }
+              ]
+            };
+          }
+          let content;
+          let outputExt = ext;
+          let mimeType;
+          if (needsTranspilation) {
+            const clientOpts = config.clientBuild;
+            const defaultPlugins = [
+              NodeModulesPolyfillPlugin(),
+              NodeGlobalsPolyfillPlugin({
+                process: true,
+                buffer: true
+              })
+            ];
+            const plugins = clientOpts.plugins ? [...clientOpts.plugins, ...defaultPlugins] : defaultPlugins;
+            const ctx = await getContext(args.path, {
+              entryPoints: [args.path],
+              bundle: true,
+              format: "esm",
+              target: "es2022",
+              platform: "browser",
+              write: false,
+              minify: true,
+              // outdir is required for esbuild to know where to put extracted CSS
+              outdir: config.outDir,
+              // Apply polyfills and user-provided client build options
+              plugins,
+              define: clientOpts.define,
+              inject: clientOpts.inject,
+              external: clientOpts.external,
+              alias: clientOpts.alias,
+              // Apply JSX configuration (defaults to @b9g/crank automatic runtime)
+              jsx: clientOpts.jsx ?? "automatic",
+              jsxFactory: clientOpts.jsxFactory,
+              jsxFragment: clientOpts.jsxFragment,
+              jsxImportSource: clientOpts.jsxImportSource ?? "@b9g/crank"
+            });
+            const result = await ctx.rebuild();
+            if (!result.outputFiles) {
+              return {
+                errors: [{ text: `No output files generated for ${args.path}` }]
+              };
+            }
+            if (wantsCSS) {
+              const cssOutput = result.outputFiles.find(
+                (f) => f.path.endsWith(".css")
+              );
+              if (!cssOutput) {
+                return {
+                  errors: [
+                    {
+                      text: `No CSS was extracted from ${args.path}. The file must import CSS for type: "css" to work.`
+                    }
+                  ]
+                };
+              }
+              content = Buffer.from(cssOutput.text);
+              outputExt = ".css";
+              mimeType = "text/css";
+            } else {
+              const jsOutput = result.outputFiles.find(
+                (f) => f.path.endsWith(".js")
+              );
+              if (!jsOutput) {
+                return {
+                  errors: [
+                    {
+                      text: `No JavaScript output was generated for ${args.path}`
+                    }
+                  ]
+                };
+              }
+              content = Buffer.from(jsOutput.text);
+              outputExt = ".js";
+              mimeType = "application/javascript";
+            }
+          } else if (needsCSSBundling) {
+            const entryPath = args.path;
+            const externalAbsolutePathsPlugin = {
+              name: "external-absolute-paths",
+              setup(build3) {
+                build3.onResolve({ filter: /^\// }, (resolveArgs) => {
+                  if (resolveArgs.kind === "entry-point") {
+                    return null;
+                  }
+                  return {
+                    path: resolveArgs.path,
+                    external: true
+                  };
+                });
+              }
+            };
+            const ctx = await getContext(entryPath, {
+              entryPoints: [entryPath],
+              bundle: true,
+              write: false,
+              minify: true,
+              // outdir required for esbuild to generate output paths
+              outdir: config.outDir,
+              plugins: [externalAbsolutePathsPlugin],
+              // Loaders for web assets referenced in CSS via url()
+              loader: {
+                // Fonts
+                ".woff": "file",
+                ".woff2": "file",
+                ".ttf": "file",
+                ".eot": "file",
+                // Images
+                ".svg": "file",
+                ".png": "file",
+                ".jpg": "file",
+                ".jpeg": "file",
+                ".gif": "file",
+                ".webp": "file",
+                ".ico": "file",
+                // Media
+                ".mp4": "file",
+                ".webm": "file",
+                ".mp3": "file",
+                ".ogg": "file"
+              }
+            });
+            const result = await ctx.rebuild();
+            const cssOutput = result.outputFiles?.find(
+              (f) => f.path.endsWith(".css")
+            );
+            if (!cssOutput) {
+              return {
+                errors: [{ text: `No CSS output generated for ${args.path}` }]
+              };
+            }
+            const basePath2 = normalizePath(args.with.assetBase);
+            const cssOutputDir = join(config.outDir, "public", basePath2);
+            if (!existsSync(cssOutputDir)) {
+              mkdirSync(cssOutputDir, { recursive: true });
+            }
+            for (const file of result.outputFiles || []) {
+              if (file === cssOutput)
+                continue;
+              const assetFilename = file.path.split("/").pop();
+              const assetPath = join(cssOutputDir, assetFilename);
+              writeFileSync(assetPath, file.contents);
+              const assetUrl = `${basePath2}${assetFilename}`;
+              const assetHash = createHash("sha256").update(file.contents).digest("hex").slice(0, HASH_LENGTH);
+              manifest.assets[assetFilename] = {
+                source: assetFilename,
+                output: assetFilename,
+                url: assetUrl,
+                hash: assetHash,
+                size: file.contents.length,
+                type: mime.getType(assetFilename) || void 0
+              };
+            }
+            content = Buffer.from(cssOutput.text);
+            outputExt = ".css";
+            mimeType = "text/css";
+          } else {
+            content = readFileSync(args.path);
+            mimeType = mime.getType(args.path) || void 0;
+          }
+          const hash = createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
+          let filename;
+          if (args.with.assetName && typeof args.with.assetName === "string") {
+            filename = args.with.assetName.replace(/\[name\]/g, name).replace(/\[ext\]/g, outputExt.slice(1));
+          } else {
+            filename = `${name}-${hash}${outputExt}`;
+          }
+          const basePath = normalizePath(args.with.assetBase);
+          const publicURL = `${basePath}${filename}`;
+          const outputDir = join(config.outDir, "public", basePath);
+          if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+          }
+          const outputPath = join(outputDir, filename);
+          writeFileSync(outputPath, content);
+          const sourcePath = relative(process.cwd(), args.path);
+          const manifestEntry = {
+            source: sourcePath,
+            output: filename,
+            url: publicURL,
+            hash,
+            size: content.length,
+            type: mimeType
+          };
+          manifest.assets[sourcePath] = manifestEntry;
+          return {
+            contents: `export default ${JSON.stringify(publicURL)};`,
+            loader: "js"
+          };
+        } catch (error) {
+          return {
+            errors: [
+              {
+                text: `Failed to process asset: ${error.message}`,
+                detail: error
+              }
+            ]
+          };
+        }
+      });
+      build2.onEnd(async () => {
+        for (const ctx of contexts.values()) {
+          await ctx.dispose();
+        }
+        contexts.clear();
+        try {
+          const manifestPath = join(config.outDir, "server", "assets.json");
+          const manifestDir = dirname(manifestPath);
+          if (!existsSync(manifestDir)) {
+            mkdirSync(manifestDir, { recursive: true });
+          }
+          writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+          logger.debug("Generated asset manifest", {
+            path: manifestPath,
+            assetCount: Object.keys(manifest.assets).length
+          });
+        } catch (error) {
+          logger.warn("Failed to write asset manifest: {error}", { error });
+        }
+      });
+    }
+  };
+}
+
+// src/plugins/import-meta.ts
+import { readFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { pathToFileURL } from "url";
+function importMetaPlugin() {
+  return {
+    name: "import-meta-transform",
+    setup(build2) {
+      build2.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
+        if (args.path.includes("node_modules") || args.path.includes("/packages/")) {
+          return null;
+        }
+        const contents = await readFile(args.path, "utf8");
+        if (!contents.includes("import.meta.url") && !contents.includes("import.meta.dirname") && !contents.includes("import.meta.filename")) {
+          return null;
+        }
+        const fileUrl = pathToFileURL(args.path).href;
+        const fileDirname = dirname2(args.path);
+        const fileFilename = args.path;
+        let transformed = contents;
+        transformed = transformed.replace(
+          /\bimport\.meta\.url\b/g,
+          JSON.stringify(fileUrl)
+        );
+        transformed = transformed.replace(
+          /\bimport\.meta\.dirname\b/g,
+          JSON.stringify(fileDirname)
+        );
+        transformed = transformed.replace(
+          /\bimport\.meta\.filename\b/g,
+          JSON.stringify(fileFilename)
+        );
+        const ext = args.path.split(".").pop();
+        let loader = "js";
+        if (ext === "ts")
+          loader = "ts";
+        else if (ext === "tsx")
+          loader = "tsx";
+        else if (ext === "jsx")
+          loader = "jsx";
+        return {
+          contents: transformed,
+          loader
+        };
+      });
+    }
+  };
+}
+
+// src/plugins/config.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2, isAbsolute } from "node:path";
+function createConfigPlugin(projectRoot, outDir = "dist", options = {}) {
+  const absoluteOutDir = isAbsolute(outDir) ? outDir : join2(projectRoot, outDir);
+  const serverOutDir = join2(absoluteOutDir, "server");
+  return {
+    name: "shovel-config",
+    setup(build2) {
+      build2.onResolve({ filter: /^shovel:config$/ }, (args) => ({
+        path: args.path,
+        namespace: "shovel-config"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "shovel-config" }, () => {
+        const rawConfig = loadRawConfig(projectRoot);
+        const configModuleCode = generateConfigModule(rawConfig, {
+          projectDir: projectRoot,
+          outDir: absoluteOutDir,
+          platformDefaults: options.platformDefaults,
+          lifecycle: options.lifecycle
+        });
+        const typesCode = generateStorageTypes(rawConfig, {
+          platformDefaults: options.platformDefaults
+        });
+        if (typesCode) {
+          mkdirSync2(serverOutDir, { recursive: true });
+          const typesPath = join2(serverOutDir, "shovel.d.ts");
+          writeFileSync2(typesPath, typesCode);
+        }
+        return {
+          contents: configModuleCode,
+          loader: "js",
+          resolveDir: projectRoot
+        };
+      });
+    }
+  };
+}
+
+// src/plugins/entry.ts
+function createEntryPlugin(projectRoot, entryPoints) {
+  return {
+    name: "shovel-entry",
+    setup(build2) {
+      build2.onResolve({ filter: /^shovel:entry(:.+)?$/ }, (args) => ({
+        path: args.path,
+        namespace: "shovel-entry"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "shovel-entry" }, (args) => {
+        const match = args.path.match(/^shovel:entry(?::(.+))?$/);
+        const entryName = match?.[1] ?? Object.keys(entryPoints)[0];
+        const contents = entryPoints[entryName];
+        if (!contents) {
+          const available = Object.keys(entryPoints).join(", ");
+          return {
+            errors: [
+              {
+                text: `Unknown entry point "${entryName}". Available: ${available}`
+              }
+            ]
+          };
+        }
+        return {
+          contents,
+          loader: "js",
+          resolveDir: projectRoot
+        };
+      });
+    }
+  };
+}
+
+// src/utils/jsx-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3, dirname as dirname3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var CRANK_JSX_DEFAULTS = {
+  jsx: "automatic",
+  jsxImportSource: "@b9g/crank"
+};
+async function findTsConfig(startDir) {
+  let dir = startDir;
+  while (dir !== dirname3(dir)) {
+    const tsconfigPath = join3(dir, "tsconfig.json");
+    if (existsSync2(tsconfigPath)) {
+      return tsconfigPath;
+    }
+    dir = dirname3(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 = dirname3(tsconfigPath);
+    let extendsPath = config.extends;
+    if (extendsPath.startsWith(".")) {
+      extendsPath = join3(baseDir, extendsPath);
+    } else {
+      extendsPath = join3(baseDir, "node_modules", extendsPath);
+    }
+    if (!extendsPath.endsWith(".json")) {
+      extendsPath += ".json";
+    }
+    if (existsSync2(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) {
+    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
+      };
+    }
+  }
+  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/git-sha.ts
+import { execSync } from "child_process";
+function getGitSHA(cwd) {
+  try {
+    return execSync("git rev-parse HEAD", {
+      encoding: "utf8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (_err) {
+    return "";
+  }
+}
+
+// src/utils/bundler.ts
+var logger2 = getLogger2(["shovel"]);
+var REQUIRE_SHIM = `import{createRequire as __cR}from'module';const require=__cR(import.meta.url);`;
+var ServerBundler = class {
+  #options;
+  #ctx;
+  #projectRoot;
+  #initialBuildComplete;
+  #initialBuildResolve;
+  #currentOutputs;
+  #configWatchers;
+  #dirWatchers;
+  #userEntryPath;
+  #watchOptions;
+  constructor(options) {
+    this.#options = options;
+    this.#projectRoot = findProjectRoot();
+    this.#initialBuildComplete = false;
+    this.#currentOutputs = { worker: "" };
+    this.#configWatchers = [];
+    this.#dirWatchers = /* @__PURE__ */ new Map();
+    this.#userEntryPath = "";
+  }
+  /**
+   * One-shot build.
+   *
+   * Produces all platform entry points:
+   * - Node/Bun: index.js (supervisor) + worker.js
+   * - Cloudflare: worker.js
+   *
+   * Build options (minify, sourcemap, etc.) come from userBuildConfig.
+   */
+  async build() {
+    const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
+    const outputDir = resolve(this.#projectRoot, this.#options.outDir);
+    const serverDir = join4(outputDir, "server");
+    await mkdir(serverDir, { recursive: true });
+    await mkdir(join4(outputDir, "public"), { recursive: true });
+    const buildOptions = await this.#createBuildOptions(entryPath, outputDir);
+    const result = await ESBuild2.build(buildOptions);
+    const external = buildOptions.external;
+    this.#validateBuildResult(result, external ?? ["node:*"]);
+    const outputs = this.#extractOutputPaths(result.metafile);
+    const success = result.errors.length === 0;
+    logger2.debug("Build complete", { outputs, success });
+    return { success, outputs };
+  }
+  /**
+   * Start watching and building.
+   *
+   * Returns after the initial build completes. Subsequent rebuilds
+   * trigger the onRebuild callback.
+   */
+  async watch(options = {}) {
+    this.#watchOptions = options;
+    const entryPath = resolve(this.#projectRoot, this.#options.entrypoint);
+    this.#userEntryPath = entryPath;
+    const outputDir = resolve(this.#projectRoot, this.#options.outDir);
+    await mkdir(join4(outputDir, "server"), { recursive: true });
+    const initialBuildPromise = new Promise((resolve2) => {
+      this.#initialBuildResolve = resolve2;
+    });
+    const buildOptions = await this.#createBuildOptions(entryPath, outputDir, {
+      watch: true
+    });
+    this.#ctx = await ESBuild2.context(buildOptions);
+    logger2.debug("Starting esbuild watch mode");
+    await this.#ctx.watch();
+    this.#watchConfigFiles();
+    return initialBuildPromise;
+  }
+  /**
+   * Stop watching and dispose of resources.
+   */
+  async stop() {
+    for (const watcher of this.#configWatchers) {
+      watcher.close();
+    }
+    this.#configWatchers = [];
+    for (const entry of this.#dirWatchers.values()) {
+      entry.watcher.close();
+    }
+    this.#dirWatchers.clear();
+    if (this.#ctx) {
+      await this.#ctx.dispose();
+      this.#ctx = void 0;
+    }
+  }
+  /**
+   * Create ESBuild options.
+   */
+  async #createBuildOptions(entryPath, outputDir, options = {}) {
+    const { watch: watch2 = false } = options;
+    const platformESBuildConfig = this.#options.platformESBuildConfig;
+    const platformDefaults = this.#options.platform.getDefaults();
+    const userBuildConfig = this.#options.userBuildConfig;
+    const relativeEntryPath = "./" + relative2(this.#projectRoot, entryPath);
+    const platformEntryPoints = this.#options.development ? this.#getDevelopmentEntryPoints(relativeEntryPath) : this.#options.platform.getProductionEntryPoints(relativeEntryPath);
+    const jsxOptions = await loadJSXConfig(this.#projectRoot);
+    const userPlugins = userBuildConfig?.plugins?.length ? await this.#loadUserPlugins(userBuildConfig.plugins) : [];
+    const platformExternal = platformESBuildConfig.external ?? ["node:*"];
+    const userExternal = userBuildConfig?.external ?? [];
+    const external = [...platformExternal, ...userExternal];
+    const isNodePlatform = (platformESBuildConfig.platform ?? "node") === "node";
+    const requireShim = isNodePlatform ? REQUIRE_SHIM : "";
+    const target = userBuildConfig?.target ?? "es2022";
+    const sourcemap = userBuildConfig?.sourcemap ?? (watch2 ? "inline" : false);
+    const minify = userBuildConfig?.minify ?? false;
+    const treeShaking = userBuildConfig?.treeShaking ?? true;
+    const esbuildEntryPoints = {
+      config: "shovel:config"
+    };
+    for (const name of Object.keys(platformEntryPoints)) {
+      esbuildEntryPoints[name] = `shovel:entry:${name}`;
+    }
+    const plugins = [
+      ...userPlugins,
+      createConfigPlugin(this.#projectRoot, this.#options.outDir, {
+        platformDefaults,
+        lifecycle: this.#options.lifecycle
+      }),
+      createEntryPlugin(this.#projectRoot, platformEntryPoints),
+      importMetaPlugin(),
+      assetsPlugin({
+        outDir: outputDir,
+        clientBuild: {
+          jsx: jsxOptions.jsx,
+          jsxFactory: jsxOptions.jsxFactory,
+          jsxFragment: jsxOptions.jsxFragment,
+          jsxImportSource: jsxOptions.jsxImportSource
+        }
+      })
+    ];
+    if (watch2) {
+      plugins.push(this.#createBuildNotifyPlugin(external));
+    }
+    const buildOptions = {
+      entryPoints: esbuildEntryPoints,
+      bundle: true,
+      format: "esm",
+      target,
+      platform: platformESBuildConfig.platform ?? "node",
+      outdir: `${outputDir}/server`,
+      entryNames: "[name]",
+      metafile: true,
+      absWorkingDir: this.#projectRoot,
+      conditions: platformESBuildConfig.conditions ?? ["import", "module"],
+      nodePaths: [getNodeModulesPath()],
+      plugins,
+      define: {
+        ...platformESBuildConfig.define ?? {},
+        ...userBuildConfig?.define ?? {},
+        __SHOVEL_OUTDIR__: JSON.stringify(outputDir),
+        __SHOVEL_GIT__: JSON.stringify(getGitSHA(this.#projectRoot))
+      },
+      alias: userBuildConfig?.alias,
+      external,
+      sourcemap,
+      minify,
+      treeShaking,
+      ...requireShim && { banner: { js: requireShim } }
+    };
+    applyJSXOptions(buildOptions, jsxOptions);
+    return buildOptions;
+  }
+  /**
+   * Extract output paths from metafile.
+   */
+  #extractOutputPaths(metafile) {
+    const outputs = {};
+    if (!metafile)
+      return outputs;
+    const outputPaths = Object.keys(metafile.outputs);
+    const indexOutput = outputPaths.find((p) => p.endsWith("index.js"));
+    if (indexOutput) {
+      outputs.index = resolve(this.#projectRoot, indexOutput);
+    }
+    const workerOutput = outputPaths.find((p) => p.endsWith("worker.js"));
+    if (workerOutput) {
+      outputs.worker = resolve(this.#projectRoot, workerOutput);
+    }
+    return outputs;
+  }
+  /**
+   * Get development entry points.
+   * Workers use startWorkerMessageLoop() to handle requests from ServiceWorkerPool.
+   */
+  #getDevelopmentEntryPoints(userEntryPath) {
+    const workerCode = `// Development Worker
+import {initWorkerRuntime, runLifecycle, startWorkerMessageLoop} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+const result = await initWorkerRuntime({config});
+const registration = result.registration;
+
+await import("${userEntryPath}");
+await runLifecycle(registration);
+startWorkerMessageLoop({registration, databases: result.databases});
+`;
+    return { worker: workerCode };
+  }
+  /**
+   * Load user ESBuild plugins from build config.
+   */
+  async #loadUserPlugins(plugins) {
+    const loadedPlugins = [];
+    for (const pluginConfig of plugins) {
+      const {
+        module: modulePath,
+        export: exportName = "default",
+        ...options
+      } = pluginConfig;
+      try {
+        const projectRequire = createRequire(
+          join4(this.#projectRoot, "package.json")
+        );
+        const resolvedPath = modulePath.startsWith(".") ? resolve(this.#projectRoot, modulePath) : projectRequire.resolve(modulePath);
+        const mod = await import(resolvedPath);
+        const pluginFactory = exportName === "default" ? mod.default : mod[exportName];
+        if (typeof pluginFactory !== "function") {
+          throw new Error(
+            `Plugin export "${exportName}" from "${modulePath}" is not a function`
+          );
+        }
+        const hasOptions = Object.keys(options).length > 0;
+        const plugin = hasOptions ? pluginFactory(options) : pluginFactory();
+        loadedPlugins.push(plugin);
+        logger2.debug("Loaded ESBuild plugin", {
+          module: modulePath,
+          export: exportName
+        });
+      } catch (error) {
+        throw new Error(
+          `Failed to load ESBuild plugin "${modulePath}": ${error instanceof Error ? error.message : error}`
+        );
+      }
+    }
+    return loadedPlugins;
+  }
+  /**
+   * Create the build-notify plugin for watch mode.
+   */
+  #createBuildNotifyPlugin(external) {
+    return {
+      name: "build-notify",
+      setup: (build2) => {
+        build2.onStart(() => {
+          logger2.info("Building...");
+        });
+        build2.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")) && !w.text.includes("./server.js")
+          );
+          if (dynamicImportWarnings.length > 0) {
+            success = false;
+            for (const warning of dynamicImportWarnings) {
+              const loc = warning.location;
+              const file = loc?.file || "unknown";
+              const line = loc?.line || "?";
+              logger2.error(
+                "Non-analyzable dynamic import at {file}:{line}: {text}",
+                { file, line, text: warning.text }
+              );
+            }
+            logger2.error(
+              "Dynamic imports must use literal strings, not variables. For config-driven providers, ensure they are registered in shovel.json."
+            );
+          }
+          if (result.metafile) {
+            const hasNodeWildcard = external.includes("node:*");
+            const allowedSet = new Set(external);
+            const unexpectedExternals = [];
+            for (const path of Object.keys(result.metafile.inputs)) {
+              if (!path.startsWith("<external>:"))
+                continue;
+              const moduleName = path.slice("<external>:".length);
+              const isAllowed = allowedSet.has(moduleName) || hasNodeWildcard && moduleName.startsWith("node:") || builtinModules.includes(moduleName);
+              if (!isAllowed && !unexpectedExternals.includes(moduleName)) {
+                unexpectedExternals.push(moduleName);
+              }
+            }
+            if (unexpectedExternals.length > 0) {
+              success = false;
+              for (const ext of unexpectedExternals) {
+                logger2.error("Unexpected external import: {module}", {
+                  module: ext
+                });
+              }
+              logger2.error(
+                "These modules are not bundled and won't be available at runtime."
+              );
+            }
+          }
+          const outputs = this.#extractOutputPaths(result.metafile);
+          if (success) {
+            logger2.debug("Build complete", { outputs });
+          } else {
+            logger2.error("Build errors: {errors}", { errors: result.errors });
+          }
+          this.#currentOutputs = outputs;
+          if (result.metafile) {
+            this.#updateSourceWatchers(result.metafile);
+          }
+          const buildResult = { success, outputs };
+          if (!this.#initialBuildComplete) {
+            this.#initialBuildComplete = true;
+            await new Promise((resolve2) => setTimeout(resolve2, 0));
+            this.#initialBuildResolve?.(buildResult);
+          } else {
+            await this.#watchOptions?.onRebuild?.(buildResult);
+          }
+        });
+      }
+    };
+  }
+  /**
+   * Validate build result.
+   */
+  #validateBuildResult(result, allowedExternals) {
+    const dynamicImportWarnings = (result.warnings || []).filter(
+      (w) => (w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")) && !w.text.includes("./server.js")
+    );
+    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: Non-analyzable dynamic imports found:
+${locations}
+
+Dynamic imports must use literal strings, not variables.`
+      );
+    }
+    if (result.metafile) {
+      const allowedSet = new Set(allowedExternals);
+      const wildcardPrefixes = allowedExternals.filter((e) => e.endsWith(":*")).map((e) => e.slice(0, -1));
+      const unexpectedExternals = [];
+      for (const path of Object.keys(result.metafile.inputs)) {
+        if (!path.startsWith("<external>:"))
+          continue;
+        const moduleName = path.slice("<external>:".length);
+        const isAllowed = allowedSet.has(moduleName) || wildcardPrefixes.some((prefix) => moduleName.startsWith(prefix)) || builtinModules.includes(moduleName);
+        if (!isAllowed && !unexpectedExternals.includes(moduleName)) {
+          unexpectedExternals.push(moduleName);
+        }
+      }
+      if (unexpectedExternals.length > 0) {
+        const externals = unexpectedExternals.map((e) => `  - ${e}`).join("\n");
+        throw new Error(
+          `Build failed: Unexpected external imports found:
+${externals}
+
+These modules are not bundled and won't be available at runtime.`
+        );
+      }
+    }
+  }
+  /**
+   * Watch config files for changes.
+   */
+  #watchConfigFiles() {
+    const configFiles = ["shovel.json", "package.json"];
+    for (const filename of configFiles) {
+      const filepath = join4(this.#projectRoot, filename);
+      if (!existsSync3(filepath))
+        continue;
+      try {
+        const watcher = watch(filepath, { persistent: false }, (event) => {
+          if (event === "change") {
+            logger2.info(`Config changed: ${filename}, rebuilding...`);
+            this.#ctx?.rebuild().catch((err) => {
+              logger2.error("Rebuild failed: {error}", { error: err });
+            });
+          }
+        });
+        this.#configWatchers.push(watcher);
+      } catch (err) {
+        logger2.warn("Failed to watch {file}: {error}", {
+          file: filename,
+          error: err
+        });
+      }
+    }
+  }
+  /**
+   * Update source file watchers from metafile.
+   */
+  #updateSourceWatchers(metafile) {
+    const newDirFiles = /* @__PURE__ */ new Map();
+    if (this.#userEntryPath) {
+      const entryDir = dirname4(this.#userEntryPath);
+      const entryFile = basename2(this.#userEntryPath);
+      if (!newDirFiles.has(entryDir)) {
+        newDirFiles.set(entryDir, /* @__PURE__ */ new Set());
+      }
+      newDirFiles.get(entryDir).add(entryFile);
+      logger2.debug("Explicitly watching user entry file: {path}", {
+        path: this.#userEntryPath
+      });
+    }
+    for (const inputPath of Object.keys(metafile.inputs)) {
+      if (inputPath.startsWith("<") || inputPath.startsWith("shovel")) {
+        continue;
+      }
+      const fullPath = resolve(this.#projectRoot, inputPath);
+      const dir = dirname4(fullPath);
+      const file = basename2(fullPath);
+      if (!newDirFiles.has(dir)) {
+        newDirFiles.set(dir, /* @__PURE__ */ new Set());
+      }
+      newDirFiles.get(dir).add(file);
+    }
+    for (const [dir, entry] of this.#dirWatchers) {
+      if (!newDirFiles.has(dir)) {
+        entry.watcher.close();
+        this.#dirWatchers.delete(dir);
+      }
+    }
+    for (const [dir, files] of newDirFiles) {
+      const existing = this.#dirWatchers.get(dir);
+      if (existing) {
+        existing.files = files;
+      } else {
+        if (!existsSync3(dir))
+          continue;
+        try {
+          const watcher = watch(
+            dir,
+            { persistent: false },
+            (_event, filename) => {
+              const entry = this.#dirWatchers.get(dir);
+              if (!entry)
+                return;
+              const isTrackedFile = filename ? entry.files.has(filename) : true;
+              if (isTrackedFile) {
+                logger2.debug("Native watcher detected change: {file}", {
+                  file: filename ? join4(dir, filename) : dir
+                });
+                this.#ctx?.rebuild().catch((err) => {
+                  logger2.error("Rebuild failed: {error}", { error: err });
+                });
+              }
+            }
+          );
+          this.#dirWatchers.set(dir, { watcher, files });
+        } catch (err) {
+          logger2.debug("Failed to watch directory {dir}: {error}", {
+            dir,
+            error: err
+          });
+        }
+      }
+    }
+    const totalFiles = Array.from(this.#dirWatchers.values()).reduce(
+      (sum, entry) => sum + entry.files.size,
+      0
+    );
+    const watchedDirs = Array.from(this.#dirWatchers.keys());
+    logger2.debug(
+      "Watching {fileCount} source files in {dirCount} directories with native fs.watch",
+      { fileCount: totalFiles, dirCount: this.#dirWatchers.size }
+    );
+    logger2.debug("Watched directories: {dirs}", {
+      dirs: watchedDirs.slice(0, 5).join(", ") + (watchedDirs.length > 5 ? "..." : "")
+    });
+  }
+};
+
+// src/utils/platform.ts
+async function createPlatform(platformName, options = {}) {
+  switch (platformName) {
+    case "node": {
+      const { default: NodePlatform } = await import("@b9g/platform-node");
+      return new NodePlatform(options);
+    }
+    case "bun": {
+      const { default: BunPlatform } = await import("@b9g/platform-bun");
+      return new BunPlatform(options);
+    }
+    case "cloudflare": {
+      const { default: CloudflarePlatform } = await import("@b9g/platform-cloudflare");
+      return new CloudflarePlatform(options);
+    }
+    default:
+      throw new Error(
+        `Unknown platform: ${platformName}. Valid platforms: node, bun, cloudflare`
+      );
+  }
+}
+
+export {
+  ServerBundler,
+  createPlatform
+};