@pikku/cli 0.12.56 → 0.12.58

package/dist/.pikku/variables/pikku-variables.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
 import type { VariablesService } from '@pikku/core/services';

package/dist/.pikku/variables/pikku-variables.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
 const VARIABLES_META = {};

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { pikkuState } from '@pikku/core/internal';
 import allWorkflowMeta from './meta/allWorkflow.gen.json' with { type: 'json' };

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.56
+ * This file was generated by @pikku/cli@0.12.58
  */
 import { addWorkflow } from '@pikku/core/workflow';
 import './pikku-workflow-wirings-meta.gen.js';

package/dist/bin/pikku-bin.mjs

@@ -11,8 +11,8 @@ async function checkForUpdate() {
     })
     if (!res.ok) return
     const { version: latest } = await res.json()
-    if (latest !== '0.12.56') {
-      process.stderr.write(`\n  Update available  0.12.56 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
+    if (latest !== '0.12.58') {
+      process.stderr.write(`\n  Update available  0.12.58 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
     }
   } catch {}
 }

package/dist/src/cli.wiring.js

@@ -16,6 +16,7 @@ import { watch } from './functions/commands/watch.js';
 import { consoleCommand } from './functions/commands/console.js';
 import { login, logout, whoami } from './functions/commands/login.js';
 import { dev } from './functions/commands/dev.js';
+import { serve } from './functions/commands/serve.js';
 import { dbMigrate } from './functions/commands/db-migrate.js';
 import { dbGenerate } from './functions/commands/db-generate.js';
 import { dbSeed } from './functions/commands/db-seed.js';
