@pikku/cli 0.12.33 → 0.12.35

package/dist/src/functions/db/local-db.js

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, } from 'node:fs';
 import { resolve, isAbsolute, relative, dirname, join } from 'node:path';
-import { execSync } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
+import { runInNewContext } from 'node:vm';
+import { transformSync } from 'esbuild';
 import { migrate } from './db-migrator.js';
 import { generateSchemaTypes } from './db-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
@@ -42,7 +42,11 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
         classificationMapFile: join(outDir, 'db', 'classification-map.gen.d.ts'),
         schemaJsonFile: join(outDir, 'db', 'pikku-db-schema.gen.json'),
         classificationsFile: join(rootDir, 'db', 'annotations.ts'),
-        classificationsGenJsonFile: join(outDir, 'db', 'annotations.gen.json'),
+        // Compiled sidecar lives beside the authored annotations.ts in db/ — this is
+        // where both consumers read it: the codegen's loadAnnotations() and the
+        // pikku-console addon (db/annotations.gen.json). Writing it into outDir
+        // (.pikku) would leave both readers looking at a file that never appears.
+        classificationsGenJsonFile: join(rootDir, 'db', 'annotations.gen.json'),
         zodFile: join(outDir, 'db', 'zod.gen.ts'),
         camelCase: true,
     });
