@pikku/cli 0.12.54 → 0.12.56

package/dist/src/deploy/bundler/bundler.d.ts

@@ -1,35 +1,30 @@
 /**
- * Main esbuild bundling pipeline for Pikku.
+ * Shared bundling orchestration for Pikku deploys.
  *
- * For each deployment unit in a DeploymentManifest, this module:
- * 1. Takes a pre-generated entry point (provided by the deploy provider)
- * 2. Runs esbuild with bundle:true, npm packages external
- * 3. Stubs Node.js-only gen files that aren't needed by this unit
- * 4. Parses the metafile to extract external dependencies
- * 5. Generates a minimal package.json with exact versions
- * 6. Writes all artifacts to `<outputDir>/<unit-name>/`
+ * `BaseBundler` performs everything that is runtime-independent for each
+ * deployment unit:
+ * 1. Take a pre-generated entry point (provided by the deploy provider)
+ * 2. Stub gen files / npm modules not needed by this unit
+ * 3. Delegate the actual compile to a runtime backend (`compile`)
+ * 4. Resolve external dependency versions into a minimal package.json
+ * 5. Write all artifacts to `<outputDir>/<unit-name>/` and hash them
+ *
+ * The runtime-specific compile step lives in `NodeBundler` (esbuild) and
+ * `BunBundler` (Bun.build); the right one is injected from `services.ts`.
  */
-import type { DeploymentManifest, DeploymentUnit, BundleOutput } from './types.js';
+import type { DeploymentManifest, BundleOutput } from './types.js';
+import type { Bundler, BundleUnitsOptions, CompileInput, CompileResult } from './bundler.interface.js';
 /**
- * Bundles all deployment units defined in a DeploymentManifest.
- *
- * Entry points must be pre-generated by the provider-specific package
- * (e.g. @pikku/deploy-cloudflare) and passed in as entryFiles.
- *
- * @param projectDir - Root directory of the Pikku project
- * @param manifest - The deployment manifest describing all units
- * @param entryFiles - Map of unit name -> entry file path (generated by the deploy provider)
- * @param outputDir - Base output directory (defaults to `<projectDir>/.deploy/build`)
+ * Runtime-independent bundling orchestration. Subclasses implement only
+ * `compile` — the actual esbuild / Bun.build invocation.
  */
-export declare function bundleUnits(projectDir: string, manifest: DeploymentManifest, entryFiles: Map<string, string>, outputDir?: string, options?: {
-    externals?: string[];
-    aliases?: Record<string, string>;
-    define?: Record<string, string>;
-    platform?: 'node' | 'neutral' | 'browser';
-    format?: 'esm' | 'cjs';
-    noRequireShim?: boolean;
-    sourcemap?: boolean;
-    emitMetafile?: boolean;
-    stubModules?: string[];
-    resolveOutputDir?: (unit: DeploymentUnit, baseOutputDir: string) => string;
-}): Promise<BundleOutput>;
+export declare abstract class BaseBundler implements Bundler {
+    /**
+     * Runtime-specific compile step: write `input.bundlePath` (and its `.map`
+     * when `input.sourcemap`) and return the external packages + optional
+     * metafile JSON.
+     */
+    protected abstract compile(input: CompileInput): Promise<CompileResult>;
+    bundleUnits(projectDir: string, manifest: DeploymentManifest, entryFiles: Map<string, string>, outputDir?: string, options?: BundleUnitsOptions): Promise<BundleOutput>;
+    private bundleUnit;
+}

