@pikku/cli 0.12.68 → 0.12.70

package/dist/src/functions/commands/bun-coverage-loader.js

@@ -0,0 +1,42 @@
+import { readFile } from 'node:fs/promises';
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const shouldInstrument = (path) => !path.includes('/node_modules/') &&
+    !path.includes('/.pikku/') &&
+    !/\.(gen|test|d)\.tsx?$/.test(path);
+/**
+ * Registers a Bun loader plugin that runs istanbul-lib-instrument over the
+ * project's TypeScript sources so `__coverage__` counters exist at runtime.
+ * Bun has no V8 precise coverage (`node:inspector` throws "Coverage APIs are
+ * not supported"), so instrumentation at load time is the coverage backend
+ * there. Must be called before the user bootstrap is imported.
+ */
+export async function registerBunCoverageLoader({ rootDir, }) {
+    const bun = globalThis.Bun;
+    if (!bun) {
+        throw new Error('registerBunCoverageLoader called outside Bun');
+    }
+    const { createInstrumenter } = await import('istanbul-lib-instrument');
+    const instrumenter = createInstrumenter({
+        esModules: true,
+        compact: false,
+        parserPlugins: [
+            'typescript',
+            'importAttributes',
+            'topLevelAwait',
+            'decorators-legacy',
+        ],
+    });
+    const filter = new RegExp(`^${escapeRegExp(rootDir)}/.*\\.tsx?$`);
+    bun.plugin({
+        name: 'pikku-istanbul-coverage',
+        setup(build) {
+            build.onLoad({ filter }, async (args) => {
+                if (!shouldInstrument(args.path))
+                    return undefined;
+                const source = await readFile(args.path, 'utf-8');
+                const contents = instrumenter.instrumentSync(source, args.path);
+                return { contents, loader: args.path.endsWith('.tsx') ? 'tsx' : 'ts' };
+            });
+        },
+    });
+}

package/dist/src/functions/commands/dev.d.ts

@@ -2,15 +2,18 @@ export declare const dev: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-    console?: string | boolean;
+    coverage?: boolean;
+    test?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-    console?: string | boolean;
+    coverage?: boolean;
+    test?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-    console?: string | boolean;
+    coverage?: boolean;
+    test?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -2,7 +2,7 @@ import { join, resolve } from 'path';
 import { pikkuSessionlessFunc } from '#pikku';
 import chokidar from 'chokidar';
 import { pikkuDevReloader } from '@pikku/core/dev';
