@pikku/cli 0.12.55 → 0.12.56

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.56
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.56
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.56
  */
 import { pikkuState } from '@pikku/core/internal';
 import allWorkflowMeta from './meta/allWorkflow.gen.json' with { type: 'json' };

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.56
  */
 import { addWorkflow } from '@pikku/core/workflow';
 import './pikku-workflow-wirings-meta.gen.js';

package/dist/bin/pikku-bin.mjs

@@ -11,8 +11,8 @@ async function checkForUpdate() {
     })
     if (!res.ok) return
     const { version: latest } = await res.json()
-    if (latest !== '0.12.55') {
-      process.stderr.write(`\n  Update available  0.12.55 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
+    if (latest !== '0.12.56') {
+      process.stderr.write(`\n  Update available  0.12.56 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
     }
   } catch {}
 }

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

@@ -12,6 +12,12 @@ export interface AnalyzerOptions {
     projectId: string;
     /** Services that can't run serverless — functions using them get target: 'server' */
     serverlessIncompatible?: string[];
+    /**
+     * Default deploy target for functions without an explicit `deploy` flag
+     * and no serverless-incompatible service. Sourced from `pikku.config.json`
+     * → `deploy.defaultTarget`. Defaults to 'serverless'.
+     */
+    defaultTarget?: 'serverless' | 'server';
     /**
      * When `true` (default), the analyzer synthesizes a per-workflow
      * orchestrator queue + a per-step queue, plus the matching producer

package/dist/src/deploy/analyzer/analyzer.js

@@ -9,6 +9,7 @@
 import { resolveDeployTarget, } from '@pikku/inspector';
 export function analyzeDeployment(state, options) {
     const serverlessIncompatible = new Set(options.serverlessIncompatible ?? []);
+    const defaultTarget = options.defaultTarget ?? 'serverless';
     const workflowQueues = options.workflowQueues ?? true;
     const units = [];
     const queues = [];
@@ -118,7 +119,7 @@ export function analyzeDeployment(state, options) {
         units.push({
             name: toSafeKebab(funcId),
             role: 'function',
-            target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId),
+            target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
             functionIds: [funcId],
             services: collectServicesForFunction(funcMeta),
             dependsOn: [],
@@ -263,7 +264,7 @@ export function analyzeDeployment(state, options) {
                     units.push({
                         name: dep,
                         role: 'function',
-                        target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId),
+                        target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
                         functionIds: [funcId],
                         services: collectServicesForFunction(funcMeta),
                         dependsOn: [],
@@ -372,10 +373,10 @@ function buildWorkflows(graphMeta, functionsMeta, rpcMeta, _httpMeta, units, wor
                 continue;
             const stepUnitName = toSafeKebab(node.rpcName);
             // Step dispatch is decided per-function: a step runs inline unless its
-            // function opts out with `inline: false` (then it dispatches via queue).
+            // function is marked `workflowQueued: true` (then it dispatches via queue).
             const stepFuncId = rpcMeta[node.rpcName] ?? node.rpcName;
             const stepFuncMeta = functionsMeta[stepFuncId] ?? functionsMeta[node.rpcName];
-            const isInline = stepFuncMeta?.inline !== false;
+            const isInline = stepFuncMeta?.workflowQueued !== true;
             steps.push({
                 name: node.stepName ?? nodeId,
                 inline: isInline,

package/dist/src/deploy/build-pipeline.d.ts

@@ -6,7 +6,8 @@
  */
 import type { InspectorState } from '@pikku/inspector';
 import type { DeploymentManifest } from './analyzer/manifest.js';
-import type { BundleResult } from './bundler/index.js';
+import type { Bundler } from './bundler/bundler.interface.js';
+import type { BundleResult } from './bundler/types.js';
 import type { ProviderAdapter } from './provider-adapter.js';
 export interface BuildLogger {
     info(msg: string): void;
@@ -35,10 +36,13 @@ export declare function runBuildPipeline(options: {
     provider: ProviderAdapter;
     inspectorState: InspectorState;
     serverlessIncompatible?: string[];
+    defaultTarget?: 'serverless' | 'server';
     getEntryContext: (unitDir: string, pikkuDir: string, unit: DeploymentManifest['units'][0], state: InspectorState) => unknown;
     deployDir?: string;
     outDir?: string;
     /** Emit sourcemaps + per-unit `metafile.json` (debug-only). Default false. */
     debugArtifacts?: boolean;
     logger: BuildLogger;
+    /** Runtime-specific bundler (esbuild for node, Bun.build for bun). */
+    bundler: Bundler;
 }): Promise<BuildPipelineResult>;

package/dist/src/deploy/build-pipeline.js

@@ -9,7 +9,6 @@ import { existsSync } from 'node:fs';
 import { mkdir, writeFile, copyFile } from 'node:fs/promises';
 import { analyzeDeployment } from './analyzer/index.js';
 import { generatePerUnitCodegen } from './codegen/per-unit-codegen.js';
-import { bundleUnits } from './bundler/index.js';
 import { generateServerEntrySource, SERVER_DOCKERFILE, SERVER_DOCKERIGNORE, } from './server-entry.js';
 const MERGED_SERVER_UNIT_NAME = 'pikku-server-container';
 const UNITS_DIR_NAME = 'units';
@@ -38,7 +37,7 @@ function findLockfile(projectDir) {
     return null;
 }
 export async function runBuildPipeline(options) {
-    const { projectDir, projectId, provider, inspectorState, getEntryContext, debugArtifacts, logger, } = options;
+    const { projectDir, projectId, provider, inspectorState, getEntryContext, debugArtifacts, logger, bundler, } = options;
     const deployDir = options.deployDir ?? join(projectDir, '.deploy');
     const providerDir = join(deployDir, provider.deployDirName);
     // Step 1: Analyze
@@ -46,6 +45,7 @@ export async function runBuildPipeline(options) {
     const manifest = analyzeDeployment(inspectorState, {
         projectId,
         serverlessIncompatible: options.serverlessIncompatible,
+        defaultTarget: options.defaultTarget,
         workflowQueues,
     });
     let bundled = [];
@@ -79,7 +79,7 @@ export async function runBuildPipeline(options) {
         await writeFile(entryPath, source, 'utf-8');
         const entryFiles = new Map();
         entryFiles.set(unitName, entryPath);
-        const bundleResult = await bundleUnits(projectDir, manifest, entryFiles, providerDir, {
+        const bundleResult = await bundler.bundleUnits(projectDir, manifest, entryFiles, providerDir, {
             externals: provider.getExternals?.(),
             stubModules: provider.getStubModules?.(),
             aliases: provider.getAliases?.(),
@@ -206,7 +206,7 @@ export async function runBuildPipeline(options) {
                 ...manifest,
                 units: manifest.units.filter((u) => u.target !== 'server'),
             };
-            const result = await bundleUnits(projectDir, serverlessManifestForBundle, serverlessEntryFiles, providerDir, {
+            const result = await bundler.bundleUnits(projectDir, serverlessManifestForBundle, serverlessEntryFiles, providerDir, {
                 externals: provider.getExternals?.(),
                 stubModules: provider.getStubModules?.(),
                 aliases: provider.getAliases?.(),
@@ -231,7 +231,7 @@ export async function runBuildPipeline(options) {
                 ...manifest,
                 units: manifest.units.filter((u) => u.target === 'server'),
             };
-            const result = await bundleUnits(projectDir, serverManifestForBundle, serverEntryFiles, providerDir, {
+            const result = await bundler.bundleUnits(projectDir, serverManifestForBundle, serverEntryFiles, providerDir, {
                 externals: ['node:*'],
                 aliases: undefined,
                 define: undefined,

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

@@ -0,0 +1,14 @@
+/**
+ * Bun (Bun.build) bundler backend.
+ *
+ * Used when the CLI runs under Bun (bun projects). Bun resolves its own `.bun`
+ * store / per-workspace symlinks natively — esbuild's `nodePaths` walk assumes a
+ * hoisted root and can't — so no esbuild dependency is needed. Bun's metafile
+ * does NOT record external imports, so externals are captured via the resolve
+ * plugin instead (that capture drives per-unit dependency extraction).
+ */
+import { BaseBundler } from './bundler.js';
+import type { CompileInput, CompileResult } from './bundler.interface.js';
+export declare class BunBundler extends BaseBundler {
+    protected compile(input: CompileInput): Promise<CompileResult>;
+}

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

@@ -0,0 +1,121 @@
+/**
+ * Bun (Bun.build) bundler backend.
+ *
+ * Used when the CLI runs under Bun (bun projects). Bun resolves its own `.bun`
+ * store / per-workspace symlinks natively — esbuild's `nodePaths` walk assumes a
+ * hoisted root and can't — so no esbuild dependency is needed. Bun's metafile
+ * does NOT record external imports, so externals are captured via the resolve
+ * plugin instead (that capture drives per-unit dependency extraction).
+ */
+import { writeFile } from 'node:fs/promises';
+import { BaseBundler } from './bundler.js';
+function getBun() {
+    const bun = globalThis.Bun;
+    if (!bun) {
+        throw new Error('BunBundler used outside the Bun runtime');
+    }
+    return bun;
+}
+const pkgHead = (spec) => spec.startsWith('@')
+    ? spec.split('/').slice(0, 2).join('/')
+    : spec.split('/')[0];
+/**
+ * Unified resolve plugin. Bun resolves its `.bun` store natively, so this plugin
+ * only replicates the option-driven behaviour the esbuild backend gets for free:
+ *   - `aliases`: rewrite bare builtins to their `node:`-prefixed form (CF's
+ *     nodejs_compat_v2 only resolves prefixed imports).
+ *   - stub patterns (dead services + provider `stubModules`): empty module.
+ *   - `externals`: keep external (node:*, cloudflare:*, declared npm deps) and
+ *     CAPTURE the real npm package names — Bun's metafile omits external
+ *     imports, so capture is how per-unit dependency extraction works.
+ */
+function createBunResolvePlugin(opts) {
+    const { aliases, externals, stubPatterns, captured } = opts;
+    const externalMatchers = externals.map((pat) => {
+        if (pat.endsWith('*')) {
+            const prefix = pat.slice(0, -1);
+            return (s) => s.startsWith(prefix);
+        }
+        return (s) => s === pat || s.startsWith(pat + '/');
+    });
+    return {
+        name: 'pikku-bun-resolve',
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, (args) => {
+                let path = args.path;
+                // Relative / absolute → let Bun resolve natively.
+                if (path.startsWith('.') || path.startsWith('/'))
+                    return;
+                // Builtin alias (e.g. crypto → node:crypto).
+                if (aliases && aliases[path])
+                    path = aliases[path];
+                // Dead/stubbed modules → empty module.
+                if (stubPatterns.some((re) => re.test(path))) {
+                    return { path, namespace: 'pikku-stub' };
+                }
+                // node: builtins are always external (covers aliased builtins on CF).
+                if (path.startsWith('node:'))
+                    return { path, external: true };
+                // Provider externals (cloudflare:*, declared npm deps).
+                if (externalMatchers.some((m) => m(path))) {
+                    // Only real npm packages are install-time deps (skip scheme imports).
+                    if (!path.includes(':'))
+                        captured.add(pkgHead(path));
+                    return { path, external: true };
+                }
+                // Everything else → Bun bundles it (resolving the .bun store natively).
+                return;
+            });
+            build.onLoad({ filter: /.*/, namespace: 'pikku-stub' }, () => ({
+                contents: 'export {}',
+                loader: 'js',
+            }));
+        },
+    };
+}
+export class BunBundler extends BaseBundler {
+    async compile(input) {
+        const captured = new Set();
+        const result = await getBun().build({
+            entrypoints: [input.entryPath],
+            target: input.platform === 'node' ? 'node' : 'browser',
+            format: input.format === 'cjs' ? 'cjs' : 'esm',
+            // identifiers:true is safe — pikku's only name-based reflection
+            // (error→status mapping) compares a class against an instance of the SAME
+            // (consistently-renamed) class, and workflow exceptions hardcode their
+            // `.name` string. So full minification preserves correctness.
+            minify: { whitespace: true, syntax: true, identifiers: true },
+            sourcemap: input.sourcemap ? 'external' : 'none',
+            define: input.define,
+            banner: input.bannerJs,
+            external: input.externals,
+            metafile: input.emitMetafile,
+            plugins: [
+                createBunResolvePlugin({
+                    aliases: input.aliases,
+                    externals: input.externals,
+                    stubPatterns: input.deadPatterns,
+                    captured,
+                }),
+            ],
+        });
+        if (!result.success) {
+            throw new Error(`Bun.build failed for unit "${input.unitName}":\n` +
+                result.logs.map((l) => String(l)).join('\n'));
+        }
+        const entryArtifact = result.outputs.find((o) => o.kind === 'entry-point') ?? result.outputs[0];
+        await writeFile(input.bundlePath, await entryArtifact.text(), 'utf-8');
+        if (input.sourcemap) {
+            const mapArtifact = result.outputs.find((o) => o.kind === 'sourcemap');
+            if (mapArtifact) {
+                await writeFile(`${input.bundlePath}.map`, await mapArtifact.text(), 'utf-8');
+            }
+        }
+        return {
+            externalPackages: captured,
+            metafileJson: input.emitMetafile && result.metafile
+                ? JSON.stringify(result.metafile, null, 2)
+                : undefined,
+        };
+    }
+}

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 {};