@pikku/cli 0.12.105 → 0.12.109

package/dist/src/functions/commands/db-check.d.ts

@@ -9,4 +9,4 @@
  * fail: something created them outside the migration history, which is worth
  * seeing but is not this command's to fix.
  */
-export declare const dbCheck: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const dbCheck: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/db-check.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { resolveDb, computeSchemaDrift } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 /**

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

@@ -8,4 +8,4 @@
  * introspects that, so `pikku all` can be given an accurate table zod on a
  * machine with no database reachable at all.
  */
-export declare const dbCodegen: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const dbCodegen: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { resolveDb, migrateAndCodegen } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 /**

package/dist/src/functions/commands/db-export.d.ts

@@ -9,4 +9,4 @@
  *
  * Run this from the addon's build, beside the rest of its codegen.
  */
-export declare const dbExport: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const dbExport: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/db-export.js

@@ -1,6 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { exportSchema } from '../db/local-db.js';
 /**
  * Publish this package's schema so a project consuming it as an addon can

package/dist/src/functions/commands/db-generate.d.ts

@@ -1 +1 @@
-export declare const dbGenerate: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const dbGenerate: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/db-generate.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { resolveDb, generateMigrations } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbGenerate = pikkuSessionlessFunc({

package/dist/src/functions/commands/db-migrate.d.ts

@@ -1 +1 @@
-export declare const dbMigrate: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const dbMigrate: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/db-migrate.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { resolveDb, migrateAndCodegen, computeAuthDrift, } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbMigrate = pikkuSessionlessFunc({

package/dist/src/functions/commands/db-reset.d.ts

@@ -6,10 +6,10 @@
  * `INSERT`s: there is no path that applies it twice, so it never has to defend
  * itself with `INSERT OR IGNORE` or `ON CONFLICT DO NOTHING`.
  */