-import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { ConsoleLogger, LocalEmailService, spy, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
 import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
 import { pikkuState } from '@pikku/core/internal';
@@ -11,11 +11,19 @@ import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+import { startCoverageService } from './start-coverage.js';
 import { createDevAIAgentRunner } from './dev-ai-runner.js';
-import { startConsoleServer } from './serve-console.js';
+import { resolveConsoleMount } from './serve-console.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, watch, hmr, console: consoleFlag }, { rpc }) => {
+    func: async ({ logger, config, getInspectorState, invalidateInspectorState, variables, devServerRunner, }, { port, watch, hmr, coverage, test }, { rpc }) => {
+        process.env.PIKKU_DEV_QUICK_LOGIN ??= 'true';
+        if (test) {
+            process.env.PIKKU_TEST_RUN = 'true';
+        }
+        const coverageService = coverage
+            ? await startCoverageService(logger, config.rootDir)
+            : undefined;
         const resolvedPort = parseInt(port || '3000', 10);
         const hostname = 'localhost';
         // Bind on IPv4 loopback explicitly. Under Bun, hostname 'localhost' resolves
@@ -177,8 +185,11 @@ export const dev = pikkuSessionlessFunc({
         const inMemoryServices = {
             logger: devLogger,
             ...(aiAgentRunner ? { aiAgentRunner } : {}),
-            emailService: new LocalEmailService(),
+            emailService: test
+                ? spy('emailService', new LocalEmailService())
+                : new LocalEmailService(),
             metaService: new LocalMetaService(pikkuDir),
+            ...(coverageService ? { coverageService } : {}),
             schedulerService,
             queueService: new InMemoryQueueService(),
             workflowService,
@@ -195,7 +206,11 @@ export const dev = pikkuSessionlessFunc({
             ...inMemoryServices,
             getInspectorState,
         });
-        const resolvedServices = { ...singletonServices, getInspectorState };
+        const resolvedServices = {
+            ...singletonServices,
+            getInspectorState,
+            ...(coverageService ? { coverageService } : {}),
+        };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
@@ -205,20 +220,22 @@ export const dev = pikkuSessionlessFunc({
             const m = await loadUserModule(serverLifecycleFactory.file);
             return m[serverLifecycleFactory.variable];
         };
+        const consoleMount = await resolveConsoleMount();
         const pikkuServer = devServerRunner.createServer({
             ...userConfig,
             hostname: bindHostname,
             port: resolvedPort,
             content: localContentConfig,
+            ...(consoleMount ? { staticMounts: [consoleMount] } : {}),
         }, logger);
         const lifecycle = await loadLifecycle();
         await pikkuServer.init();
         await lifecycle?.beforeStart?.(resolvedServices);
         await pikkuServer.start();
         await lifecycle?.afterStart?.(resolvedServices);
-        const consoleServer = consoleFlag
-            ? await startConsoleServer(consoleFlag, hostname, logger)
-            : undefined;
+        if (consoleMount) {
+            logger.info(`Pikku Console available at http://${hostname}:${resolvedPort}${consoleMount.urlPrefix}`);
+        }
         let configWatcher;
         let watcher;
         process.once('SIGINT', async () => {
@@ -229,7 +246,6 @@ export const dev = pikkuSessionlessFunc({
                 await configWatcher?.close();
                 await watcher?.close();
                 await pikkuServer.stop();
-                consoleServer?.close();
                 await lifecycle?.afterStop?.(resolvedServices);
             }
             finally {
@@ -259,6 +275,7 @@ export const dev = pikkuSessionlessFunc({
                     const handle = async () => {
                         try {
                             const start = Date.now();
+                            invalidateInspectorState();
                             await runAllWithCommandState();
                             workflowService.wireQueueWorkers();
                             logger.info({

package/dist/src/functions/commands/{user-flow.d.ts → scenario.d.ts}

@@ -1,14 +1,17 @@
-export declare const userFlowList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
-export declare const userFlowRun: import("#pikku").PikkuFunctionConfig<{
+export declare const scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
     tags?: string;
+    coverage?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     environment: string;
     flows?: string;
     tags?: string;
+    coverage?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     environment: string;
     flows?: string;
     tags?: string;
+    coverage?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/{user-flow.js → scenario.js}

@@ -1,23 +1,24 @@
-import { resolve } from 'path';
+import { resolve, join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
-import { InMemoryWorkflowService, createHttpUserFlowActors, } from '@pikku/core/services';
+import { InMemoryWorkflowService, createHttpScenarioActors, } from '@pikku/core/services';
 import { pikkuState } from '@pikku/core/internal';
 import { loadUserBootstrap } from './load-user-project.js';
-const isUserFlow = (wf) => wf?.userFlow === true;
-const listUserFlows = (state) => Object.entries(state.workflows?.meta ?? {})
-    .filter(([, wf]) => isUserFlow(wf))
+const isScenario = (wf) => wf?.scenario === true;
+const listScenarios = (state) => Object.entries(state.workflows?.meta ?? {})
+    .filter(([, wf]) => isScenario(wf))
     .map(([id, wf]) => ({
     id,
     name: wf.name ?? id,
     description: wf.description ?? wf.summary ?? wf.title ?? null,
     tags: wf.tags ?? [],
 }));
-export const userFlowList = pikkuSessionlessFunc({
+export const scenarioList = pikkuSessionlessFunc({
     func: async ({ logger, getInspectorState }) => {
         const state = await getInspectorState();
-        const flows = listUserFlows(state);
+        const flows = listScenarios(state);
         if (flows.length === 0) {
-            logger.info('No user flows found (pikkuUserFlow exports).');
+            logger.info('No scenarios found (pikkuScenario exports).');
             return;
         }
         for (const flow of flows) {
@@ -29,26 +30,24 @@ export const userFlowList = pikkuSessionlessFunc({
         }
     },
 });
-export const userFlowRun = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, tags }) => {
+export const scenarioRun = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, tags, coverage }) => {
         const state = await getInspectorState(true);
-        // --- resolve the target environment ---
-        const environments = config.userFlows?.environments ?? {};
+        const environments = config.scenarios?.environments ?? {};
         const env = environments[environment];
         if (!env) {
             const known = Object.keys(environments);
-            throw new Error(`Unknown user-flow environment '${environment}'. ` +
+            throw new Error(`Unknown scenario environment '${environment}'. ` +
                 (known.length
                     ? `Configured environments: ${known.join(', ')}`
-                    : `Add userFlows.environments to pikku.config.json, e.g. { "${environment}": { "apiUrl": "https://app.example.com/api" } }`));
+                    : `Add scenarios.environments to pikku.config.json, e.g. { "${environment}": { "apiUrl": "https://app.example.com/api" } }`));
         }
-        // --- select flows ---
-        let selected = listUserFlows(state);
+        let selected = listScenarios(state);
         if (flows) {
             const names = new Set(flows.split(',').map((f) => f.trim()));
             const unknown = [...names].filter((n) => !selected.some((f) => f.name === n));
             if (unknown.length) {
-                throw new Error(`Unknown user flow(s): ${unknown.join(', ')}. Available: ${selected.map((f) => f.name).join(', ')}`);
+                throw new Error(`Unknown scenario(s): ${unknown.join(', ')}. Available: ${selected.map((f) => f.name).join(', ')}`);
             }
             selected = selected.filter((f) => names.has(f.name));
         }
@@ -57,27 +56,22 @@ export const userFlowRun = pikkuSessionlessFunc({
             selected = selected.filter((f) => wanted.some((t) => f.tags.includes(t)));
         }
         if (selected.length === 0) {
-            logger.error('No user flows matched.');
+            logger.error('No scenarios matched.');
             process.exitCode = 1;
             return;
         }
-        // --- actors: registry from config, secret STRICTLY from env ---
-        const secret = await variables.get('USER_FLOW_ACTOR_SECRET');
+        const secret = await variables.get('SCENARIO_ACTOR_SECRET');
         if (!secret) {
-            throw new Error('USER_FLOW_ACTOR_SECRET is not set — user-flow actors cannot sign in. ' +
+            throw new Error('SCENARIO_ACTOR_SECRET is not set — scenario actors cannot sign in. ' +
                 'Export it in the environment running this command (never put it in pikku.config.json).');
         }
-        const actors = createHttpUserFlowActors({
+        const actors = createHttpScenarioActors({
             apiUrl: env.apiUrl,
             secret,
-            actors: config.userFlows?.actors ?? {},
+            actors: config.scenarios?.actors ?? {},
             signInPath: env.signInPath,
             rpcPath: env.rpcPath,
         });
-        // --- load the project's generated bootstrap so flows are registered.
-        // Deliberately NO user services: flows may only use logger/config
-        // (inspector-enforced), and internal rpc dispatch is refused below so a
-        // run against staging/production can never touch local services.
         await loadUserBootstrap(resolve(config.rootDir, config.outDir));
         const workflowService = new InMemoryWorkflowService();
         pikkuState(null, 'package', 'singletonServices', {
@@ -87,15 +81,44 @@ export const userFlowRun = pikkuSessionlessFunc({
         });
         const guardRpc = {
             rpcWithWire: async (rpcName) => {
-                throw new Error(`User flow tried to run '${rpcName}' as an internal step. Every workflow.do ` +
-                    `in a user flow must carry { actor: actors.x } so it executes against ` +
+                throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
+                    `in a scenario must carry { actor: actors.x } so it executes against ` +
                     `'${environment}' (${env.apiUrl}), not local services.`);
             },
         };
-        // --- run sequentially: flows are stories; parallel actors would share cookie jars ---
         const results = [];
+        const coverageActor = coverage ? Object.values(actors)[0] : undefined;
+        let coverageActive = Boolean(coverageActor);
+        if (coverage && !coverageActor) {
+            logger.warn('--coverage requires at least one configured actor — skipping coverage.');
+        }
+        const scenarioCoverage = {};
+        const invokeCoverage = async (rpcName) => {
+            if (!coverageActive || !coverageActor)
+                return null;
+            try {
+                return await coverageActor.invoke(rpcName, null);
+            }
+            catch (e) {
+                coverageActive = false;
+                logger.warn(`Coverage disabled — '${rpcName}' failed against '${environment}': ${e?.message ?? e}. ` +
+                    `Is the server running with --coverage and the console addon wired?`);
+                return null;
+            }
+        };
         for (const flow of selected) {
             const startedAt = Date.now();
+            if (coverageActive) {
+                const reset = await invokeCoverage('console:resetLiveCoverage');
+                if (reset && reset.enabled === false) {
+                    coverageActive = false;
+                    logger.warn(`Coverage disabled — '${environment}' is not collecting (start the server with --coverage).`);
+                }
+            }
+            try {
+                await coverageActor?.invoke('console:resetStubs', null);
+            }
+            catch { }
             try {
                 const { runId } = await workflowService.startWorkflow(flow.name, undefined, { type: 'cli' }, guardRpc, { actors });
                 const run = await workflowService.getRun(runId);
@@ -124,8 +147,26 @@ export const userFlowRun = pikkuSessionlessFunc({
                     error: e?.message ?? String(e),
                 });
             }
+            if (coverageActive) {
+                const report = await invokeCoverage('console:takeLiveCoverage');
+                if (report) {
+                    scenarioCoverage[flow.name] = report;
+                    const covered = report.functions?.filter((f) => f.status === 'covered' || f.status === 'partial');
+                    logger.info(`  coverage: ${covered?.length ?? 0}/${report.summary?.total ?? 0} functions exercised by '${flow.name}'`);
+                }
+            }
+        }
+        if (coverage && Object.keys(scenarioCoverage).length > 0) {
+            const coverageDir = join(resolve(config.rootDir, config.outDir), 'coverage');
+            mkdirSync(coverageDir, { recursive: true });
+            const outFile = join(coverageDir, 'scenario-coverage.json');
+            writeFileSync(outFile, JSON.stringify({
+                generatedAt: new Date().toISOString(),
+                environment,
+                scenarios: scenarioCoverage,
+            }, null, 2) + '\n');
+            logger.info(`Scenario coverage → ${outFile}`);
         }
-        // --- report ---
         const failed = results.filter((r) => r.status === 'failed');
         for (const r of results) {
             if (r.status === 'passed') {
@@ -135,7 +176,7 @@ export const userFlowRun = pikkuSessionlessFunc({
                 logger.error(`FAIL ${r.name} (${r.durationMs}ms): ${r.error}`);
             }
         }
-        logger.info(`${results.length - failed.length}/${results.length} user flows passed against '${environment}'`);
+        logger.info(`${results.length - failed.length}/${results.length} scenarios passed against '${environment}'`);
         if (failed.length > 0) {
             process.exitCode = 1;
         }

package/dist/src/functions/commands/serve-console.d.ts

@@ -1,4 +1,3 @@
-import { createServer } from 'http';
-import type { Logger } from '@pikku/core/services';
+import type { StaticMount } from '@pikku/node-http-server';
 export declare function resolveConsoleDir(): string;
-export declare function startConsoleServer(consoleFlag: string | boolean, hostname: string, logger: Logger): Promise<ReturnType<typeof createServer> | undefined>;
+export declare function resolveConsoleMount(): Promise<StaticMount | undefined>;

package/dist/src/functions/commands/serve-console.js

@@ -1,62 +1,16 @@
-import { createServer } from 'http';
-import { readFile, stat } from 'fs/promises';
-import { join, extname } from 'path';
+import { stat } from 'fs/promises';
+import { join } from 'path';
 import { fileURLToPath } from 'url';
-const MIME_TYPES = {
-    '.html': 'text/html',
-    '.js': 'application/javascript',
-    '.css': 'text/css',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.svg': 'image/svg+xml',
-    '.ico': 'image/x-icon',
-    '.webmanifest': 'application/manifest+json',
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-    '.ttf': 'font/ttf',
-    '.map': 'application/json',
-};
 export function resolveConsoleDir() {
     return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'console-app');
 }
-export async function startConsoleServer(consoleFlag, hostname, logger) {
+export async function resolveConsoleMount() {
     const consoleDir = resolveConsoleDir();
-    const consolePort = typeof consoleFlag === 'string' ? parseInt(consoleFlag, 10) : 51442;
     try {
-        await stat(consoleDir);
+        await stat(join(consoleDir, 'index.html'));
     }
     catch {
-        logger.error('Console app not found. Please rebuild @pikku/cli with the console app bundled.');
         return undefined;
     }
-    const server = createServer(async (req, res) => {
-        const url = new URL(req.url || '/', `http://localhost:${consolePort}`);
-        let filePath = join(consoleDir, url.pathname);
-        try {
-            const s = await stat(filePath);
-            if (s.isDirectory())
-                filePath = join(filePath, 'index.html');
-        }
-        catch {
-            filePath = join(consoleDir, 'index.html');
-        }
-        try {
-            const content = await readFile(filePath);
-            const contentType = MIME_TYPES[extname(filePath)] || 'application/octet-stream';
-            res.writeHead(200, { 'Content-Type': contentType });
-            res.end(content);
-        }
-        catch {
-            res.writeHead(404, { 'Content-Type': 'text/plain' });
-            res.end('Not Found');
-        }
-    });
-    await new Promise((resolve, reject) => {
-        server.listen(consolePort, () => {
-            logger.info(`Pikku Console running at http://${hostname}:${consolePort}`);
-            resolve();
-        });
-        server.on('error', reject);
-    });
-    return server;
+    return { urlPrefix: '/console', directory: consoleDir, spaFallback: true };
 }

package/dist/src/functions/commands/serve.d.ts

@@ -1,10 +1,10 @@
 export declare const serve: import("#pikku").PikkuFunctionConfig<{
     port?: string;
-    console?: string | boolean;
+    console?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
-    console?: string | boolean;
+    console?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
-    console?: string | boolean;
+    console?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -10,10 +10,11 @@ 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';
-import { startConsoleServer } from './serve-console.js';
+import { resolveConsoleMount } from './serve-console.js';
 export const serve = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, console: consoleFlag }) => {
+    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, console: serveConsole }) => {
+        process.env.PIKKU_DEV_QUICK_LOGIN ??= 'true';
         const resolvedPort = parseInt(port || '3000', 10);
         const hostname = 'localhost';
         const bindHostname = '127.0.0.1';
@@ -101,7 +102,10 @@ export const serve = pikkuSessionlessFunc({
             ...inMemoryServices,
             getInspectorState,
         });
-        const resolvedServices = { ...singletonServices, getInspectorState };
+        const resolvedServices = {
+            ...singletonServices,
+            getInspectorState,
+        };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
@@ -111,27 +115,31 @@ export const serve = pikkuSessionlessFunc({
             const m = await loadUserModule(serverLifecycleFactory.file);
             return m[serverLifecycleFactory.variable];
         };
+        const consoleMount = serveConsole ? await resolveConsoleMount() : undefined;
+        if (serveConsole && !consoleMount) {
+            logger.warn('Console app not found. Please rebuild @pikku/cli with the console app bundled.');
+        }
         const pikkuServer = devServerRunner.createServer({
             ...userConfig,
             hostname: bindHostname,
             port: resolvedPort,
             content: localContentConfig,
+            ...(consoleMount ? { staticMounts: [consoleMount] } : {}),
         }, logger);
         const lifecycle = await loadLifecycle();
         await pikkuServer.init();
         await lifecycle?.beforeStart?.(resolvedServices);
         await pikkuServer.start();
         await lifecycle?.afterStart?.(resolvedServices);
-        const consoleServer = consoleFlag
-            ? await startConsoleServer(consoleFlag, hostname, logger)
-            : undefined;
+        if (consoleMount) {
+            logger.info(`Pikku Console available at http://${hostname}:${resolvedPort}${consoleMount.urlPrefix}`);
+        }
         process.once('SIGINT', async () => {
             logger.info('Stopping server...');
             try {
                 await lifecycle?.beforeStop?.(resolvedServices);
                 await stopSingletonServices();
                 await pikkuServer.stop();
-                consoleServer?.close();
                 await lifecycle?.afterStop?.(resolvedServices);
             }
             finally {

package/dist/src/functions/commands/start-coverage.d.ts

@@ -0,0 +1,13 @@
+import { type CoverageService } from '@pikku/core/services';
+interface CoverageLogger {
+    info(message: string): void;
+    warn(message: string): void;
+}
+/**
+ * Starts the coverage backend for `pikku dev --coverage`: V8 precise coverage
+ * on Node, istanbul load-time instrumentation on Bun. Must run before the
+ * user bootstrap is imported so the Bun loader plugin sees every module.
+ * Returns undefined (with a warning) when no backend is available.
+ */
+export declare function startCoverageService(logger: CoverageLogger, rootDir: string): Promise<CoverageService | undefined>;
+export {};

package/dist/src/functions/commands/start-coverage.js

@@ -0,0 +1,26 @@
+import { V8CoverageService, IstanbulCoverageService, } from '@pikku/core/services';
+import { registerBunCoverageLoader } from './bun-coverage-loader.js';
+const isBunRuntime = () => typeof globalThis.Bun !== 'undefined';
+/**
+ * Starts the coverage backend for `pikku dev --coverage`: V8 precise coverage
+ * on Node, istanbul load-time instrumentation on Bun. Must run before the
+ * user bootstrap is imported so the Bun loader plugin sees every module.
+ * Returns undefined (with a warning) when no backend is available.
+ */
+export async function startCoverageService(logger, rootDir) {
+    if (isBunRuntime()) {
+        await registerBunCoverageLoader({ rootDir });
+        logger.info('Istanbul coverage enabled (Bun) — snapshot via console:takeLiveCoverage, reset via console:resetLiveCoverage');
+        return new IstanbulCoverageService();
+    }
+    const coverageService = new V8CoverageService();
+    try {
+        await coverageService.start();
+        logger.info('V8 precise coverage enabled — snapshot via console:takeLiveCoverage, reset via console:resetLiveCoverage');
+        return coverageService;
+    }
+    catch (e) {
+        logger.warn(`V8 precise coverage is not supported on this runtime — continuing without coverage: ${e instanceof Error ? e.message : e}`);
+        return undefined;
+    }
+}

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

@@ -3,7 +3,7 @@ import chokidar from 'chokidar';
 import { pikkuDevReloader } from '@pikku/core/dev';
 export const watch = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config }, { hmr }, { rpc }) => {
+    func: async ({ logger, config, invalidateInspectorState }, { hmr }, { rpc }) => {
         const watchDirectories = [
             ...new Set([config.emailTemplatesDir, ...config.srcDirectories].filter(Boolean)),
         ];
@@ -29,6 +29,7 @@ export const watch = pikkuSessionlessFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
+                        invalidateInspectorState();
                         await rpc.invoke('all');
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,

package/dist/src/functions/wirings/workflow/pikku-command-workflow.js

@@ -3,7 +3,7 @@ import { ErrorCode } from '@pikku/inspector';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeWorkflowTypes } from './serialize-workflow-types.js';
-import { serializeUserFlowActors } from './serialize-user-flow-actors.js';
+import { serializeScenarioActors } from './serialize-scenario-actors.js';
 import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
 import { serializeWorkflowMap } from './serialize-workflow-map.js';
 import { serializeWorkflowBootstrapMap } from './serialize-workflow-bootstrap-map.js';
@@ -63,13 +63,14 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
-        const userFlowActors = config.userFlows?.actors;
-        if (userFlowActors && Object.keys(userFlowActors).length > 0) {
-            await writeFileInDir(logger, config.userFlowActorsFile, serializeUserFlowActors(userFlowActors));
+        const scenarioActors = config.scenarios?.actors;
+        if (scenarioActors && Object.keys(scenarioActors).length > 0) {
+            const agentMapImportPath = getFileImportRelativePath(config.scenarioActorsFile, config.agentMapDeclarationFile, packageMappings);
+            await writeFileInDir(logger, config.scenarioActorsFile, serializeScenarioActors(scenarioActors, agentMapImportPath));
             // JSON twin for the runtime meta service (console personas view). Lives
             // next to workflow/meta but NOT inside it — getWorkflowMeta() treats
             // every workflow/meta/*.gen.json as a workflow.
-            await writeFileInDir(logger, join(dirname(config.userFlowActorsFile), 'user-flow-actors.gen.json'), JSON.stringify(userFlowActors, null, 2));
+            await writeFileInDir(logger, join(dirname(config.scenarioActorsFile), 'scenario-actors.gen.json'), JSON.stringify(scenarioActors, null, 2));
         }
         await writeFileInDir(logger, workflowMapDeclarationFile, bootstrap
             ? serializeWorkflowBootstrapMap(workflows.meta, workflows.graphMeta)

package/dist/src/functions/wirings/workflow/serialize-scenario-actors.d.ts

@@ -0,0 +1,2 @@
+import type { PikkuCLIConfig } from '../../../../types/config.js';
+export declare const serializeScenarioActors: (actors: NonNullable<NonNullable<PikkuCLIConfig["scenarios"]>["actors"]>, agentMapImportPath: string) => string;

package/dist/src/functions/wirings/workflow/serialize-scenario-actors.js

@@ -0,0 +1,29 @@
+export const serializeScenarioActors = (actors, agentMapImportPath) => {
+    return `/** Scenario actors declared in pikku.config.json (\`scenarios.actors\`) */
+import {
+  createHttpScenarioActors,
+  type HttpScenarioActorsConfig,
+  type ScenarioActor,
+  type ScenarioActorConfig,
+} from '@pikku/core/services'
+import type { AgentMap } from '${agentMapImportPath}'
+
+export const scenarioActorConfigs = ${JSON.stringify(actors, null, 2)} as const satisfies Record<string, ScenarioActorConfig>
+
+export type ScenarioActorName = keyof typeof scenarioActorConfigs
+
+export type AgentName = keyof AgentMap & string
+export type TypedScenarioActors = Record<
+  ScenarioActorName,
+  ScenarioActor<AgentName>
+>
+
+export const createScenarioActors = (
+  options: Omit<HttpScenarioActorsConfig, 'actors'>
+): TypedScenarioActors =>
+  createHttpScenarioActors({
+    ...options,
+    actors: scenarioActorConfigs,
+  }) as TypedScenarioActors
+`;
+};