@pikku/core 0.12.141 → 0.12.142

package/dist/wirings/virtual-user/virtual-user-schedule-store.d.ts

@@ -1,20 +1,20 @@
 import type { VirtualUserBudget, VirtualUserDisposition } from './virtual-user.types.js';
 /**
- * One persona's standing instruction to keep using the app.
+ * One virtual user's standing instruction to keep using the app.
  *
  * A virtual user that runs once tells you about one afternoon. What an app
- * actually wants to know is what a persona hits over a fortnight, and that is
+ * actually wants to know is what a virtual user hits over a fortnight, and that is
  * a cadence, not a longer run — a budget already caps how far a single run
  * goes, and raising it only buys a more tired user.
  *
  * The row is the schedule. There is deliberately no timer, interval or
  * in-memory loop anywhere near it: a process that holds the next run in its own
- * heap forgets it on the next deploy, and a persona silently stops. Something
+ * heap forgets it on the next deploy, and a virtual user silently stops. Something
  * outside asks which rows are due; the answer survives restarts because it is
  * written down.
  */
 export interface VirtualUserScheduleRecord {
-    persona: string;
+    virtualUserId: string;
     /**
      * Off by default. A schedule that ran the moment it was written would start
      * spending an app's model budget as a side effect of a migration.
@@ -24,20 +24,20 @@ export interface VirtualUserScheduleRecord {
     goals: string[];
     budget: VirtualUserBudget | null;
     /**
-     * The gap to the next run is drawn between these, not fixed. A persona that
+     * The gap to the next run is drawn between these, not fixed. A virtual user that
      * appears at exactly 09:00 every day exercises one cache state and one cron
      * neighbourhood; a real one does not keep an appointment.
      */
     minIntervalMs: number;
     maxIntervalMs: number;
-    /** When this persona is next allowed to run. The whole schedule, in one field. */
+    /** When this virtual user is next allowed to run. The whole schedule, in one field. */
     nextRunAt: Date;
     lastRunId: string | null;
     lastRunAt: Date | null;
 }
 /** A partial write — anything left out keeps whatever the row already had. */
 export interface VirtualUserScheduleInput {
-    persona: string;
+    virtualUserId: string;
     enabled?: boolean;
     disposition?: VirtualUserDisposition;
     goals?: readonly string[];
@@ -57,33 +57,33 @@ export interface VirtualUserScheduleInput {
  * smaller permission than deciding they should keep going.
  */
 export interface VirtualUserScheduleStore {
-    /** Creates or updates one persona's cadence. Returns the row as it now stands. */
+    /** Creates or updates one virtual user's cadence. Returns the row as it now stands. */
     set(schedule: VirtualUserScheduleInput): Promise<VirtualUserScheduleRecord>;
-    get(persona: string): Promise<VirtualUserScheduleRecord | null>;
+    get(virtualUserId: string): Promise<VirtualUserScheduleRecord | null>;
     list(): Promise<VirtualUserScheduleRecord[]>;
     /** Enabled rows whose `nextRunAt` has passed. */
     due(now: Date): Promise<VirtualUserScheduleRecord[]>;
     /**
-     * Pushes the persona's next run out, and records which run this was.
+     * Pushes the virtual user's next run out, and records which run this was.
      *
      * Called *before* the run is dispatched, so a tick that dies halfway does not
      * leave a row due and get re-dispatched by the next one. The cost is that a
      * dispatch which throws waits a full interval rather than retrying, which is
-     * the right way round: a persona that is failing to start should not be
+     * the right way round: a virtual user that is failing to start should not be
      * retried every minute for a week.
      *
      * `from` is the `nextRunAt` the caller read, and the write must match it to
-     * land — the claim is how a tick wins the persona, not just how it records
+     * land — the claim is how a tick wins the virtual user, not just how it records
      * winning. Two processes on the same cron read the same due row, and without
      * the compare-and-set both would dispatch: the same user acting twice over,
      * at twice the budget, producing findings neither run can reproduce. The
-     * loser is told `false` and leaves the persona to whoever got there first.
+     * loser is told `false` and leaves the virtual user to whoever got there first.
      */
-    claim(persona: string, claim: {
+    claim(virtualUserId: string, claim: {
         from: Date;
         nextRunAt: Date;
         runId: string | null;
         at: Date;
     }): Promise<boolean>;
-    remove(persona: string): Promise<void>;
+    remove(virtualUserId: string): Promise<void>;
 }

package/dist/wirings/virtual-user/virtual-user-schedule.d.ts

@@ -6,7 +6,7 @@ import type { VirtualUserScheduleRecord, VirtualUserScheduleStore } from './virt
  *
  * A run holds no process across a restart — see {@link VirtualUserRunRecord} —
  * so a deploy mid-run strands the record, and a stranded record would block its
- * persona's schedule for good. Twice the longest duration budget anyone sets in
+ * virtual user's schedule for good. Twice the longest duration budget anyone sets in
  * practice, because the failure this guards against is cheap to recover from
  * and expensive to trigger early: reaping a run that was still working loses
  * its findings.
@@ -25,7 +25,7 @@ export declare const DEFAULT_MAX_INTERVAL_MS: number;
 /** Whether a row is the tick's business, for stores that cannot ask in a query. */
 export declare const isDue: (schedule: VirtualUserScheduleRecord, now: Date) => boolean;
 /**
- * When this persona should next appear, drawn from its own interval.
+ * When this virtual user should next appear, drawn from its own interval.
  *
  * Uniform between the two bounds. Reversed bounds are read as a range rather
  * than rejected, because a schedule is configuration and a swapped pair is a
@@ -35,11 +35,11 @@ export declare const nextRunAt: (schedule: Pick<VirtualUserScheduleRecord, 'minI
 export type VirtualUserSkipReason = 'in-flight' | 'dispatch-failed' | 'claimed-elsewhere';
 export interface VirtualUserTickResult {
     dispatched: {
-        persona: string;
+        virtualUserId: string;
         runId: string;
     }[];
     skipped: {
-        persona: string;
+        virtualUserId: string;
         reason: VirtualUserSkipReason;
     }[];
     /** Runs found stranded at `running` and marked failed. */
@@ -55,14 +55,14 @@ export interface VirtualUserTickParams {
     staleAfterMs?: number;
 }
 /**
- * Acts on whichever personas are due, once.
+ * Acts on whichever virtual users are due, once.
  *
  * The whole cadence lives in this one call, so what schedules it is the host's
  * choice — a cron wiring, a platform scheduler, or a person clicking a button.
  * Pikku does not start a timer on an app's behalf; a scaffold that did would
  * begin spending model budget the moment a project ran `pikku all`.
  *
- * A persona is skipped, not queued, while its previous run is still going. Two
+ * A virtual user is skipped, not queued, while its previous run is still going. Two
  * copies of the same user acting at once is not a heavier test, it is a
  * different one, and every finding it produces is unreproducible. Two ticks
  * running at once are held to the same rule by the claim, which only lands for

package/dist/wirings/virtual-user/virtual-user-schedule.js

@@ -4,7 +4,7 @@
  *
  * A run holds no process across a restart — see {@link VirtualUserRunRecord} —
  * so a deploy mid-run strands the record, and a stranded record would block its
- * persona's schedule for good. Twice the longest duration budget anyone sets in
+ * virtual user's schedule for good. Twice the longest duration budget anyone sets in
  * practice, because the failure this guards against is cheap to recover from
  * and expensive to trigger early: reaping a run that was still working loses
  * its findings.
@@ -23,7 +23,7 @@ export const DEFAULT_MAX_INTERVAL_MS = 24 * 60 * 60 * 1000;
 /** Whether a row is the tick's business, for stores that cannot ask in a query. */
 export const isDue = (schedule, now) => schedule.enabled && schedule.nextRunAt.getTime() <= now.getTime();
 /**
- * When this persona should next appear, drawn from its own interval.
+ * When this virtual user should next appear, drawn from its own interval.
  *
  * Uniform between the two bounds. Reversed bounds are read as a range rather
  * than rejected, because a schedule is configuration and a swapped pair is a
@@ -35,14 +35,14 @@ export const nextRunAt = (schedule, now, random) => {
     return new Date(now.getTime() + low + random() * (high - low));
 };
 /**
- * Acts on whichever personas are due, once.
+ * Acts on whichever virtual users are due, once.
  *
  * The whole cadence lives in this one call, so what schedules it is the host's
  * choice — a cron wiring, a platform scheduler, or a person clicking a button.
  * Pikku does not start a timer on an app's behalf; a scaffold that did would
  * begin spending model budget the moment a project ran `pikku all`.
  *
- * A persona is skipped, not queued, while its previous run is still going. Two
+ * A virtual user is skipped, not queued, while its previous run is still going. Two
  * copies of the same user acting at once is not a heavier test, it is a
  * different one, and every finding it produces is unreproducible. Two ticks
  * running at once are held to the same rule by the claim, which only lands for
@@ -55,17 +55,17 @@ export const tickVirtualUserSchedules = async ({ schedules, runs, dispatch, now
         reaped: [],
     };
     for (const schedule of await schedules.due(now)) {
-        const [latest] = await runs.list({ persona: schedule.persona, limit: 1 });
+        const [latest] = await runs.list({ virtualUserId: schedule.virtualUserId, limit: 1 });
         if (latest?.status === 'running') {
             if (now.getTime() - latest.createdAt.getTime() < staleAfterMs) {
-                result.skipped.push({ persona: schedule.persona, reason: 'in-flight' });
+                result.skipped.push({ virtualUserId: schedule.virtualUserId, reason: 'in-flight' });
                 continue;
             }
             await runs.fail(latest.runId, `Abandoned: still running ${Math.round((now.getTime() - latest.createdAt.getTime()) / 60000)}m after it started, which is longer than any budget allows.`);
             result.reaped.push(latest.runId);
         }
         const due = nextRunAt(schedule, now, random);
-        const acquired = await schedules.claim(schedule.persona, {
+        const acquired = await schedules.claim(schedule.virtualUserId, {
             from: schedule.nextRunAt,
             nextRunAt: due,
             runId: null,
@@ -73,7 +73,7 @@ export const tickVirtualUserSchedules = async ({ schedules, runs, dispatch, now
         });
         if (!acquired) {
             result.skipped.push({
-                persona: schedule.persona,
+                virtualUserId: schedule.virtualUserId,
                 reason: 'claimed-elsewhere',
             });
             continue;
@@ -84,18 +84,18 @@ export const tickVirtualUserSchedules = async ({ schedules, runs, dispatch, now
         }
         catch {
             result.skipped.push({
-                persona: schedule.persona,
+                virtualUserId: schedule.virtualUserId,
                 reason: 'dispatch-failed',
             });
             continue;
         }
-        await schedules.claim(schedule.persona, {
+        await schedules.claim(schedule.virtualUserId, {
             from: due,
             nextRunAt: due,
             runId,
             at: now,
         });
-        result.dispatched.push({ persona: schedule.persona, runId });
+        result.dispatched.push({ virtualUserId: schedule.virtualUserId, runId });
     }
     return result;
 };

package/dist/wirings/virtual-user/virtual-user-target.d.ts

@@ -1,15 +1,15 @@
-import type { ScenarioPersona } from '../../services/personas-service.js';
+import type { ScenarioVirtualUser } from '../../services/virtual-users-service.js';
 import type { VirtualUserTarget } from './virtual-user.types.js';
-export interface PersonaTargetOptions {
-    /** Model the persona uses for its side of a conversation with an agent. */
+export interface VirtualUserTargetOptions {
+    /** Model the virtual user uses for its side of a conversation with an agent. */
     model?: string;
     /** Agents this user may talk to. Omit to leave `talkTo` unavailable. */
     agents?: readonly string[];
 }
 /**
- * Drive a virtual user through a signed-in persona.
+ * Drive a virtual user's run through its signed-in session.
  *
- * This is the only place the engine meets the network. A persona already signs
+ * This is the only place the engine meets the network. A virtual user already signs
  * in as a real user over the app's own auth, keeps its cookies, re-logs-in when
  * a session expires mid-run and reports a status as data rather than throwing —
  * everything a user imitating a user needs, and none of it worth building twice.
@@ -18,4 +18,4 @@ export interface PersonaTargetOptions {
  * error, it is the system saying no, which is information it should be allowed
  * to act on.
  */
-export declare const personaVirtualUserTarget: (persona: ScenarioPersona, { model, agents }?: PersonaTargetOptions) => VirtualUserTarget;
+export declare const virtualUserTarget: (virtualUser: ScenarioVirtualUser, { model, agents }?: VirtualUserTargetOptions) => VirtualUserTarget;

package/dist/wirings/virtual-user/virtual-user-target.js

@@ -1,7 +1,7 @@
 /**
- * Drive a virtual user through a signed-in persona.
+ * Drive a virtual user's run through its signed-in session.
  *
- * This is the only place the engine meets the network. A persona already signs
+ * This is the only place the engine meets the network. A virtual user already signs
  * in as a real user over the app's own auth, keeps its cookies, re-logs-in when
  * a session expires mid-run and reports a status as data rather than throwing —
  * everything a user imitating a user needs, and none of it worth building twice.
@@ -10,8 +10,8 @@
  * error, it is the system saying no, which is information it should be allowed
  * to act on.
  */
-export const personaVirtualUserTarget = (persona, { model, agents } = {}) => ({
-    call: (rpcName, args) => persona.invokeRaw(rpcName, args),
+export const virtualUserTarget = (virtualUser, { model, agents } = {}) => ({
+    call: (rpcName, args) => virtualUser.invokeRaw(rpcName, args),
     talkTo: agents?.length
         ? async (agent, task) => {
             if (!agents.includes(agent)) {
@@ -21,7 +21,7 @@ export const personaVirtualUserTarget = (persona, { model, agents } = {}) => ({
                     transcript: [],
                 };
             }
-            return persona.converse({
+            return virtualUser.converse({
                 agent,
                 task,
                 // A user asking for something judges the answer by whether they got

package/dist/wirings/virtual-user/virtual-user.types.d.ts

@@ -1,9 +1,9 @@
-import type { ScenarioHttpResponse } from '../../services/personas-service.js';
-import type { ActorFlowVerdict } from '../actor-flow/actor-flow.types.js';
+import type { ScenarioHttpResponse } from '../../services/virtual-users-service.js';
+import type { ConversationVerdict } from './conversation/conversation.types.js';
 /**
  * How a virtual user behaves, mechanically. A disposition changes the loop, the
  * input generation, the memory and the oracle — anything that only changes how
- * the user *talks* is persona prose (`ResolvedPersona.personality`) and does
+ * the user *talks* is virtual user prose (`ResolvedVirtualUser.personality`) and does
  * not belong here.
  *
  * - `realistic` — schema-first, goal-directed, plausible values (default).
@@ -17,11 +17,11 @@ import type { ActorFlowVerdict } from '../actor-flow/actor-flow.types.js';
  * `accountable` sits opposite `adversarial` on an *intent* axis — bad faith
  * against good faith — where `careless` and `thorough` are a *care* axis. It is
  * the one disposition whose actions carry consequences: no oracle, no rollback,
- * and every call attributed to the persona in the audit log like anyone else's.
+ * and every call attributed to the virtual user in the audit log like anyone else's.
  */
 export type VirtualUserDisposition = 'realistic' | 'careless' | 'newcomer' | 'stale' | 'auditor' | 'adversarial' | 'accountable';
 /**
- * The one disposition a production environment accepts.
+ * The one disposition a declaration may name for a production environment. Virtual users never run against production, so this only keeps the declaration check honest.
  *
  * Every other disposition exists to find out what the product does wrong, which
  * is not a thing to do to real customers' data. Named here so the declaration
@@ -79,7 +79,7 @@ export interface ApiCatalogueEntry {
     /**
      * Scopes the session must hold to call this, all of them.
      *
-     * Splits the catalogue in two: what a persona's roles entitle it to reach,
+     * Splits the catalogue in two: what a virtual user's roles entitle it to reach,
      * and what they do not. Scopes rather than permission-function names because
      * a scope is declared and checkable, whereas a permission is arbitrary code
      * whose verdict nobody can predict without running it.
@@ -105,8 +105,8 @@ export interface IntentSource {
     /** Step prose, as a person would be told it. Never rpc names. */
     steps?: readonly string[];
     tags?: readonly string[];
-    /** Persona ids this intent is available to. Empty means everyone. */
-    personas?: readonly string[];
+    /** Virtual user ids this intent is available to. Empty means everyone. */
+    virtualUsers?: readonly string[];
 }
 /** Why the engine flagged something. */
 export type VirtualUserFindingKind = 'server-error' | 'transport-error' | 'schema-violation' | 'unexpected-success' | 'custom';
@@ -122,14 +122,14 @@ export interface VirtualUserFinding {
 }
 /**
  * The transport the virtual user acts through. HTTP in production (an
- * `HttpPersona`), but the engine only sees this contract — which is what
+ * `HttpVirtualUser`), but the engine only sees this contract — which is what
  * lets the whole loop be tested without a network.
  */
 export interface VirtualUserTarget {
     /** Invoke an RPC as this user, reporting the status as data rather than throwing. */
     call(rpcName: string, args: unknown): Promise<ScenarioHttpResponse>;
-    /** Converse with an AI agent in persona. Omitted by apps that have no agents. */
-    talkTo?(agent: string, task: string): Promise<ActorFlowVerdict>;
+    /** Converse with an AI agent in virtual user. Omitted by apps that have no agents. */
+    talkTo?(agent: string, task: string): Promise<ConversationVerdict>;
     /** Send a fixture file. Omitted by apps with no upload surface. */
     upload?(file: string): Promise<ScenarioHttpResponse>;
 }

package/dist/wirings/virtual-user/virtual-user.types.js

@@ -1,5 +1,5 @@
 /**
- * The one disposition a production environment accepts.
+ * The one disposition a declaration may name for a production environment. Virtual users never run against production, so this only keeps the declaration check honest.
  *
  * Every other disposition exists to find out what the product does wrong, which
  * is not a thing to do to real customers' data. Named here so the declaration

package/dist/wirings/workflow/dsl/workflow-dsl.types.d.ts

@@ -5,7 +5,7 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { SerializedError } from '../../../errors/serialized-error.js';
 import type { WorkflowRun } from '../workflow.types.js';
-import type { ScenarioPersona } from '../../../services/personas-service.js';
+import type { ScenarioVirtualUser } from '../../../services/virtual-users-service.js';
 import type { ScenarioStepOptions, ScenarioStepPhase, ScenarioSurface } from '../scenario-step.types.js';
 /**
  * Workflow step options
@@ -24,12 +24,12 @@ export interface WorkflowStepOptions {
      */
     compensate?: false;
     /**
-     * Run this step as an actor (scenarios). The RPC is sent through the
-     * actor's authenticated client over the REAL transport — never dispatched
+     * Run this step as a virtual user (scenarios). The RPC is sent through the
+     * virtual user's authenticated client over the REAL transport — never dispatched
      * internally — so auth middleware and permissions are exercised end-to-end.
      * The step is recorded durably like any RPC step.
      */
-    actor?: ScenarioPersona;
+    virtualUser?: ScenarioVirtualUser;
 }
 /**
  * Options for workflow.expectEventually() — a durable polling step used by
@@ -240,8 +240,8 @@ export interface RpcStepMeta {
     inputs?: Record<string, InputSource> | 'passthrough';
     /** Step options */
     options?: WorkflowStepOptions;
-    /** Scenario actor name this step runs as ({ actor: actors.x }) */
-    actor?: string;
+    /** Scenario virtual user name this step runs as ({ virtualUser: virtualUsers.x }) */
+    virtualUser?: string;
     /** True for workflow.expectEventually polling steps */
     expectEventually?: boolean;
 }
@@ -267,8 +267,8 @@ export interface ScenarioStepMeta {
     inputs?: Record<string, InputSource> | 'passthrough';
     /** Step options */
     options?: WorkflowStepOptions;
-    /** Scenario actor name this step runs as ({ actor: actors.x }) */
-    actor?: string;
+    /** Scenario virtual user name this step runs as ({ virtualUser: virtualUsers.x }) */
+    virtualUser?: string;
     /** Mirrors the surfaces the step function declares a binding for */
     surfaces?: ScenarioSurface[];
 }
@@ -595,7 +595,7 @@ export interface PikkuScenarioWire<Out = unknown> extends PikkuWorkflowWire {
      */
     context: ScenarioContext<Out>;
     /**
-     * Durable polling step: invoke `rpcName` (as an actor when `options.actor`
+     * Durable polling step: invoke `rpcName` (as a virtual user when `options.virtualUser`
      * is set) until `predicate` passes or `options.within` elapses.
      */
     expectEventually: <TOutput = any, TInput = any>(stepName: string, rpcName: string, data: TInput, predicate: (output: TOutput) => boolean, options?: WorkflowExpectEventuallyOptions) => Promise<TOutput>;

package/dist/wirings/workflow/pikku-scenario-service.d.ts

@@ -2,7 +2,7 @@ import { PikkuError } from '../../errors/error-handler.js';
 import { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js';
 import type { RunLifecycleContext, WorkflowRunEngine, WorkflowRunExtension } from './workflow-run-engine.types.js';
 import type { PikkuRawWire } from '../../types/core.types.js';
-import type { ScenarioPersonas } from '../../services/personas-service.js';
+import type { ScenarioVirtualUsers } from '../../services/virtual-users-service.js';
 import type { ScenarioStepVideoOffset } from './scenario-run.types.js';
 import type { ScenarioBrowserProvider, ScenarioEnvironment, ScenarioSurface } from './scenario-step.types.js';
 import type { PikkuWorkflowWire, WorkflowQueueOptions } from './workflow.types.js';
@@ -12,11 +12,11 @@ export type { ScenarioArtifact, ScenarioFailureDetail, ScenarioResult, ScenarioR
 export { SCENARIO_SURFACES } from './scenario-step.types.js';
 export { resolveScenarioSurfaces } from './scenario-surface.js';
 export { pollUntil, type PollOptions } from './scenario-poll.js';
-export { createCookieJar } from './scenario-cookie-jar.js';
-export type { ScenarioCookieJar } from './scenario-cookie-jar.js';
+export { createCookieJar } from '../../services/scenario-cookie-jar.js';
+export type { ScenarioCookieJar } from '../../services/scenario-cookie-jar.js';
 export { composeStepProse, renderStepTemplate } from './scenario-prose.js';
 export { requireScenarioEnv } from './scenario-step-guards.js';
-export type { ScenarioHttpResponse, ScenarioJsonRequest, } from '../../services/personas-service.js';
+export type { ScenarioHttpResponse, ScenarioJsonRequest, } from '../../services/virtual-users-service.js';
 /**
  * A workflow service with the scenario capability attached — the two lines
  * `pikku scenario run` needs, in one call so no caller has to remember that the
@@ -44,7 +44,7 @@ export declare class ScenarioHookError extends PikkuError {
  * Two witnesses of the same `then` disagreed.
  *
  * This is the failure the whole additive-witness design exists to produce: the
- * system of record is right and the surface the actor was looking at is not, or
+ * system of record is right and the surface the virtual user was looking at is not, or
  * the other way round. Both observations go in the message, because either one
  * alone reads as a passing assertion.
  */
@@ -74,14 +74,14 @@ export declare class ScenarioBrowserUnavailable extends PikkuError {
     constructor(stepFunc: string);
 }
 /**
- * A step that is driven by a persona was dispatched without one.
+ * A step that is driven by a virtual user was dispatched without one.
  *
  * Raised before the body runs rather than partway through it: the step declared
- * that it needs an actor — by having a `browser` binding, which cannot be
- * provisioned without a window to open, or by `actor: true` — so a call site
+ * that it needs a virtual user — by having a `browser` binding, which cannot be
+ * provisioned without a window to open, or by `virtualUser: true` — so a call site
  * that omits one is a mistake at the call site.
  */
-export declare class ScenarioActorRequired extends PikkuError {
+export declare class ScenarioVirtualUserRequired extends PikkuError {
     readonly stepFunc: string;
     constructor(stepFunc: string);
 }
@@ -122,7 +122,7 @@ export declare class ScenarioNoWitness extends PikkuError {
  * An assertion ran, but not on the surface the run targets.
  *
  * The sibling of {@link ScenarioNoWitness}: that one checked nothing anywhere,
- * this one checked the system of record while the prose claims the actor saw it
+ * this one checked the system of record while the prose claims the virtual user saw it
  * on the page. Ordinary runs count it as a coverage gap; a strict run refuses
  * it, because a flow that cannot be observed end to end on the run surface is
  * not a flow that surface can be documented from.
@@ -138,7 +138,7 @@ export declare class ScenarioUnwitnessedAssertion extends PikkuError {
  * The scenario capability, layered onto a workflow service rather than being
  * one.
  *
- * Every scenario affordance — steps, actors, lifecycle hooks, the browser
+ * Every scenario affordance — steps, virtual users, lifecycle hooks, the browser
  * provider, the assertion wire members — lives here rather than on
  * `PikkuWorkflowService`, because a bundler drops an unused *module* but never
  * an unused class member: anything declared on the workflow service ships in
@@ -160,7 +160,7 @@ export declare class ScenarioUnwitnessedAssertion extends PikkuError {
  */
 export declare class PikkuScenarioService implements WorkflowRunExtension {
     private readonly engine;
-    private runActors;
+    private runVirtualUsers;
     private runContexts;
     private runVideoOffsets;
     private scenarioBrowserProvider?;
@@ -169,7 +169,7 @@ export declare class PikkuScenarioService implements WorkflowRunExtension {
     private strictSurface;
     constructor(engine: WorkflowRunEngine);
     /**
-     * The surface every actor drives the system through for this run, set once by
+     * The surface every virtual user drives the system through for this run, set once by
      * the runner from `--run`. `default` is the server-side path — the fast suite.
      *
      * `strict` removes both routes off that surface: an action may not fall back
@@ -196,7 +196,7 @@ export declare class PikkuScenarioService implements WorkflowRunExtension {
     setScenarioEnvironment(env: ScenarioEnvironment | undefined): void;
     getScenarioEnvironment(): ScenarioEnvironment | undefined;
     /**
-     * Where each of a run's browser steps fell in its actor's video, keyed by the
+     * Where each of a run's browser steps fell in its virtual user's video, keyed by the
      * durable step name, handed over and forgotten in one call.
      *
      * Taken rather than read because the runner joins these onto the step rows
@@ -204,18 +204,18 @@ export declare class PikkuScenarioService implements WorkflowRunExtension {
      * clear them, and the only moment they are still wanted.
      */
     takeStepVideoOffsets(runId: string): Map<string, ScenarioStepVideoOffset[]>;
-    /** Where a step starting now falls in this actor's recording, if anywhere. */
+    /** Where a step starting now falls in this virtual user's recording, if anywhere. */
     private videoOffsetFor;
     /**
-     * Stamp where a step began inside one actor's recording.
+     * Stamp where a step began inside one virtual user's recording.
      *
-     * First write per actor wins: a `then` step runs once per witness, and the
+     * First write per virtual user wins: a `then` step runs once per witness, and the
      * moment the reader wants is when the sentence started, not when its last
      * witness got around to the browser.
      */
     private recordVideoOffset;
     attachRunContext(runId: string, workflowMeta: any, options?: {
-        actors?: ScenarioPersonas;
+        virtualUsers?: ScenarioVirtualUsers;
     }): Promise<void>;
     detachRunContext(runId: string): void;
     /**
@@ -249,20 +249,20 @@ export declare class PikkuScenarioService implements WorkflowRunExtension {
      *
      * A hook is not a pikku function: it has no id, no meta and no schema, so it
      * cannot go through `runPikkuFunc` and the runner records nothing for it. It
-     * gets exactly what the scenario body gets — the same wire (so `actors` is
+     * gets exactly what the scenario body gets — the same wire (so `virtualUsers` is
      * how it reaches the app), and singleton services composed with this
      * invocation's wire services — and nothing else.
      */
     private runScenarioHook;
     /**
-     * Build HTTP scenario actors for a run started without them; undefined when
-     * SCENARIO_ACTOR_SECRET or the API URL is missing.
+     * Build HTTP scenario virtual users for a run started without them; undefined when
+     * the app has no auth service or the API URL is missing.
      *
-     * The actor client is imported lazily so that even a runner bundle only pays
-     * for the AI persona conversation loop it pulls in when a scenario actually
-     * signs an actor in.
+     * The virtual user client is imported lazily so that even a runner bundle only pays
+     * for the AI virtual user conversation loop it pulls in when a scenario actually
+     * signs a virtual user in.
      */
-    resolvePersonas(): Promise<ScenarioPersonas | undefined>;
+    resolveVirtualUsers(): Promise<ScenarioVirtualUsers | undefined>;
     decorateWorkflowWire(wire: PikkuWorkflowWire, context: {
         name: string;
         runId: string;
@@ -278,8 +278,8 @@ export declare class PikkuScenarioService implements WorkflowRunExtension {
      */
     private declaredSurfaces;
     /**
-     * Whether a step is driven by a persona, and so must be given one. Stamped by
-     * the definer from a `browser` binding or an explicit `actor: true`.
+     * Whether a step is driven by a virtual user, and so must be given one. Stamped by
+     * the definer from a `browser` binding or an explicit `virtualUser: true`.
      */
-    private requiresActor;
+    private requiresVirtualUser;
 }