@pikku/cli 0.12.91 → 0.12.92

package/dist/src/functions/wirings/scenarios/register-scenario-instrumentation.js

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { addFunction } from '@pikku/core/function';
+import { pikkuState } from '@pikku/core/internal';
+import { getStubTracker, isTestRun, } from '@pikku/core/services';
+/**
+ * The instrumentation `pikku scenario run` calls on the server under test:
+ * snapshot/reset live coverage, and reset/read recorded stub calls.
+ *
+ * These are pikku's, not the application's. They were previously scaffolded into
+ * the project as ordinary `pikkuFunc`s, which is why they ended up registered in
+ * the app bootstrap and shipped — `expose: true` — inside every deployed bundle.
+ * Registering them here instead means the only process that has them is the one
+ * that should: a development server. Nothing is generated, nothing is written to
+ * the user's source tree, and a bundle cannot carry what was never in its
+ * bootstrap.
+ *
+ * The bodies are unchanged from the generated ones, minus their schemas: an
+ * instrumentation endpoint with a single optional string argument has nothing to
+ * validate, and dropping the schemas drops the `zod` dependency the scaffold
+ * silently required of every project.
+ */
+const takeLiveCoverage = {
+    func: async ({ coverageService, metaService }) => {
+        if (!coverageService?.takeReport || !metaService?.basePath)
+            return null;
+        let functionsMeta;
+        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);
+    },
+};
+const resetLiveCoverage = {
+    func: async ({ coverageService }) => {
+        if (!coverageService)
+            return { enabled: false };
+        await coverageService.reset();
+        return { enabled: true };
+    },
+};
+const resetStubs = {
+    func: async () => {
+        getStubTracker().reset();
+        return { enabled: isTestRun() };
+    },
+};
+const getStubCalls = {
+    func: async (_services, data) => getStubTracker().getCalls(data?.service ?? undefined),
+};
+const instrumentation = {
+    pikkuScenarioTakeLiveCoverage: {
+        ...takeLiveCoverage,
+        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).',
+    },
+    pikkuScenarioResetLiveCoverage: {
+        ...resetLiveCoverage,
+        title: 'Reset Live Coverage',
+        description: 'Clears 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.',
+    },
+    pikkuScenarioResetStubs: {
+        ...resetStubs,
+        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.',
+    },
+    pikkuScenarioGetStubCalls: {
+        ...getStubCalls,
+        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).',
+    },
+};
+/**
+ * Register the instrumentation into the running dev server's state, so the
+ * scenario runner can reach it over `/rpc/<name>` exactly as before.
+ *
+ * They are registered sessionless: `auth` decides whether a session is
+ * *required*, and a sessioned function would demand one regardless of the flag —
+ * which is what made `scaffold.scenarios: true` (as opposed to `'auth'`) refuse
+ * every call and log a warning about it.
+ */
+export const registerScenarioInstrumentation = (requireAuth) => {
+    const meta = pikkuState(null, 'function', 'meta');
+    for (const [name, { func, title, description }] of Object.entries(instrumentation)) {
+        addFunction(name, { func, auth: requireAuth });
+        meta[name] = {
+            pikkuFuncId: name,
+            inputSchemaName: null,
+            outputSchemaName: null,
+            expose: true,
+            sessionless: true,
+            tags: ['pikku'],
+            title,
+            description,
+        };
+    }
+    pikkuState(null, 'function', 'meta', meta);
+};

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

