@pikku/cli 0.12.69 → 0.12.71

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

@@ -78,8 +78,17 @@ async function listSourceFiles(dir) {
 }
 // Heavy/generated dirs pruned during a source walk.
 const SKIP_WALK_DIRS = new Set([
-    'node_modules', '.git', '.next', 'dist', 'build', '.pikku',
-    '.pikku-runtime', '.vite', '.tanstack', '.turbo', '.reports',
+    'node_modules',
+    '.git',
+    '.next',
+    'dist',
+    'build',
+    '.pikku',
+    '.pikku-runtime',
+    '.vite',
+    '.tanstack',
+    '.turbo',
+    '.reports',
 ]);
 // Recursively list handwritten .ts/.tsx files under a dir, pruning heavy dirs
 // (node_modules, build output, generated) DURING traversal and skipping .gen.*
@@ -430,14 +439,48 @@ export async function runValidate(startDir = process.cwd()) {
     // need to bun install?" — aborting the deploy. Catch that class here.
     {
         const NODE_BUILTINS = new Set([
-            'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
-            'constants', 'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http',
-            'http2', 'https', 'inspector', 'module', 'net', 'os', 'path', 'perf_hooks',
-            'process', 'punycode', 'querystring', 'readline', 'repl', 'stream',
-            'string_decoder', 'timers', 'tls', 'tty', 'url', 'util', 'v8', 'vm',
-            'worker_threads', 'zlib',
+            'assert',
+            'async_hooks',
+            'buffer',
+            'child_process',
+            'cluster',
+            'console',
+            'constants',
+            'crypto',
+            'dgram',
+            'dns',
+            'domain',
+            'events',
+            'fs',
+            'http',
+            'http2',
+            'https',
+            'inspector',
+            'module',
+            'net',
+            'os',
+            'path',
+            'perf_hooks',
+            'process',
+            'punycode',
+            'querystring',
+            'readline',
+            'repl',
+            'stream',
+            'string_decoder',
+            'timers',
+            'tls',
+            'tty',
+            'url',
+            'util',
+            'v8',
+            'vm',
+            'worker_threads',
+            'zlib',
         ]);
-        const pkgNameOf = (spec) => spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0];
+        const pkgNameOf = (spec) => spec.startsWith('@')
+            ? spec.split('/').slice(0, 2).join('/')
+            : spec.split('/')[0];
         const wsDirs = [];
         for (const group of ['packages', 'apps', 'backends']) {
             const groupDir = join(root, group);
@@ -445,7 +488,8 @@ export async function runValidate(startDir = process.cwd()) {
                 continue;
             try {
                 for (const d of await readdir(groupDir, { withFileTypes: true })) {
-                    if (d.isDirectory() && existsSync(join(groupDir, d.name, 'package.json'))) {
+                    if (d.isDirectory() &&
+                        existsSync(join(groupDir, d.name, 'package.json'))) {
                         wsDirs.push(join(groupDir, d.name));
                     }
                 }
@@ -1020,11 +1064,6 @@ export async function runValidate(startDir = process.cwd()) {
     if (!existsSync(join(root, 'packages', 'components'))) {
         info('components-missing', 'packages/components/ not found — Fabric design features require a components package', join(root, 'packages', 'components'), `Create packages/components/ with your shared UI components. See ${designDocUrl}`);
     }
-    // ── packages/functions/tests/ ─────────────────────────────────────────
-    const testsDir = join(fnDir, 'tests');
-    if (!existsSync(testsDir)) {
-        info('tests-missing', 'packages/functions/tests/ not found — no function test harness', testsDir, lines('Run `pikku tests init` from the repo root.', 'That should scaffold `packages/functions/tests/` with the generated function test harness.', 'Expected contents include feature files, step definitions, and support files.', 'Commit the scaffolded files after generation.'));
-    }
     // ── packages/functions-sdk/ ───────────────────────────────────────────
     const sdkDir = join(root, 'packages', 'functions-sdk');
     if (!existsSync(sdkDir)) {

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

@@ -1,12 +1,25 @@
 import { pikkuVoidFunc } from '#pikku';
+import { computeMetaDiff, readMetaSnapshot } from '../../utils/meta-diff.js';
 export const all = pikkuVoidFunc({
     remote: true,
-    func: async ({ workflowService, logger }, _data, { rpc }) => {
+    func: async ({ workflowService, logger, config }, _data, { rpc }) => {
+        // --diff: snapshot the meta BEFORE codegen overwrites it, so we can report
+        // exactly what this run changes. Cheap (a few small JSON reads), skipped
+        // unless requested.
+        const beforeMeta = config.diff ? readMetaSnapshot(config.outDir) : null;
         // Drive the run directly (the CLI is always inline — no queueService) so we
         // can read back the per-step durations already recorded on each step's
         // state. startWorkflow runs the job to completion before returning in inline
         // mode and re-throws on failure, matching runToCompletion's behaviour.
         const { runId } = await workflowService.startWorkflow('allWorkflow', {}, { type: 'internal' }, rpc, { inline: true });
+        // Reached only on success (startWorkflow re-throws → non-zero exit above),
+        // so the diff never emits on a failed codegen. Print it as a single marker
+        // line on stdout for the sandbox "what changed" build card to consume.
+        if (beforeMeta) {
+            const diff = computeMetaDiff(beforeMeta, readMetaSnapshot(config.outDir));
+            // eslint-disable-next-line no-console
+            console.log(`PIKKU_DIFF ${JSON.stringify(diff)}`);
+        }
         // Per-step timing breakdown for debugging slow runs (e.g. which inspector
         // re-runs dominate). Opt-in via PIKKU_TIMING so normal runs stay quiet.
         if (typeof process !== 'undefined' && process.env?.PIKKU_TIMING) {

package/dist/src/functions/commands/bun-coverage-loader.d.ts

@@ -0,0 +1,11 @@
+export interface BunCoverageLoaderOptions {
+    rootDir: string;
+}
+/**
+ * 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 declare function registerBunCoverageLoader({ rootDir, }: BunCoverageLoaderOptions): Promise<void>;

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,12 +2,18 @@ export declare const dev: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
+    coverage?: boolean;
+    test?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
+    coverage?: boolean;
+    test?: boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: 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,12 +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 { resolveConsoleMount } from './serve-console.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, watch, hmr }, { 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
@@ -178,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,
@@ -196,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;
@@ -261,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/enable.d.ts

@@ -1,5 +1,6 @@
 export declare const enableRpc: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
 export declare const enableConsole: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const enableScenarios: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
 export declare const enableAgent: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
 export declare const enableWorkflow: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
 export declare const enableEvents: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -5,6 +5,7 @@ const FEATURE_DEFAULTS = {
     rpc: 'auth',
     agent: 'auth',
     console: 'auth',
+    scenarios: 'auth',
     workflow: 'auth',
     events: 'auth',
     remoteRpc: 'no-auth',
@@ -22,7 +23,11 @@ async function enableFeature(feature, logger, config, data) {
     }
     // The console is an admin surface — every RPC requires a session, so it can
     // never be scaffolded no-auth (the --no-auth flag is ignored for it).
-    const value = feature === 'console' ? 'auth' : noAuth ? 'no-auth' : FEATURE_DEFAULTS[feature];
+    const value = feature === 'console'
+        ? 'auth'
+        : noAuth
+            ? 'no-auth'
+            : FEATURE_DEFAULTS[feature];
     json.scaffold[feature] = value;
     await writeFile(configPath, JSON.stringify(json, null, 2) + '\n', 'utf-8');
     logger.info(`Enabled scaffold.${feature} = '${value}' in ${configPath}`);
@@ -33,6 +38,9 @@ export const enableRpc = pikkuVoidFunc({
 export const enableConsole = pikkuVoidFunc({
     func: async ({ logger, config }, data) => enableFeature('console', logger, config, data),
 });
+export const enableScenarios = pikkuVoidFunc({
+    func: async ({ logger, config }, data) => enableFeature('scenarios', logger, config, data),
+});
 export const enableAgent = pikkuVoidFunc({
     func: async ({ logger, config }, data) => enableFeature('agent', logger, config, data),
 });

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

@@ -3,12 +3,15 @@ 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/scenario.js

@@ -1,4 +1,5 @@
-import { resolve } from 'path';
+import { resolve, join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
 import { InMemoryWorkflowService, createHttpScenarioActors, } from '@pikku/core/services';
 import { pikkuState } from '@pikku/core/internal';
@@ -30,9 +31,8 @@ export const scenarioList = pikkuSessionlessFunc({
     },
 });
 export const scenarioRun = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, tags }) => {
+    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, tags, coverage }) => {
         const state = await getInspectorState(true);
-        // --- resolve the target environment ---
         const environments = config.scenarios?.environments ?? {};
         const env = environments[environment];
         if (!env) {
@@ -42,7 +42,6 @@ export const scenarioRun = pikkuSessionlessFunc({
                     ? `Configured environments: ${known.join(', ')}`
                     : `Add scenarios.environments to pikku.config.json, e.g. { "${environment}": { "apiUrl": "https://app.example.com/api" } }`));
         }
-        // --- select flows ---
         let selected = listScenarios(state);
         if (flows) {
             const names = new Set(flows.split(',').map((f) => f.trim()));
@@ -61,7 +60,6 @@ export const scenarioRun = pikkuSessionlessFunc({
             process.exitCode = 1;
             return;
         }
-        // --- actors: registry from config, secret STRICTLY from env ---
         const secret = await variables.get('SCENARIO_ACTOR_SECRET');
         if (!secret) {
             throw new Error('SCENARIO_ACTOR_SECRET is not set — scenario actors cannot sign in. ' +
@@ -74,10 +72,6 @@ export const scenarioRun = pikkuSessionlessFunc({
             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', {
@@ -92,10 +86,39 @@ export const scenarioRun = pikkuSessionlessFunc({
                     `'${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 "scaffold.scenarios" enabled in pikku.config.json?`);
+                return null;
+            }
+        };
         for (const flow of selected) {
             const startedAt = Date.now();
+            if (coverageActive) {
+                const reset = await invokeCoverage('pikkuScenarioResetLiveCoverage');
+                if (reset && reset.enabled === false) {
+                    coverageActive = false;
+                    logger.warn(`Coverage disabled — '${environment}' is not collecting (start the server with --coverage).`);
+                }
+            }
+            try {
+                await coverageActor?.invoke('pikkuScenarioResetStubs', 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 scenarioRun = pikkuSessionlessFunc({
                     error: e?.message ?? String(e),
                 });
             }
+            if (coverageActive) {
+                const report = await invokeCoverage('pikkuScenarioTakeLiveCoverage');
+                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') {

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

@@ -102,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;

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,42 @@
+import { V8CoverageService } from '@pikku/core/services/v8-coverage';
+import { IstanbulCoverageService } from '@pikku/core/services/istanbul-coverage';
+import { registerBunCoverageLoader } from './bun-coverage-loader.js';
+import { mapPreciseCoverage, mapLineHitsToReport, } from '../../utils/precise-coverage-map.js';
+const isBunRuntime = () => typeof globalThis.Bun !== 'undefined';
+// The source-map-aware span mapping (and its @jridgewell/trace-mapping
+// dependency) lives in the CLI, not @pikku/core — the scaffolded
+// pikkuScenarioTakeLiveCoverage function reaches it through the optional
+// CoverageService.takeReport, which only the CLI-booted service provides.
+const withTakeReport = (service) => {
+    service.takeReport = async (functionsMeta) => {
+        const snapshot = await service.takeCoverage();
+        if (snapshot.kind === 'line-hits') {
+            return mapLineHitsToReport(snapshot.lineHits, functionsMeta);
+        }
+        return mapPreciseCoverage(snapshot.scripts, snapshot.getScriptSource, functionsMeta);
+    };
+    return service;
+};
+/**
+ * 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 pikkuScenarioTakeLiveCoverage, reset via pikkuScenarioResetLiveCoverage');
+        return withTakeReport(new IstanbulCoverageService());
+    }
+    const coverageService = new V8CoverageService();
+    try {
+        await coverageService.start();
+        logger.info('V8 precise coverage enabled — snapshot via pikkuScenarioTakeLiveCoverage, reset via pikkuScenarioResetLiveCoverage');
+        return withTakeReport(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/validate/workspace-validate.js

@@ -228,10 +228,6 @@ export async function runWorkspaceValidate(startDir = process.cwd()) {
             info('config-missing', 'packages/functions/src/config.ts not found', join(fnDir, 'src', 'config.ts'), 'Create src/config.ts and export your workspace config factory');
         }
     }
-    const testsDir = join(fnDir, 'tests');
-    if (!existsSync(testsDir)) {
-        info('tests-missing', 'packages/functions/tests/ not found — no function test harness', testsDir, 'Run `pikku tests init` to scaffold the generated function test harness under packages/functions/tests/ (feature files, step defs, and support files)');
-    }
     const sdkDir = join(root, 'packages', 'functions-sdk');
     if (!existsSync(sdkDir)) {
         info('functions-sdk-missing', 'packages/functions-sdk/ not found — generated RPC client and React Query hooks will not be available', sdkDir, 'Create packages/functions-sdk/ as a workspace with src/pikku/ as the generated output root; point clientFiles.rpcMapDeclarationFile and clientFiles.reactQueryFile there');

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -94,12 +94,6 @@ export const consoleRoutes = defineHTTPRoutes({
       sse: true,
       func: ref('console:streamWorkflowRun'),
     },
-    functionTestsStream: {
-      route: '/function-tests/stream',
-      method: 'get',
-      sse: true,
-      func: ref('console:streamFunctionTests'),
-    },
   },
 })
 

package/dist/src/functions/wirings/scenarios/pikku-command-scenario-functions.d.ts

@@ -0,0 +1 @@
+export declare const pikkuScenarioFunctions: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/scenarios/pikku-command-scenario-functions.js

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeScenarioFunctions } from './serialize-scenario-functions.js';
+export const pikkuScenarioFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
+        if (config.scaffold?.scenarios && config.scenariosFunctionsFile) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.scenariosFunctionsFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.scenariosFunctionsFile, serializeScenarioFunctions(pathToPikkuTypes, config.scaffold.scenarios === 'auth'));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Scenario functions',
+            commandEnd: 'Generated Scenario functions',
+        }),
+    ],
+});

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

@@ -0,0 +1,6 @@
+/**
+ * Generate the scenario instrumentation functions (`pikku scenario` coverage
+ * snapshots and stub-call inspection) into the project scaffold, so scenario
+ * runs work against any server without requiring the console addon.
+ */
+export declare const serializeScenarioFunctions: (pathToPikkuTypes: string, requireAuth?: boolean) => string;