@pikku/cli 0.12.69 → 0.12.71

package/dist/src/functions/wirings/scenarios/serialize-scenario-functions.js

@@ -0,0 +1,98 @@
+/**
+ * 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 const serializeScenarioFunctions = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
+    return `/**
+ * Auto-generated scenario instrumentation functions
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pikkuFunc } from '${pathToPikkuTypes}'
+import {
+  getStubTracker,
+  isTestRun,
+  type CoverageFunctionMeta,
+  type FunctionCoverageReport,
+  type StubCall,
+} from '@pikku/core/services'
+
+export const pikkuScenarioTakeLiveCoverage = pikkuFunc<
+  null,
+  FunctionCoverageReport | null
+>({
+  tags: ['pikku'],
+  title: 'Take Live Coverage',
+  description:
+    'Snapshots the live coverage collected since the server started (or since the last reset) — V8 precise coverage on Node, istanbul instrumentation on Bun — and maps it onto function body spans. Returns null unless the server was started with coverage enabled (pikku dev --coverage).',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ coverageService, metaService }) => {
+    if (!coverageService?.takeReport || !metaService?.basePath) return null
+    let functionsMeta: Record<string, CoverageFunctionMeta>
+    try {
+      const content = await readFile(
+        join(
+          metaService.basePath,
+          'function',
+          'pikku-functions-meta-verbose.gen.json'
+        ),
+        'utf-8'
+      )
+      functionsMeta = JSON.parse(content)
+    } catch {
+      return null
+    }
+    return await coverageService.takeReport(functionsMeta)
+  },
+})
+
+export const pikkuScenarioResetLiveCoverage = pikkuFunc<
+  null,
+  { enabled: boolean }
+>({
+  tags: ['pikku'],
+  title: 'Reset Live Coverage',
+  description:
+    'Clears V8 precise-coverage call counts so the next takeLiveCoverage snapshot is attributable to a single scenario run. Reports enabled: false when the server was not started with coverage enabled.',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ coverageService }) => {
+    if (!coverageService) return { enabled: false }
+    await coverageService.reset()
+    return { enabled: true }
+  },
+})
+
+export const pikkuScenarioResetStubs = pikkuFunc<null, { enabled: boolean }>({
+  tags: ['pikku'],
+  title: 'Reset Stubs',
+  description:
+    'Clears recorded stub calls so the next getStubCalls result is attributable to a single scenario run. Reports enabled: false when the server was not started in test mode.',
+  expose: true,
+  auth: ${authFlag},
+  func: async () => {
+    getStubTracker().reset()
+    return { enabled: isTestRun() }
+  },
+})
+
+export const pikkuScenarioGetStubCalls = pikkuFunc<
+  { service?: string },
+  StubCall[]
+>({
+  tags: ['pikku'],
+  title: 'Get Stub Calls',
+  description:
+    'Returns calls recorded against stubbed/spied services (via the stub()/spy() core utils). Empty unless the server records service calls (pikku dev --test).',
+  expose: true,
+  auth: ${authFlag},
+  func: async (_services, data) => {
+    return getStubTracker().getCalls(data?.service ?? undefined)
+  },
+})
+`;
+};

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

@@ -10,7 +10,7 @@ import { serializeWorkflowBootstrapMap } from './serialize-workflow-bootstrap-ma
 import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-import { join, dirname } from 'path';
+import { join } from 'path';
 export const pikkuWorkflow = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, input) => {
         const bootstrap = input?.bootstrap === true;
@@ -67,10 +67,9 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         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.scenarioActorsFile), 'scenario-actors.gen.json'), JSON.stringify(scenarioActors, null, 2));
+            // Fixed path getScenarioActorsMeta() reads; kept out of workflow/meta,
+            // which getWorkflowMeta() globs as workflows.
+            await writeFileInDir(logger, join(config.outDir, 'workflow', '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

@@ -1,8 +1,2 @@
 import type { PikkuCLIConfig } from '../../../../types/config.js';
-/**
- * Generate the typed scenario actor registry from pikku.config.json's
- * `scenarios.actors`. Apps wire the result as the `actors` singleton service:
- *
- *   actors: createScenarioActors({ apiUrl, secret })
- */
 export declare const serializeScenarioActors: (actors: NonNullable<NonNullable<PikkuCLIConfig["scenarios"]>["actors"]>, agentMapImportPath: string) => string;

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