@@ -157,6 +158,10 @@ wireCLI({
                 excludeTarget: {
                     description: 'Exclude functions by deploy target (comma-separated: serverless, server)',
                 },
+                forceRelativeImports: {
+                    description: 'Emit relative imports even when packageMappings would apply (used by per-unit deploy codegen)',
+                    default: false,
+                },
             },
         }),
         bootstrap: pikkuCLICommand({
@@ -190,6 +195,23 @@ wireCLI({
                     description: 'Enable hot module reload',
                     default: true,
                 },
+                console: {
+                    description: 'Also serve the Pikku Console UI (optionally specify port, default 51442)',
+                },
+            },
+        }),
+        serve: pikkuCLICommand({
+            func: serve,
+            description: 'Start a server using the bundled bun or node runner (no watch, no codegen)',
+            options: {
+                port: {
+                    description: 'Port for the server',
+                    default: '3000',
+                    short: 'p',
+                },
+                console: {
+                    description: 'Also serve the Pikku Console UI (optionally specify port, default 51442)',
+                },
             },
         }),
         console: pikkuCLICommand({
@@ -283,7 +305,7 @@ wireCLI({
             subcommands: {
                 migrate: pikkuCLICommand({
                     func: dbMigrate,
-                    description: 'Apply pending SQL migrations and regenerate db/schema.d.ts',
+                    description: 'Apply pending SQL migrations and regenerate db/schema.gen.d.ts',
                 }),
                 generate: pikkuCLICommand({
                     func: dbGenerate,

package/dist/src/deploy/bundler/bundler.js

@@ -101,7 +101,17 @@ export class BaseBundler {
                 results.push(result);
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
+                // AggregateError (thrown by Bun.build) carries per-file errors in `errors`.
+                const aggErrors = err != null &&
+                    typeof err === 'object' &&
+                    'errors' in err &&
+                    Array.isArray(err.errors)
+                    ? err.errors
+                        .map((e) => e?.message ?? String(e))
+                        .join('\n  ')
+                    : '';
+                const message = (err instanceof Error ? err.message : String(err)) +
+                    (aggErrors ? `\n  ${aggErrors}` : '');
                 errors.push({ unitName: unit.name, error: message });
             }
         }

package/dist/src/deploy/codegen/per-unit-codegen.js

@@ -226,6 +226,7 @@ export async function generatePerUnitCodegen(options) {
                     `--stateInput=${stateFilePath}`,
                     `--names=${namesArg}`,
                     `--outDir=${unitPikkuDir}`,
+                    '--force-relative-imports',
                     '--silent',
                 ], {
                     cwd: projectDir,

package/dist/src/fabric/functions/validate.function.js

@@ -258,6 +258,19 @@ export async function runValidate(startDir = process.cwd()) {
             w('gitignore-missing-generated', `.gitignore does not ignore Fabric generated/runtime artifacts: ${missing.join(', ')} — committing them lets a stale copy shadow the freshly generated one (e.g. a committed __fabric_scaffold.vite.config.mjs or .pikku-runtime breaks the sandbox dev server)`, gitignorePath, lines('Add these entries to .gitignore:', ...missing.map((entry) => `  ${entry}`), 'They are regenerated on every dev boot / scaffold / codegen and must never be committed.'));
         }
     }
+    // ── required project files ────────────────────────────────────────────
+    // These files must exist and be committed — they are seeded from the sandbox
+    // but belong to the project so the AI agent can read and update them.
+    for (const relPath of [
+        'db/annotations.ts',
+        'knowledge/design-language.md',
+        'knowledge/security.md',
+        'knowledge/technology.md',
+    ]) {
+        if (!existsSync(join(root, relPath))) {
+            w(`missing-required-file-${relPath.replace(/[^a-z0-9]/gi, '-')}`, `${relPath} is missing — this file must be committed to the project`, join(root, relPath), lines(`Create ${relPath} and commit it.`, 'The starter-template ships a stub you can copy as a starting point.'));
+        }
+    }
     const rootPkgPath = join(root, 'package.json');
     const rootPkg = await readJsonSafe(rootPkgPath);
     if (!rootPkg) {
@@ -359,6 +372,24 @@ export async function runValidate(startDir = process.cwd()) {
             if (!fnPkg.imports?.['#pikku']) {
                 e('functions-pkg-missing-pikku-import', 'packages/functions/package.json is missing a bare "#pikku" entry in "imports" — the Fabric-injected telemetry middleware imports from "#pikku" and will fail to bundle without it', fnPkgPath, 'Add to "imports": { "#pikku": "./.pikku/pikku-types.gen.ts", "#pikku/*": "./.pikku/*" }');
             }
+            if (!fnPkg.imports?.['#pikku/*']) {
+                e('functions-pkg-missing-pikku-wildcard-import', 'packages/functions/package.json is missing "#pikku/*" in "imports" — wiring files that import e.g. "#pikku/pikku-types.gen.js" fail at runtime with "Cannot find module"', fnPkgPath, 'Add to "imports": { "#pikku": "./.pikku/pikku-types.gen.ts", "#pikku/*": "./.pikku/*" }');
+            }
+            // .pikku/pikku-types.gen.js wrapper — the sandbox runs `pikku dev` via
+            // bare Node.js (no tsx), which cannot load .ts files. Every .gen.ts in
+            // .pikku/ needs a matching .gen.js wrapper. The sandbox entrypoint creates
+            // these during provisioning but NOT on subsequent restarts after agent
+            // edits — so after any restart pikku dev crashes with
+            // "Cannot find module '#pikku/pikku-types.gen.js'". Run `pikku fabric smoke`
+            // to test locally; the smoke command recreates the wrappers automatically.
+            {
+                const pikkuGenDir = join(fnDir, '.pikku');
+                const typesGenTs = join(pikkuGenDir, 'pikku-types.gen.ts');
+                const typesGenJs = join(pikkuGenDir, 'pikku-types.gen.js');
+                if (existsSync(typesGenTs) && !existsSync(typesGenJs)) {
+                    e('pikku-types-js-wrapper-missing', 'packages/functions/.pikku/pikku-types.gen.js is missing — the sandbox runs pikku dev via bare Node.js, which cannot load .ts files; without the .js wrapper it crashes with "Cannot find module \'#pikku/pikku-types.gen.js\'" on every restart', typesGenTs, lines('Create packages/functions/.pikku/pikku-types.gen.js:', "  import './pikku-types.gen.ts';", "  export * from './pikku-types.gen.ts';", 'Or run `pikku fabric smoke` to test the full boot locally (it creates the wrappers).', 'This file is gitignored — it must be recreated after every `pikku all` run.'));
+                }
+            }
             const fnAllDeps = {
                 ...fnPkg.dependencies,
                 ...fnPkg.devDependencies,
@@ -441,8 +472,10 @@ export async function runValidate(startDir = process.cwd()) {
                     const baseURL = text.match(/createAuthClient\s*\([^)]*baseURL\s*:\s*([^,)\n]+)/)?.[1];
                     // Heuristic: flag a bare /api baseURL with no /auth segment anywhere
                     // near the client config.
-                    if (baseURL && /['"`]\/api['"`]/.test(baseURL) && !/auth/i.test(baseURL)) {
-                        w('better-auth-client-baseurl-missing-auth', `createAuthClient baseURL is ${baseURL.trim()} — it omits the /auth segment, so the client calls /api/sign-in/email instead of /api/auth/sign-in/email and auth 404s`, join(appsDir, rel), "Append the auth basePath: baseURL: `${apiUrl()}/auth` (resolving to /api/auth)");
+                    if (baseURL &&
+                        /['"`]\/api['"`]/.test(baseURL) &&
+                        !/auth/i.test(baseURL)) {
+                        w('better-auth-client-baseurl-missing-auth', `createAuthClient baseURL is ${baseURL.trim()} — it omits the /auth segment, so the client calls /api/sign-in/email instead of /api/auth/sign-in/email and auth 404s`, join(appsDir, rel), 'Append the auth basePath: baseURL: `${apiUrl()}/auth` (resolving to /api/auth)');
                     }
                 }
             }
@@ -562,7 +595,7 @@ export async function runValidate(startDir = process.cwd()) {
                 dbTypesText.includes('.pikku\\db\\schema');
             const hasInlineTypes = /(?:^|\n)\s*(?:export\s+)?(?:interface\s+\w|type\s+\w+\s*=)/.test(dbTypesText);
             if (hasInlineTypes && !isReexport) {
-                w('db-types-hand-edited', 'src/types/db.types.ts contains inline type definitions — it should only re-export from .pikku', dbTypesPath, "Replace the file with a single line: export type { DB } from '../../.pikku/db/schema.js' then run `yarn db:types` to regenerate");
+                w('db-types-hand-edited', 'src/types/db.types.ts contains inline type definitions — it should only re-export from .pikku', dbTypesPath, "Replace the file with a single line: export type { DB } from '../../.pikku/db/schema.gen.js' then run `yarn db:types` to regenerate");
             }
         }
         // Structure: src/functions/, src/wirings/, src/config.ts

package/dist/src/functions/commands/dev.d.ts

@@ -2,12 +2,15 @@ export declare const dev: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
+    console?: string | boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
+    console?: string | boolean;
 }, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
+    console?: string | boolean;
 }, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/dev.js

@@ -12,9 +12,10 @@ import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
 import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { startConsoleServer } from './serve-console.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, watch, hmr }, { rpc }) => {
+    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, watch, hmr, console: consoleFlag }, { rpc }) => {
         const resolvedPort = parseInt(port || '3000', 10);
         const hostname = 'localhost';
         // Bind on IPv4 loopback explicitly. Under Bun, hostname 'localhost' resolves
@@ -105,7 +106,6 @@ export const dev = pikkuSessionlessFunc({
             return;
         }
         await loadUserBootstrap(pikkuDir);
-        workflowService.rewireQueueWorkers();
         const configModule = await loadUserModule(pikkuConfigFactory.file);
         const servicesModule = await loadUserModule(singletonServicesFactory.file);
         const userCreateConfig = configModule[pikkuConfigFactory.variable];
@@ -195,28 +195,42 @@ export const dev = pikkuSessionlessFunc({
             ...inMemoryServices,
             getInspectorState,
         });
-        pikkuState(null, 'package', 'singletonServices', {
-            ...singletonServices,
-            getInspectorState,
-        });
+        const resolvedServices = { ...singletonServices, getInspectorState };
+        pikkuState(null, 'package', 'singletonServices', resolvedServices);
+        resolvedServices.workflowService?.wireQueueWorkers?.();
+        const { serverLifecycleFactory } = inspectorState.filesAndMethods;
+        const loadLifecycle = async () => {
+            if (!serverLifecycleFactory)
+                return undefined;
+            const m = await loadUserModule(serverLifecycleFactory.file);
+            return m[serverLifecycleFactory.variable];
+        };
         const pikkuServer = devServerRunner.createServer({
             ...userConfig,
             hostname: bindHostname,
             port: resolvedPort,
             content: localContentConfig,
         }, logger);
+        const lifecycle = await loadLifecycle();
         await pikkuServer.init();
-        await schedulerService.start();
+        await lifecycle?.beforeStart?.(resolvedServices);
         await pikkuServer.start();
+        await lifecycle?.afterStart?.(resolvedServices);
+        const consoleServer = consoleFlag
+            ? await startConsoleServer(consoleFlag, hostname, logger)
+            : undefined;
         let configWatcher;
         let watcher;
         process.once('SIGINT', async () => {
             logger.info('Stopping dev server...');
             try {
+                await lifecycle?.beforeStop?.(resolvedServices);
                 await stopSingletonServices();
                 await configWatcher?.close();
                 await watcher?.close();
                 await pikkuServer.stop();
+                consoleServer?.close();
+                await lifecycle?.afterStop?.(resolvedServices);
             }
             finally {
                 process.exit(0);
@@ -246,7 +260,7 @@ export const dev = pikkuSessionlessFunc({
                         try {
                             const start = Date.now();
                             await runAllWithCommandState();
-                            workflowService.rewireQueueWorkers();
+                            workflowService.wireQueueWorkers();
                             logger.info({
                                 message: `✓ Generated in ${Date.now() - start}ms`,
                                 type: 'timing',

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -12,7 +12,7 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
             addonBootstraps.push(`${decl.package}/.pikku/pikku-bootstrap.gen.js`);
             logger.debug(`• Addon bootstrap: ${decl.package}`);
         }
-        const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings, config.forceRelativeImports)}'`);
         const localImportTargets = Array.from(new Set([
             ...(config.rpcInternalWiringMetaFile &&
                 existsSync(config.rpcInternalWiringMetaFile)
@@ -26,7 +26,7 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
             logger.warn(`Skipping invalid bootstrap import path: ${String(to)}`);
             return false;
         });
-        const localImports = safeLocalImportTargets.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const localImports = safeLocalImportTargets.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings, config.forceRelativeImports)}'`);
         const addonImports = addonBootstraps.map((packagePath) => `import '${packagePath}'`);
         const outDir = dirname(config.bootstrapFile);
         const metaServiceFile = join(outDir, 'pikku-meta-service.gen.ts');

package/dist/src/functions/commands/serve-console.d.ts

@@ -0,0 +1,4 @@
+import { createServer } from 'http';
+import type { Logger } from '@pikku/core/services';
+export declare function resolveConsoleDir(): string;
+export declare function startConsoleServer(consoleFlag: string | boolean, hostname: string, logger: Logger): Promise<ReturnType<typeof createServer> | undefined>;

package/dist/src/functions/commands/serve-console.js

@@ -0,0 +1,62 @@
+import { createServer } from 'http';
+import { readFile, stat } from 'fs/promises';
+import { join, extname } from 'path';
+import { fileURLToPath } from 'url';
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.webmanifest': 'application/manifest+json',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.map': 'application/json',
+};
+export function resolveConsoleDir() {
+    return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'console-app');
+}
+export async function startConsoleServer(consoleFlag, hostname, logger) {
+    const consoleDir = resolveConsoleDir();
+    const consolePort = typeof consoleFlag === 'string' ? parseInt(consoleFlag, 10) : 51442;
+    try {
+        await stat(consoleDir);
+    }
+    catch {
+        logger.error('Console app not found. Please rebuild @pikku/cli with the console app bundled.');
+        return undefined;
+    }
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url || '/', `http://localhost:${consolePort}`);
+        let filePath = join(consoleDir, url.pathname);
+        try {
+            const s = await stat(filePath);
+            if (s.isDirectory())
+                filePath = join(filePath, 'index.html');
+        }
+        catch {
+            filePath = join(consoleDir, 'index.html');
+        }
+        try {
+            const content = await readFile(filePath);
+            const contentType = MIME_TYPES[extname(filePath)] || 'application/octet-stream';
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+        catch {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not Found');
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(consolePort, () => {
+            logger.info(`Pikku Console running at http://${hostname}:${consolePort}`);
+            resolve();
+        });
+        server.on('error', reject);
+    });
+    return server;
+}

package/dist/src/functions/commands/serve.d.ts

@@ -0,0 +1,10 @@
+export declare const serve: import("#pikku").PikkuFunctionConfig<{
+    port?: string;
+    console?: string | boolean;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    port?: string;
+    console?: string | boolean;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    port?: string;
+    console?: string | boolean;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/serve.js

@@ -0,0 +1,143 @@
+import { join, resolve } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
+import { stopSingletonServices } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { LocalMetaService } from '@pikku/core/services/local-meta';
+import { LocalContent, } from '@pikku/core/services/local-content';
+import { InMemorySchedulerService } from '@pikku/schedule';
+import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
+import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { startConsoleServer } from './serve-console.js';
+export const serve = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, console: consoleFlag }) => {
+        const resolvedPort = parseInt(port || '3000', 10);
+        const hostname = 'localhost';
+        const bindHostname = '127.0.0.1';
+        const pikkuDir = resolve(config.rootDir, config.outDir);
+        const inspectorState = await getInspectorState(true);
+        const { pikkuConfigFactory, singletonServicesFactory } = inspectorState.filesAndMethods;
+        if (!pikkuConfigFactory || !singletonServicesFactory) {
+            logger.error('createConfig and createSingletonServices must be defined in your project');
+            return;
+        }
+        await loadUserBootstrap(pikkuDir);
+        const workflowService = new InMemoryWorkflowService();
+        const configModule = await loadUserModule(pikkuConfigFactory.file);
+        const servicesModule = await loadUserModule(singletonServicesFactory.file);
+        const userCreateConfig = configModule[pikkuConfigFactory.variable];
+        const userCreateSingletonServices = servicesModule[singletonServicesFactory.variable];
+        const userConfig = await userCreateConfig();
+        const envDatabaseUrl = await variables.get('DATABASE_URL');
+        const effectiveDbConfig = envDatabaseUrl
+            ? parseDatabaseUrl(envDatabaseUrl)
+            : userConfig;
+        const resolvedDb = resolveDb(effectiveDbConfig, config.rootDir, config.outDir, config.runtimeDir);
+        const resolvedLocalDb = resolvedDb ?? undefined;
+        const kysely = resolvedLocalDb
+            ? await createKysely(resolvedLocalDb)
+            : undefined;
+        const resolvedRuntimeDir = config.runtimeDir ?? join(config.rootDir, '.pikku-runtime');
+        const localContentConfig = userConfig.content
+            ? {
+                localFileUploadPath: userConfig.content.contentPath
+                    ? resolve(config.rootDir, userConfig.content.contentPath)
+                    : join(resolvedRuntimeDir, 'content'),
+                uploadUrlPrefix: userConfig.content.uploadUrlPrefix ?? '/upload',
+                assetUrlPrefix: userConfig.content.assetUrlPrefix ?? '/assets',
+                server: `http://${hostname}:${resolvedPort}`,
+                sizeLimit: userConfig.content.sizeLimit,
+            }
+            : undefined;
+        const localContent = localContentConfig
+            ? new LocalContent(localContentConfig, logger)
+            : undefined;
+        const schedulerService = new InMemorySchedulerService();
+        const aiStorage = kysely
+            ? new KyselyAIStorageService(kysely)
+            : undefined;
+        const aiRunState = kysely
+            ? new KyselyAIRunStateService(kysely)
+            : new InMemoryAIRunStateService();
+        const agentRunService = kysely
+            ? new KyselyAgentRunService(kysely)
+            : undefined;
+        if (aiStorage)
+            await aiStorage.init();
+        if ('init' in aiRunState && typeof aiRunState.init === 'function') {
+            await aiRunState.init();
+        }
+        const devLogger = new ConsoleLogger();
+        const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
+        const aiAgentRunner = hasAgents
+            ? await createDevAIAgentRunner({
+                logger,
+                projectRoot: config.rootDir,
+                variables,
+            })
+            : undefined;
+        const eventHub = await devServerRunner.createEventHub();
+        const inMemoryServices = {
+            logger: devLogger,
+            ...(aiAgentRunner ? { aiAgentRunner } : {}),
+            emailService: new LocalEmailService(),
+            metaService: new LocalMetaService(pikkuDir),
+            schedulerService,
+            queueService: new InMemoryQueueService(),
+            workflowService,
+            workflowRunService: workflowService,
+            triggerService: new InMemoryTriggerService(),
+            aiStorage,
+            aiRunState,
+            agentRunService,
+            eventHub,
+            ...(kysely ? { kysely } : {}),
+            ...(localContent ? { content: localContent } : {}),
+        };
+        const singletonServices = await userCreateSingletonServices(userConfig, {
+            ...inMemoryServices,
+            getInspectorState,
+        });
+        const resolvedServices = { ...singletonServices, getInspectorState };
+        pikkuState(null, 'package', 'singletonServices', resolvedServices);
+        resolvedServices.workflowService?.wireQueueWorkers?.();
+        const { serverLifecycleFactory } = inspectorState.filesAndMethods;
+        const loadLifecycle = async () => {
+            if (!serverLifecycleFactory)
+                return undefined;
+            const m = await loadUserModule(serverLifecycleFactory.file);
+            return m[serverLifecycleFactory.variable];
+        };
+        const pikkuServer = devServerRunner.createServer({
+            ...userConfig,
+            hostname: bindHostname,
+            port: resolvedPort,
+            content: localContentConfig,
+        }, logger);
+        const lifecycle = await loadLifecycle();
+        await pikkuServer.init();
+        await lifecycle?.beforeStart?.(resolvedServices);
+        await pikkuServer.start();
+        await lifecycle?.afterStart?.(resolvedServices);
+        const consoleServer = consoleFlag
+            ? await startConsoleServer(consoleFlag, hostname, logger)
+            : undefined;
+        process.once('SIGINT', async () => {
+            logger.info('Stopping server...');
+            try {
+                await lifecycle?.beforeStop?.(resolvedServices);
+                await stopSingletonServices();
+                await pikkuServer.stop();
+                consoleServer?.close();
+                await lifecycle?.afterStop?.(resolvedServices);
+            }
+            finally {
+                process.exit(0);
+            }
+        });
+        await new Promise(() => { });
+    },
+});

package/dist/src/functions/commands/tests-init.js

@@ -212,8 +212,8 @@ export const pikkuTestsInit = pikkuSessionlessFunc({
         const configImport = toJs(rel(pikkuConfigFactory.file));
         const servicesImport = toJs(rel(singletonServicesFactory.file));
         // coercion/schema may live under outDir/db (new default) or rootDir/db (legacy)
-        const schemaInOutDir = join(config.outDir, 'db', 'schema.d.ts');
-        const schemaInRootDir = join(config.rootDir, 'db', 'schema.d.ts');
+        const schemaInOutDir = join(config.outDir, 'db', 'schema.gen.d.ts');
+        const schemaInRootDir = join(config.rootDir, 'db', 'schema.gen.d.ts');
         const schemaFile = existsSync(schemaInOutDir)
             ? schemaInOutDir
             : schemaInRootDir;
@@ -256,7 +256,10 @@ export const pikkuTestsInit = pikkuSessionlessFunc({
                 join(supportDir, 'services.ts'),
                 servicesTs(configImport, servicesImport, schemaImport, coercionImport, pikkuConfigFactory.variable, singletonServicesFactory.variable, repoRootRel, hasDb, migrationsRel, seedRel),
             ],
-            [join(ftestDir, 'tests', 'features', 'example.feature'), starterFeature()],
+            [
+                join(ftestDir, 'tests', 'features', 'example.feature'),
+                starterFeature(),
+            ],
         ];
         for (const [filePath, content] of files) {
             await mkdir(dirname(filePath), { recursive: true });

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

@@ -36,7 +36,7 @@ export interface CodegenResult {
     /**
      * Per-interface, per-field zod `format` overrides for the zod codegen. Keyed
      * by interface name (PascalCase) and field name (camelCase), matching the
-     * shapes the zod emitter parses out of `schema.d.ts`.
+     * shapes the zod emitter parses out of `schema.gen.d.ts`.
      */
     zodFormats: Record<string, Record<string, ZodFormat>>;
 }

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

@@ -183,7 +183,8 @@ function emitInterface(table, camelCase, explicitAnnotations, dialect, enumByNam
         // from a Postgres enum (`type` is 'USER-DEFINED', real values via `udtName`)
         // or, on SQLite, from a `CHECK (col IN (…))` constraint the introspector
         // parsed onto `col.enumValues`.
-        const enumValues = col.enumValues ?? (col.udtName ? enumByName.get(col.udtName) : undefined);
+        const enumValues = col.enumValues ??
+            (col.udtName ? enumByName.get(col.udtName) : undefined);
         const enumUnion = enumValues && enumValues.length > 0
             ? enumValues.map((v) => `'${escapeTsString(v)}'`).join(' | ')
             : null;
@@ -334,7 +335,7 @@ function emitClassificationMap(tables) {
 }
 /**
  * Introspect `introspector` and emit:
- *   - `schema.d.ts`            Kysely DB type with classification brands
+ *   - `schema.gen.d.ts`        Kysely DB type with classification brands
  *   - `coercion.gen.ts`        Runtime CoercionMap for date/bool/json coercion
  *   - `classification.gen.ts`  Data-classification manifest (when manifestFile set)
  */
@@ -352,7 +353,8 @@ function emitEnumsModule(tables, enumByName) {
     for (const t of tables) {
         const tablePart = pascal(snakeToCamel(bareTableName(t.name)));
         for (const col of t.columns) {
-            const values = col.enumValues ?? (col.udtName ? enumByName.get(col.udtName) : undefined);
+            const values = col.enumValues ??
+                (col.udtName ? enumByName.get(col.udtName) : undefined);
             if (!values || values.length === 0)
                 continue;
             const name = `${tablePart}${pascal(snakeToCamel(col.name))}`;
@@ -393,7 +395,7 @@ export async function generateSchemaTypes(introspector, options) {
         enumByName.set(e.name, e.values);
         enumByName.set(`${e.schema}.${e.name}`, e.values);
     }
-    // ── schema.d.ts ─────────────────────────────────────────────────────────────
+    // ── schema.gen.d.ts ──────────────────────────────────────────────────────────
     const warnings = [];
     const zodFormats = {};
     const interfaces = tables

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

@@ -42,7 +42,7 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
     const base = (sub) => ({
         rootDir,
         migrationsDir: resolveAgainst(rootDir, sub),
-        schemaFile: join(outDir, 'db', 'schema.d.ts'),
+        schemaFile: join(outDir, 'db', 'schema.gen.d.ts'),
         coercionFile: join(outDir, 'db', 'coercion.gen.ts'),
         manifestFile: join(outDir, 'db', 'classification.gen.ts'),
         classificationMapFile: join(outDir, 'db', 'classification-map.gen.d.ts'),

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

@@ -33,7 +33,7 @@ export interface ZodCodegenOptions {
     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),
+     * (PascalCase, as it appears in `schema.gen.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.