@@ -12,6 +12,12 @@ export type WiringFileMap = Map<string, {
  * them in `.pikku/scenarios/`, reachable only from `pikku scenario run`.
  */
 export declare const isScenarioStep: (meta: FunctionsMeta[string] | undefined) => boolean;
+/**
+ * A scenario's own body is a function too, so the app meta used to carry every
+ * scenario's name, schemas and hashes — and a deployed bundle imports that meta
+ * wholesale. Both kinds belong on the scenario side of the split.
+ */
+export declare const isScenarioFunction: (meta: FunctionsMeta[string] | undefined) => boolean;
 export declare const partitionScenarioFunctions: (files: WiringFileMap, functionsMeta: FunctionsMeta) => {
     app: WiringFileMap;
     scenario: WiringFileMap;
@@ -27,3 +33,10 @@ export declare const partitionScenarioWorkflows: (workflowNames: string[], workf
     appFiles: WiringFileMap;
     scenarioFiles: WiringFileMap;
 };
+/**
+ * Drop every scenario and step from a function meta map. The deploy analyzer
+ * reads inspector state rather than the partitioned codegen output, so it needs
+ * the same split applied before it decides what a deployment contains.
+ */
+export declare const withoutScenarios: (functionsMeta: FunctionsMeta) => FunctionsMeta;
+export declare const withoutScenarioWorkflows: (graphMeta: SerializedWorkflowGraphs) => SerializedWorkflowGraphs;

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

@@ -6,11 +6,17 @@
  * them in `.pikku/scenarios/`, reachable only from `pikku scenario run`.
  */
 export const isScenarioStep = (meta) => meta?.scenarioStep === true;
+/**
+ * A scenario's own body is a function too, so the app meta used to carry every
+ * scenario's name, schemas and hashes — and a deployed bundle imports that meta
+ * wholesale. Both kinds belong on the scenario side of the split.
+ */
+export const isScenarioFunction = (meta) => isScenarioStep(meta) || meta?.scenario === true;
 export const partitionScenarioFunctions = (files, functionsMeta) => {
     const app = new Map();
     const scenario = new Map();
     for (const [name, entry] of files) {
-        if (isScenarioStep(functionsMeta[name])) {
+        if (isScenarioFunction(functionsMeta[name])) {
             scenario.set(name, entry);
         }
         else {
@@ -23,7 +29,7 @@ export const partitionScenarioFunctionsMeta = (functionsMeta) => {
     const app = {};
     const scenario = {};
     for (const [name, meta] of Object.entries(functionsMeta)) {
-        if (isScenarioStep(meta)) {
+        if (isScenarioFunction(meta)) {
             scenario[name] = meta;
         }
         else {
@@ -56,3 +62,10 @@ export const partitionScenarioWorkflows = (workflowNames, workflowFiles, graphMe
     }
     return { appNames, scenarioNames, appFiles, scenarioFiles };
 };
+/**
+ * Drop every scenario and step from a function meta map. The deploy analyzer
+ * reads inspector state rather than the partitioned codegen output, so it needs
+ * the same split applied before it decides what a deployment contains.
+ */
+export const withoutScenarios = (functionsMeta) => Object.fromEntries(Object.entries(functionsMeta).filter(([, meta]) => !isScenarioFunction(meta)));
+export const withoutScenarioWorkflows = (graphMeta) => Object.fromEntries(Object.entries(graphMeta ?? {}).filter(([name]) => !isScenarioWorkflow(graphMeta, name)));

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

@@ -0,0 +1,33 @@
+import type { FunctionsMeta } from '@pikku/core';
+/**
+ * The schema names a set of functions validates against.
+ *
+ * `getUniqueName` is the inspector's own type→schema naming, so this resolves a
+ * name the same way `computeRequiredSchemas` did when it filled `requiredSchemas`.
+ * The two must not disagree: a scenario schema this failed to name would stay on
+ * the app side, which is the leak the split exists to close.
+ */
+export declare const schemaNamesFor: (meta: FunctionsMeta, getUniqueName: (name: string) => string) => Set<string>;
+/**
+ * Split the required schemas into the app's register and the scenario register.
+ *
+ * A scenario's input/output schemas are as test-only as its body, and the app's
+ * `register.gen.ts` is imported by every deployed bundle — on one project half the
+ * registered schemas belonged to scenarios and steps. Both sets are derived from
+ * `requiredSchemas`, so every name lands in exactly one register and a name the
+ * scenario side claims is removed from the app side by construction.
+ *
+ * Two things deliberately stay on the app side: a schema an application function
+ * also needs (registering a shared schema twice is worse than registering it in
+ * one place), and a type the project asked for by hand via `schemasFromTypes`,
+ * whatever happens to reference it.
+ */
+export declare const partitionRequiredSchemas: ({ functionsMeta, requiredSchemas, getUniqueName, schemasFromTypes, }: {
+    functionsMeta: FunctionsMeta;
+    requiredSchemas: Set<string>;
+    getUniqueName: (name: string) => string;
+    schemasFromTypes?: string[];
+}) => {
+    appRequired: Set<string>;
+    scenarioOnly: Set<string>;
+};

package/dist/src/functions/wirings/scenarios/scenario-schema-partition.js

@@ -0,0 +1,49 @@
+import { partitionScenarioFunctionsMeta } from './scenario-partition.js';
+/**
+ * The schema names a set of functions validates against.
+ *
+ * `getUniqueName` is the inspector's own type→schema naming, so this resolves a
+ * name the same way `computeRequiredSchemas` did when it filled `requiredSchemas`.
+ * The two must not disagree: a scenario schema this failed to name would stay on
+ * the app side, which is the leak the split exists to close.
+ */
+export const schemaNamesFor = (meta, getUniqueName) => {
+    const names = new Set();
+    for (const { inputs, outputs } of Object.values(meta)) {
+        for (const type of [inputs?.[0], outputs?.[0]]) {
+            if (!type)
+                continue;
+            try {
+                names.add(getUniqueName(type));
+            }
+            catch {
+                names.add(type);
+            }
+        }
+    }
+    return names;
+};
+/**
+ * Split the required schemas into the app's register and the scenario register.
+ *
+ * A scenario's input/output schemas are as test-only as its body, and the app's
+ * `register.gen.ts` is imported by every deployed bundle — on one project half the
+ * registered schemas belonged to scenarios and steps. Both sets are derived from
+ * `requiredSchemas`, so every name lands in exactly one register and a name the
+ * scenario side claims is removed from the app side by construction.
+ *
+ * Two things deliberately stay on the app side: a schema an application function
+ * also needs (registering a shared schema twice is worse than registering it in
+ * one place), and a type the project asked for by hand via `schemasFromTypes`,
+ * whatever happens to reference it.
+ */
+export const partitionRequiredSchemas = ({ functionsMeta, requiredSchemas, getUniqueName, schemasFromTypes, }) => {
+    const { app: appFunctionsMeta, scenario: scenarioFunctionsMeta } = partitionScenarioFunctionsMeta(functionsMeta);
+    const appSchemaNames = schemaNamesFor(appFunctionsMeta, getUniqueName);
+    const requestedByHand = new Set(schemasFromTypes ?? []);
+    const scenarioOnly = new Set([...schemaNamesFor(scenarioFunctionsMeta, getUniqueName)].filter((name) => requiredSchemas.has(name) &&
+        !appSchemaNames.has(name) &&
+        !requestedByHand.has(name)));
+    const appRequired = new Set([...requiredSchemas].filter((name) => !scenarioOnly.has(name)));
+    return { appRequired, scenarioOnly };
+};

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

@@ -1,7 +1,7 @@
 import { existsSync } from 'fs';
 import { pikkuWorkflowComplexFunc } from '#pikku/workflow/pikku-workflow-types.gen.js';
 import { assertSingleCoreVersion } from '../../utils/assert-single-core-version.js';
-import { pruneLegacyScaffoldFiles } from '../../utils/remove-legacy-scaffold-file.js';
+import { pruneLegacyScaffoldFiles, removeRetiredScaffoldFiles, } from '../../utils/remove-legacy-scaffold-file.js';
 import { PikkuTypecheckFailedError, renderTscFull, renderTscSummary, runProjectTypecheck, } from '../../utils/tsc-check.js';
 const scaffoldFiles = (config) => {
     const files = [];
@@ -17,11 +17,6 @@ const scaffoldFiles = (config) => {
             file: config.consoleFunctionsFile,
             generator: 'pikkuConsoleFunctions',
         });
-    if (config.scaffold?.scenarios && config.scenariosFunctionsFile)
-        files.push({
-            file: config.scenariosFunctionsFile,
-            generator: 'pikkuScenarioFunctions',
-        });
     if (config.scaffold?.userAdmin && config.userAdminFunctionsFile)
         files.push({
             file: config.userAdminFunctionsFile,
@@ -46,6 +41,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         // (workflows/RPCs "disappear"), so refuse to codegen against it.
         await assertSingleCoreVersion(config.rootDir, logger);
         await pruneLegacyScaffoldFiles(config);
+        await removeRetiredScaffoldFiles(config);
         const allImports = [];
         let typesDeclarationFileExists = true;
         if (!existsSync(config.outDir)) {
@@ -150,7 +146,6 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             workflow.do('Graph wirings', 'pikkuGraphWirings', null),
             workflow.do('Public RPC', 'pikkuPublicRPC', null),
             workflow.do('Console functions', 'pikkuConsoleFunctions', null),
-            workflow.do('Scenario functions', 'pikkuScenarioFunctions', null),
             workflow.do('User admin functions', 'pikkuUserAdminFunctions', null),
             workflow.do('Events scaffold', 'pikkuEventsScaffold', null),
             workflow.do('Emails', 'pikkuEmails', null),

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

@@ -1,5 +1,5 @@
 import { dirname, join } from 'path';
-import { mkdir, readFile, writeFile, rm } from 'fs/promises';
+import { mkdir, readFile, rename, writeFile, rm } from 'fs/promises';
 import { existsSync } from 'fs';
 import { getCLIVersion } from './get-cli-version.js';
 export const DO_NOT_MODIFY_COMMENT = `/**
@@ -36,7 +36,19 @@ export const writeFileInDir = async (logger, path, content, { ignoreModifyCommen
     // Only write if content has changed or file doesn't exist
     if (existingContent !== content) {
         await mkdir(dirname(path), { recursive: true });
-        await writeFile(path, content, 'utf-8');
+        // Atomically, because generated files are read while they are generated:
+        // `pikku scenario run --spawn` bundles the registers while the dev server it
+        // spawned is regenerating them, and `writeFile` truncates before it writes —
+        // a reader that lands in that window gets an empty file, not an old one.
+        const tmp = `${path}.${process.pid}.tmp`;
+        try {
+            await writeFile(tmp, content, 'utf-8');
+            await rename(tmp, path);
+        }
+        catch (e) {
+            await rm(tmp, { force: true }).catch(() => { });
+            throw e;
+        }
         if (TS_FILE_REGEX.test(path)) {
             tsWriteGeneration++;
         }

package/dist/src/utils/pikku-cli-config.d.ts

@@ -1,4 +1,18 @@
 import type { PikkuCLIConfig } from '../../types/config.js';
 import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const getPikkuCLIConfig: (logger: CLILogger, configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, exitProcess?: boolean, outDirOverride?: string) => Promise<PikkuCLIConfig>;
+/** A config that was found and parsed, but says something impossible. */
+export declare class PikkuCLIConfigError extends Error {
+}
+/**
+ * The two schema registers must be two directories.
+ *
+ * `saveSchemas` owns whatever directory it is given: it writes `register.gen.ts`
+ * and prunes every schema file that its own required-set does not name. Point the
+ * scenario write at `schemaDirectory` and the second call overwrites the app's
+ * register with the scenario-only one and deletes the app's schema files — the
+ * exact leak the split exists to prevent, silently, and only in a deployed
+ * bundle. Nothing downstream can detect it, so it is rejected here.
+ */
+export declare const assertSchemaDirectoriesAreDistinct: (config: Pick<PikkuCLIConfig, "schemaDirectory" | "scenarioSchemaDirectory">) => void;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

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

@@ -32,6 +32,28 @@ async function findConfigFile() {
     }
     throw new Error('Config file pikku.config.json not found');
 }
+/** A config that was found and parsed, but says something impossible. */
+export class PikkuCLIConfigError extends Error {
+}
+/**
+ * The two schema registers must be two directories.
+ *
+ * `saveSchemas` owns whatever directory it is given: it writes `register.gen.ts`
+ * and prunes every schema file that its own required-set does not name. Point the
+ * scenario write at `schemaDirectory` and the second call overwrites the app's
+ * register with the scenario-only one and deletes the app's schema files — the
+ * exact leak the split exists to prevent, silently, and only in a deployed
+ * bundle. Nothing downstream can detect it, so it is rejected here.
+ */
+export const assertSchemaDirectoriesAreDistinct = (config) => {
+    const { schemaDirectory, scenarioSchemaDirectory } = config;
+    if (!schemaDirectory || !scenarioSchemaDirectory) {
+        return;
+    }
+    if (resolve(schemaDirectory) === resolve(scenarioSchemaDirectory)) {
+        throw new PikkuCLIConfigError(`scenarioSchemaDirectory must not be the same directory as schemaDirectory (both resolve to ${resolve(schemaDirectory)}). Scenario schemas are written with their own register, which would replace the application one.`);
+    }
+};
 const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields, exitProcess = false, outDirOverride) => {
     if (!configFile) {
         configFile = await findConfigFile();
@@ -374,6 +396,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.scenarioMetaDir) {
             result.scenarioMetaDir = join(scenarioDir, 'meta');
         }
+        // Schemas only a scenario or a step validates against. They live here rather
+        // than in `schemaDirectory` because the app's `register.gen.ts` is imported
+        // by every deployed bundle, and a test-only schema has no business in one.
+        if (!result.scenarioSchemaDirectory) {
+            result.scenarioSchemaDirectory = join(scenarioDir, 'schemas');
+        }
         if (!result.scenarioBootstrapFile) {
             result.scenarioBootstrapFile = join(result.outDir, 'pikku-bootstrap-scenarios.gen.ts');
         }
@@ -549,6 +577,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);
         }
+        assertSchemaDirectoriesAreDistinct(result);
         if (result.addon) {
             const packageJsonPath = join(result.rootDir, 'package.json');
             try {
@@ -568,6 +597,11 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         return result;
     }
     catch (e) {
+        // A config that parsed but is contradictory is not a missing config, and
+        // saying so sends the reader looking for the wrong problem.
+        if (e instanceof PikkuCLIConfigError) {
+            throw e;
+        }
         logger.error(e);
         throw new Error(`Config file not found: ${configFile}`);
     }

package/dist/src/utils/remove-legacy-scaffold-file.d.ts

@@ -1,3 +1,17 @@
 import type { PikkuCLIConfig } from '../../types/config.js';
 export declare const removeLegacyScaffoldFile: (file: string) => Promise<void>;
+/**
+ * Delete scaffolds pikku has stopped generating.
+ *
+ * The scenario instrumentation scaffold is why this exists: those four functions
+ * are pikku's own and are now registered by `pikku dev` itself, because as project
+ * source they were indistinguishable from application code and shipped —
+ * `expose: true` — in every deployed bundle. The inspector ignores them by name so
+ * an unregenerated project is already safe, but the file is then dead code that
+ * still imports `zod`, so it goes.
+ *
+ * Unlike `pruneLegacyScaffoldFiles`, which removes a file from a path pikku used
+ * to write to, this removes a file pikku no longer writes at all.
+ */
+export declare const removeRetiredScaffoldFiles: (config: PikkuCLIConfig) => Promise<void>;
 export declare const pruneLegacyScaffoldFiles: (config: PikkuCLIConfig) => Promise<void>;

package/dist/src/utils/remove-legacy-scaffold-file.js

@@ -34,6 +34,29 @@ export const removeLegacyScaffoldFile = async (file) => {
         await rm(legacy, { force: true });
     }
 };
+/**
+ * Delete scaffolds pikku has stopped generating.
+ *
+ * The scenario instrumentation scaffold is why this exists: those four functions
+ * are pikku's own and are now registered by `pikku dev` itself, because as project
+ * source they were indistinguishable from application code and shipped —
+ * `expose: true` — in every deployed bundle. The inspector ignores them by name so
+ * an unregenerated project is already safe, but the file is then dead code that
+ * still imports `zod`, so it goes.
+ *
+ * Unlike `pruneLegacyScaffoldFiles`, which removes a file from a path pikku used
+ * to write to, this removes a file pikku no longer writes at all.
+ */
+export const removeRetiredScaffoldFiles = async (config) => {
+    for (const file of [
+        config.scenariosFunctionsFile,
+        config.scenariosSchemasFile,
+    ]) {
+        if (file && existsSync(file)) {
+            await rm(file, { force: true });
+        }
+    }
+};
 export const pruneLegacyScaffoldFiles = async (config) => {
     for (const file of scaffoldFiles(config)) {
         if (file) {

package/dist/src/utils/serialize-schemas.d.ts

@@ -1,3 +1,5 @@
 import type { JSONValue } from '@pikku/core';
 import type { CLILogger } from '../services/cli-logger.service.js';
-export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, requiredSchemas: Set<string>, supportsImportAttributes: boolean, packageName?: string | null): Promise<void>;
+export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, requiredSchemas: Set<string>, supportsImportAttributes: boolean, packageName?: string | null, 
+/** Names the set in log output — there is more than one now (app, scenario). */
+label?: string): Promise<void>;

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

@@ -1,6 +1,39 @@
 import { writeFileInDir } from './file-writer.js';
-import { mkdir, readdir, unlink, writeFile } from 'fs/promises';
+import { mkdir, readdir, readFile, rename, unlink, writeFile, } from 'fs/promises';
 const SCHEMA_FILE_SUFFIX = '.schema.json';
+/**
+ * Write a schema file without ever exposing a half-written one.
+ *
+ * `writeFile` truncates and then writes, so a reader that opens the path in
+ * between sees an empty file. That reader is real: `pikku scenario run --spawn`
+ * bundles the register while the dev server it just spawned is running codegen,
+ * and esbuild fails the whole run with "Unexpected end of file in JSON" on
+ * whichever schema it happened to catch mid-write. A rename is atomic, so a
+ * reader gets either the previous complete file or the new one.
+ *
+ * Unchanged content is not rewritten at all. Most runs regenerate hundreds of
+ * byte-identical schemas, and every one of those is a window that does not need
+ * to exist — it also stops file watchers waking on output that did not change.
+ */
+async function writeSchemaFile(path, contents) {
+    try {
+        if ((await readFile(path, 'utf-8')) === contents) {
+            return;
+        }
+    }
+    catch {
+        // Unreadable or absent — fall through and write it.
+    }
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+        await writeFile(tmp, contents, 'utf-8');
+        await rename(tmp, path);
+    }
+    catch (e) {
+        await unlink(tmp).catch(() => { });
+        throw e;
+    }
+}
 function toValidIdentifier(name) {
     let result = name.replace(/[-./: ]/g, '_');
     if (/^\d/.test(result)) {
@@ -55,19 +88,21 @@ async function pruneOrphanedSchemaFiles(logger, schemaParentDir, keep) {
         logger.info(`• Removed ${orphans.length} stale schema file(s).\x1b[0m`);
     }
 }
-export async function saveSchemas(logger, schemaParentDir, schemas, requiredSchemas, supportsImportAttributes, packageName) {
+export async function saveSchemas(logger, schemaParentDir, schemas, requiredSchemas, supportsImportAttributes, packageName, 
+/** Names the set in log output — there is more than one now (app, scenario). */
+label = 'schemas') {
     if (requiredSchemas.size === 0) {
         await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
         // Every file in schemas/ is now an orphan: register.gen.ts registers nothing, so
         // leaving them would be exactly the misleading state this prune exists to prevent.
         await pruneOrphanedSchemaFiles(logger, schemaParentDir, new Set());
-        logger.info(`• Skipping schemas since none found.\x1b[0m`);
+        logger.info(`• Skipping ${label} since none found.\x1b[0m`);
         return;
     }
     await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
     await Promise.all(Object.entries(schemas).map(async ([schemaName, schema]) => {
         if (requiredSchemas.has(schemaName)) {
-            await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
+            await writeSchemaFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema));
         }
     }));
     // Sort so register.gen.ts is byte-identical across runs — requiredSchemas is