@pikku/cli 0.12.104 → 0.12.107

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-ai-runner.d.ts → dev-agent-runner.d.ts}

@@ -1,5 +1,6 @@
-import type { Logger, VariablesService } from '@pikku/core/services';
-import type { AIAgentRunnerService } 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.
  *
@@ -24,8 +25,8 @@ import type { AIAgentRunnerService } from '@pikku/core/services';
  * If it becomes worth it, delegate just `transcription`/`speech` to the full
  * provider and leave everything else on this one.
  */
-export declare function createDevAIAgentRunner({ logger, projectRoot, variables, }: {
+export declare function createDevAgentRunner({ logger, projectRoot, variables, }: {
     logger: Logger;
     projectRoot: string;
     variables: VariablesService;
-}): Promise<AIAgentRunnerService | undefined>;
+}): Promise<AgentRunnerService | undefined>;

package/dist/src/functions/commands/{dev-ai-runner.js → dev-agent-runner.js}

@@ -25,7 +25,7 @@ import { pathToFileURL } from 'url';
  * If it becomes worth it, delegate just `transcription`/`speech` to the full
  * provider and leave everything else on this one.
  */
-export async function createDevAIAgentRunner({ logger, projectRoot, variables, }) {
+export async function createDevAgentRunner({ logger, projectRoot, variables, }) {
     // Pair the URL with its matching key — coalescing each var independently could
     // combine an OPENAI_BASE_URL with a LITELLM_API_KEY (or vice versa) and
     // misroute or 401 every call. Take a complete OpenAI pair first, else LiteLLM.
@@ -68,11 +68,11 @@ export async function createDevAIAgentRunner({ logger, projectRoot, variables, }
             : ['@pikku/ai-vercel', '@ai-sdk/openai-compatible'];
         return Promise.all([import(runner), import(provider)]);
     };
-    let VercelAIAgentRunner;
+    let VercelAgentRunner;
     let createOpenAICompatible;
     try {
         const [runnerModule, providerModule] = await loadPair();
-        ({ VercelAIAgentRunner } = runnerModule);
+        ({ VercelAgentRunner } = runnerModule);
         ({ createOpenAICompatible } = providerModule);
     }
     catch (error) {
@@ -100,5 +100,5 @@ export async function createDevAIAgentRunner({ logger, projectRoot, variables, }
         }),
     });
     logger.info(`pikku dev: AI agent runner wired to ${baseURL}`);
-    return new VercelAIAgentRunner(buildProviders(apiKey), buildProviders);
+    return new VercelAgentRunner(buildProviders(apiKey), buildProviders);
 }

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,13 +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, reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/dev';
-import { ConsoleLogger, LocalEmailService, spy, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, QueueWebhookService, } from '@pikku/core/services';
-import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
-import { stopSingletonServices } from '@pikku/core';
-import { pikkuState } from '@pikku/core/ecosystem';
-import { wireAIScorerQueueWorkers } from '@pikku/core/ai-scorer';
+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/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';
@@ -15,7 +18,7 @@ import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
 import { registerScenarioInstrumentation } from '../wirings/scenarios/register-scenario-instrumentation.js';
 import { startCoverageService } from './start-coverage.js';
