@pikku/cli 0.12.90 → 0.12.92

package/dist/src/functions/db/schema-sql.js

@@ -0,0 +1,135 @@
+/**
+ * Reading a schema source's own SQL back out, one table at a time.
+ *
+ * A source hands `db generate` both what must exist (`tables`) and what creates
+ * it (`sql`). The column map is a comparison surface — it answers "is this
+ * table there, and does it have these columns" — and it is deliberately lossy:
+ * primary keys, foreign keys, uniqueness, check constraints and indexes are all
+ * absent from it. So the moment the generator has to *create* something, the
+ * only honest source is the SQL, and this is what pulls the relevant part of it
+ * out.
+ */
+/**
+ * Split a SQL script into its top-level statements, semicolons included.
+ *
+ * A naive `split(';')` is wrong in a way that only shows up later: a semicolon
+ * inside a string literal, a quoted identifier or a comment is not a statement
+ * boundary, and cutting there yields two fragments that are each valid-looking
+ * and neither of which does what the original did.
+ */
+export function splitStatements(sql) {
+    const statements = [];
+    let start = 0;
+    let i = 0;
+    const closeQuote = (quote) => {
+        i++;
+        while (i < sql.length) {
+            if (sql[i] === '\\' && quote === "'") {
+                i += 2;
+                continue;
+            }
+            if (sql[i] === quote) {
+                // A doubled quote is an escaped one, not the end of the literal.
+                if (sql[i + 1] === quote) {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                return;
+            }
+            i++;
+        }
+    };
+    while (i < sql.length) {
+        const ch = sql[i];
+        if (ch === "'" || ch === '"' || ch === '`') {
+            closeQuote(ch);
+            continue;
+        }
+        if (ch === '-' && sql[i + 1] === '-') {
+            const end = sql.indexOf('\n', i);
+            i = end === -1 ? sql.length : end + 1;
+            continue;
+        }
+        if (ch === '/' && sql[i + 1] === '*') {
+            const end = sql.indexOf('*/', i + 2);
+            i = end === -1 ? sql.length : end + 2;
+            continue;
+        }
+        // Postgres dollar quoting: everything between `$tag$` and its twin is a
+        // literal, and a function body written that way is full of semicolons.
+        if (ch === '$') {
+            const tag = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
+            if (tag) {
+                const end = sql.indexOf(tag[0], i + tag[0].length);
+                i = end === -1 ? sql.length : end + tag[0].length;
+                continue;
+            }
+        }
+        if (ch === ';') {
+            const statement = sql.slice(start, i + 1).trim();
+            if (statement.length > 1)
+                statements.push(statement);
+            start = i + 1;
+        }
+        i++;
+    }
+    // A script whose last statement has no trailing semicolon still ran it.
+    const tail = sql.slice(start).trim();
+    if (tail.length > 0)
+        statements.push(tail);
+    return statements;
+}
+/**
+ * Reduce a written table name to the form two sources can be compared on.
+ *
+ * The same table is `two_factor` to one writer, `"two_factor"` to Kysely and
+ * `public.two_factor` to Postgres introspection. Dropping the schema qualifier,
+ * the quoting and the case is the only shape all three agree on.
+ */
+export function bareTableName(name) {
+    const last = name.split('.').pop() ?? name;
+    return last.replace(/^["'`[]|["'`\]]$/g, '').toLowerCase();
+}
+const CREATE_TABLE = /^CREATE\s+(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)*TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)/i;
+const CREATE_INDEX = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?\S+\s+ON\s+(?:ONLY\s+)?([^\s(]+)/i;
+const ALTER_TABLE = /^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?([^\s(]+)/i;
+/**
+ * Every statement in `sql` that builds `table`, in the order the source wrote
+ * them.
+ *
+ * The `CREATE TABLE` and its indexes, plus any `ALTER TABLE` the source uses to
+ * hang a constraint on it afterwards — which together are what the column list
+ * cannot express. Source order is preserved because it is load-bearing: an
+ * index cannot precede its table, and a table cannot precede one it references.
+ *
+ * An empty result means the source's SQL does not visibly create the table.
+ * That is a real answer rather than a failure — a source may create a table
+ * from something other than a literal `CREATE TABLE` — and the caller is
+ * expected to fall back rather than emit nothing.
+ */
+export function tableCreationSql(sql, table) {
+    const wanted = bareTableName(table);
+    const statements = [];
+    let creates = false;
+    for (const statement of splitStatements(sql)) {
+        const create = CREATE_TABLE.exec(statement);
+        if (create && bareTableName(create[1]) === wanted) {
+            creates = true;
+            statements.push(statement);
+            continue;
+        }
+        const index = CREATE_INDEX.exec(statement);
+        if (index && bareTableName(index[1]) === wanted) {
+            statements.push(statement);
+            continue;
+        }
+        const alter = ALTER_TABLE.exec(statement);
+        if (alter && bareTableName(alter[1]) === wanted) {
+            statements.push(statement);
+        }
+    }
+    // Indexes and alters without the table they belong to would fail on their own,
+    // and their presence says the table came from somewhere this cannot read.
+    return creates ? statements : [];
+}

package/dist/src/functions/db/sqlite/sqlite-kysely.js

@@ -1,4 +1,21 @@
 import { Kysely, SqliteDialect, CamelCasePlugin, } from 'kysely';
+/**
+ * Whether a value is a JSON column's worth of data rather than some other
+ * object that merely happens to be one. A `Map`, a `RegExp` or a class
+ * instance stringifies to `"{}"` or to a partial view of itself, which would
+ * silently persist an empty JSON blob where the caller meant something.
+ *
+ * Kept in lockstep with `isJsonEncodable` in `@pikku/kysely-sqlite`'s
+ * LibsqlWebDialect: whatever binds here under `pikku dev` has to bind the same
+ * way once the app is deployed, or the dev and deployed runtimes disagree
+ * about what a query may do.
+ */
+function isJsonEncodable(v) {
+    if (Array.isArray(v))
+        return true;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
 function coerce(v) {
     if (v === null || v === undefined)
         return null;
@@ -8,8 +25,11 @@ function coerce(v) {
         return v.toISOString();
     if (v instanceof Uint8Array)
         return v;
-    if (typeof v === 'object')
-        return JSON.stringify(v);
+    if (typeof v === 'object') {
+        if (isJsonEncodable(v))
+            return JSON.stringify(v);
+        throw new Error(`sqlite: unsupported argument type ${v.constructor?.name ?? 'object'}`);
+    }
     return v;
 }
 // A statement returns rows when it is a SELECT or carries a RETURNING clause.

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

@@ -4,19 +4,22 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeFunctionImports } from './serialize-function-imports.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, reattachFunctionServices, } from '../../../utils/strip-verbose-meta.js';
+import { partitionScenarioFunctions, partitionScenarioFunctionsMeta, } from '../scenarios/scenario-partition.js';
+import { serializeScenarioFunctionMeta } from '../scenarios/serialize-scenario-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { functionsMetaFile, functionsMetaJsonFile, functionsFile, packageMappings, schema, } = config;
-        let minimalMeta = stripVerboseFields(functions.meta);
+        const { functionsMetaFile, functionsMetaJsonFile, functionsFile, scenarioStepsFile, scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings, schema, } = config;
+        const { app: appFunctionsMeta, scenario: scenarioFunctionsMeta } = partitionScenarioFunctionsMeta(functions.meta);
+        let minimalMeta = stripVerboseFields(appFunctionsMeta);
         if (config.addonName) {
-            minimalMeta = reattachFunctionServices(minimalMeta, functions.meta);
+            minimalMeta = reattachFunctionServices(minimalMeta, appFunctionsMeta);
         }
         await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
         // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(functions.meta)) {
+        if (hasVerboseFields(appFunctionsMeta)) {
             const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(functions.meta, null, 2));
+            await writeFileInDir(logger, verbosePath, JSON.stringify(appFunctionsMeta, null, 2));
         }
         const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
@@ -31,11 +34,26 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
         const hasFunctions = functions.files.size > 0;
         const shouldGenerateFunctionsFile = isAddon ? hasFunctions : hasRPCs;
+        // For addon packages, use all function files; for main packages, use internal RPC files
+        const filesToRegister = isAddon ? functions.files : rpc.internalFiles;
+        const { app: appFiles, scenario: scenarioFiles } = partitionScenarioFunctions(filesToRegister, functions.meta);
         if (shouldGenerateFunctionsFile) {
-            // For addon packages, use all function files; for main packages, use internal RPC files
-            const filesToRegister = isAddon ? functions.files : rpc.internalFiles;
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.addonName));
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, appFiles, appFunctionsMeta, packageMappings, config.addonName));
         }
