@pikku/cli 0.12.55 → 0.12.56

package/dist/src/fabric/functions/addon-verify.function.js

@@ -0,0 +1,153 @@
+import { z } from 'zod';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { pikkuSessionlessFunc } from '../../../.pikku/pikku-types.gen.js';
+import { added, removed, dim } from '../lib/output.js';
+const CheckSchema = z.object({
+    name: z.string(),
+    ok: z.boolean(),
+    detail: z.string().optional(),
+});
+export const FabricAddonVerifyInput = z.object({
+    dir: z.string().optional(),
+});
+export const FabricAddonVerifyOutputSchema = z.object({
+    ok: z.boolean(),
+    addonDir: z.string(),
+    packageName: z.string().optional(),
+    version: z.string().optional(),
+    checks: z.array(CheckSchema),
+});
+async function readJsonSafe(path) {
+    if (!existsSync(path))
+        return { ok: false, reason: 'missing' };
+    try {
+        return { ok: true, value: JSON.parse(await readFile(path, 'utf8')) };
+    }
+    catch {
+        return { ok: false, reason: 'invalid' };
+    }
+}
+export const FabricAddonVerify = pikkuSessionlessFunc({
+    description: 'Verify an addon directory is correctly built and ready to publish',
+    input: FabricAddonVerifyInput,
+    output: FabricAddonVerifyOutputSchema,
+    func: async (_services, { dir }) => {
+        const addonDir = resolve(dir ?? process.cwd());
+        const checks = [];
+        const pass = (name, detail) => ({
+            name,
+            ok: true,
+            detail,
+        });
+        const fail = (name, detail) => ({
+            name,
+            ok: false,
+            detail,
+        });
+        const pkgResult = await readJsonSafe(join(addonDir, 'package.json'));
+        if (!pkgResult.ok) {
+            checks.push(fail('package.json', pkgResult.reason === 'missing' ? 'not found' : 'invalid JSON'));
+            return { ok: false, addonDir, checks };
+        }
+        checks.push(pass('package.json'));
+        const pkg = pkgResult.value;
+        if (!pkg.name)
+            checks.push(fail('package name', 'missing name field'));
+        else
+            checks.push(pass('package name', pkg.name));
+        if (!pkg.version)
+            checks.push(fail('package version', 'missing version field'));
+        else
+            checks.push(pass('package version', pkg.version));
+        const hasDistInFiles = pkg.files?.some((f) => f === 'dist' || f === 'dist/' || f.startsWith('dist/'));
+        if (!hasDistInFiles) {
+            checks.push(fail('files field', 'must include "dist" (or "dist/", "dist/**/*")'));
+        }
+        else {
+            checks.push(pass('files field', '"dist" included'));
+        }
+        const pikkuConfigResult = await readJsonSafe(join(addonDir, 'pikku.config.json'));
+        if (!pikkuConfigResult.ok) {
+            checks.push(fail('pikku.config.json', pikkuConfigResult.reason === 'missing' ? 'not found' : 'invalid JSON'));
+        }
+        else if (!pikkuConfigResult.value.addon) {
+            checks.push(fail('pikku.config.json', 'addon: true not set'));
+        }
+        else {
+            checks.push(pass('pikku.config.json', 'addon: true'));
+        }
+        if (!existsSync(join(addonDir, 'dist'))) {
+            checks.push(fail('dist/', 'not found — run build first'));
+            return {
+                ok: false,
+                addonDir,
+                packageName: pkg.name,
+                version: pkg.version,
+                checks,
+            };
+        }
+        checks.push(pass('dist/'));
+        const distPikku = join(addonDir, 'dist', '.pikku');
+        if (!existsSync(distPikku)) {
+            checks.push(fail('dist/.pikku/', 'missing — build script must run `cp -r .pikku dist/`'));
+            return {
+                ok: false,
+                addonDir,
+                packageName: pkg.name,
+                version: pkg.version,
+                checks,
+            };
+        }
+        checks.push(pass('dist/.pikku/'));
+        const funcsMetaResult = await readJsonSafe(join(distPikku, 'function', 'pikku-functions-meta.gen.json'));
+        const funcCount = funcsMetaResult.ok
+            ? Object.keys(funcsMetaResult.value).length
+            : 0;
+        if (funcCount === 0) {
+            checks.push(fail('functions', 'no functions found in dist/.pikku/function/pikku-functions-meta.gen.json'));
+        }
+        else {
+            checks.push(pass('functions', `${funcCount} function${funcCount === 1 ? '' : 's'} exported`));
+        }
+        const schemasDir = join(distPikku, 'schemas', 'schemas');
+        checks.push(pass('schemas dir', existsSync(schemasDir) ? 'present' : 'empty (ok)'));
+        if (!existsSync(join(addonDir, 'README.md'))) {
+            checks.push(fail('README.md', 'missing'));
+        }
+        else {
+            checks.push(pass('README.md'));
+        }
+        const consoleMetaResult = await readJsonSafe(join(distPikku, 'console', 'pikku-addon-meta.gen.json'));
+        const icon = consoleMetaResult.ok
+            ? consoleMetaResult.value.package?.icon
+            : undefined;
+        if (!icon) {
+            checks.push({ name: 'icon', ok: true, detail: 'none (optional)' });
+        }
+        else {
+            checks.push(pass('icon', icon.slice(0, 40)));
+        }
+        const ok = checks.every((c) => c.ok);
+        return { ok, addonDir, packageName: pkg.name, version: pkg.version, checks };
+    },
+});
+export function renderAddonVerify(_s, result) {
+    console.log(`\n${dim('Addon:')} ${result.packageName ?? '(unknown)'}@${result.version ?? '?'}`);
+    console.log(`${dim('Dir:  ')} ${result.addonDir}\n`);
+    for (const c of result.checks) {
+        const icon = c.ok ? added('✓') : removed('✗');
+        const label = c.ok ? c.name : removed(c.name);
+        const detail = c.detail ? `  ${dim(c.detail)}` : '';
+        console.log(`  ${icon} ${label}${detail}`);
+    }
+    console.log('');
+    if (result.ok) {
+        console.log(added('  Ready to publish.'));
+    }
+    else {
+        console.log(removed('  Fix the errors above before publishing.'));
+        process.exitCode = 1;
+    }
+}