-import { createDevAIAgentRunner } from './dev-ai-runner.js';
+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';
@@ -77,11 +80,15 @@ export const dev = pikkuSessionlessFunc({
             // auth requests saw CLI services (no kysely) and crashed.
             const isHotReload = previousSingletonServices !== commandSingletonServices &&
                 !!previousSingletonServices;
+            // Overlaid rather than swapped: swapping left the app reading the CLI's
+            // config for as long as codegen ran.
             const codegenServices = isHotReload
                 ? {
                     ...previousSingletonServices,
-                    config: commandSingletonServices?.config ??
-                        previousSingletonServices.config,
+                    config: {
+                        ...previousSingletonServices.config,
+                        ...commandSingletonServices?.config,
+                    },
                 }
                 : commandSingletonServices;
             pikkuState(null, 'package', 'singletonServices', codegenServices);
@@ -163,19 +170,19 @@ export const dev = pikkuSessionlessFunc({
             ? new LocalContent(localContentConfig, logger, contentSigningJWT)
             : undefined;
         const schedulerService = new InMemorySchedulerService();
-        const aiStorage = kysely
-            ? new KyselyAIStorageService(kysely)
+        const agentStorage = kysely
+            ? new KyselyAgentStorageService(kysely)
             : undefined;
-        const aiRunState = kysely
-            ? new KyselyAIRunStateService(kysely)
-            : new InMemoryAIRunStateService();
+        const agentRunState = kysely
+            ? new KyselyAgentRunStateService(kysely)
+            : new InMemoryAgentRunStateService();
         const agentRunService = kysely
             ? new KyselyAgentRunService(kysely)
             : undefined;
-        if (aiStorage)
-            await aiStorage.init();
-        if ('init' in aiRunState && typeof aiRunState.init === 'function') {
-            await aiRunState.init();
+        if (agentStorage)
+            await agentStorage.init();
+        if ('init' in agentRunState && typeof agentRunState.init === 'function') {
+            await agentRunState.init();
         }
         // InMemoryWorkflowService implements both the workflowService and
         // workflowRunService surfaces (listRuns/getRun live on it). Expose the
@@ -190,8 +197,8 @@ export const dev = pikkuSessionlessFunc({
         // Only when the project declares agents — otherwise the runner's
         // missing-SDK warning fires spuriously for projects with global AI env.
         const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
-        const aiAgentRunner = hasAgents
-            ? await createDevAIAgentRunner({
+        const agentRunner = hasAgents
+            ? await createDevAgentRunner({
                 logger,
                 projectRoot: config.rootDir,
                 variables,
@@ -204,7 +211,7 @@ export const dev = pikkuSessionlessFunc({
         const devQueueService = new InMemoryQueueService();
         const inMemoryServices = {
             logger: devLogger,
-            ...(aiAgentRunner ? { aiAgentRunner } : {}),
+            ...(agentRunner ? { agentRunner } : {}),
             emailService: test
                 ? spy('emailService', new LocalEmailService())
                 : new LocalEmailService(),
@@ -216,8 +223,8 @@ export const dev = pikkuSessionlessFunc({
             workflowService,
             workflowRunService: workflowService,
             triggerService: new InMemoryTriggerService(),
-            aiStorage,
-            aiRunState,
+            agentStorage,
+            agentRunState,
             agentRunService,
             eventHub,
             ...(kysely ? { kysely } : {}),
@@ -234,7 +241,7 @@ export const dev = pikkuSessionlessFunc({
         };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
-        wireAIScorerQueueWorkers();
+        wireAgentScorerQueueWorkers();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
         const loadLifecycle = async () => {
             if (!serverLifecycleFactory)
@@ -334,7 +341,7 @@ export const dev = pikkuSessionlessFunc({
                             invalidateInspectorState();
                             await runAllWithCommandState();
                             workflowService.wireQueueWorkers();
-                            wireAIScorerQueueWorkers();
+                            wireAgentScorerQueueWorkers();
                             // Pull the regenerated meta + JSON schemas into the running
                             // process so new/changed functions are callable without a
                             // restart (the hot-reloader registers their implementations).

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,6 +1,6 @@
 import { readFile, writeFile } from 'fs/promises';
 import { join } from 'path';
-import { pikkuVoidFunc } from '#pikku';
+import { pikkuVoidFunc } from '#pikku/function';
 /**
  * Remote RPC workers carry no auth dimension — `serialize-remote-rpc.ts`
  * hardcodes `auth: false` on what it generates — so enabling it writes a bare
@@ -23,7 +23,9 @@ async function enableFeature(feature, logger, config, data) {
     //
     // 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 wantsPublic = noAuth &&
+        feature !== 'console' &&
+        !NO_AUTH_DIMENSION.has(feature);
     const value = feature === 'webhook' ? true : wantsPublic ? { auth: false } : true;
     json.scaffold[feature] = value;
     await writeFile(configPath, JSON.stringify(json, null, 2) + '\n', 'utf-8');

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 };
+};