-export declare const dbReset: import("#pikku").PikkuFunctionConfig<{
+export declare const dbReset: import("#pikku/function").PikkuFunctionConfig<{
     noSeed?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     noSeed?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     noSeed?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/db-reset.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { resolveDb, reset, migrateAndCodegen, devSeed } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 /**

package/dist/src/functions/commands/deploy-apply.d.ts

@@ -9,22 +9,22 @@ export declare function resolveProvider(config?: {
 }, providerName?: string, options?: {
     runtime?: string;
 }): Promise<ProviderAdapter>;
-export declare const deployApply: import("#pikku").PikkuFunctionConfig<{
+export declare const deployApply: import("#pikku/function").PikkuFunctionConfig<{
     fromPlan?: boolean;
     provider?: string;
     runtime?: string;
     resultFile?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     fromPlan?: boolean;
     provider?: string;
     runtime?: string;
     resultFile?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     fromPlan?: boolean;
     provider?: string;
     runtime?: string;
     resultFile?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/deploy-apply.js

@@ -1,8 +1,8 @@
 import { basename, join, relative } from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
-import { runBuildPipeline } from '../../deploy/build-pipeline.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { runBuildPipeline, describeBuildFailure, PikkuDeployBuildFailedError, } from '../../deploy/build-pipeline.js';
 function toRelativeImport(fromDir, toFile) {
     let rel = relative(fromDir, toFile).replace(/\\/g, '/');
     if (!rel.startsWith('.'))
@@ -226,6 +226,18 @@ export const deployApply = pikkuSessionlessFunc({
             });
             return;
         }
+        const buildFailure = describeBuildFailure(buildResult);
+        if (buildFailure) {
+            await writeResultFile(resultFile, {
+                success: false,
+                errors: buildResult.bundleErrors.map((e) => ({
+                    step: 'bundle',
+                    error: `${e.unitName}: ${e.error}`,
+                })),
+                codegenErrors: buildResult.codegenErrors,
+            });
+            throw new PikkuDeployBuildFailedError(buildFailure);
+        }
         const { providerDir, bundled } = buildResult;
         if (typeof provider.deploy === 'function') {
             await runDeploy(provider, providerDir, logger, resultFile);

package/dist/src/functions/commands/deploy-info.d.ts

@@ -1 +1 @@
-export declare const deployInfo: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const deployInfo: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/deploy-info.js

@@ -1,6 +1,6 @@
 import { basename, join } from 'node:path';
 import { readFile } from 'node:fs/promises';
-import { pikkuVoidFunc } from '#pikku';
+import { pikkuVoidFunc } from '#pikku/function';
 import { analyzeDeployment } from '../../deploy/analyzer/index.js';
 const ANSI = {
     green: '\x1b[32m',

package/dist/src/functions/commands/deploy-plan.d.ts

@@ -1,16 +1,16 @@
-export declare const deployPlan: import("#pikku").PikkuFunctionConfig<{
+export declare const deployPlan: import("#pikku/function").PikkuFunctionConfig<{
     resultFile?: string;
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     resultFile?: string;
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     resultFile?: string;
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/deploy-plan.js

@@ -1,9 +1,9 @@
 import { basename, join } from 'node:path';
 import { readFile } from 'node:fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { generatePlan } from '../../deploy/plan/index.js';
 import { formatPlan } from '../../deploy/plan/formatter.js';
-import { runBuildPipeline } from '../../deploy/build-pipeline.js';
+import { runBuildPipeline, describeBuildFailure, PikkuDeployBuildFailedError, } from '../../deploy/build-pipeline.js';
 import { resolveProvider, getEntryContext } from './deploy-apply.js';
 function sanitizeProjectId(raw) {
     return (raw
@@ -104,5 +104,9 @@ export const deployPlan = pikkuSessionlessFunc({
                 },
             }, null, 2), 'utf-8');
         }
+        const buildFailure = describeBuildFailure(result);
+        if (buildFailure) {
+            throw new PikkuDeployBuildFailedError(buildFailure);
+        }
     },
 });

package/dist/src/functions/commands/dev-agent-runner.d.ts

@@ -1,4 +1,5 @@
-import type { Logger, VariablesService } from '@pikku/core/services';
+import type { Logger } from '@pikku/core/services';
+import type { VariablesService } from '@pikku/core/services';
 import type { AgentRunnerService } from '@pikku/core/services';
 /**
  * Build the AI agent runner for `pikku dev` from env.

package/dist/src/functions/commands/dev-agent-runner.js

@@ -54,26 +54,61 @@ export async function createDevAgentRunner({ logger, projectRoot, variables, })
     // copy of `@ai-sdk/provider` handed to a runner built against another is the
     // one combination that fails at call time rather than at load time, with an
     // error about the model spec that names neither package.
+    const PAIR = ['@pikku/ai-vercel', '@ai-sdk/openai-compatible'];
+    // `projectRoot` is the root package.json, and under an isolated node_modules
+    // layout (bun, pnpm) that resolves only what the *root* declares — a monorepo
+    // that installed the pair in the workspace using it still misses here. Say so
+    // rather than silently swapping in our own copies: the failure that follows
+    // names neither package, so the log line is the only thing connecting it back.
+    const resolveFromProject = (name) => {
+        try {
+            return pathToFileURL(fromProject.resolve(name)).href;
+        }
+        catch {
+            return undefined;
+        }
+    };
     const loadPair = async () => {
-        const project = ['@pikku/ai-vercel', '@ai-sdk/openai-compatible'].map((name) => {
-            try {
-                return pathToFileURL(fromProject.resolve(name)).href;
-            }
-            catch {
-                return undefined;
-            }
-        });
-        const [runner, provider] = project.every(Boolean)
-            ? project
-            : ['@pikku/ai-vercel', '@ai-sdk/openai-compatible'];
-        return Promise.all([import(runner), import(provider)]);
+        const project = PAIR.map(resolveFromProject);
+        const complete = project.every(Boolean);
+        if (!complete && project.some(Boolean)) {
+            const missing = PAIR.filter((_, index) => !project[index]);
+            logger.warn(`pikku dev: ${missing.join(' and ')} could not be resolved from ${join(projectRoot, 'package.json')}, so the CLI's own AI SDK copies are being used for all of ${PAIR.join(' and ')}. In a monorepo with an isolated node_modules layout, declare them at the root.`);
+        }
+        const [runner, provider] = complete ? project : PAIR;
+        return Promise.all([import(runner), import(provider)]).then((modules) => [...modules, complete ? project : undefined]);
+    };
+    // The runner and the provider each hold their own `@ai-sdk/provider`. When the
+    // majors differ the provider builds a model whose `specificationVersion` the
+    // runner's `ai` refuses, and the throw arrives at the first model call reading
+    // `Unsupported model version …` — naming the model and the gateway, but not
+    // the two packages that actually disagree. Check it here instead, where both
+    // paths are in hand.
+    const providerSpecVersion = (from) => {
+        if (!from) {
+            return undefined;
+        }
+        try {
+            return createRequire(from)('@ai-sdk/provider/package.json')
+                .version;
+        }
+        catch {
+            return undefined;
+        }
     };
     let VercelAgentRunner;
     let createOpenAICompatible;
     try {
-        const [runnerModule, providerModule] = await loadPair();
+        const [runnerModule, providerModule, resolved] = await loadPair();
         ({ VercelAgentRunner } = runnerModule);
         ({ createOpenAICompatible } = providerModule);
+        const [runnerSpec, providerSpec] = (resolved ?? []).map(providerSpecVersion);
+        if (runnerSpec &&
+            providerSpec &&
+            runnerSpec.split('.')[0] !== providerSpec.split('.')[0]) {
+            logger.error(`pikku dev: AI agents disabled — @pikku/ai-vercel resolves @ai-sdk/provider@${runnerSpec} but @ai-sdk/openai-compatible resolves @ai-sdk/provider@${providerSpec}. Those majors are incompatible: the provider builds models the runner's \`ai\` refuses. @ai-sdk/openai-compatible publishes one line per major of \`ai\` (npm dist-tags ai-v5/ai-v6/latest) — install the line matching the \`ai\` your @pikku/ai-vercel peer-depends on.`);
+            return undefined;
+        }
     }
     catch (error) {
         logger.warn(`pikku dev: AI provider env is set but the AI SDK packages could not be loaded — AI agents disabled: ${error instanceof Error ? error.message : String(error)}`);

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

@@ -1,22 +1,22 @@
-export declare const dev: import("#pikku").PikkuFunctionConfig<{
+export declare const dev: import("#pikku/function").PikkuFunctionConfig<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,15 +1,16 @@
 import { join, resolve } from 'path';
 import { existsSync, readFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import chokidar from 'chokidar';
-import { pikkuDevReloader } from '@pikku/core/dev';
-import { reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/ecosystem/dev';
-import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, QueueWebhookService, } from '@pikku/core/services';
-import { spy, InMemoryAgentRunStateService, } from '@pikku/core/ecosystem/services';
+import { pikkuDevReloader, reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/dev';
+import { InMemoryQueueService, QueueWebhookService } from '@pikku/core/services';
+import { ConsoleLogger, LocalEmailService, spy, InMemoryAgentRunStateService, } from '@pikku/core/services';
+import { InMemoryTriggerService } from '@pikku/core/services';
+import { InMemoryWorkflowService } from '@pikku/core/services';
 import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
-import { stopSingletonServices } from '@pikku/core';
-import { pikkuState } from '@pikku/core/ecosystem';
-import { wireAgentScorerQueueWorkers } from '@pikku/core/ecosystem/agent-scorer';
+import { stopSingletonServices } from '@pikku/core/utils';
+import { pikkuState } from '@pikku/core/state';
+import { wireAgentScorerQueueWorkers } from '@pikku/core/agent-scorer';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
 import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
@@ -21,7 +22,6 @@ import { createDevAgentRunner } from './dev-agent-runner.js';
 import { resolveConsoleMount } from './serve-console.js';
 import { serverReadyLine } from '../../server/server-ready.js';
 import { createEphemeralContentSigningJWT } from '../../server/content-signing-jwt.js';
-import { resolveScaffoldFeature } from '../../utils/resolve-scaffold-feature.js';
 import { applyModelAliasOverride } from '../../utils/model-alias-override.js';
 export const dev = pikkuSessionlessFunc({
     remote: true,
@@ -134,7 +134,7 @@ export const dev = pikkuSessionlessFunc({
         // project — an app bootstrap is what a deployed bundle imports, and coverage
         // endpoints have no business in one.
         if (config.scaffold?.scenarios) {
-            registerScenarioInstrumentation(resolveScaffoldFeature('scenarios', config.scaffold.scenarios).auth);
+            registerScenarioInstrumentation();
         }
         const configModule = await loadUserModule(pikkuConfigFactory.file);
         const servicesModule = await loadUserModule(singletonServicesFactory.file);

package/dist/src/functions/commands/emails-init.d.ts

@@ -1,5 +1,5 @@
 type EmailsInitInput = {
     force?: boolean;
 };
-export declare const pikkuEmailsInit: import("#pikku").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuEmailsInit: import("#pikku/function").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 export {};

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

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { generateEmailsArtifacts } from '../wirings/emails/pikku-command-emails.js';
 const DEFAULT_EMAIL_DIR = 'emails';
 const DEFAULT_THEME = {
@@ -116,7 +116,8 @@ async function updateJsonConfig(configDir, emailDir) {
     }
     const raw = await readFile(configPath, 'utf8');
     const parsed = JSON.parse(raw);
-    if (typeof parsed.emailTemplatesDir === 'string' && parsed.emailTemplatesDir) {
+    if (typeof parsed.emailTemplatesDir === 'string' &&
+        parsed.emailTemplatesDir) {
         return false;
     }
     parsed.emailTemplatesDir = emailDir;
@@ -131,13 +132,25 @@ export const pikkuEmailsInit = pikkuSessionlessFunc({
             ? config.emailTemplatesDir
             : join(config.rootDir, DEFAULT_EMAIL_DIR);
         const files = [
-            [join(emailDir, 'theme.json'), `${JSON.stringify(DEFAULT_THEME, null, 2)}\n`],
-            [join(emailDir, 'locales', 'en.json'), `${JSON.stringify(DEFAULT_EN_LOCALE, null, 2)}\n`],
-            [join(emailDir, 'locales', 'de.json'), `${JSON.stringify(DEFAULT_DE_LOCALE, null, 2)}\n`],
+            [
+                join(emailDir, 'theme.json'),
+                `${JSON.stringify(DEFAULT_THEME, null, 2)}\n`,
+            ],
+            [
+                join(emailDir, 'locales', 'en.json'),
+                `${JSON.stringify(DEFAULT_EN_LOCALE, null, 2)}\n`,
+            ],
+            [
+                join(emailDir, 'locales', 'de.json'),
+                `${JSON.stringify(DEFAULT_DE_LOCALE, null, 2)}\n`,
+            ],
             [join(emailDir, 'partials', 'layout.html'), layoutTemplate()],
             [join(emailDir, 'partials', 'footer.html'), footerPartial()],
             [join(emailDir, 'templates', 'hello-world.html'), helloWorldHtml()],
-            [join(emailDir, 'templates', 'hello-world.subject.txt'), helloWorldSubject()],
+            [
+                join(emailDir, 'templates', 'hello-world.subject.txt'),
+                helloWorldSubject(),
+            ],
             [join(emailDir, 'templates', 'hello-world.text.txt'), helloWorldText()],
         ];
         const existing = !force

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

@@ -1,8 +1,8 @@
-export declare const enableRpc: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableConsole: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableScenarios: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableAgent: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableWorkflow: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableEvents: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableRemoteRpc: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
-export declare const enableWebhook: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableConsole: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableScenarios: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableAgent: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableWorkflow: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableEvents: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableRemoteRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableWebhook: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,14 +1,7 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
-import { pikkuVoidFunc } from '#pikku';
-/**
- * Remote RPC workers carry no auth dimension — `serialize-remote-rpc.ts`
- * hardcodes `auth: false` on what it generates — so enabling it writes a bare
- * `true` and there is nothing to opt out of.
- */
-const NO_AUTH_DIMENSION = new Set(['remoteRpc']);
-async function enableFeature(feature, logger, config, data) {
-    const noAuth = data?.noAuth ?? false;
+import { pikkuVoidFunc } from '#pikku/function';
+async function enableFeature(feature, logger, config) {
     const configPath = join(config.configDir, 'pikku.config.json');
     const raw = await readFile(configPath, 'utf-8');
     const json = JSON.parse(raw);
@@ -18,39 +11,32 @@ async function enableFeature(feature, logger, config, data) {
     if (!json.scaffold.pikkuDir) {
         json.scaffold.pikkuDir = 'pikku';
     }
-    // `true` is enabled AND authenticated. Only an explicit --no-auth writes the
-    // object form, so a feature can never be turned on public by accident.
-    //
-    // The console is an admin surface — every RPC requires a session, so
-    // --no-auth is ignored for it.
-    const wantsPublic = noAuth && feature !== 'console' && !NO_AUTH_DIMENSION.has(feature);
-    const value = feature === 'webhook' ? true : wantsPublic ? { auth: false } : true;
+    const value = true;
     json.scaffold[feature] = value;
     await writeFile(configPath, JSON.stringify(json, null, 2) + '\n', 'utf-8');
-    logger.info(`Enabled scaffold.${feature} = ${JSON.stringify(value)} in ${configPath}` +
-        (wantsPublic ? ' (public — no session required)' : ''));
+    logger.info(`Enabled scaffold.${feature} = ${JSON.stringify(value)} in ${configPath}`);
 }
 export const enableRpc = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('rpc', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('rpc', logger, config),
 });
 export const enableConsole = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('console', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('console', logger, config),
 });
 export const enableScenarios = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('scenarios', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('scenarios', logger, config),
 });
 export const enableAgent = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('agent', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('agent', logger, config),
 });
 export const enableWorkflow = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('workflow', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('workflow', logger, config),
 });
 export const enableEvents = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('events', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('events', logger, config),
 });
 export const enableRemoteRpc = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('remoteRpc', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('remoteRpc', logger, config),
 });
 export const enableWebhook = pikkuVoidFunc({
-    func: async ({ logger, config }, data) => enableFeature('webhook', logger, config, data),
+    func: async ({ logger, config }) => enableFeature('webhook', logger, config),
 });

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

