@pikku/cli 0.12.91 → 0.12.92

package/dist/src/functions/db/migration-identifiers.js

@@ -0,0 +1,262 @@
+/**
+ * Catching camelCase columns at migrate time, before they can half-work.
+ *
+ * Pikku's Kysely runs with `CamelCasePlugin`, so `priceCents` in TypeScript is
+ * `price_cents` in SQL and nothing else. A migration that declares the column
+ * *as* `priceCents` is not merely unconventional — it is broken in the one way
+ * that hides itself: `.selectAll()` compiles to `SELECT *` and never names an
+ * identifier, so the table reads back perfectly, while the first query that
+ * names the column (`.select(['animal.priceCents'])`) asks for `price_cents`
+ * and gets `no such column`. The usual conclusion is that the plugin is broken,
+ * and the usual response is a raw `sql` template or a retreat to `.selectAll()`
+ * — both of which keep the real cause alive.
+ *
+ * There is no exception to escape. Even the Better Auth schema `db generate`
+ * writes is snake_case (`email_verified`, `user_id`), because Better Auth is
+ * handed the app's own Kysely and its camelCase field names compile the same
+ * way everyone else's do.
+ */
+import { splitStatements } from './schema-sql.js';
+export class CamelCaseIdentifierError extends Error {
+    offenders;
+    constructor(offenders) {
+        const lines = offenders.map((o) => `  ${o.file}  ${o.column === null ? o.table : `${o.table}.${o.column}`}  →  ${o.suggestion}`);
+        super(`[PKU-DB-CAMEL] Migrations declare camelCase identifiers.\n\n` +
+            `Pikku's Kysely runs with CamelCasePlugin, which maps camelCase in TypeScript\n` +
+            `to snake_case in SQL. A camelCase column half-works: \`.selectAll()\` emits\n` +
+            `\`SELECT *\` so the table reads fine, but naming the column compiles it to\n` +
+            `snake_case and the database answers \`no such column\`.\n\n` +
+            `${lines.join('\n')}\n\n` +
+            `Fix the column definition in the migration file itself and replay your dev\n` +
+            `database from scratch. Do not write a RENAME COLUMN migration — that leaves\n` +
+            `the banned identifier in a SQL file forever.`);
+        this.offenders = offenders;
+        this.name = 'CamelCaseIdentifierError';
+    }
+}
+/**
+ * Strip comments so a word in prose can never be read as an identifier.
+ *
+ * `splitStatements` already skips over comments when it looks for a boundary,
+ * but it hands back the statement with them still in it, and `-- the userId
+ * column` would otherwise be flagged. Quoting rules are honoured for the same
+ * reason they are there: `'a -- b'` is a string, not a comment.
+ */
+export function stripSqlComments(sql) {
+    let out = '';
+    let i = 0;
+    while (i < sql.length) {
+        const ch = sql[i];
+        if (ch === "'" || ch === '"' || ch === '`') {
+            const start = i;
+            i++;
+            while (i < sql.length) {
+                if (sql[i] === '\\' && ch === "'") {
+                    i += 2;
+                    continue;
+                }
+                if (sql[i] === ch) {
+                    if (sql[i + 1] === ch) {
+                        i += 2;
+                        continue;
+                    }
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            out += sql.slice(start, i);
+            continue;
+        }
+        if (ch === '-' && sql[i + 1] === '-') {
+            const end = sql.indexOf('\n', i);
+            i = end === -1 ? sql.length : end;
+            continue;
+        }
+        if (ch === '/' && sql[i + 1] === '*') {
+            const end = sql.indexOf('*/', i + 2);
+            i = end === -1 ? sql.length : end + 2;
+            // A block comment can span lines, and removing it outright would join two
+            // statements onto one line. A space keeps the tokens either side apart.
+            out += ' ';
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
+const IDENTIFIER = String.raw `"[^"]*"|\`[^\`]*\`|\[[^\]]*\]|[A-Za-z_][A-Za-z_0-9$]*`;
+const CREATE_TABLE = new RegExp(String.raw `^CREATE\s+(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)*TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\S+?)\s*\(`, 'i');
+const ALTER_TABLE = new RegExp(String.raw `^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(\S+)`, 'i');
+const ADD_COLUMN = new RegExp(String.raw `^\s*ADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(${IDENTIFIER})`, 'i');
+const COLUMN_NAME = new RegExp(String.raw `^\s*(${IDENTIFIER})`);
+/**
+ * The words that open a table-level constraint rather than a column.
+ *
+ * Only consulted for an unquoted first token: `"check"` in quotes is a column
+ * named check, however unwise, and skipping it would let `"checkedAt"`'s
+ * neighbours hide behind it.
+ */
+const CONSTRAINT_KEYWORDS = new Set([
+    'constraint',
+    'primary',
+    'foreign',
+    'unique',
+    'check',
+    'exclude',
+    'index',
+    'key',
+    'like',
+    'period',
+    'fulltext',
+    'spatial',
+]);
+/** Drop the quoting a dialect happens to use, leaving the identifier itself. */
+const unquote = (name) => /^["`[]/.test(name) ? name.slice(1, -1) : name;
+const isCamelCase = (name) => /[a-z][A-Z]/.test(name);
+const toSnakeCase = (name) => name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+/**
+ * Walk `sql` from `from` and return the offsets just inside and just outside
+ * the parenthesised group that starts there, or `null` if it never closes.
+ *
+ * Quote-aware, because a `)` inside `DEFAULT ')'` closes nothing.
+ */
+function parenSpan(sql, from) {
+    let depth = 0;
+    let i = from;
+    while (i < sql.length) {
+        const ch = sql[i];
+        if (ch === "'" || ch === '"' || ch === '`') {
+            i++;
+            while (i < sql.length && sql[i] !== ch)
+                i++;
+            i++;
+            continue;
+        }
+        if (ch === '(') {
+            depth++;
+            if (depth === 1)
+                from = i + 1;
+        }
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return { start: from, end: i };
+        }
+        i++;
+    }
+    return null;
+}
+/**
+ * Split a definition list on the commas that separate its items.
+ *
+ * The commas inside `NUMERIC(10,2)`, a `CHECK (x IN ('a','b'))` or a compound
+ * `PRIMARY KEY (a, b)` belong to those and not to the list, so only depth zero
+ * counts.
+ */
+function splitTopLevel(list) {
+    const items = [];
+    let depth = 0;
+    let start = 0;
+    let i = 0;
+    while (i < list.length) {
+        const ch = list[i];
+        if (ch === "'" || ch === '"' || ch === '`') {
+            i++;
+            while (i < list.length && list[i] !== ch)
+                i++;
+            i++;
+            continue;
+        }
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            items.push(list.slice(start, i));
+            start = i + 1;
+        }
+        i++;
+    }
+    items.push(list.slice(start));
+    return items.filter((item) => item.trim().length > 0);
+}
+/**
+ * Every camelCase identifier one migration file declares.
+ *
+ * Only declarations are read — a `CREATE TABLE` column list and an `ALTER TABLE
+ * … ADD COLUMN`. Everywhere else an identifier merely refers to something that
+ * was declared somewhere, and reporting those would name the same mistake once
+ * per reference while adding nothing to the fix.
+ */
+export function findCamelCaseIdentifiers(file, sql) {
+    const offenders = [];
+    for (const statement of splitStatements(stripSqlComments(sql))) {
+        const create = CREATE_TABLE.exec(statement);
+        if (create) {
+            const table = unquote(create[1].split('.').pop());
+            if (isCamelCase(table)) {
+                offenders.push({
+                    file,
+                    table,
+                    column: null,
+                    suggestion: toSnakeCase(table),
+                });
+            }
+            const span = parenSpan(statement, create.index + create[0].length - 1);
+            if (!span)
+                continue;
+            for (const item of splitTopLevel(statement.slice(span.start, span.end))) {
+                const name = COLUMN_NAME.exec(item)?.[1];
+                if (!name)
+                    continue;
+                if (CONSTRAINT_KEYWORDS.has(name.toLowerCase()))
+                    continue;
+                const column = unquote(name);
+                if (isCamelCase(column)) {
+                    offenders.push({
+                        file,
+                        table,
+                        column,
+                        suggestion: toSnakeCase(column),
+                    });
+                }
+            }
+            continue;
+        }
+        const alter = ALTER_TABLE.exec(statement);
+        if (!alter)
+            continue;
+        const table = unquote(alter[1].split('.').pop());
+        // Postgres lets one ALTER carry several actions, and only the ADDs declare.
+        for (const action of splitTopLevel(statement.slice(alter[0].length).replace(/;\s*$/, ''))) {
+            const name = ADD_COLUMN.exec(action)?.[1];
+            if (!name)
+                continue;
+            if (CONSTRAINT_KEYWORDS.has(name.toLowerCase()))
+                continue;
+            const column = unquote(name);
+            if (isCamelCase(column)) {
+                offenders.push({
+                    file,
+                    table,
+                    column,
+                    suggestion: toSnakeCase(column),
+                });
+            }
+        }
+    }
+    return offenders;
+}
+/**
+ * Bail unless every migration on disk is snake_case throughout.
+ *
+ * Reports all of them at once: a camelCase column is rarely alone, and a
+ * one-at-a-time failure turns a single edit into one migrate run per column.
+ */
+export function assertSnakeCaseIdentifiers(migrations) {
+    const offenders = migrations.flatMap(({ name, sql }) => findCamelCaseIdentifiers(name, sql));
+    if (offenders.length > 0)
+        throw new CamelCaseIdentifierError(offenders);
+}

package/dist/src/functions/db/migration-provenance.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Who declared a table, and where the declaration came from.
+ *
+ * `source` is the stable identifier a consumer filters on — the same label
+ * `db generate` gives the migration it writes (`better-auth`, `pikku-runtime`,
+ * an addon's flattened package name). `origin` is the prose from the migration
+ * header, written for a human reading a tooltip.
+ */
+export interface TableProvenance {
+    source: string;
+    origin: string;
+}
+/**
+ * Drop the schema qualifier and any quoting, so `"app"."user"` and `user` are
+ * the same key.
+ *
+ * Introspection reports a bare name on SQLite and a qualified one on Postgres,
+ * while a migration may write either — comparing on the bare, unquoted name is
+ * the only form both sides agree on.
+ */
+export declare function bareUnquotedTableName(name: string): string;
+/**
+ * Read the table→source map out of a project's migration directory.
+ *
+ * Provenance is decided at `db generate` time, but the schema JSON is written
+ * at `db migrate` time, and the two commands do not have to run together. The
+ * migration files are the durable record that survives between them: each
+ * generated one carries its origin in a header and its source in its filename,
+ * so re-reading them costs a directory scan and needs neither a Better Auth
+ * config load nor a live database.
+ *
+ * Tables absent from the result are app-owned — including every table when the
+ * project has no generated migrations at all.
+ */
+export declare function readMigrationProvenance(migrationsDir: string): Map<string, TableProvenance>;

package/dist/src/functions/db/migration-provenance.js

@@ -0,0 +1,80 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * The header `db generate` stamps on every migration it writes.
+ *
+ * Matching it is what separates a generated migration from one the project
+ * authored: a file without this line declares the project's own tables, and
+ * anything it creates is app-owned by definition.
+ */
+const GENERATED_HEADER = /^-- Generated by `pikku db generate` from (.+)\.\s*$/m;
+/** `0002-pikku-runtime.sql` → `pikku-runtime`. */
+const MIGRATION_LABEL = /^\d+-(.+)\.sql$/;
+/**
+ * Strip `--` line comments so a `CREATE TABLE` quoted inside a REVIEW note is
+ * not mistaken for one the migration actually runs.
+ */
+const stripComments = (sql) => sql.replace(/--[^\n]*/g, '');
+const CREATE_TABLE = /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(;]+)/gi;
+/**
+ * Drop the schema qualifier and any quoting, so `"app"."user"` and `user` are
+ * the same key.
+ *
+ * Introspection reports a bare name on SQLite and a qualified one on Postgres,
+ * while a migration may write either — comparing on the bare, unquoted name is
+ * the only form both sides agree on.
+ */
+export function bareUnquotedTableName(name) {
+    const last = name.split('.').pop() ?? name;
+    return last.replace(/^["'`[]|["'`\]]$/g, '');
+}
+/**
+ * Read the table→source map out of a project's migration directory.
+ *
+ * Provenance is decided at `db generate` time, but the schema JSON is written
+ * at `db migrate` time, and the two commands do not have to run together. The
+ * migration files are the durable record that survives between them: each
+ * generated one carries its origin in a header and its source in its filename,
+ * so re-reading them costs a directory scan and needs neither a Better Auth
+ * config load nor a live database.
+ *
+ * Tables absent from the result are app-owned — including every table when the
+ * project has no generated migrations at all.
+ */
+export function readMigrationProvenance(migrationsDir) {
+    const provenance = new Map();
+    let files;
+    try {
+        files = readdirSync(migrationsDir);
+    }
+    catch {
+        // No migrations directory is the ordinary case for a project that has not
+        // run `db generate` yet — every table is app-owned.
+        return provenance;
+    }
+    for (const file of files.filter((f) => f.endsWith('.sql')).sort()) {
+        let sql;
+        try {
+            sql = readFileSync(join(migrationsDir, file), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const header = GENERATED_HEADER.exec(sql);
+        if (!header)
+            continue;
+        const label = MIGRATION_LABEL.exec(file);
+        if (!label)
+            continue;
+        const source = label[1];
+        const origin = header[1];
+        for (const match of stripComments(sql).matchAll(CREATE_TABLE)) {
+            const table = bareUnquotedTableName(match[1]);
+            // First writer wins: a later migration that recreates a table is fixing
+            // it, not claiming it.
+            if (!provenance.has(table))
+                provenance.set(table, { source, origin });
+        }
+    }
+    return provenance;
+}

package/dist/src/functions/db/schema-sql.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 declare function splitStatements(sql: string): string[];
+/**
+ * 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 declare function bareTableName(name: string): string;
+/**
+ * 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 declare function tableCreationSql(sql: string, table: string): string[];

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/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/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;