package/dist/src/deploy/bundler/bundler.interface.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Bundler abstraction.
+ *
+ * A `Bundler` turns a deployment manifest's units into self-contained bundles.
+ * The shared orchestration (dead-module stubbing, dependency extraction,
+ * package.json + hashing) lives in `BaseBundler`; each runtime supplies only the
+ * compile step via a `Bundler` implementation (esbuild for node, Bun.build for
+ * bun). The runtime is resolved once in `services.ts` and injected — no
+ * `typeof Bun` checks in the pipeline.
+ */
+import type { DeploymentManifest, DeploymentUnit, BundleOutput } from './types.js';
+/**
+ * Inputs the shared orchestration hands to a backend's runtime-specific compile
+ * step. The backend writes `bundlePath` (and `${bundlePath}.map` when
+ * `sourcemap`) itself and returns the external packages + optional metafile.
+ */
+export interface CompileInput {
+    unitName: string;
+    entryPath: string;
+    bundlePath: string;
+    projectDir: string;
+    platform: 'node' | 'neutral' | 'browser';
+    format: 'esm' | 'cjs';
+    externals: string[];
+    aliases?: Record<string, string>;
+    define?: Record<string, string>;
+    /** ESM require/__filename/__dirname shim, or undefined when not needed. */
+    bannerJs?: string;
+    sourcemap: boolean;
+    emitMetafile: boolean;
+    /** Regexes for modules to replace with an empty `export {}` module. */
+    deadPatterns: RegExp[];
+}
+export interface CompileResult {
+    /** Real npm package names kept external — drive the unit's package.json. */
+    externalPackages: Set<string>;
+    /** Stringified metafile when `emitMetafile` was set; otherwise undefined. */
+    metafileJson?: string;
+}
+export interface BundleUnitsOptions {
+    externals?: string[];
+    aliases?: Record<string, string>;
+    define?: Record<string, string>;
+    platform?: 'node' | 'neutral' | 'browser';
+    format?: 'esm' | 'cjs';
+    noRequireShim?: boolean;
+    sourcemap?: boolean;
+    emitMetafile?: boolean;
+    stubModules?: string[];
+    resolveOutputDir?: (unit: DeploymentUnit, baseOutputDir: string) => string;
+}
+export interface Bundler {
+    bundleUnits(projectDir: string, manifest: DeploymentManifest, entryFiles: Map<string, string>, outputDir?: string, options?: BundleUnitsOptions): Promise<BundleOutput>;
+}

package/dist/src/deploy/bundler/bundler.interface.js

@@ -0,0 +1,11 @@
+/**
+ * Bundler abstraction.
+ *
+ * A `Bundler` turns a deployment manifest's units into self-contained bundles.
+ * The shared orchestration (dead-module stubbing, dependency extraction,
+ * package.json + hashing) lives in `BaseBundler`; each runtime supplies only the
+ * compile step via a `Bundler` implementation (esbuild for node, Bun.build for
+ * bun). The runtime is resolved once in `services.ts` and injected — no
+ * `typeof Bun` checks in the pipeline.
+ */
+export {};

package/dist/src/deploy/bundler/bundler.js

@@ -1,19 +1,21 @@
 /**
- * Main esbuild bundling pipeline for Pikku.
+ * Shared bundling orchestration for Pikku deploys.
  *
- * For each deployment unit in a DeploymentManifest, this module:
- * 1. Takes a pre-generated entry point (provided by the deploy provider)
- * 2. Runs esbuild with bundle:true, npm packages external
- * 3. Stubs Node.js-only gen files that aren't needed by this unit
- * 4. Parses the metafile to extract external dependencies
- * 5. Generates a minimal package.json with exact versions
- * 6. Writes all artifacts to `<outputDir>/<unit-name>/`
+ * `BaseBundler` performs everything that is runtime-independent for each
+ * deployment unit:
+ * 1. Take a pre-generated entry point (provided by the deploy provider)
+ * 2. Stub gen files / npm modules not needed by this unit
+ * 3. Delegate the actual compile to a runtime backend (`compile`)
+ * 4. Resolve external dependency versions into a minimal package.json
+ * 5. Write all artifacts to `<outputDir>/<unit-name>/` and hash them
+ *
+ * The runtime-specific compile step lives in `NodeBundler` (esbuild) and
+ * `BunBundler` (Bun.build); the right one is injected from `services.ts`.
  */
-import { build } from 'esbuild';
 import { writeFile, mkdir, stat, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createHash } from 'node:crypto';