@@ -13,6 +13,18 @@ export interface PikkuEnvironment {
     signInPath?: string;
     rpcPath?: string;
     appUrl?: string;
+    /**
+     * Where each app is served, keyed by the `app` its personas declare.
+     *
+     * A product can be more than one frontend — staff in one, customers in
+     * another — and the two are usually different paths on one host. A browser
+     * step navigates as its actor, so the actor's app decides which of these it
+     * navigates against, and `appUrl` is the fallback for a persona that names
+     * no app. Without this a run has one base for everybody: whichever app owns
+     * it is proved twice and the other never, silently, because both sets of
+     * paths resolve against the wrong app and load.
+     */
+    appUrls?: Record<string, string>;
     /** Real consequences: only an `accountable` persona may run against it. */
     production?: boolean;
 }
@@ -33,3 +45,18 @@ export interface ResolveEnvironmentOptions {
  * flags override fields on a configured environment, they do not invent one.
  */
 export declare const resolveEnvironment: ({ environment, environments, apiUrl, appUrl, spawn, }: ResolveEnvironmentOptions) => PikkuEnvironment;
+/**
+ * `--app-url` as one url, or as `<app>=<url>` pairs, or both.
+ *
+ *   --app-url https://host/
+ *   --app-url workshop=https://host/,storefront=https://host/_frontend/storefront/
+ *   --app-url https://host/,storefront=https://host/_frontend/storefront/
+ *
+ * Comma-separated to match `--flows` and `--tags` rather than taking the flag
+ * repeatedly, which the option parser types as a single string. A bare url is
+ * the fallback for personas naming no app; a pair binds one app.
+ */
+export declare const parseAppUrls: (value: string) => {
+    base?: string;
+    byApp: Record<string, string>;
+};

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

@@ -55,8 +55,42 @@ export const resolveEnvironment = ({ environment, environments, apiUrl, appUrl,
         resolved.apiUrl = apiUrl;
     }
     if (appUrl !== undefined) {
-        assertAbsoluteUrl('--app-url', appUrl);
-        resolved.appUrl = appUrl;
+        const { base, byApp } = parseAppUrls(appUrl);
+        if (base !== undefined)
+            resolved.appUrl = base;
+        if (Object.keys(byApp).length > 0) {
+            resolved.appUrls = { ...resolved.appUrls, ...byApp };
+        }
     }
     return resolved;
 };
+/**
+ * `--app-url` as one url, or as `<app>=<url>` pairs, or both.
+ *
+ *   --app-url https://host/
+ *   --app-url workshop=https://host/,storefront=https://host/_frontend/storefront/
+ *   --app-url https://host/,storefront=https://host/_frontend/storefront/
+ *
+ * Comma-separated to match `--flows` and `--tags` rather than taking the flag
+ * repeatedly, which the option parser types as a single string. A bare url is
+ * the fallback for personas naming no app; a pair binds one app.
+ */
+export const parseAppUrls = (value) => {
+    const byApp = {};
+    let base;
+    for (const raw of value.split(',')) {
+        const segment = raw.trim();
+        if (!segment)
+            continue;
+        const pair = /^([a-z0-9][a-z0-9-]*)=(.+)$/i.exec(segment);
+        if (!pair) {
+            assertAbsoluteUrl('--app-url', segment);
+            base = segment;
+            continue;
+        }
+        const [, app, url] = pair;
+        assertAbsoluteUrl(`--app-url ${app}`, url);
+        byApp[app] = url;
+    }
+    return { base, byApp };
+};