@@ -1,14 +1,5 @@
-/**
- * Generate the typed scenario actor registry from pikku.config.json's
- * `scenarios.actors`. Apps wire the result as the `actors` singleton service:
- *
- *   actors: createScenarioActors({ apiUrl, secret })
- */
 export const serializeScenarioActors = (actors, agentMapImportPath) => {
-    return `/**
- * Scenario actors declared in pikku.config.json (\`scenarios.actors\`).
- * Any scenario can impersonate any actor.
- */
+    return `/** Scenario actors declared in pikku.config.json (\`scenarios.actors\`) */
 import {
   createHttpScenarioActors,
   type HttpScenarioActorsConfig,
@@ -21,17 +12,12 @@ export const scenarioActorConfigs = ${JSON.stringify(actors, null, 2)} as const
 
 export type ScenarioActorName = keyof typeof scenarioActorConfigs
 
-/** \`actor.converse({ agent })\` is constrained to the project's agent names. */
 export type AgentName = keyof AgentMap & string
 export type TypedScenarioActors = Record<
   ScenarioActorName,
   ScenarioActor<AgentName>
 >
 
-/**
- * Build the injected \`actors\` service: one lazy HTTP actor per registry
- * entry, signing in via the Better Auth actor plugin on first invoke.
- */
 export const createScenarioActors = (
   options: Omit<HttpScenarioActorsConfig, 'actors'>
 ): TypedScenarioActors =>

package/dist/src/functions/workflows/all.workflow.js

@@ -11,6 +11,11 @@ const scaffoldFiles = (config) => {
             file: config.consoleFunctionsFile,
             generator: 'pikkuConsoleFunctions',
         });
+    if (config.scaffold?.scenarios && config.scenariosFunctionsFile)
+        files.push({
+            file: config.scenariosFunctionsFile,
+            generator: 'pikkuScenarioFunctions',
+        });
     if (config.scaffold?.agent && config.publicAgentFile)
         files.push({
             file: config.publicAgentFile,
@@ -126,6 +131,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await Promise.all([
             workflow.do('Public RPC', 'pikkuPublicRPC', null),
             workflow.do('Console functions', 'pikkuConsoleFunctions', null),
+            workflow.do('Scenario functions', 'pikkuScenarioFunctions', null),
             workflow.do('Events scaffold', 'pikkuEventsScaffold', null),
             workflow.do('Emails', 'pikkuEmails', null),
             workflow.do('Secret definition types', 'pikkuSecretDefinitionTypes', null),

package/dist/src/services.js

@@ -10,6 +10,7 @@ import { CLILoggerForwarder } from './services/cli-logger-forwarder.service.js';
 import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { loadManifest } from './utils/contract-versions.js';
+import { getTsWriteGeneration } from './utils/file-writer.js';
 import { join } from 'path';
 import { NodeBundler } from './deploy/bundler/node-bundler.js';
 import { BunBundler } from './deploy/bundler/bun-bundler.js';
@@ -142,6 +143,8 @@ export const createSingletonServices = async (config) => {
     // Store unfiltered state
     let unfilteredState = preloadedInspectorState;
     let unfilteredStateIsSetupOnly = false;
+    let inspectedTsGeneration;
+    let inspectorInvalidated = false;
     const getInspectorState = async (refresh = false, setupOnly = false, bootstrapMode = false) => {
         // In bootstrap mode, return a minimal "zero state" with core types
         // This allows bootstrap to run immediately without inspecting the codebase
@@ -184,7 +187,10 @@ export const createSingletonServices = async (config) => {
         // inspection (setupOnly=false) is now requested — setupOnly skips
         // visitRoutes so variables/secrets/etc. are absent from that cache.
         if (!unfilteredState ||
-            (refresh && !preloadedInspectorState) ||
+            (refresh &&
+                !preloadedInspectorState &&
+                (inspectorInvalidated ||
+                    getTsWriteGeneration() !== inspectedTsGeneration)) ||
             (unfilteredStateIsSetupOnly && !setupOnly && !preloadedInspectorState)) {
             // Run inspector WITHOUT filters to get full state
             const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`, {
@@ -223,6 +229,7 @@ export const createSingletonServices = async (config) => {
             const oldProgram = unfilteredState?.program ?? undefined;
             const inspectStart = Date.now();
             unfilteredStateIsSetupOnly = setupOnly;
+            const tsGenerationAtInspect = getTsWriteGeneration();
             unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
@@ -256,6 +263,8 @@ export const createSingletonServices = async (config) => {
                 manifest,
             });
             logger.debug(`Inspector took ${Date.now() - inspectStart}ms`);
+            inspectedTsGeneration = tsGenerationAtInspect;
+            inspectorInvalidated = false;
             if ('diagnostics' in unfilteredState &&
                 unfilteredState.diagnostics.length > 0) {
                 processDiagnostics(unfilteredState.diagnostics, config.lint);
@@ -277,6 +286,9 @@ export const createSingletonServices = async (config) => {
         const filteredState = filterInspectorState(unfilteredState, filters, logger);
         return filteredState;
     };
+    const invalidateInspectorState = () => {
+        inspectorInvalidated = true;
+    };
     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
@@ -289,6 +301,7 @@ export const createSingletonServices = async (config) => {
         secrets: new LocalSecretService(variables),
         audit: new NoopAuditService(),
         getInspectorState,
+        invalidateInspectorState,
         workflowService,
         bundler: isBun ? new BunBundler() : new NodeBundler(),
         devServerRunner: isBun ? new BunServerRunner() : new NodeServerRunner(),

package/dist/src/utils/file-writer.d.ts

@@ -1,5 +1,6 @@
 import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const DO_NOT_MODIFY_COMMENT: string;
+export declare const getTsWriteGeneration: () => number;
 export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
     ignoreModifyComment?: boolean;
     logWrite?: boolean;

package/dist/src/utils/file-writer.js

@@ -6,6 +6,9 @@ export const DO_NOT_MODIFY_COMMENT = `/**
  * This file was generated by @pikku/cli@${getCLIVersion()}
  */
 `;
+let tsWriteGeneration = 0;
+const TS_FILE_REGEX = /\.[mc]?tsx?$/;
+export const getTsWriteGeneration = () => tsWriteGeneration;
 export const writeFileInDir = async (logger, path, content, { ignoreModifyComment = false, logWrite = true, } = {}) => {
     if (path.includes('.json')) {
         ignoreModifyComment = true;
@@ -34,6 +37,9 @@ export const writeFileInDir = async (logger, path, content, { ignoreModifyCommen
     if (existingContent !== content) {
         await mkdir(dirname(path), { recursive: true });
         await writeFile(path, content, 'utf-8');
+        if (TS_FILE_REGEX.test(path)) {
+            tsWriteGeneration++;
+        }
         if (logWrite) {
             logger.debug({ message: `✓ File written to ${path}`, type: 'success' });
         }
@@ -56,6 +62,9 @@ export const removeFileInDir = async (logger, path, { logRemove = true } = {}) =
     // Check if file exists before attempting removal
     if (existsSync(path)) {
         await rm(path, { force: true });
+        if (TS_FILE_REGEX.test(path)) {
+            tsWriteGeneration++;
+        }
         if (logRemove) {
             logger.debug({ message: `✓ File removed at ${path}`, type: 'success' });
         }

package/dist/src/utils/meta-diff.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Structural diff of the generated `.pikku` meta between two points in time —
+ * used by `pikku all --diff` to report what a codegen run added/removed/changed
+ * (functions, wirings, workflows, emails, …). The snapshot is a plain in-memory
+ * copy of the meta files, so diffing is a couple of small JSON reads, not a
+ * second inspection pass. Only user-visible buildable surfaces are included;
+ * plumbing (secrets/variables/middleware/permissions) is intentionally omitted.
+ */
+export type MetaDiffCategoryName = 'functions' | 'http' | 'workflow' | 'email' | 'scheduler' | 'queue' | 'channel' | 'trigger' | 'mcp' | 'agent';
+export interface MetaDiffEntry {
+    id: string;
+    status: 'added' | 'removed' | 'modified';
+}
+export interface MetaDiffCategory {
+    added: number;
+    removed: number;
+    modified: number;
+    entries: MetaDiffEntry[];
+}
+export interface MetaDiff {
+    totals: {
+        added: number;
+        removed: number;
+        modified: number;
+    };
+    categories: Partial<Record<MetaDiffCategoryName, MetaDiffCategory>>;
+}
+export type MetaSnapshot = Partial<Record<MetaDiffCategoryName, Record<string, unknown>>>;
+/** Read the current meta from disk into an in-memory snapshot. */
+export declare function readMetaSnapshot(outDir: string): MetaSnapshot;
+/** Diff two snapshots; only changed ids and non-empty categories are returned. */
+export declare function computeMetaDiff(before: MetaSnapshot, after: MetaSnapshot): MetaDiff;

package/dist/src/utils/meta-diff.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+// Single-file categories: one JSON file whose top-level keys are the ids
+// (http is nested `{ method: { route: meta } }` and flattened to `method route`).
+const SINGLE_FILE = {
+    functions: 'function/pikku-functions-meta.gen.json',
+    http: 'http/pikku-http-wirings-meta.gen.json',
+    email: 'email/pikku-emails-meta.gen.json',
+    scheduler: 'scheduler/pikku-schedulers-wirings-meta.gen.json',
+    queue: 'queue/pikku-queue-workers-wirings-meta.gen.json',
+    channel: 'channel/pikku-channels-meta.gen.json',
+    trigger: 'trigger/pikku-trigger-meta.gen.json',
+    mcp: 'mcp/pikku-mcp-wirings-meta.gen.json',
+    agent: 'agent/pikku-agent-wirings-meta.gen.json',
+};
+// A few meta files wrap their real entities under a single key rather than
+// keying them at the top level — unwrap to that map so ids are the entities.
+const UNWRAP = {
+    email: 'templates',
+    agent: 'agentsMeta',
+};
+// Workflows (incl. userflows/scenarios) are written one file per workflow under
+// this dir; the file basename (sans `.gen.json`) is the id, `-verbose` excluded.
+const WORKFLOW_META_DIR = 'workflow/meta';
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function readSingle(outDir, category, relPath) {
+    let raw = readJson(join(outDir, relPath));
+    const unwrapKey = UNWRAP[category];
+    if (unwrapKey) {
+        const inner = raw[unwrapKey];
+        raw = inner && typeof inner === 'object' && !Array.isArray(inner) ? inner : {};
+    }
+    if (category !== 'http')
+        return raw;
+    const flat = {};
+    for (const [method, routes] of Object.entries(raw)) {
+        if (routes && typeof routes === 'object' && !Array.isArray(routes)) {
+            for (const [route, meta] of Object.entries(routes)) {
+                flat[`${method.toUpperCase()} ${route}`] = meta;
+            }
+        }
+    }
+    return flat;
+}
+function readWorkflows(outDir) {
+    const dir = join(outDir, WORKFLOW_META_DIR);
+    if (!existsSync(dir))
+        return {};
+    const out = {};
+    for (const file of readdirSync(dir)) {
+        if (!file.endsWith('.gen.json') || file.endsWith('-verbose.gen.json'))
+            continue;
+        out[file.slice(0, -'.gen.json'.length)] = readJson(join(dir, file));
+    }
+    return out;
+}
+/** Read the current meta from disk into an in-memory snapshot. */
+export function readMetaSnapshot(outDir) {
+    if (!outDir || !existsSync(outDir))
+        return {};
+    const snap = {};
+    for (const [category, relPath] of Object.entries(SINGLE_FILE)) {
+        snap[category] = readSingle(outDir, category, relPath);
+    }
+    snap.workflow = readWorkflows(outDir);
+    return snap;
+}
+// Volatile fields that vary by absolute path / environment but aren't a
+// meaningful structural change — excluded from equality (matches StateDiffService).
+const NORMALIZE_IGNORE = new Set(['sourceFile']);
+function normalize(value) {
+    if (Array.isArray(value))
+        return value.map(normalize);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            if (NORMALIZE_IGNORE.has(key))
+                continue;
+            out[key] = normalize(value[key]);
+        }
+        return out;
+    }
+    return value;
+}
+function equal(a, b) {
+    return JSON.stringify(normalize(a)) === JSON.stringify(normalize(b));
+}
+/** Diff two snapshots; only changed ids and non-empty categories are returned. */
+export function computeMetaDiff(before, after) {
+    const categories = {};
+    const totals = { added: 0, removed: 0, modified: 0 };
+    const names = new Set([
+        ...Object.keys(before),
+        ...Object.keys(after),
+    ]);
+    for (const name of names) {
+        const o = before[name] ?? {};
+        const a = after[name] ?? {};
+        const ids = new Set([...Object.keys(o), ...Object.keys(a)]);
+        const entries = [];
+        let added = 0;
+        let removed = 0;
+        let modified = 0;
+        for (const id of ids) {
+            const inO = id in o;
+            const inA = id in a;
+            if (inA && !inO) {
+                entries.push({ id, status: 'added' });
+                added++;
+            }
+            else if (inO && !inA) {
+                entries.push({ id, status: 'removed' });
+                removed++;
+            }
+            else if (!equal(o[id], a[id])) {
+                entries.push({ id, status: 'modified' });
+                modified++;
+            }
+        }
+        if (entries.length === 0)
+            continue;
+        entries.sort((x, y) => {
+            const order = { added: 0, modified: 1, removed: 2 };
+            return order[x.status] - order[y.status] || x.id.localeCompare(y.id);
+        });
+        categories[name] = { added, removed, modified, entries };
+        totals.added += added;
+        totals.removed += removed;
+        totals.modified += modified;
+    }
+    return { totals, categories };
+}

package/dist/src/utils/pikku-cli-config.js

@@ -221,6 +221,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (result.scaffold?.console && !result.consoleFunctionsFile) {
             result.consoleFunctionsFile = join(resolvedScaffoldDir, 'console.gen.ts');
         }
+        if (result.scaffold?.scenarios && !result.scenariosFunctionsFile) {
+            result.scenariosFunctionsFile = join(resolvedScaffoldDir, 'scenarios.gen.ts');
+        }
         if (!result.authFile) {
             result.authFile = join(resolvedScaffoldDir, 'auth.gen.ts');
         }

package/dist/src/utils/precise-coverage-map.d.ts

@@ -0,0 +1,4 @@
+import type { CoverageFunctionMeta, FunctionCoverageReport, ScriptCoverage as ScriptCoverageInput } from '@pikku/core/services';
+export type { ScriptCoverageInput };
+export declare function mapPreciseCoverage(scripts: ScriptCoverageInput[], getScriptSource: (scriptId: string) => Promise<string>, functionsMeta: Record<string, CoverageFunctionMeta>): Promise<FunctionCoverageReport>;
+export declare function mapLineHitsToReport(lineHits: Map<string, Map<number, number>>, functionsMeta: Record<string, CoverageFunctionMeta>): FunctionCoverageReport;

package/dist/src/utils/precise-coverage-map.js

@@ -0,0 +1,176 @@
+// Offsets are mapped through the inline source map rather than line-based
+// statement maps: esbuild emits the whole module on one generated line, which
+// would collapse every statement onto line 1.
+import { fileURLToPath } from 'node:url';
+import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping';
+const INLINE_SOURCE_MAP = /\/\/# sourceMappingURL=data:application\/json[^,]*;base64,([A-Za-z0-9+/=]+)/;
+function extractInlineSourceMap(source) {
+    const match = source.match(INLINE_SOURCE_MAP);
+    if (!match)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.from(match[1], 'base64').toString('utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function computeLineStarts(source) {
+    const starts = [0];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] === '\n')
+            starts.push(i + 1);
+    }
+    return starts;
+}
+function offsetToGeneratedPosition(offset, lineStarts) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+        const mid = (low + high + 1) >> 1;
+        if (lineStarts[mid] <= offset)
+            low = mid;
+        else
+            high = mid - 1;
+    }
+    return { line: low + 1, column: offset - lineStarts[low] };
+}
+function normalizeSourcePath(source) {
+    if (source.startsWith('file://')) {
+        try {
+            return fileURLToPath(source);
+        }
+        catch {
+            return source;
+        }
+    }
+    return source;
+}
+async function scriptToLineCoverage(script, getScriptSource, lineHits) {
+    let scriptPath;
+    try {
+        scriptPath = fileURLToPath(script.url);
+    }
+    catch {
+        return;
+    }
+    let source;
+    try {
+        source = await getScriptSource(script.scriptId);
+    }
+    catch {
+        return;
+    }
+    const sourcemap = extractInlineSourceMap(source);
+    let tracer;
+    if (sourcemap) {
+        try {
+            tracer = new TraceMap(sourcemap);
+        }
+        catch {
+            tracer = undefined;
+        }
+    }
+    const lineStarts = computeLineStarts(source);
+    const mapOffset = (offset) => {
+        const generated = offsetToGeneratedPosition(offset, lineStarts);
+        if (!tracer)
+            return { file: scriptPath, line: generated.line };
+        const original = originalPositionFor(tracer, generated);
+        if (original.source == null || original.line == null)
+            return undefined;
+        const sourceIndex = tracer.sources.indexOf(original.source);
+        const resolved = sourceIndex >= 0
+            ? (tracer.resolvedSources[sourceIndex] ?? original.source)
+            : original.source;
+        return { file: normalizeSourcePath(resolved), line: original.line };
+    };
+    const setHits = (file, from, to, count) => {
+        let hits = lineHits.get(file);
+        if (!hits) {
+            hits = new Map();
+            lineHits.set(file, hits);
+        }
+        for (let line = from; line <= to; line++) {
+            hits.set(line, count);
+        }
+    };
+    for (const fn of script.functions) {
+        // Inner ranges overwrite the outer count (V8 override semantics).
+        for (const range of fn.ranges) {
+            const start = mapOffset(range.startOffset);
+            const end = mapOffset(Math.max(range.startOffset, range.endOffset - 1));
+            if (!start && !end)
+                continue;
+            const file = (start ?? end).file;
+            const from = start?.line ?? end.line;
+            const to = end && end.file === file ? Math.max(end.line, from) : from;
+            setHits(file, from, to, range.count);
+        }
+    }
+}
+export async function mapPreciseCoverage(scripts, getScriptSource, functionsMeta) {
+    const lineHits = new Map();
+    for (const script of scripts) {
+        await scriptToLineCoverage(script, getScriptSource, lineHits);
+    }
+    return mapLineHitsToReport(lineHits, functionsMeta);
+}
+export function mapLineHitsToReport(lineHits, functionsMeta) {
+    const functions = Object.values(functionsMeta)
+        .filter((m) => m.sourceFile && !m.sourceFile.endsWith('.gen.ts'))
+        .map((m) => {
+        const hits = lineHits.get(m.bodySourceFile ?? m.sourceFile);
+        const covered = [];
+        const missed = [];
+        if (hits && m.bodyStart !== undefined && m.bodyEnd !== undefined) {
+            for (const [line, count] of hits) {
+                if (line < m.bodyStart || line > m.bodyEnd)
+                    continue;
+                if (count > 0)
+                    covered.push(line);
+                else
+                    missed.push(line);
+            }
+        }
+        const total = covered.length + missed.length;
+        const ratio = total ? covered.length / total : 0;
+        const status = total === 0
+            ? 'unknown'
+            : covered.length === 0
+                ? 'uncovered'
+                : missed.length === 0
+                    ? 'covered'
+                    : 'partial';
+        return {
+            name: m.name,
+            sourceFile: m.sourceFile,
+            exposed: m.expose !== false,
+            description: m.description ?? null,
+            coveredLines: covered.length,
+            totalLines: total,
+            missedLines: missed.sort((a, b) => a - b),
+            ratio: Number(ratio.toFixed(3)),
+            status,
+        };
+    })
+        .sort((a, b) => a.ratio - b.ratio || a.name.localeCompare(b.name));
+    const summary = {
+        total: functions.length,
+        covered: 0,
+        partial: 0,
+        uncovered: 0,
+        unknown: 0,
+        overallRatio: 0,
+    };
+    for (const f of functions)
+        summary[f.status]++;
+    summary.overallRatio = functions.length
+        ? Number((functions.reduce((a, f) => a + f.ratio, 0) / functions.length).toFixed(3))
+        : 0;
+    return {
+        generatedAt: new Date().toISOString(),
+        summary,
+        functions,
+    };
+}

package/dist/src/utils/serialize-schemas.js

@@ -8,8 +8,8 @@ function toValidIdentifier(name) {
     return result;
 }
 export async function saveSchemas(logger, schemaParentDir, schemas, requiredSchemas, supportsImportAttributes, packageName) {
-    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     if (requiredSchemas.size === 0) {
+        await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
         logger.info(`• Skipping schemas since none found.\x1b[0m`);
         return;
     }