package/dist/src/fabric/functions/llm-key.function.js

@@ -30,7 +30,7 @@ export const FabricLLMKey = pikkuSessionlessFunc({
             throw new UnauthorizedError('Not logged in. Run `pikku fabric login` first.');
         }
         const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
-        const result = (await rpc.invoke('getDeveloperLiteLLMKey', {}));
+        const result = await rpc.invoke('getDeveloperLiteLLMKey', {});
         const format = shell
             ? 'shell'
             : env

package/dist/src/fabric/functions/publish.function.js

@@ -29,7 +29,12 @@ export const FabricPublish = pikkuSessionlessFunc({
     description: 'Publish a package directory to the Fabric community registry.',
     input: FabricPublishInput,
     output: FabricPublishOutput,
-    func: async (_services, { dir, apiUrl: apiUrlOverride }) => {
+    func: async (_services, { dir, apiUrl: apiUrlOverride }, { rpc, cli }) => {
+        const verification = await rpc.invoke('FabricAddonVerify', { dir });
+        await cli?.channel.send(verification);
+        if (!verification.ok) {
+            throw new Error('Addon verification failed — fix the errors above before publishing.');
+        }
         const ctx = await resolveApiContext({ apiUrlOverride });
         if (!ctx.token)
             throw new Error('Not logged in. Run `pikku fabric login` first.');
@@ -64,14 +69,14 @@ export const FabricPublish = pikkuSessionlessFunc({
             return r.json();
         };
         // 1. presigned upload URL (short-lived)
-        const { uploadUrl, artifactKey } = await post('/registry/packages/publish-url', { packageName: pkg.name, version: pkg.version });
+        const { uploadUrl, artifactKey } = await post('/registry/addons/publish-url', { packageName: pkg.name, version: pkg.version });
         // 2. PUT the artifact to the exact signed URL (no extra headers — the URL
         //    is signed over host only; mismatched headers break the signature).
         const put = await fetch(uploadUrl, { method: 'PUT', body: artifact });
         if (!put.ok)
             throw new Error(`upload failed → ${put.status}: ${await put.text()}`);
         // 3. finalize — server reads the artifact back, extracts meta, indexes it
-        const entry = await post('/registry/packages/publish', { artifactKey });
+        const entry = await post('/registry/addons/publish', { artifactKey });
         const publisher = entry.publisher?.name ?? null;
         console.log(`[fabric] published ${entry.name}@${entry.version} (id=${entry.id})` +
             (publisher ? ` as ${publisher}` : ''));

package/dist/src/functions/commands/deploy-apply.js

@@ -176,7 +176,7 @@ async function runDeploy(provider, providerDir, logger, resultFile) {
     }
 }
 export const deployApply = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }, data) => {
+    func: async ({ logger, config, getInspectorState, bundler }, data) => {
         const projectDir = config.rootDir;
         const provider = await resolveProvider(config, data?.provider, {
             runtime: data?.runtime,
@@ -209,10 +209,12 @@ export const deployApply = pikkuSessionlessFunc({
             provider,
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
+            defaultTarget: config.deploy?.defaultTarget,
             getEntryContext,
             outDir: config.outDir,
             debugArtifacts: data?.debugArtifacts ?? false,
             logger,
+            bundler,
         });
         if (buildResult.manifest.units.length === 0) {
             logger.info('No deployment units found. Nothing to deploy.');

package/dist/src/functions/commands/deploy-plan.js

@@ -43,7 +43,7 @@ function createEmptyProvider() {
     };
 }
 export const deployPlan = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }, data) => {
+    func: async ({ logger, config, getInspectorState, bundler }, data) => {
         const projectDir = config.rootDir;
         const inspectorState = await getInspectorState(true);
         const projectId = await resolveProjectId(projectDir);
@@ -56,10 +56,12 @@ export const deployPlan = pikkuSessionlessFunc({
             provider,
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
+            defaultTarget: config.deploy?.defaultTarget,
             getEntryContext,
             outDir: config.outDir,
             debugArtifacts: data?.debugArtifacts ?? false,
             logger,
+            bundler,
         });
         if (result.manifest.units.length === 0) {
             logger.info('No deployment units found.');

package/dist/src/functions/commands/dev.js

@@ -7,18 +7,14 @@ import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService,
 import { stopSingletonServices } from '@pikku/core';
 import { pikkuState } from '@pikku/core/internal';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
-import { LocalEventHubService } from '@pikku/core/channel/local';
 import { LocalContent, } from '@pikku/core/services/local-content';
-import { pikkuWebsocketHandler } from '@pikku/ws';
-import { PikkuNodeHTTPServer } from '@pikku/node-http-server';
-import { WebSocketServer } from 'ws';
 import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
 import { createDevAIAgentRunner } from './dev-ai-runner.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables }, { port, watch, hmr }, { rpc }) => {
+    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, watch, hmr }, { rpc }) => {
         const resolvedPort = parseInt(port || '3000', 10);
         const hostname = 'localhost';
         // Bind on IPv4 loopback explicitly. Under Bun, hostname 'localhost' resolves
@@ -174,20 +170,10 @@ export const dev = pikkuSessionlessFunc({
                 variables,
             })
             : undefined;
-        // When the CLI itself runs under bun (e.g. the compiled brew binary), serve
-        // over @pikku/bun-server (native Bun.serve WebSockets) instead of the node
-        // http server + ws package. The bun runtime is dynamically imported so a
-        // node-run CLI never loads it. The same BunEventHubService instance is
-        // shared with the singleton services so function-side broadcasts reach the
-        // sockets the transport holds.
-        const isBun = typeof globalThis.Bun !== 'undefined';
-        const bun = isBun
-            ? await (async () => {
-                const mod = await import('@pikku/bun-server');
-                return { mod, eventHub: new mod.BunEventHubService() };
-            })()
-            : null;
-        const eventHub = bun ? bun.eventHub : new LocalEventHubService();
+        // The dev server runner (node http+ws, or bun-server) is resolved by DI in
+        // services.ts. Its EventHub is shared into the singleton services so
+        // function-side broadcasts reach the sockets the transport holds.
+        const eventHub = await devServerRunner.createEventHub();
         const inMemoryServices = {
             logger: devLogger,
             ...(aiAgentRunner ? { aiAgentRunner } : {}),
@@ -213,29 +199,12 @@ export const dev = pikkuSessionlessFunc({
             ...singletonServices,
             getInspectorState,
         });
-        let wss;
-        let pikkuServer;
-        if (bun) {
-            pikkuServer = new bun.mod.PikkuBunServer({
-                ...userConfig,
-                hostname: bindHostname,
-                port: resolvedPort,
-                content: localContentConfig,
-            }, logger, { eventHub: bun.eventHub });
-        }
-        else {
-            wss = new WebSocketServer({ noServer: true });
-            pikkuServer = new PikkuNodeHTTPServer({
-                ...userConfig,
-                hostname: bindHostname,
-                port: resolvedPort,
-                content: localContentConfig,
-            }, logger, {
-                configureServer: (httpServer) => {
-                    pikkuWebsocketHandler({ server: httpServer, wss: wss, logger });
-                },
-            });
-        }
+        const pikkuServer = devServerRunner.createServer({
+            ...userConfig,
+            hostname: bindHostname,
+            port: resolvedPort,
+            content: localContentConfig,
+        }, logger);
         await pikkuServer.init();
         await schedulerService.start();
         await pikkuServer.start();
@@ -247,9 +216,6 @@ export const dev = pikkuSessionlessFunc({
                 await stopSingletonServices();
                 await configWatcher?.close();
                 await watcher?.close();
-                if (wss) {
-                    await new Promise((resolve, reject) => wss.close((err) => (err ? reject(err) : resolve())));
-                }
                 await pikkuServer.stop();
             }
             finally {

package/dist/src/functions/db/db-codegen.js

@@ -191,6 +191,20 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
         const typeAnn = typingKind || effectiveTsType
             ? { kind: typingKind, tsType: effectiveTsType }
             : null;
+        // JSON/JSONB columns carry no inherent TypeScript shape — without a
+        // concrete `tsType` they degrade to `unknown`, erasing type-safety at
+        // every call site. Warn (non-blocking) so an AI or developer can give the
+        // column a real type. An explicit `tsType: 'unknown'`/`'any'` is allowed
+        // (the developer has acknowledged it) but is still flagged as discouraged.
+        const isJsonColumn = col.type.toUpperCase().includes('JSON') || ann?.kind === 'json';
+        if (isJsonColumn) {
+            const resolved = selectBase(typeAnn, col);
+            if (resolved === 'unknown' || resolved === 'any') {
+                warnings.push(`Column "${bare}.${col.name}" is ${col.type} and will be typed as ` +
+                    `\`${resolved}\` — JSON/JSONB columns need a concrete TypeScript type. ` +
+                    `In db/annotations.ts add: "${col.name}": { kind: 'json', tsType: 'YourType' }.`);
+            }
+        }
         // A `format` validator refines the zod schema only and keeps the TS type
         // as `string`. It therefore applies only when the resolved select base is
         // plain `string`; on anything else (Date/Uuid/boolean/enum/unknown via

package/dist/src/functions/wirings/functions/serialize-function-types.js

@@ -372,26 +372,14 @@ export type PikkuFunctionConfigWithSchema<
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * Supports two patterns:
- * 1. Generic types: \`pikkuFunc<Input, Output>({ func: ... })\`
- * 2. Zod schemas: \`pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })\`
+ * Define the input and output with Zod schemas — the function's types are
+ * inferred from them, and the schemas double as runtime validation.
  *
- * @template In - Input type for the function (inferred from schema if provided)
- * @template Out - Output type for the function (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
+ * @param config - Function definition with \`input\`/\`output\` Zod schemas and \`func\`.
  * @returns The normalized configuration object
  *
  * @example
  * \`\`\`typescript
- * // Pattern 1: Using generic types
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
- *   func: async ({db}, input) => {
- *     const user = await db.users.create(input)
- *     return { id: user.id }
- *   }
- * })
- *
- * // Pattern 2: Using Zod schemas (types inferred automatically)
  * const createUserInput = z.object({ name: z.string(), email: z.string() })
  * const createUserOutput = z.object({ id: z.number() })
  *
@@ -483,25 +471,14 @@ export type PikkuFunctionSessionlessConfigWithSchema<
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * Supports two patterns:
- * 1. Generic types: \`pikkuSessionlessFunc<Input, Output>({ func: ... })\`
- * 2. Zod schemas: \`pikkuSessionlessFunc({ input: z.object(...), func: ... })\`
+ * Define the input and output with Zod schemas — the function's types are
+ * inferred from them, and the schemas double as runtime validation.
  *
- * @template In - Input type for the function (inferred from schema if provided)
- * @template Out - Output type for the function (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
+ * @param config - Function definition with \`input\`/\`output\` Zod schemas and \`func\`.
  * @returns The normalized configuration object
  *
  * @example
  * \`\`\`typescript
- * // Pattern 1: Using generic types
- * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
- *   func: async ({logger}) => {
- *     return { status: 'healthy' }
- *   }
- * })
- *
- * // Pattern 2: Using Zod schemas
  * const greetInput = z.object({ name: z.string() })
  * const greetOutput = z.object({ message: z.string() })
  *

package/dist/src/server/bun-server-runner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bun dev server runner — `@pikku/bun-server` (native `Bun.serve` WebSockets).
+ * Used when the CLI runs under Bun. The bun-server module is dynamically
+ * imported so a node-run CLI never loads its bun-only code; types are pulled via
+ * `import type` (erased at runtime). The same BunEventHubService instance is
+ * shared with singleton services so function-side broadcasts reach the sockets
+ * the transport holds.
+ */
+import type { EventHubService } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
+import type { DevServerRunner, DevServerInstance, DevServerConfig } from './dev-server-runner.interface.js';
+export declare class BunServerRunner implements DevServerRunner {
+    private mod?;
+    private eventHub?;
+    createEventHub(): Promise<EventHubService<any>>;
+    createServer(config: DevServerConfig, logger: Logger): DevServerInstance;
+}

package/dist/src/server/bun-server-runner.js

@@ -0,0 +1,25 @@
+/**
+ * Bun dev server runner — `@pikku/bun-server` (native `Bun.serve` WebSockets).
+ * Used when the CLI runs under Bun. The bun-server module is dynamically
+ * imported so a node-run CLI never loads its bun-only code; types are pulled via
+ * `import type` (erased at runtime). The same BunEventHubService instance is
+ * shared with singleton services so function-side broadcasts reach the sockets
+ * the transport holds.
+ */
+export class BunServerRunner {
+    mod;
+    eventHub;
+    async createEventHub() {
+        this.mod = await import('@pikku/bun-server');
+        this.eventHub = new this.mod.BunEventHubService();
+        return this.eventHub;
+    }
+    createServer(config, logger) {
+        if (!this.mod || !this.eventHub) {
+            throw new Error('createEventHub() must be called before createServer()');
+        }
+        return new this.mod.PikkuBunServer(config, logger, {
+            eventHub: this.eventHub,
+        });
+    }
+}

package/dist/src/server/dev-server-runner.interface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Dev server runner abstraction.
+ *
+ * The `pikku dev` server differs by runtime: under Node it's
+ * `@pikku/node-http-server` + the `ws` WebSocketServer; under Bun it's
+ * `@pikku/bun-server` (native `Bun.serve` WebSockets). Both also supply the
+ * EventHub that is shared into singleton services so function-side broadcasts
+ * reach the transport's sockets. The right runner is resolved once in
+ * `services.ts` and injected — no `typeof Bun` checks in the dev command.
+ */
+import type { EventHubService } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
+import type { NodeHTTPServerConfig } from '@pikku/node-http-server';
+export interface DevServerInstance {
+    init(): Promise<void>;
+    start(): Promise<void>;
+    /** Full teardown — closes the server and any owned WebSocket server. */
+    stop(): Promise<void>;
+}
+/** Config shape both runtimes accept (Core config + host/port/content). */
+export type DevServerConfig = NodeHTTPServerConfig;
+export interface DevServerRunner {
+    /**
+     * Create the EventHub for this runtime. Shared into singleton services so
+     * function-side broadcasts reach the transport's sockets. Must be called
+     * once before `createServer`.
+     */
+    createEventHub(): Promise<EventHubService<any>>;
+    /** Create the dev HTTP/WS server. Must be called after `createEventHub`. */
+    createServer(config: DevServerConfig, logger: Logger): DevServerInstance;
+}

package/dist/src/server/dev-server-runner.interface.js

@@ -0,0 +1,11 @@
+/**
+ * Dev server runner abstraction.
+ *
+ * The `pikku dev` server differs by runtime: under Node it's
+ * `@pikku/node-http-server` + the `ws` WebSocketServer; under Bun it's
+ * `@pikku/bun-server` (native `Bun.serve` WebSockets). Both also supply the
+ * EventHub that is shared into singleton services so function-side broadcasts
+ * reach the transport's sockets. The right runner is resolved once in
+ * `services.ts` and injected — no `typeof Bun` checks in the dev command.
+ */
+export {};

package/dist/src/server/node-server-runner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Node dev server runner — `@pikku/node-http-server` + the `ws` WebSocketServer.
+ * Used when the CLI runs under Node. Owns the WebSocketServer so teardown
+ * (close ws then the http server) is encapsulated in the returned instance.
+ */
+import type { EventHubService } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
+import type { DevServerRunner, DevServerInstance, DevServerConfig } from './dev-server-runner.interface.js';
+export declare class NodeServerRunner implements DevServerRunner {
+    createEventHub(): Promise<EventHubService<any>>;
+    createServer(config: DevServerConfig, logger: Logger): DevServerInstance;
+}

package/dist/src/server/node-server-runner.js

@@ -0,0 +1,30 @@
+/**
+ * Node dev server runner — `@pikku/node-http-server` + the `ws` WebSocketServer.
+ * Used when the CLI runs under Node. Owns the WebSocketServer so teardown
+ * (close ws then the http server) is encapsulated in the returned instance.
+ */
+import { LocalEventHubService } from '@pikku/core/channel/local';
+import { PikkuNodeHTTPServer } from '@pikku/node-http-server';
+import { pikkuWebsocketHandler } from '@pikku/ws';
+import { WebSocketServer } from 'ws';
+export class NodeServerRunner {
+    async createEventHub() {
+        return new LocalEventHubService();
+    }
+    createServer(config, logger) {
+        const wss = new WebSocketServer({ noServer: true });
+        const server = new PikkuNodeHTTPServer(config, logger, {
+            configureServer: (httpServer) => {
+                pikkuWebsocketHandler({ server: httpServer, wss, logger });
+            },
+        });
+        return {
+            init: () => server.init(),
+            start: () => server.start(),
+            stop: async () => {
+                await new Promise((resolve, reject) => wss.close((err) => (err ? reject(err) : resolve())));
+                await server.stop();
+            },
+        };
+    }
+}

package/dist/src/services.js

@@ -11,6 +11,10 @@ import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { loadManifest } from './utils/contract-versions.js';
 import { join } from 'path';
+import { NodeBundler } from './deploy/bundler/node-bundler.js';
+import { BunBundler } from './deploy/bundler/bun-bundler.js';
+import { NodeServerRunner } from './server/node-server-runner.js';
+import { BunServerRunner } from './server/bun-server-runner.js';
 import { parseCLIFilters } from './utils/parse-cli-filters.js';
 const DIAGNOSTIC_CODE_TO_LINT_KEY = {
     [ErrorCode.SERVICES_NOT_DESTRUCTURED]: 'servicesNotDestructured',
@@ -274,6 +278,10 @@ export const createSingletonServices = async (config) => {
         return filteredState;
     };
     const workflowService = new InMemoryWorkflowService();
+    // Resolve the runtime ONCE here, then inject runtime-specific implementations.
+    // Keeping the check in this single place avoids `typeof Bun` branches leaking
+    // into the deploy pipeline / dev command.
+    const isBun = typeof globalThis.Bun !== 'undefined';
     return {
         config,
         logger,
@@ -282,6 +290,8 @@ export const createSingletonServices = async (config) => {
         audit: new NoopAuditService(),
         getInspectorState,
         workflowService,
+        bundler: isBun ? new BunBundler() : new NodeBundler(),
+        devServerRunner: isBun ? new BunServerRunner() : new NodeServerRunner(),
     };
 };
 export const createWireServices = async ({ logger }, { cli, channel }) => {

package/dist/src/utils/parse-cli-filters.d.ts

@@ -13,6 +13,7 @@ export type CLIFilters = InspectorFilters & {
 export declare function parseCLIFilters(data: any, cliConfig?: {
     deploy?: {
         serverlessIncompatible?: string[];
+        defaultTarget?: 'serverless' | 'server';
     };
     namedFilters?: Record<string, InspectorFilters>;
 }): CLIFilters;

package/dist/src/utils/parse-cli-filters.js

@@ -94,6 +94,7 @@ export function parseCLIFilters(data, cliConfig) {
     filters.excludeTarget = validateTargetList(filters.excludeTarget, '--exclude-target');
     if (filters.target || filters.excludeTarget) {
         filters.serverlessIncompatible = cliConfig?.deploy?.serverlessIncompatible;
+        filters.defaultTarget = cliConfig?.deploy?.defaultTarget;
     }
     return filters;
 }