-import { extractDependencies, generateMinimalPackageJson, } from './dep-extractor.js';
+import { resolveExternalVersions, generateMinimalPackageJson, } from './dep-extractor.js';
 /**
  * Mapping of service name -> gen file pattern that should be stubbed
  * when the service is not required by a deployment unit.
@@ -66,196 +68,124 @@ async function getDeadGenFilePatterns(unitOutputDir) {
     }
     return patterns;
 }
-/**
- * esbuild plugin that stubs gen files for services not needed by this unit.
- * This prevents Node.js-only modules (e.g. LocalMetaService which uses fs)
- * from being pulled into serverless worker bundles via dynamic imports.
- */
-function createDeadModuleStubPlugin(patterns) {
-    return {
-        name: 'pikku-dead-module-stub',
-        setup(build) {
-            if (patterns.length === 0)
-                return;
-            const combined = new RegExp(patterns.map((p) => p.source).join('|'));
-            build.onResolve({ filter: combined }, (args) => ({
-                path: args.path,
-                namespace: 'pikku-stub',
-            }));
-            build.onLoad({ filter: /.*/, namespace: 'pikku-stub' }, () => ({
-                contents: 'export {}',
-                loader: 'js',
-            }));
-        },
-    };
-}
 const BUNDLE_FILENAME = 'bundle.js';
 const METAFILE_FILENAME = 'metafile.json';
 const PACKAGE_JSON_FILENAME = 'package.json';
 const EXACT_DEPENDENCIES_FILENAME = 'exact-dependencies.json';
 /**
- * Bundles a single deployment unit using esbuild.
- *
- * Produces three files in the unit output directory:
- * - bundle.js: The bundled code (user code only, external deps as bare imports)
- * - metafile.json: esbuild's metafile for analysis
- * - package.json: Minimal manifest with only the external deps this unit needs
+ * Runtime-independent bundling orchestration. Subclasses implement only
+ * `compile` — the actual esbuild / Bun.build invocation.
  */
