@pikku/cli 0.12.104 → 0.12.107

package/dist/src/functions/commands/new-middleware.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'fs';
 import { dirname } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { scaffoldFilePath } from '../../utils/file-writer.js';
 export const pikkuNewMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config }, { name, type = 'simple' }) => {
@@ -13,7 +13,7 @@ export const pikkuNewMiddleware = pikkuSessionlessFunc({
         let content;
         switch (type) {
             case 'factory':
-                content = `import { pikkuMiddlewareFactory } from '#pikku'
+                content = `import { pikkuMiddlewareFactory } from '#pikku/function'
 
 export const ${name} = pikkuMiddlewareFactory(
   (param: string) =>
@@ -28,7 +28,7 @@ export const ${name} = pikkuMiddlewareFactory(
                 break;
             case 'simple':
             default:
-                content = `import { pikkuMiddleware } from '#pikku'
+                content = `import { pikkuMiddleware } from '#pikku/function'
 
 export const ${name} = pikkuMiddleware(
   async ({ logger }, _data, next) => {

package/dist/src/functions/commands/new-permission.d.ts

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

package/dist/src/functions/commands/new-permission.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'fs';
 import { dirname } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { scaffoldFilePath } from '../../utils/file-writer.js';
 export const pikkuNewPermission = pikkuSessionlessFunc({
     func: async ({ logger, config }, { name, type = 'simple' }) => {
@@ -13,7 +13,7 @@ export const pikkuNewPermission = pikkuSessionlessFunc({
         let content;
         switch (type) {
             case 'factory':
-                content = `import { pikkuPermissionFactory } from '#pikku'
+                content = `import { pikkuPermissionFactory } from '#pikku/auth'
 
 export const ${name} = pikkuPermissionFactory(
   (param: string) =>
@@ -26,7 +26,7 @@ export const ${name} = pikkuPermissionFactory(
                 break;
             case 'simple':
             default:
-                content = `import { pikkuPermission } from '#pikku'
+                content = `import { pikkuPermission } from '#pikku/auth'
 
 export const ${name} = pikkuPermission(
   async ({ logger }, _data, { session }) => {

package/dist/src/functions/commands/new-wiring.d.ts

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

package/dist/src/functions/commands/new-wiring.js

@@ -1,12 +1,12 @@
 import { existsSync } from 'fs';
 import { dirname } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { scaffoldFilePath } from '../../utils/file-writer.js';
 function getWiringTemplate(type, name) {
     switch (type) {
         case 'http':
-            return `import { wireHTTP } from '#pikku'
+            return `import { wireHTTP } from '#pikku/http'
 // import { myFunc } from '../functions/${name}.functions.js'
 
 wireHTTP({
@@ -17,7 +17,7 @@ wireHTTP({
 })
 `;
         case 'channel':
-            return `import { wireChannel } from '#pikku'
+            return `import { wireChannel } from '#pikku/channel'
 // import { onConnect, onMessage, onDisconnect } from '../functions/${name}.functions.js'
 
 wireChannel({
@@ -30,7 +30,7 @@ wireChannel({
 })
 `;
         case 'scheduler':
-            return `import { wireScheduler } from '#pikku'
+            return `import { wireScheduler } from '#pikku/scheduler'
 // import { myTask } from '../functions/${name}.functions.js'
 
 wireScheduler({
@@ -40,7 +40,7 @@ wireScheduler({
 })
 `;
         case 'queue':
-            return `import { wireQueueWorker } from '#pikku'
+            return `import { wireQueueWorker } from '#pikku/queue'
 // import { processItem } from '../functions/${name}.functions.js'
 
 wireQueueWorker({
@@ -49,7 +49,7 @@ wireQueueWorker({
 })
 `;
         case 'mcp':
-            return `import { wireMCPResource } from '#pikku'
+            return `import { wireMCPResource } from '#pikku/mcp'
 // import { myResource } from '../functions/${name}.functions.js'
 
 wireMCPResource({
@@ -60,7 +60,7 @@ wireMCPResource({
 })
 `;
         case 'cli':
-            return `import { wireCLI, pikkuCLICommand } from '#pikku'
+            return `import { wireCLI, pikkuCLICommand } from '#pikku/cli'
 // import { myCommand } from '../functions/${name}.functions.js'
 
 wireCLI({
@@ -74,7 +74,7 @@ wireCLI({
 })
 `;
         case 'trigger':
-            return `import { wireTrigger } from '#pikku'
+            return `import { wireTrigger } from '#pikku/trigger'
 // import { handleEvent } from '../functions/${name}.functions.js'
 
 wireTrigger({

package/dist/src/functions/commands/persona-sync.d.ts

@@ -18,16 +18,16 @@
  * command has no way to check that, so pointing it at a stage's API and a local
  * database provisions nobody usefully.
  */
-export declare const personaSync: import("#pikku").PikkuFunctionConfig<{
+export declare const personaSync: import("#pikku/function").PikkuFunctionConfig<{
     environment: string;
     apiUrl?: string;
     dryRun?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     environment: string;
     apiUrl?: string;
     dryRun?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     environment: string;
     apiUrl?: string;
     dryRun?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/persona-sync.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { createHttpPersonas } from '@pikku/core/persona';
 import { personaEnvironmentRefusal } from '@pikku/core/persona';
 import { resolvePersonas } from '../../utils/resolve-personas.js';

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

@@ -11,7 +11,7 @@
  * proves nothing — what it produces is findings, and the absence of them is
  * only ever "not this time, not with this seed".
  */
-export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
+export declare const personaRun: import("#pikku/function").PikkuFunctionConfig<{
     environment: string;
     persona: string;
     disposition?: string;
@@ -25,7 +25,7 @@ export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
     allowApproval?: boolean;
     skipRoleCheck?: boolean;
     out?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     environment: string;
     persona: string;
     disposition?: string;
@@ -39,7 +39,7 @@ export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
     allowApproval?: boolean;
     skipRoleCheck?: boolean;
     out?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     environment: string;
     persona: string;
     disposition?: string;
@@ -53,6 +53,6 @@ export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
     allowApproval?: boolean;
     skipRoleCheck?: boolean;
     out?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 /** Who this app is for, and what each of them wants, without running anything. */
-export declare const personaList: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const personaList: 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/persona.js

@@ -1,11 +1,11 @@
 import { resolve, dirname } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/persona';
-import { personaVirtualUserTarget, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, runVirtualUser, } from '@pikku/core/virtual-user';
+import { personaVirtualUserTarget, runVirtualUser, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, } from '@pikku/core/virtual-user';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
-import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { createDevAgentRunner } from './dev-agent-runner.js';
 import { formatVirtualUserReport } from './virtual-user-formatter.js';
 const dispositionNames = Object.keys(DISPOSITIONS);
 /**
@@ -84,12 +84,12 @@ export const personaRun = pikkuSessionlessFunc({
         if (!resolvedModel) {
             throw new Error('No model to think with — pass --model, or set scenarios.model in pikku.config.json.');
         }
-        const aiAgentRunner = await createDevAIAgentRunner({
+        const agentRunner = await createDevAgentRunner({
             logger,
             projectRoot: config.rootDir,
             variables,
         });
-        if (!aiAgentRunner) {
+        if (!agentRunner) {
             throw new Error('No AI provider is configured. Set OPENAI_BASE_URL + OPENAI_API_KEY (or LITELLM_PROXY_URL + LITELLM_API_KEY).');
         }
         // Shared with the scaffolded `runVirtualUser` RPC, which does the same
@@ -153,7 +153,7 @@ export const personaRun = pikkuSessionlessFunc({
                 model: resolvedModel,
                 agents: agents.map((agent) => agent.name),
             }),
-            llm: (params) => aiAgentRunner.run(params),
+            llm: (params) => agentRunner.run(params),
             model: resolvedModel,
             seed: seed ? Number(seed) : undefined,
             allowApprovalRequired: allowApproval ?? false,

package/dist/src/functions/commands/pikku-command-bootstrap.d.ts

@@ -1,4 +1,4 @@
 export type BootstrapInput = {
     allImports: string[];
 };
-export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuBootstrap: import("#pikku/function").PikkuFunctionConfig<BootstrapInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<BootstrapInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<BootstrapInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../utils/file-import-path.js';
 import { writeFileInDir } from '../../utils/file-writer.js';
 export const pikkuBootstrap = pikkuSessionlessFunc({
@@ -35,7 +36,7 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
         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');
+        const metaServiceFile = join(outDir, 'services', 'pikku-meta-service.gen.ts');
         const escapedOutDir = outDir.replace(/\\/g, '/').replace(/'/g, "\\'");
         const metaServiceContent = [
             `import { LocalMetaService } from '@pikku/core/services/local-meta'`,
@@ -48,6 +49,10 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
             ``,
         ].join('\n');
         await writeFileInDir(logger, metaServiceFile, metaServiceContent);
+        // The meta service used to sit loose at the root of the output dir. A
+        // project generated before it moved under `services/` still has that file,
+        // and tsc compiles every file in the output tree.
+        await rm(join(outDir, 'pikku-meta-service.gen.ts'), { force: true });
         const allBootstrapImports = [
             ...localImports,
             ...wireAddonFileImports,

package/dist/src/functions/commands/pikku-command-summary.d.ts

@@ -1 +1 @@
-export declare const pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuSummary: 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/pikku-command-summary.js

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { PikkuError } from '@pikku/core';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { PikkuError } from '@pikku/core/errors';
 import { CommandSummary } from '../../utils/command-summary.js';
 // A blocking-diagnostics failure is expected (the gate did its job) — throw a
 // PikkuError so the workflow runner logs the message alone, not a stack trace.

package/dist/src/functions/commands/roles-audit.d.ts

@@ -1 +1 @@
-export declare const rolesAudit: 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 rolesAudit: 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/roles-audit.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredRoles, openScopeServiceForRoles, reportStaleRoles, } from './roles-shared.js';
 export const rolesAudit = pikkuSessionlessFunc({
     remote: true,

package/dist/src/functions/commands/roles-prune.d.ts

@@ -7,10 +7,10 @@
  * whole point of the additive sync: deleting a `defineSystemRole` declaration
  * leaves people holding the role until somebody decides otherwise here.
  */
-export declare const rolesPrune: import("#pikku").PikkuFunctionConfig<{
+export declare const rolesPrune: import("#pikku/function").PikkuFunctionConfig<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/roles-prune.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredRoles, openScopeServiceForRoles, reportStaleRoles, } from './roles-shared.js';
 /**
  * Removes system roles that are no longer declared in code, cascading them out

package/dist/src/functions/commands/scenario-browser.d.ts

@@ -7,7 +7,7 @@
  * making the driver's optional isolation and diagnostics safe to call
  * unconditionally.
  */
-import type { ScenarioBrowserFailure, ScenarioBrowserProvider } from '@pikku/core/scenario';
+import type { ScenarioArtifact, ScenarioBrowserFailure, ScenarioBrowserProvider } from '@pikku/core/scenario';
 import type { ResolvedPersona } from '@pikku/core/services';
 /** The default driver, used when a project names no other. */
 export declare const DEFAULT_BROWSER_DRIVER = "@pikku/playwright";
@@ -15,7 +15,6 @@ export interface ScenarioBrowserDriverOptions {
     secret: string;
     actors: Record<string, ResolvedPersona>;
     signInPath?: string;
-    failureDir?: string;
     capture?: ScenarioCaptureOptions;
     config: unknown;
 }
@@ -41,6 +40,7 @@ export interface ScenarioBrowserDriver {
      */
     browserConfigFromEnv?: (overrides: {
         appUrl?: string;
+        appUrls?: Record<string, string>;
         apiUrl: string;
     }) => unknown;
 }
@@ -54,8 +54,10 @@ export interface ScenarioCaptureOptions {
     dir: string;
     /** The invocation these artifacts belong to. */
     runId: string;
-    /** Record a video per scenario. */
-    video?: boolean;
+    /** Write the screenshots a scenario asks for by name. */
+    screenshots?: boolean;
+    /** Which scenarios keep their recording. */
+    video?: 'off' | 'failed' | 'all';
     /** Re-encode with ffmpeg when available. Defaults on — the footage is nearly static. */
     compress?: boolean;
 }
@@ -64,15 +66,16 @@ export interface ResolveScenarioBrowserProviderOptions {
     environment: string;
     apiUrl: string;
     appUrl?: string;
+    /** Base url per app, for a product whose personas sign into more than one. */
+    appUrls?: Record<string, string>;
     secret: string;
     actors: Record<string, ResolvedPersona>;
     signInPath?: string;
-    /** Where failure screenshots are written. */
-    failureDir: string;
     /**
-     * Artifacts for this run — named screenshots, and optionally a video per
-     * scenario. Undefined leaves capture off, which is the default: most runs
-     * ask a pass/fail question and writing video to answer it is waste.
+     * Artifacts for this run — named screenshots, failure screenshots, and a
+     * video per scenario kept according to its retention. Undefined leaves
+     * capture off entirely, which is what a driver used outside
+     * `pikku scenario run` gets.
      */
     capture?: ScenarioCaptureOptions;
     /** The scenarios that declared browser steps, named in the missing-driver error. */
@@ -93,15 +96,18 @@ export interface ResolveScenarioBrowserProviderOptions {
  * because a run against a placeholder URL is worse than one that refuses to
  * start.
  */
-export declare const resolveScenarioBrowserProvider: ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, capture, browserScenarios, driver, importDriver, }: ResolveScenarioBrowserProviderOptions) => Promise<ScenarioBrowserProvider>;
+export declare const resolveScenarioBrowserProvider: ({ environment, apiUrl, appUrl, appUrls, secret, actors, signInPath, capture, browserScenarios, driver, importDriver, }: ResolveScenarioBrowserProviderOptions) => Promise<ScenarioBrowserProvider>;
 /**
- * The three calls the run loop makes, safe against a run with no browser and
- * against a driver that implements neither optional member.
+ * The calls the run loop makes, safe against a run with no browser and against
+ * a driver that implements none of the optional members.
  */
 export interface ScenarioBrowserLifecycle {
     reset(): Promise<void>;
     beginScenario(scenario: string): void;
+    endScenario(outcome: 'passed' | 'failed'): void;
     captureFailure(label: string): Promise<ScenarioBrowserFailure[]>;
+    /** What the run filed, complete only once `close()` has been called. */
+    artifacts(): ScenarioArtifact[];
     close(): Promise<void>;
 }
 export declare const scenarioBrowserLifecycle: (provider: ScenarioBrowserProvider | undefined) => ScenarioBrowserLifecycle;

package/dist/src/functions/commands/scenario-browser.js

@@ -12,7 +12,7 @@ export const DEFAULT_BROWSER_DRIVER = '@pikku/playwright';
  * because a run against a placeholder URL is worse than one that refuses to
  * start.
  */
-export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, capture, browserScenarios, driver = DEFAULT_BROWSER_DRIVER, importDriver = (specifier) => import(specifier), }) => {
+export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appUrl, appUrls, secret, actors, signInPath, capture, browserScenarios, driver = DEFAULT_BROWSER_DRIVER, importDriver = (specifier) => import(specifier), }) => {
     const module = await importDriver(driver).catch(() => {
         const install = driver === DEFAULT_BROWSER_DRIVER
             ? `Run 'yarn add -D ${driver} @playwright/test'`
@@ -20,19 +20,29 @@ export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appU
         throw new Error(`Scenarios ${browserScenarios.join(', ')} declare browser steps but '${driver}' could not be loaded. ` +
             `${install}, or run with --no-browser to skip them.`);
     });
-    const config = (module.browserConfigFromEnv?.({ appUrl, apiUrl }) ?? {
-        appUrl,
-        apiUrl,
-    });
+    const overrides = { appUrl, apiUrl, ...(appUrls ? { appUrls } : {}) };
+    const config = (module.browserConfigFromEnv?.(overrides) ??
+        overrides);
     if (!config.appUrl || config.appUrlSource === 'default') {
         throw new Error(`Scenario environment '${environment}' has browser steps but no 'appUrl', and '${driver}' resolved none from the environment. ` +
             `Add it to environments.${environment} in pikku.config.json, pass --app-url for a target that only exists at run time, or run with --no-browser to skip them.`);
     }
+    // An actor whose app has no url would browse the fallback: the wrong app's
+    // pages, loading fine, asserting nothing about the app the scenario meant.
+    // Cheaper to refuse now than to read a green run that proved one app twice.
+    const unmapped = [
+        ...new Set(Object.values(actors)
+            .map((persona) => persona.app)
+            .filter((app) => !!app && !config.appUrls?.[app])),
+    ];
+    if (unmapped.length > 0 && Object.keys(config.appUrls ?? {}).length > 0) {
+        throw new Error(`No app url for ${unmapped.map((app) => `'${app}'`).join(', ')}, which ${unmapped.length > 1 ? 'personas sign' : 'a persona signs'} into. ` +
+            `Pass --app-url ${unmapped[0]}=<url> (repeatable, comma-separated) or add it to environments.${environment}.appUrls in pikku.config.json.`);
+    }
     const options = {
         secret,
         actors,
         signInPath,
-        failureDir,
         capture,
         config,
     };
@@ -56,6 +66,9 @@ export const scenarioBrowserLifecycle = (provider) => ({
     beginScenario: (scenario) => {
         provider?.beginScenario?.(scenario);
     },
+    endScenario: (outcome) => {
+        provider?.endScenario?.(outcome);
+    },
     captureFailure: async (label) => {
         try {
             return (await provider?.captureFailure?.(label)) ?? [];
@@ -66,6 +79,7 @@ export const scenarioBrowserLifecycle = (provider) => ({
             return [];
         }
     },
+    artifacts: () => provider?.artifacts?.() ?? [],
     close: async () => {
         await provider?.close();
     },

package/dist/src/functions/commands/scenario-formatter.d.ts

@@ -1,62 +1,16 @@
 /**
- * The scenario run report, and how it is rendered.
+ * How a scenario run is rendered to a terminal.
  *
  * Everything a run prints goes through here, so the shape of the output is one
  * file rather than log calls scattered through the command. The report itself
- * is plain serialisable data — no Maps, no meta handles — which is what makes a
- * second formatter (JSON, JUnit) a matter of writing one function rather than
- * unpicking the runner.
+ * is plain serialisable data — no Maps, no meta handles — declared in
+ * `@pikku/core` because the same shapes are what a run is stored as and what
+ * the console reads back, which is also what makes a second formatter (JSON,
+ * JUnit) a matter of writing one function rather than unpicking the runner.
  */
-import type { ScenarioBrowserFailure } from '@pikku/core/scenario';
+import type { ScenarioFailureDetail, ScenarioRunReport, ScenarioStepRow } from '@pikku/core/scenario';
 /** The longest gherkin keyword ("Given"), so sentences line up under each other. */
 declare const KEYWORD_WIDTH = 5;
-/** One step of a run, already joined to the prose that declared it. */
-export interface ScenarioStepRow {
-    sentence: string;
-    status: string;
-    durationMs?: number;
-    error?: string;
-}
-/** Everything known about why one scenario failed. */
-export interface ScenarioFailureDetail {
-    /** The rendered sentence of the failing step; absent if no step failed. */
-    sentence?: string;
-    message: string;
-    stack?: string;
-    /**
-     * True when the failure was a deliberate one (a PikkuError). Its message is
-     * the whole story, so the stack is noise.
-     */
-    expected?: boolean;
-    browser?: ScenarioBrowserFailure[];
-}
-export interface ScenarioResult {
-    name: string;
-    status: 'passed' | 'failed';
-    durationMs: number;
-    output?: unknown;
-    error?: string;
-    steps?: ScenarioStepRow[];
-    failure?: ScenarioFailureDetail;
-}
-/** One scenario that was not run, and why. */
-export interface ScenarioSkip {
-    name: string;
-    reason: string;
-}
-export interface ScenarioRunReport {
-    environment: string;
-    results: ScenarioResult[];
-    /**
-     * Scenarios not run at all, each carrying why. A skip is only useful if the
-     * reader can tell a browser scenario held back by `--no-browser` from one the
-     * project itself quarantined, so the reason travels with the name rather than
-     * being assumed by the formatter.
-     */
-    skipped: ScenarioSkip[];
-    /** Feature-level hook failures, which belong to no single scenario. */
-    hookFailures: string[];
-}
 export interface ScenarioReportLine {
     level: 'info' | 'error';
     text: string;

package/dist/src/functions/commands/scenario-ladder.d.ts

@@ -1,7 +1,7 @@
-import type { ScenarioStepPhase, ScenarioSurface } from '@pikku/core/scenario';
-import type { WorkflowStepMeta } from '@pikku/core/workflow/types';
-import type { FunctionsMeta } from '@pikku/core';
-import type { ScenarioFailureDetail, ScenarioStepRow } from './scenario-formatter.js';
+import type { ScenarioSurface, ScenarioStepPhase } from '@pikku/core/scenario';
+import type { WorkflowStepMeta } from '@pikku/core/workflow';
+import type { FunctionsMeta } from '@pikku/core/services';
+import type { ScenarioFailureDetail, ScenarioStepRow } from '@pikku/core/scenario';
 export interface ScenarioStepProse {
     phase: ScenarioStepPhase;
     description: string;

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

@@ -1,54 +1,51 @@
 import type { ScenarioSurface } from '@pikku/core/scenario';
-export declare const scenarioList: 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 scenarioRun: import("#pikku").PikkuFunctionConfig<{
+export declare const scenarioList: 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>;
+export declare const scenarioRun: import("#pikku/function").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
     features?: string;
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     environment: string;
     flows?: string;
     features?: string;
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     environment: string;
     flows?: string;
     features?: string;
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;