@pikku/cli 0.12.105 → 0.12.107

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,9 +1,8 @@
 import { resolve, dirname } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
-import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/ecosystem/persona';
-import { personaVirtualUserTarget, runVirtualUser, } from '@pikku/core/virtual-user';
-import { catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, } from '@pikku/core/ecosystem/virtual-user';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/persona';
+import { personaVirtualUserTarget, runVirtualUser, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, } from '@pikku/core/virtual-user';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
 import { createDevAgentRunner } from './dev-agent-runner.js';

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/roles-shared.d.ts

@@ -1,4 +1,4 @@
-import type { SystemRole } from '@pikku/core/ecosystem/role';
+import type { SystemRole } from '@pikku/core/role';
 import { openScopeService } from './scopes-shared.js';
 import type { OpenedScopeService } from './scopes-shared.js';
 type Logger = {

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

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { flattenSystemRoleDefinitions } from '@pikku/core/ecosystem/role';
+import { flattenSystemRoleDefinitions } from '@pikku/core/role';
 import { loadDeclaredScopes, openScopeService } from './scopes-shared.js';
 const isRoleDefinitionsMeta = (value) => typeof value === 'object' &&
     value !== null &&

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

@@ -7,15 +7,14 @@
  * making the driver's optional isolation and diagnostics safe to call
  * unconditionally.
  */
-import type { ScenarioBrowserFailure, ScenarioBrowserProvider } from '@pikku/core/ecosystem/scenario';
-import type { ResolvedPersona } from '@pikku/core/ecosystem/services';
+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";
 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/ecosystem/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,8 +1,7 @@
-import type { ScenarioSurface } from '@pikku/core/scenario';
-import type { ScenarioStepPhase } from '@pikku/core/ecosystem/scenario';
-import type { WorkflowStepMeta } from '@pikku/core/ecosystem/workflow';
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
-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-ladder.js

@@ -8,7 +8,7 @@
  * belongs to `scenario-formatter.ts`; this module only decides what each step
  * is called.
  */
-import { composeStepProse } from '@pikku/core/ecosystem/scenario';
+import { composeStepProse } from '@pikku/core/scenario';
 import { KEYWORD_WIDTH } from './scenario-formatter.js';
 /**
  * Walk a workflow's steps — including the ones nested inside branches, fanouts

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

@@ -1,5 +1,5 @@
-import type { CoreWorkflow } from '@pikku/core/ecosystem/workflow';
-import type { CoreFeature } from '@pikku/core/ecosystem/scenario';
+import type { CoreWorkflow } from '@pikku/core/workflow';
+import type { CoreFeature } from '@pikku/core/scenario';
 /** One scenario run: a scenario name and, for a feature's paired entry, its input. */
 export type ScenarioPlanEntry = {
     scenarioName: string;

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

@@ -1,4 +1,4 @@
-import { resolveFeatureScenarios } from '@pikku/core/ecosystem/scenario';
+import { resolveFeatureScenarios } from '@pikku/core/scenario';
 /**
  * Turn the registered scenarios and features into an ordered list of run units.
  *

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

@@ -1,6 +1,6 @@
 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;
@@ -13,10 +13,10 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     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;
@@ -29,10 +29,10 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     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;
@@ -45,7 +45,7 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     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>;