-async function bundleUnit(options) {
-    const { unit, entryPath, unitOutputDir, projectDir, externals, aliases, define, platform, format, sourcemap, emitMetafile, stubModules, } = options;
-    await mkdir(unitOutputDir, { recursive: true });
-    const bundlePath = join(unitOutputDir, BUNDLE_FILENAME);
-    const metafilePath = join(unitOutputDir, METAFILE_FILENAME);
-    const packageJsonPath = join(unitOutputDir, PACKAGE_JSON_FILENAME);
-    const exactDependenciesPath = join(unitOutputDir, EXACT_DEPENDENCIES_FILENAME);
-    // Determine which gen files to stub based on per-unit service requirements,
-    // plus any provider-supplied module stubs (modules the provider's runtime
-    // never executes — e.g. the `postgres` driver on CF Workers, which use a
-    // libsql/Turso dialect; the postgres branch is URL-gated and never taken).
-    const deadPatterns = await getDeadGenFilePatterns(unitOutputDir);
-    for (const source of stubModules ?? []) {
-        deadPatterns.push(new RegExp(source));
-    }
-    // Run esbuild — inline everything into a self-contained bundle.
-    // Only Node built-ins are kept external (CF Workers provides them).
-    // The stub plugin replaces gen files for unused services with empty
-    // modules, preventing Node.js-only code from entering the bundle.
-    // Resolve node_modules paths up the directory tree for workspace packages
-    const nodePaths = [];
-    let dir = projectDir;
-    while (true) {
-        const nm = join(dir, 'node_modules');
-        nodePaths.push(nm);
-        const parent = join(dir, '..');
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    // For ESM + node platform, CJS deps may use require() / __filename / __dirname
-    // for builtins or to locate native addons (the `bindings` package, used
-    // transitively by `pg` and many others, calls `__filename` directly). esbuild
-    // wraps require() as __require() which fails at runtime in ESM, and leaves
-    // `__filename` / `__dirname` as undefined references. The banner shims all
-    // three via createRequire / fileURLToPath so CJS builtins resolve and native-
-    // addon loaders find their .node files.
-    // Skipped when the provider opts out via `noRequireShim` (e.g. CF Workers
-    // — `import.meta.url` is undefined there, so the shim crashes at boot).
-    const resolvedFormat = format ?? 'esm';
-    const banner = resolvedFormat === 'esm' &&
-        (platform ?? 'node') === 'node' &&
-        !options.noRequireShim
-        ? {
-            js: `import { createRequire as __pikkuCreateRequire } from 'node:module'; import { fileURLToPath as __pikkuFileURLToPath } from 'node:url'; import { dirname as __pikkuDirname } from 'node:path'; const require = __pikkuCreateRequire(import.meta.url); const __filename = __pikkuFileURLToPath(import.meta.url); const __dirname = __pikkuDirname(__filename);`,
+export class BaseBundler {
+    async bundleUnits(projectDir, manifest, entryFiles, outputDir, options) {
+        const buildDir = outputDir ?? join(projectDir, '.deploy', 'build');
+        const results = [];
+        const errors = [];
+        if (manifest.units.length === 0) {
+            return { results, errors };
+        }
+        for (const unit of manifest.units) {
+            const entryPath = entryFiles.get(unit.name);
+            if (!entryPath) {
+                errors.push({
+                    unitName: unit.name,
+                    error: `No entry point provided for unit "${unit.name}"`,
+                });
+                continue;
+            }
+            const unitOutputDir = options?.resolveOutputDir
+                ? options.resolveOutputDir(unit, buildDir)
+                : join(buildDir, unit.name);
+            try {
+                const result = await this.bundleUnit(unit, entryPath, unitOutputDir, projectDir, options ?? {});
+                results.push(result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                errors.push({ unitName: unit.name, error: message });
+            }
         }
-        : undefined;
-    const result = await build({
-        entryPoints: [entryPath],
-        bundle: true,
-        absWorkingDir: projectDir,
-        nodePaths,
-        platform: platform ?? 'node',
-        format: resolvedFormat,
-        banner,
-        metafile: true,
-        target: 'es2022',
-        outfile: bundlePath,
-        // Minify every deploy bundle — esbuild output ships straight to the runtime
-        // (CF Workers / container), tsc is never the bundler. keepNames preserves
-        // Function.name / constructor.name so name-based reflection still works.
-        minify: true,
-        keepNames: true,
-        sourcemap: sourcemap ?? false,
-        logLevel: 'warning',
-        loader: { '.ts': 'ts' },
-        external: externals ?? ['node:*'],
-        alias: aliases,
-        define,
-        plugins: [createDeadModuleStubPlugin(deadPatterns)],
-    });
-    // Always produced in-memory (drives dependency extraction); only persisted
-    // when requested — it's large (~1.6MB/unit) and never needed at runtime.
-    if (emitMetafile) {
-        const metafileJson = JSON.stringify(result.metafile, null, 2);
-        await writeFile(metafilePath, metafileJson, 'utf-8');
-    }
-    // Extract dependencies and generate minimal package.json
-    const { exactDependencies, exactOptionalDependencies } = await extractDependencies(result.metafile, projectDir);
-    const packageJson = generateMinimalPackageJson(unit.name, exactDependencies, exactOptionalDependencies);
-    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
-    await writeFile(exactDependenciesPath, JSON.stringify({
-        dependencies: Object.fromEntries(Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b))),
-        optionalDependencies: Object.fromEntries(Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b))),
-    }, null, 2), 'utf-8');
-    // Get bundle size
-    const bundleStat = await stat(bundlePath);
-    const bundleContents = await readFile(bundlePath);
-    const bundleHash = createHash('sha256').update(bundleContents).digest('hex');
-    const exactDependenciesHash = createHash('sha256')
-        .update(JSON.stringify({
-        dependencies: Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b)),
-        optionalDependencies: Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b)),
-    }))
-        .digest('hex');
-    return {
-        unitName: unit.name,
-        bundlePath,
-        packageJsonPath,
-        exactDependenciesPath,
-        metafilePath,
-        bundleSizeBytes: bundleStat.size,
-        bundleHash,
-        exactDependenciesHash,
-        exactDependencies,
-        exactOptionalDependencies,
-    };
-}
-/**
- * Bundles all deployment units defined in a DeploymentManifest.
- *
- * Entry points must be pre-generated by the provider-specific package
- * (e.g. @pikku/deploy-cloudflare) and passed in as entryFiles.
- *
- * @param projectDir - Root directory of the Pikku project
- * @param manifest - The deployment manifest describing all units
- * @param entryFiles - Map of unit name -> entry file path (generated by the deploy provider)
- * @param outputDir - Base output directory (defaults to `<projectDir>/.deploy/build`)
- */
-export async function bundleUnits(projectDir, manifest, entryFiles, outputDir, options) {
-    const buildDir = outputDir ?? join(projectDir, '.deploy', 'build');
-    const results = [];
-    const errors = [];
-    if (manifest.units.length === 0) {
         return { results, errors };
     }
-    for (const unit of manifest.units) {
-        const entryPath = entryFiles.get(unit.name);
-        if (!entryPath) {
-            errors.push({
-                unitName: unit.name,
-                error: `No entry point provided for unit "${unit.name}"`,
-            });
-            continue;
-        }
-        const unitOutputDir = options?.resolveOutputDir
-            ? options.resolveOutputDir(unit, buildDir)
-            : join(buildDir, unit.name);
-        try {
-            const result = await bundleUnit({
-                unit,
-                entryPath,
-                unitOutputDir,
-                projectDir,
-                ...options,
-            });
-            results.push(result);
+    async bundleUnit(unit, entryPath, unitOutputDir, projectDir, options) {
+        await mkdir(unitOutputDir, { recursive: true });
+        const bundlePath = join(unitOutputDir, BUNDLE_FILENAME);
+        const metafilePath = join(unitOutputDir, METAFILE_FILENAME);
+        const packageJsonPath = join(unitOutputDir, PACKAGE_JSON_FILENAME);
+        const exactDependenciesPath = join(unitOutputDir, EXACT_DEPENDENCIES_FILENAME);
+        // Determine which gen files to stub based on per-unit service requirements,
+        // plus any provider-supplied module stubs (modules the provider's runtime
+        // never executes — e.g. the `postgres` driver on CF Workers, which use a
+        // libsql/Turso dialect; the postgres branch is URL-gated and never taken).
+        const deadPatterns = await getDeadGenFilePatterns(unitOutputDir);
+        for (const source of options.stubModules ?? []) {
+            deadPatterns.push(new RegExp(source));
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            errors.push({
-                unitName: unit.name,
-                error: message,
-            });
+        const platform = options.platform ?? 'node';
+        const format = options.format ?? 'esm';
+        const externals = options.externals ?? ['node:*'];
+        const sourcemap = options.sourcemap ?? false;
+        const emitMetafile = options.emitMetafile ?? false;
+        // For ESM + node platform, CJS deps may use require() / __filename /
+        // __dirname for builtins or to locate native addons (the `bindings`
+        // package, used transitively by `pg`, calls `__filename` directly). esbuild
+        // wraps require() as __require() which fails at runtime in ESM, and leaves
+        // `__filename` / `__dirname` as undefined references. The banner shims all
+        // three so CJS builtins resolve and native-addon loaders find their .node
+        // files. Skipped when the provider opts out via `noRequireShim` (e.g. CF
+        // Workers — `import.meta.url` is undefined there, so the shim crashes).
+        const bannerJs = format === 'esm' && platform === 'node' && !options.noRequireShim
+            ? `import { createRequire as __pikkuCreateRequire } from 'node:module'; import { fileURLToPath as __pikkuFileURLToPath } from 'node:url'; import { dirname as __pikkuDirname } from 'node:path'; const require = __pikkuCreateRequire(import.meta.url); const __filename = __pikkuFileURLToPath(import.meta.url); const __dirname = __pikkuDirname(__filename);`
+            : undefined;
+        const { externalPackages, metafileJson } = await this.compile({
+            unitName: unit.name,
+            entryPath,
+            bundlePath,
+            projectDir,
+            platform,
+            format,
+            externals,
+            aliases: options.aliases,
+            define: options.define,
+            bannerJs,
+            sourcemap,
+            emitMetafile,
+            deadPatterns,
+        });
+        // Metafile is large (~1.6MB/unit) and never needed at runtime — only
+        // persisted for debugging.
+        if (emitMetafile && metafileJson) {
+            await writeFile(metafilePath, metafileJson, 'utf-8');
         }
+        // Extract dependencies and generate minimal package.json
+        const { exactDependencies, exactOptionalDependencies } = await resolveExternalVersions(externalPackages, projectDir);
+        const packageJson = generateMinimalPackageJson(unit.name, exactDependencies, exactOptionalDependencies);
+        await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+        await writeFile(exactDependenciesPath, JSON.stringify({
+            dependencies: Object.fromEntries(Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b))),
+            optionalDependencies: Object.fromEntries(Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b))),
+        }, null, 2), 'utf-8');
+        // Get bundle size + hashes
+        const bundleStat = await stat(bundlePath);
+        const bundleContents = await readFile(bundlePath);
+        const bundleHash = createHash('sha256').update(bundleContents).digest('hex');
+        const exactDependenciesHash = createHash('sha256')
+            .update(JSON.stringify({
+            dependencies: Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b)),
+            optionalDependencies: Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b)),
+        }))
+            .digest('hex');
+        return {
+            unitName: unit.name,
+            bundlePath,
+            packageJsonPath,
+            exactDependenciesPath,
+            metafilePath,
+            bundleSizeBytes: bundleStat.size,
+            bundleHash,
+            exactDependenciesHash,
+            exactDependencies,
+            exactOptionalDependencies,
+        };
     }