+        // Always written, even when empty: a project that deletes its last scenario
+        // must stop registering the one it had, and the scenario bootstrap imports
+        // these unconditionally.
+        await writeFileInDir(logger, scenarioStepsMetaJsonFile, JSON.stringify(stripVerboseFields(scenarioFunctionsMeta), null, 2));
+        // The bootstrap imports the stripped copy; the verbose one is read off disk
+        // by whatever documents a scenario — the console needs `sourceFile` and
+        // `exportedName` to show the code a step runs.
+        if (hasVerboseFields(scenarioFunctionsMeta)) {
+            await writeFileInDir(logger, scenarioStepsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json'), JSON.stringify(scenarioFunctionsMeta, null, 2));
+        }
+        await writeFileInDir(logger, scenarioStepsMetaFile, serializeScenarioFunctionMeta(getFileImportRelativePath(scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings), getFileImportRelativePath(scenarioStepsMetaFile, functionsMetaFile, packageMappings), supportsImportAttributes, config.addonName));
+        await writeFileInDir(logger, scenarioStepsFile, scenarioFiles.size === 0
+            ? 'export {}'
+            : serializeFunctionImports(scenarioStepsFile, scenarioFiles, scenarioFunctionsMeta, packageMappings, config.addonName));
         return shouldGenerateFunctionsFile;
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.js

@@ -1,6 +1,7 @@
 import { pikkuSessionlessFunc } from '#pikku';
 import { saveSchemas } from '../../../utils/serialize-schemas.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { partitionRequiredSchemas } from '../scenarios/scenario-schema-partition.js';
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -16,7 +17,18 @@ export const pikkuSchemas = pikkuSessionlessFunc({
             Object.keys(visitState.schemas).length === 0) {
             return undefined;
         }
-        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.addonName || null);
+        const supportsImportAttributes = config.schema?.supportsImportAttributes ?? true;
+        const { appRequired, scenarioOnly } = partitionRequiredSchemas({
+            functionsMeta: visitState.functions.meta,
+            requiredSchemas: visitState.requiredSchemas,
+            getUniqueName: (name) => visitState.functions.typesMap.getUniqueName(name),
+            schemasFromTypes: config.schemasFromTypes,
+        });
+        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, appRequired, supportsImportAttributes, config.addonName || null);
+        // Always written, even when empty — the scenario bootstrap imports it
+        // unconditionally, and a project that deleted its last scenario must stop
+        // registering the schemas it had.
+        await saveSchemas(logger, config.scenarioSchemaDirectory, visitState.schemas, scenarioOnly, supportsImportAttributes, config.addonName || null, 'scenario schemas');
         return true;
     },
     middleware: [

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

@@ -7,7 +7,7 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
         ? nodeCategories.map((c) => `'${c}'`).join(' | ')
         : 'string';
     const workflowImport = workflowTypesImport ||
-        `import type { TypedWorkflow, TypedScenario } from '../workflow/pikku-workflow-types.gen.js'`;
+        `import type { TypedWorkflow, TypedScenario, TypedScenarioActors } from '../workflow/pikku-workflow-types.gen.js'`;
     // Falls back to `string` when a project has no scopes codegen, so that
     // `scopes` stays usable rather than resolving to an unbound type name.
     const scopesImport = scopesTypeImport || `type ScopeId = string`;
@@ -299,7 +299,7 @@ export type PikkuFunctionSessionless<
     Out,
     RequiredServices,
     Session,
-    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario>, RequiredWires>
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario, TypedScenarioActors>, RequiredWires>
   >
 
 /**
@@ -320,7 +320,7 @@ export type PikkuFunction<
     Out,
     RequiredServices,
     Session,
-    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario>, RequiredWires>
+    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario, TypedScenarioActors>, RequiredWires>
   >
 
 /**

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

@@ -2,6 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { withoutScenarios } from '../scenarios/scenario-partition.js';
 export function filterInternalRPCMeta(internalMeta, functionsMeta) {
     const filteredInternalMeta = {};
     for (const [key, value] of Object.entries(internalMeta)) {
@@ -18,7 +19,11 @@ export const pikkuRPC = pikkuSessionlessFunc({
         // Keep direct function ids and unversioned aliases whose target function
         // survived filtering. Without the second check, aliases like `listCards`
         // get dropped even though `listCards@v2` still exists.
-        const filteredInternalMeta = filterInternalRPCMeta(rpc.internalMeta, functions.meta);
+        // Scenarios are excluded along with the steps they call: a scenario name in
+        // the app's RPC meta is a name a deployed bundle carries and, in principle,
+        // dispatches. Scenario runs don't need the entry — the mapping is the
+        // identity, which is also the fallback when a name is absent.
+        const filteredInternalMeta = filterInternalRPCMeta(rpc.internalMeta, withoutScenarios(functions.meta));
         if (Object.keys(filteredInternalMeta).length > 0) {
             await writeFileInDir(logger, rpcInternalWiringMetaJsonFile, JSON.stringify(filteredInternalMeta, null, 2));
             const jsonImportPath = getFileImportRelativePath(rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings);

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

@@ -0,0 +1,10 @@
+/**
+ * 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 declare const registerScenarioInstrumentation: (requireAuth: boolean) => void;

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

@@ -0,0 +1,42 @@
+import type { FunctionsMeta } from '@pikku/core';
+import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
+export type WiringFileMap = Map<string, {
+    path: string;
+    exportedName: string;
+}>;
+/**
+ * Scenario steps and scenarios are ordinary pikku functions and workflows, so
+ * without a split they register into the same bootstrap a deployed server
+ * imports — dragging every step body (and whatever it imports: Playwright, test
+ * fixtures, assertion helpers) into production. These partitions are what keep
+ * 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;
+};
+export declare const partitionScenarioFunctionsMeta: (functionsMeta: FunctionsMeta) => {
+    app: FunctionsMeta;
+    scenario: FunctionsMeta;
+};
+export declare const isScenarioWorkflow: (graphMeta: SerializedWorkflowGraphs, name: string) => boolean;
+export declare const partitionScenarioWorkflows: (workflowNames: string[], workflowFiles: WiringFileMap, graphMeta: SerializedWorkflowGraphs) => {
+    appNames: string[];
+    scenarioNames: string[];
+    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

@@ -0,0 +1,71 @@
+/**
+ * Scenario steps and scenarios are ordinary pikku functions and workflows, so
+ * without a split they register into the same bootstrap a deployed server
+ * imports — dragging every step body (and whatever it imports: Playwright, test
+ * fixtures, assertion helpers) into production. These partitions are what keep
+ * 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 (isScenarioFunction(functionsMeta[name])) {
+            scenario.set(name, entry);
+        }
+        else {
+            app.set(name, entry);
+        }
+    }
+    return { app, scenario };
+};
+export const partitionScenarioFunctionsMeta = (functionsMeta) => {
+    const app = {};
+    const scenario = {};
+    for (const [name, meta] of Object.entries(functionsMeta)) {
+        if (isScenarioFunction(meta)) {
+            scenario[name] = meta;
+        }
+        else {
+            app[name] = meta;
+        }
+    }
+    return { app, scenario };
+};
+export const isScenarioWorkflow = (graphMeta, name) => graphMeta[name]?.source === 'scenario';
+export const partitionScenarioWorkflows = (workflowNames, workflowFiles, graphMeta) => {
+    const appNames = [];
+    const scenarioNames = [];
+    for (const name of workflowNames) {
+        if (isScenarioWorkflow(graphMeta, name)) {
+            scenarioNames.push(name);
+        }
+        else {
+            appNames.push(name);
+        }
+    }
+    const appFiles = new Map();
+    const scenarioFiles = new Map();
+    for (const [name, entry] of workflowFiles) {
+        if (isScenarioWorkflow(graphMeta, name)) {
+            scenarioFiles.set(name, entry);
+        }
+        else {
+            appFiles.set(name, entry);
+        }
+    }
+    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/wirings/scenarios/serialize-feature-meta.d.ts

@@ -0,0 +1,14 @@
+import type { FeaturesMeta } from '@pikku/core/workflow/types';
+import type { InspectorFeature } from '@pikku/inspector';
+/**
+ * The feature meta the console reads, built from what the inspector could read
+ * off the source.
+ *
+ * Entry order is the declared order and is deliberately not sorted — a
+ * feature's scenarios read top to bottom the way they were written, the same
+ * way a gherkin Feature file does.
+ *
+ * The source path is dropped: it is absolute to the machine that generated the
+ * meta, and nothing rendering a feature needs it.
+ */
+export declare const buildFeaturesMeta: (featureFiles: Map<string, InspectorFeature>) => FeaturesMeta;