@@ -87,6 +91,9 @@ function resolveAgainst(root, p) {
 export async function migrateAndCodegen(resolved) {
     let migrateResult;
     let codegenResult;
+    // Compile any authored db/annotations.ts → sidecar BEFORE codegen so edits
+    // reflect in a single `db migrate` (codegen reads the sidecar).
+    compileClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile);
     if (resolved.dialect === 'sqlite') {
         mkdirSync(dirname(resolved.dbFile), { recursive: true });
         const runtime = await loadSqliteRuntime();
@@ -103,7 +110,7 @@ export async function migrateAndCodegen(resolved) {
                 schemaJsonFile: resolved.schemaJsonFile,
                 camelCase: resolved.camelCase,
                 rootDir: resolved.rootDir,
-                migrationsDir: resolved.migrationsDir,
+                dialect: 'sqlite',
             });
         }
         finally {
@@ -129,7 +136,7 @@ export async function migrateAndCodegen(resolved) {
                     schemaJsonFile: resolved.schemaJsonFile,
                     camelCase: resolved.camelCase,
                     rootDir: resolved.rootDir,
-                    migrationsDir: resolved.migrationsDir,
+                    dialect: 'postgres',
                 });
             }
             finally {
@@ -143,9 +150,13 @@ export async function migrateAndCodegen(resolved) {
     const zodResult = generateZodTypes({
         schemaFile: resolved.schemaFile,
         outFile: resolved.zodFile,
+        formats: codegenResult.zodFormats,
     });
     // ── Classifications step ──────────────────────────────────────────────────
-    const { scaffolded, jsonWritten } = syncClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile, codegenResult.tables);
+    // Scaffold the authored file if missing (needs the table list), then compile
+    // it to the sidecar so a freshly-scaffolded file is captured too.
+    const scaffolded = scaffoldClassificationsFile(resolved.classificationsFile, codegenResult.tables);
+    const jsonWritten = compileClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile);
     return {
         migrate: migrateResult,
         codegen: codegenResult,
@@ -179,86 +190,93 @@ export function reset(resolved, rootDir) {
 }
 // ── Classification sync ───────────────────────────────────────────────────────
 /**
- * Loads `db/classifications.ts` via tsx, serialises it to
- * `.pikku/db/classifications.gen.json` for runtime consumption (console, etc.).
- *
- * If `db/classifications.ts` doesn't exist yet, writes a scaffold with every
- * table defaulting to `private` so the developer has a starting point.
+ * If `db/annotations.ts` doesn't exist yet, write a scaffold listing every
+ * table/column so the developer has a typed starting point. Every field of
+ * `ColumnEntry` is optional, so the empty-per-table scaffold is valid and means
+ * "everything default `private`". Returns whether a scaffold was written.
  */
-function syncClassifications(classificationsFile, genJsonFile, tableNames) {
-    let scaffolded = false;
-    if (!existsSync(classificationsFile)) {
-        const relMap = join(dirname(classificationsFile), '..', '.pikku', 'db', 'classification-map.gen.d.ts');
-        const relMapPosix = relMap.replace(/\\/g, '/');
-        const groups = new Map();
-        for (const name of tableNames) {
-            const dot = name.indexOf('.');
-            const schema = dot >= 0 ? name.slice(0, dot) : '';
-            const table = dot >= 0 ? name.slice(dot + 1) : name;
-            if (!groups.has(schema))
-                groups.set(schema, []);
-            groups.get(schema).push(table);
-        }
-        const bodyLines = [
-            `import type { DbClassificationMap } from '${relMapPosix}'`,
-            ``,
-            `export const classifications = {`,
-        ];
-        for (const [schema, tables] of groups) {
-            if (schema)
-                bodyLines.push(`  ${JSON.stringify(schema)}: {`);
-            for (const table of tables) {
-                bodyLines.push(schema
-                    ? `    ${JSON.stringify(table)}: {`
-                    : `  ${JSON.stringify(table)}: {`);
-                bodyLines.push(schema ? `    },` : `  },`);
-            }
-            if (schema)
-                bodyLines.push(`  },`);
+function scaffoldClassificationsFile(classificationsFile, tableNames) {
+    if (existsSync(classificationsFile))
+        return false;
+    const relMap = join(dirname(classificationsFile), '..', '.pikku', 'db', 'classification-map.gen.d.ts');
+    const relMapPosix = relMap.replace(/\\/g, '/');
+    const groups = new Map();
+    for (const name of tableNames) {
+        const dot = name.indexOf('.');
+        const schema = dot >= 0 ? name.slice(0, dot) : '';
+        const table = dot >= 0 ? name.slice(dot + 1) : name;
+        if (!groups.has(schema))
+            groups.set(schema, []);
+        groups.get(schema).push(table);
+    }
+    const bodyLines = [
+        `import type { DbClassificationMap } from '${relMapPosix}'`,
+        ``,
+        `export const classifications = {`,
+    ];
+    for (const [schema, tables] of groups) {
+        if (schema)
+            bodyLines.push(`  ${JSON.stringify(schema)}: {`);
+        for (const table of tables) {
+            bodyLines.push(schema
+                ? `    ${JSON.stringify(table)}: {`
+                : `  ${JSON.stringify(table)}: {`);
+            bodyLines.push(schema ? `    },` : `  },`);
         }
-        bodyLines.push(`} satisfies DbClassificationMap`, ``);
-        mkdirSync(dirname(classificationsFile), { recursive: true });
-        writeFileSync(classificationsFile, bodyLines.join('\n'), 'utf8');
-        scaffolded = true;
+        if (schema)
+            bodyLines.push(`  },`);
     }
-    // Resolve tsx from the CLI package's own node_modules so it works regardless
-    // of whether the user's project has tsx installed.
-    const _require = createRequire(fileURLToPath(import.meta.url));
-    let tsxEsmPath = null;
+    bodyLines.push(`} satisfies DbClassificationMap`, ``);
+    mkdirSync(dirname(classificationsFile), { recursive: true });
+    writeFileSync(classificationsFile, bodyLines.join('\n'), 'utf8');
+    return true;
+}
+/**
+ * Compile `db/annotations.ts` into the `annotations.gen.json` sidecar that the
+ * codegen and the pikku-console addon read. No-op if the authored file doesn't
+ * exist (nothing to compile yet). Returns whether the sidecar changed on disk.
+ *
+ * Uses esbuild (a CLI dependency) to transpile the TS in-process and a `vm`
+ * sandbox to evaluate it — no subprocess and no tsx. The previous `node --import
+ * tsx/esm` subprocess silently fails on Node ≥ 23 (ERR_REQUIRE_CYCLE_MODULE),
+ * which is why this sidecar never materialised before.
+ *
+ * Run BEFORE codegen so authored edits reflect in a single `db migrate` (and
+ * again after, to capture a freshly-scaffolded file).
+ */
+function compileClassifications(classificationsFile, genJsonFile) {
+    if (!existsSync(classificationsFile))
+        return false;
+    let value;
     try {
-        tsxEsmPath = _require.resolve('tsx/esm');
+        const src = readFileSync(classificationsFile, 'utf8');
+        const { code } = transformSync(src, {
+            loader: 'ts',
+            format: 'cjs',
+        });
+        const mod = { exports: {} };
+        runInNewContext(code, {
+            module: mod,
+            exports: mod.exports,
+            require: createRequire(classificationsFile),
+        });
+        value = Object.values(mod.exports)[0];
     }
     catch {
-        // tsx not bundled with this CLI install — skip JSON emit
+        return false; // syntax/transform error — skip JSON emit
     }
-    const script = [
-        `import * as mod from ${JSON.stringify(classificationsFile)}`,
-        `const val = Object.values(mod)[0]`,
-        `process.stdout.write(JSON.stringify(val))`,
-    ].join('\n');
-    let jsonWritten = false;
-    if (tsxEsmPath) {
-        try {
-            const json = execSync(`node --import ${JSON.stringify(tsxEsmPath)} --input-type=module`, {
-                input: script,
-                encoding: 'utf8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            const existing = existsSync(genJsonFile)
-                ? readFileSync(genJsonFile, 'utf8')
-                : null;
-            const next = JSON.stringify(JSON.parse(json), null, 2) + '\n';
-            if (existing !== next) {
-                mkdirSync(dirname(genJsonFile), { recursive: true });
-                writeFileSync(genJsonFile, next, 'utf8');
-                jsonWritten = true;
-            }
-        }
-        catch {
-            // annotations file has syntax errors — skip JSON emit
-        }
+    if (value === undefined)
+        return false;
+    const next = JSON.stringify(value, null, 2) + '\n';
+    const existing = existsSync(genJsonFile)
+        ? readFileSync(genJsonFile, 'utf8')
+        : null;
+    if (existing !== next) {
+        mkdirSync(dirname(genJsonFile), { recursive: true });
+        writeFileSync(genJsonFile, next, 'utf8');
+        return true;
     }
-    return { scaffolded, jsonWritten };
+    return false;
 }
 export async function createKysely(resolved) {
     mkdirSync(dirname(resolved.dbFile), { recursive: true });

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -33,6 +33,7 @@ export class PostgresIntrospector {
         const result = await this.client.query(`SELECT
          c.column_name,
          c.data_type,
+         c.udt_name,
          c.is_nullable,
          c.column_default,
          c.is_generated,
@@ -54,6 +55,7 @@ export class PostgresIntrospector {
         return result.rows.map((r) => ({
             name: r.column_name,
             type: r.data_type,
+            udtName: r.udt_name,
             notNull: r.is_nullable === 'NO',
             pk: Boolean(r.is_pk),
             defaultValue: r.column_default,

package/dist/src/functions/db/zod-codegen.d.ts

@@ -1,6 +1,44 @@
+/**
+ * Canonical map of `format` tokens (authored in `db/annotations.ts`) to the zod
+ * expression they emit. These are all *string* refinements — they do not change
+ * the column's TypeScript type (it stays `string`), only the runtime validator.
+ * This is the single source of truth: `annotation-parser` imports it to validate
+ * authored values and `db-codegen` imports the key list to emit the `format`
+ * union in `ColumnEntry`. All confirmed present in zod 4.
+ */
+export declare const ZOD_FORMATS: {
+    readonly email: "z.email()";
+    readonly url: "z.url()";
+    readonly emoji: "z.emoji()";
+    readonly e164: "z.e164()";
+    readonly jwt: "z.jwt()";
+    readonly cuid: "z.cuid()";
+    readonly cuid2: "z.cuid2()";
+    readonly ulid: "z.ulid()";
+    readonly nanoid: "z.nanoid()";
+    readonly base64: "z.base64()";
+    readonly base64url: "z.base64url()";
+    readonly ipv4: "z.ipv4()";
+    readonly ipv6: "z.ipv6()";
+    readonly cidrv4: "z.cidrv4()";
+    readonly cidrv6: "z.cidrv6()";
+    readonly isoDate: "z.iso.date()";
+    readonly isoTime: "z.iso.time()";
+    readonly isoDatetime: "z.iso.datetime()";
+    readonly isoDuration: "z.iso.duration()";
+};
+export type ZodFormat = keyof typeof ZOD_FORMATS;
 export interface ZodCodegenOptions {
     schemaFile: string;
     outFile: string;
+    /**
+     * Per-interface, per-field `format` overrides. Keyed by the *interface* name
+     * (PascalCase, as it appears in `schema.d.ts`) and the *field* name (camelCase),
+     * matching how `parseTables` reads the schema. Computed by `db-codegen` (which
+     * owns the snake→Pascal/camel name mapping) so this emitter stays a dumb
+     * string→zod translator.
+     */
+    formats?: Record<string, Record<string, ZodFormat>>;
 }
 export interface ZodCodegenResult {
     outFile: string;

package/dist/src/functions/db/zod-codegen.js

@@ -1,11 +1,40 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+/**
+ * Canonical map of `format` tokens (authored in `db/annotations.ts`) to the zod
+ * expression they emit. These are all *string* refinements — they do not change
+ * the column's TypeScript type (it stays `string`), only the runtime validator.
+ * This is the single source of truth: `annotation-parser` imports it to validate
+ * authored values and `db-codegen` imports the key list to emit the `format`
+ * union in `ColumnEntry`. All confirmed present in zod 4.
+ */
+export const ZOD_FORMATS = {
+    email: 'z.email()',
+    url: 'z.url()',
+    emoji: 'z.emoji()',
+    e164: 'z.e164()',
+    jwt: 'z.jwt()',
+    cuid: 'z.cuid()',
+    cuid2: 'z.cuid2()',
+    ulid: 'z.ulid()',
+    nanoid: 'z.nanoid()',
+    base64: 'z.base64()',
+    base64url: 'z.base64url()',
+    ipv4: 'z.ipv4()',
+    ipv6: 'z.ipv6()',
+    cidrv4: 'z.cidrv4()',
+    cidrv6: 'z.cidrv6()',
+    isoDate: 'z.iso.date()',
+    isoTime: 'z.iso.time()',
+    isoDatetime: 'z.iso.datetime()',
+    isoDuration: 'z.iso.duration()',
+};
 const INTERFACE_RE = /export\s+interface\s+(\w+)\s*\{([^}]*)\}/g;
 const FIELD_RE = /^\s*(\w+)\s*:\s*(.+?)\s*$/gm;
 export function generateZodTypes(options) {
     const src = readFileSync(options.schemaFile, 'utf8');
     const tables = parseTables(src);
-    const body = emitZodModule(tables);
+    const body = emitZodModule(tables, options.formats ?? {});
     let existing = null;
     try {
         existing = readFileSync(options.outFile, 'utf8');
@@ -39,7 +68,7 @@ function parseTables(src) {
     }
     return tables;
 }
-function emitZodModule(tables) {
+function emitZodModule(tables, formats) {
     const lines = [];
     lines.push('// Generated by @pikku/cli — do not edit by hand.');
     lines.push('// Run `pikku db migrate` to refresh.');
@@ -49,8 +78,9 @@ function emitZodModule(tables) {
     for (const table of tables) {
         const rowFields = [];
         const insertFields = [];
+        const tableFormats = formats[table.name] ?? {};
         for (const field of table.fields) {
-            const { schema, generated } = zodForType(field.type);
+            const { schema, generated } = zodForType(field.type, tableFormats[field.name]);
             rowFields.push(`  ${field.name}: ${schema},`);
             insertFields.push(`  ${field.name}: ${schema}${generated ? '.optional()' : ''},`);
         }
@@ -67,43 +97,200 @@ function emitZodModule(tables) {
     }
     return `${lines.join('\n')}\n`;
 }
-function zodForType(tsType) {
-    const generatedMatch = tsType.match(/^Generated<(.+)>$/);
-    const generated = generatedMatch !== null;
-    let inner = generated ? generatedMatch[1].trim() : tsType;
+/**
+ * Resolve a Kysely field type to a `{ schema, generated }` pair, where `schema`
+ * is the zod expression for the *row* (select) shape and `generated` is true
+ * when the column is optional on insert.
+ *
+ * `db-codegen` emits two field shapes depending on a column's classification:
+ *   - public columns →  `Generated<T>`, bare `T`, `T | null`, or a public
+ *                       bool/date column as `Generated<ColumnType<base, rw, rw>>`
+ *   - private/pii/secret columns (the default is `private`) →
+ *                       `ColumnType<Brand<base> | null, insert | undefined, update>`
+ *                       where Brand is `Private` | `Pii` | `Secret`.
+ *
+ * For `ColumnType<Select, Insert, Update>` the row schema comes from `Select`
+ * and the column is insert-optional when `Insert` admits `undefined` (Kysely's
+ * encoding for default/auto/generated columns).
+ */
+function zodForType(tsType, format) {
+    let inner = tsType.trim();
+    let generated = false;
+    // Peel a single `Generated<…>` wrapper. For public bool/date columns this
+    // wraps a `ColumnType<…>`, so the unwrapped inner is handled below.
+    const generatedMatch = inner.match(/^Generated<(.+)>$/);
+    if (generatedMatch) {
+        generated = true;
+        inner = generatedMatch[1].trim();
+    }
+    // `ColumnType<Select, Insert, Update>` — classified columns and wrapped
+    // public bool/date columns. Row schema from Select; optional from Insert.
+    if (inner.startsWith('ColumnType<') && inner.endsWith('>')) {
+        const args = splitGenericArgs(inner.slice('ColumnType<'.length, -1));
+        const selectT = args[0]?.trim() ?? 'unknown';
+        const insertT = args[1]?.trim() ?? '';
+        if (unionIncludesUndefined(insertT)) {
+            generated = true;
+        }
+        return { schema: scalarSchema(selectT, format), generated };
+    }
+    return { schema: scalarSchema(inner, format), generated };
+}
+/**
+ * Resolve a scalar/select type expression to a zod expression. Handles a
+ * trailing `| null`, classification brands (`Private`/`Pii`/`Secret`), arrays,
+ * and the known scalar bases. Unknown bases fall back to `z.unknown()` so
+ * generation stays total.
+ */
+function scalarSchema(tsType, format) {
+    let inner = tsType.trim();
+    // Defensive: a Select arg may itself be `Generated<…>` in older schemas.
+    const generatedMatch = inner.match(/^Generated<(.+)>$/);
+    if (generatedMatch) {
+        inner = generatedMatch[1].trim();
+    }
     const nullable = inner.endsWith(' | null');
     if (nullable) {
         inner = inner.slice(0, -' | null'.length).trim();
     }
+    // Unwrap a classification brand: `Private<T>` / `Pii<T>` / `Secret<T>` → T.
+    const brandMatch = inner.match(/^(?:Private|Pii|Secret)<(.+)>$/);
+    if (brandMatch) {
+        inner = brandMatch[1].trim();
+    }
     let schema;
-    switch (inner) {
-        case 'string':
-            schema = 'z.string()';
-            break;
-        case 'number':
-            schema = 'z.number()';
-            break;
-        case 'boolean':
-            schema = 'z.boolean()';
-            break;
-        case 'Date':
-            schema = 'z.date()';
-            break;
-        case 'unknown':
-            schema = 'z.unknown()';
-            break;
-        default:
-            if (inner.endsWith('[]')) {
-                const item = zodForType(inner.slice(0, -2).trim()).schema;
-                schema = `z.array(${item})`;
-            }
-            else {
-                schema = 'z.unknown()';
+    // A `format` override (e.g. `email`, `url`) replaces the string base with a
+    // refined string validator. `db-codegen` only emits a format hint for columns
+    // whose select type is plain `string`, so this never collides with Date/enum.
+    if (format) {
+        schema = ZOD_FORMATS[format];
+    }
+    else {
+        // An enum column is emitted as a union of string literals, e.g.
+        // `'admin' | 'user'`. Detect it (after brand-unwrap + null-peel) and map to
+        // `z.enum([...])` (or `z.literal(...)` for a single value).
+        const literals = stringLiteralUnion(inner);
+        if (literals) {
+            schema =
+                literals.length === 1
+                    ? `z.literal('${literals[0]}')`
+                    : `z.enum([${literals.map((l) => `'${l}'`).join(', ')}])`;
+        }
+        else {
+            switch (inner) {
+                case 'string':
+                    schema = 'z.string()';
+                    break;
+                case 'number':
+                    schema = 'z.number()';
+                    break;
+                case 'boolean':
+                    schema = 'z.boolean()';
+                    break;
+                case 'Date':
+                    schema = 'z.date()';
+                    break;
+                case 'Uuid':
+                    schema = 'z.uuid()';
+                    break;
+                case 'unknown':
+                    schema = 'z.unknown()';
+                    break;
+                default:
+                    if (inner.endsWith('[]')) {
+                        schema = `z.array(${scalarSchema(inner.slice(0, -2).trim())})`;
+                    }
+                    else {
+                        schema = 'z.unknown()';
+                    }
+                    break;
             }
-            break;
+        }
     }
     if (nullable) {
         schema += '.nullable()';
     }
-    return { schema, generated };
+    return schema;
+}
+/**
+ * If `s` is a union of single-quoted string literals (`'a' | 'b' | 'c'`),
+ * return the unescaped-as-written label list; otherwise null. Quote-aware so a
+ * label containing `|` does not split the union. Re-emitting wraps each captured
+ * group back in quotes, so escaping is preserved verbatim.
+ */
+function stringLiteralUnion(s) {
+    const parts = splitUnion(s);
+    const labels = [];
+    for (const part of parts) {
+        const match = part.trim().match(/^'((?:[^'\\]|\\.)*)'$/);
+        if (!match)
+            return null;
+        labels.push(match[1]);
+    }
+    return labels.length > 0 ? labels : null;
+}
+/** Split a union on top-level `|`, skipping `|` inside `'…'` strings or `<>`/`()`. */
+function splitUnion(s) {
+    const parts = [];
+    let depth = 0;
+    let inStr = false;
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const char = s[i];
+        if (inStr) {
+            if (char === '\\')
+                i++;
+            else if (char === "'")
+                inStr = false;
+            continue;
+        }
+        if (char === "'")
+            inStr = true;
+        else if (char === '<' || char === '(')
+            depth++;
+        else if (char === '>' || char === ')')
+            depth--;
+        else if (char === '|' && depth === 0) {
+            parts.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(s.slice(start));
+    return parts;
+}
+/**
+ * Split the generic argument list of `Foo<a, b, c>` on top-level commas.
+ * Quote-aware so a comma inside an enum label literal (`'a,b'`) does not split.
+ */
+function splitGenericArgs(args) {
+    const parts = [];
+    let depth = 0;
+    let inStr = false;
+    let start = 0;
+    for (let i = 0; i < args.length; i++) {
+        const char = args[i];
+        if (inStr) {
+            if (char === '\\')
+                i++;
+            else if (char === "'")
+                inStr = false;
+            continue;
+        }
+        if (char === "'")
+            inStr = true;
+        else if (char === '<')
+            depth++;
+        else if (char === '>')
+            depth--;
+        else if (char === ',' && depth === 0) {
+            parts.push(args.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(args.slice(start));
+    return parts;
+}
+/** True when a union type expression contains `undefined` as a top-level member. */
+function unionIncludesUndefined(union) {
+    return union.split('|').some((member) => member.trim() === 'undefined');
 }

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.33
+ * This file was generated by @pikku/cli@0.12.35
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.33",
+  "version": "0.12.35",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -26,10 +26,10 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.30",
+    "@pikku/core": "^0.12.31",
     "@pikku/deploy-cloudflare": "^0.12.3",
     "@pikku/fetch": "^0.12.3",
-    "@pikku/inspector": "^0.12.18",
+    "@pikku/inspector": "^0.12.19",
     "@pikku/kysely": "^0.12.14",
     "@pikku/kysely-node-sqlite": "^0.12.1",
     "@pikku/node-http-server": "^0.12.2",