-    return { results, errors };
 }

package/dist/src/deploy/bundler/dep-extractor.d.ts

@@ -21,12 +21,20 @@ export declare function extractExternalPackages(metafile: Metafile): Set<string>
  * Returns null for relative imports or other non-package specifiers.
  */
 export declare function parsePackageName(specifier: string): string | null;
+/**
+ * Resolves exact versions for a set of external package names.
+ *
+ * Shared by both bundler backends: esbuild derives the set from its metafile
+ * (`extractExternalPackages`), while the Bun.build backend captures it via a
+ * resolve plugin (Bun's metafile does not record external imports).
+ */
+export declare function resolveExternalVersions(externalPackages: Set<string>, projectDir: string): Promise<{
+    exactDependencies: Record<string, string>;
+    exactOptionalDependencies: Record<string, string>;
+}>;
 /**
  * Given an esbuild metafile, extracts all external packages and resolves
  * their versions from the project's dependency files.
- *
- * Returns a record of package name to exact version, suitable for
- * writing into a minimal package.json.
  */
 export declare function extractDependencies(metafile: Metafile, projectDir: string): Promise<{
     exactDependencies: Record<string, string>;

package/dist/src/deploy/bundler/dep-extractor.js

@@ -244,14 +244,13 @@ async function resolveVersion(packageName, projectDeps, yarnLockVersions, projec
     return null;
 }
 /**
- * Given an esbuild metafile, extracts all external packages and resolves
- * their versions from the project's dependency files.
+ * Resolves exact versions for a set of external package names.
  *
- * Returns a record of package name to exact version, suitable for
- * writing into a minimal package.json.
+ * Shared by both bundler backends: esbuild derives the set from its metafile
+ * (`extractExternalPackages`), while the Bun.build backend captures it via a
+ * resolve plugin (Bun's metafile does not record external imports).
  */
-export async function extractDependencies(metafile, projectDir) {
-    const externalPackages = extractExternalPackages(metafile);
+export async function resolveExternalVersions(externalPackages, projectDir) {
     if (externalPackages.size === 0) {
         return { exactDependencies: {}, exactOptionalDependencies: {} };
     }
@@ -278,6 +277,13 @@ export async function extractDependencies(metafile, projectDir) {
     }
     return { exactDependencies, exactOptionalDependencies };
 }
+/**
+ * Given an esbuild metafile, extracts all external packages and resolves
+ * their versions from the project's dependency files.
+ */
+export async function extractDependencies(metafile, projectDir) {
+    return resolveExternalVersions(extractExternalPackages(metafile), projectDir);
+}
 /**
  * Generates a minimal package.json content object for a unit bundle.
  */

package/dist/src/deploy/bundler/index.d.ts

@@ -1,3 +1,6 @@
-export { bundleUnits } from './bundler.js';
-export { extractDependencies, extractExternalPackages, parsePackageName, generateMinimalPackageJson, } from './dep-extractor.js';
+export { BaseBundler } from './bundler.js';
+export { NodeBundler } from './node-bundler.js';
+export { BunBundler } from './bun-bundler.js';
+export type { Bundler, BundleUnitsOptions } from './bundler.interface.js';
+export { extractDependencies, extractExternalPackages, resolveExternalVersions, parsePackageName, generateMinimalPackageJson, } from './dep-extractor.js';
 export type { BundleResult, BundleError, BundleOutput, DeploymentUnit, DeploymentUnitRole, } from './types.js';

package/dist/src/deploy/bundler/index.js

@@ -1,2 +1,4 @@
-export { bundleUnits } from './bundler.js';
-export { extractDependencies, extractExternalPackages, parsePackageName, generateMinimalPackageJson, } from './dep-extractor.js';
+export { BaseBundler } from './bundler.js';
+export { NodeBundler } from './node-bundler.js';
+export { BunBundler } from './bun-bundler.js';
+export { extractDependencies, extractExternalPackages, resolveExternalVersions, parsePackageName, generateMinimalPackageJson, } from './dep-extractor.js';

package/dist/src/deploy/bundler/node-bundler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Node (esbuild) bundler backend.
+ *
+ * Used when the CLI runs under Node (yarn/npm projects). esbuild resolves deps
+ * via `nodePaths` walking up the directory tree, which assumes a flat, hoisted
+ * `node_modules` — exactly what yarn/npm produce. For bun's per-workspace
+ * symlink layout use `BunBundler` instead (selected in `services.ts`).
+ */
+import { BaseBundler } from './bundler.js';
+import type { CompileInput, CompileResult } from './bundler.interface.js';
+export declare class NodeBundler extends BaseBundler {
+    protected compile(input: CompileInput): Promise<CompileResult>;
+}

package/dist/src/deploy/bundler/node-bundler.js

@@ -0,0 +1,80 @@
+/**
+ * Node (esbuild) bundler backend.
+ *
+ * Used when the CLI runs under Node (yarn/npm projects). esbuild resolves deps
+ * via `nodePaths` walking up the directory tree, which assumes a flat, hoisted
+ * `node_modules` — exactly what yarn/npm produce. For bun's per-workspace
+ * symlink layout use `BunBundler` instead (selected in `services.ts`).
+ */
+import { build } from 'esbuild';
+import { join } from 'node:path';
+import { extractExternalPackages } from './dep-extractor.js';
+import { BaseBundler } from './bundler.js';
+/**
+ * esbuild plugin that stubs gen files / modules not needed by this unit,
+ * preventing Node-only modules (e.g. LocalMetaService using fs) from being
+ * pulled into serverless worker bundles via dynamic imports.
+ */
+function createDeadModuleStubPlugin(patterns) {
+    return {
+        name: 'pikku-dead-module-stub',
+        setup(build) {
+            if (patterns.length === 0)
+                return;
+            const combined = new RegExp(patterns.map((p) => p.source).join('|'));
+            build.onResolve({ filter: combined }, (args) => ({
+                path: args.path,
+                namespace: 'pikku-stub',
+            }));
+            build.onLoad({ filter: /.*/, namespace: 'pikku-stub' }, () => ({
+                contents: 'export {}',
+                loader: 'js',
+            }));
+        },
+    };
+}
+export class NodeBundler extends BaseBundler {
+    async compile(input) {
+        // Resolve node_modules paths up the directory tree for workspace packages.
+        const nodePaths = [];
+        let dir = input.projectDir;
+        while (true) {
+            nodePaths.push(join(dir, 'node_modules'));
+            const parent = join(dir, '..');
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        const result = await build({
+            entryPoints: [input.entryPath],
+            bundle: true,
+            absWorkingDir: input.projectDir,
+            nodePaths,
+            platform: input.platform,
+            format: input.format,
+            banner: input.bannerJs ? { js: input.bannerJs } : undefined,
+            metafile: true,
+            target: 'es2022',
+            outfile: input.bundlePath,
+            // Minify every deploy bundle — esbuild output ships straight to the
+            // runtime (CF Workers / container), tsc is never the bundler. keepNames
+            // preserves Function.name / constructor.name so name-based reflection
+            // still works.
+            minify: true,
+            keepNames: true,
+            sourcemap: input.sourcemap,
+            logLevel: 'warning',
+            loader: { '.ts': 'ts' },
+            external: input.externals,
+            alias: input.aliases,
+            define: input.define,
+            plugins: [createDeadModuleStubPlugin(input.deadPatterns)],
+        });
+        return {
+            externalPackages: extractExternalPackages(result.metafile),
+            metafileJson: input.emitMetafile
+                ? JSON.stringify(result.metafile, null, 2)
+                : undefined,
+        };
+    }
+}