@pikku/core 0.12.139 → 0.12.142

package/dist/wirings/{persona/persona-email.d.ts → virtual-user/virtual-user-email.d.ts}

@@ -1,21 +1,21 @@
 /**
- * A persona's email address is computed, never declared.
+ * A virtual user's email address is computed, never declared.
  *
- * A persona that cannot read its own email cannot complete sign-up, magic
+ * A virtual user that cannot read its own email cannot complete sign-up, magic
  * links, invites or password resets — which are most of the flows worth
  * exercising. So addresses are real and deliverable against a domain the stage
  * actually receives mail on, rather than a synthetic `.local` dead end.
  */
 /**
- * Lower-cases and strips a persona id down to something an address can carry.
+ * Lower-cases and strips a virtual user id down to something an address can carry.
  *
- * Personas are declared as object keys, so they are already identifier-shaped;
+ * Virtual users are declared as object keys, so they are already identifier-shaped;
  * this exists for the ones that are not (`'susan.buyer'`, `'Susan_2'`) rather
  * than to permit arbitrary input.
  */
-export declare const personaEmailLabel: (personaId: string) => string;
+export declare const virtualUserEmailLabel: (virtualUserId: string) => string;
 /**
- * The address a persona reads mail at during a run.
+ * The address a virtual user reads mail at during a run.
  *
  * The `runId` suffix is not decoration. Without it two concurrent runs share an
  * inbox *and* a user row, and run B reads run A's magic link. Sub-addressing
@@ -25,13 +25,13 @@ export declare const personaEmailLabel: (personaId: string) => string;
  * Omitting `runId` gives the bare form, which is what a seeded fixture that has
  * to stay stable across runs wants.
  */
-export declare const personaEmail: (personaId: string, domain: string, runId?: string) => string;
+export declare const virtualUserEmail: (virtualUserId: string, domain: string, runId?: string) => string;
 /**
- * Every address in a run, keyed by persona.
+ * Every address in a run, keyed by virtual user.
  *
- * All of a persona's logins share one address. That is not a simplification:
+ * All of a virtual user's logins share one address. That is not a simplification:
  * better-auth keeps `email` on the `user` and defaults `allowDifferentEmails`
  * to false, so giving a linked account its own address would have the library
- * under test refuse to link the very thing the persona declared as linked.
+ * under test refuse to link the very thing the virtual user declared as linked.
  */
-export declare const personaEmails: (personaIds: readonly string[], domain: string, runId?: string) => Record<string, string>;
+export declare const virtualUserEmails: (virtualUserIds: readonly string[], domain: string, runId?: string) => Record<string, string>;

package/dist/wirings/{persona/persona-email.js → virtual-user/virtual-user-email.js}

@@ -1,31 +1,31 @@
 /**
- * A persona's email address is computed, never declared.
+ * A virtual user's email address is computed, never declared.
  *
- * A persona that cannot read its own email cannot complete sign-up, magic
+ * A virtual user that cannot read its own email cannot complete sign-up, magic
  * links, invites or password resets — which are most of the flows worth
  * exercising. So addresses are real and deliverable against a domain the stage
  * actually receives mail on, rather than a synthetic `.local` dead end.
  */
 const LABEL = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
 /**
- * Lower-cases and strips a persona id down to something an address can carry.
+ * Lower-cases and strips a virtual user id down to something an address can carry.
  *
- * Personas are declared as object keys, so they are already identifier-shaped;
+ * Virtual users are declared as object keys, so they are already identifier-shaped;
  * this exists for the ones that are not (`'susan.buyer'`, `'Susan_2'`) rather
  * than to permit arbitrary input.
  */
-export const personaEmailLabel = (personaId) => {
-    const label = personaId
+export const virtualUserEmailLabel = (virtualUserId) => {
+    const label = virtualUserId
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '');
     if (!LABEL.test(label)) {
-        throw new Error(`Persona '${personaId}' has no usable email label. A persona id must contain at least one letter or digit.`);
+        throw new Error(`VirtualUser '${virtualUserId}' has no usable email label. A virtual user id must contain at least one letter or digit.`);
     }
     return label;
 };
 /**
- * The address a persona reads mail at during a run.
+ * The address a virtual user reads mail at during a run.
  *
  * The `runId` suffix is not decoration. Without it two concurrent runs share an
  * inbox *and* a user row, and run B reads run A's magic link. Sub-addressing
@@ -35,31 +35,31 @@ export const personaEmailLabel = (personaId) => {
  * Omitting `runId` gives the bare form, which is what a seeded fixture that has
  * to stay stable across runs wants.
  */
-export const personaEmail = (personaId, domain, runId) => {
-    const label = personaEmailLabel(personaId);
+export const virtualUserEmail = (virtualUserId, domain, runId) => {
+    const label = virtualUserEmailLabel(virtualUserId);
     const cleanDomain = domain.trim().toLowerCase().replace(/^@/, '');
     if (!cleanDomain || cleanDomain.includes('@') || !cleanDomain.includes('.')) {
-        throw new Error(`Persona email domain '${domain}' is not a domain. Set it to a domain the stage actually receives mail on.`);
+        throw new Error(`VirtualUser email domain '${domain}' is not a domain. Set it to a domain the stage actually receives mail on.`);
     }
-    const suffix = runId ? `+${personaEmailLabel(runId)}` : '';
+    const suffix = runId ? `+${virtualUserEmailLabel(runId)}` : '';
     return `${label}${suffix}@${cleanDomain}`;
 };
 /**
- * Every address in a run, keyed by persona.
+ * Every address in a run, keyed by virtual user.
  *
- * All of a persona's logins share one address. That is not a simplification:
+ * All of a virtual user's logins share one address. That is not a simplification:
  * better-auth keeps `email` on the `user` and defaults `allowDifferentEmails`
  * to false, so giving a linked account its own address would have the library
- * under test refuse to link the very thing the persona declared as linked.
+ * under test refuse to link the very thing the virtual user declared as linked.
  */
-export const personaEmails = (personaIds, domain, runId) => {
+export const virtualUserEmails = (virtualUserIds, domain, runId) => {
     const emails = {};
     const seen = new Map();
-    for (const id of personaIds) {
-        const address = personaEmail(id, domain, runId);
+    for (const id of virtualUserIds) {
+        const address = virtualUserEmail(id, domain, runId);
         const collidesWith = seen.get(address);
         if (collidesWith !== undefined) {
-            throw new Error(`Personas '${collidesWith}' and '${id}' both compute the address ${address}. ` +
+            throw new Error(`VirtualUsers '${collidesWith}' and '${id}' both compute the address ${address}. ` +
                 `They would share a user row and read each other's email.`);
         }
         seen.set(address, id);

package/dist/wirings/{persona/persona-environments.d.ts → virtual-user/virtual-user-environments.d.ts}

@@ -1,6 +1,6 @@
 import { type VirtualUserDisposition } from '../virtual-user/virtual-user.types.js';
 /**
- * Which environments a persona may run against, and the one rule on it.
+ * Which environments a virtual user may run against, and the one rule on it.
  *
  * Two callers, deliberately sharing this file. The inspector checks the
  * declaration at build time; sign-in re-checks against the environment actually
@@ -8,31 +8,31 @@ import { type VirtualUserDisposition } from '../virtual-user/virtual-user.types.
  * and the run check does not trust which artifact got deployed.
  */
 /** The part of an environment entry this rule cares about. */
-export interface PersonaEnvironment {
+export interface VirtualUserEnvironment {
     production?: boolean;
 }
-/** What a persona needs to expose for the rule to be applied to it. */
-export interface PersonaEnvironmentSubject {
+/** What a virtual user needs to expose for the rule to be applied to it. */
+export interface VirtualUserEnvironmentSubject {
     disposition?: VirtualUserDisposition;
     environments?: string[];
 }
 /**
- * The environments a persona may target, resolved.
+ * The environments a virtual user may target, resolved.
  *
  * An omitted `environments` means every configured environment **except** the
  * production ones: production is opt-in for everybody, so nothing reaches it by
  * being forgotten.
  */
-export declare const resolvePersonaEnvironments: (persona: PersonaEnvironmentSubject, environments: Readonly<Record<string, PersonaEnvironment>>) => string[];
+export declare const resolveVirtualUserEnvironments: (virtualUser: VirtualUserEnvironmentSubject, environments: Readonly<Record<string, VirtualUserEnvironment>>) => string[];
 /**
- * The declaration check, as a list of messages. Empty means the persona's
+ * The declaration check, as a list of messages. Empty means the virtual user's
  * `environments` are coherent with the config and its disposition.
  *
  * An unknown environment name is an error rather than a shrug: a typo silently
- * narrowing a persona to nothing is the same class of bug as the one this whole
+ * narrowing a virtual user to nothing is the same class of bug as the one this whole
  * rule exists to prevent, only quieter.
  */
-export declare const personaEnvironmentErrors: (id: string, persona: PersonaEnvironmentSubject, environments: Readonly<Record<string, PersonaEnvironment>>) => string[];
+export declare const virtualUserEnvironmentErrors: (id: string, virtualUser: VirtualUserEnvironmentSubject, environments: Readonly<Record<string, VirtualUserEnvironment>>) => string[];
 /**
  * The sign-in check: the message to refuse with, or `null` to let the run
  * start.
@@ -42,4 +42,4 @@ export declare const personaEnvironmentErrors: (id: string, persona: PersonaEnvi
  * artifact than the one running, so treating "I don't know where I am" as
  * permission is exactly backwards.
  */
-export declare const personaEnvironmentRefusal: (id: string, persona: PersonaEnvironmentSubject, environmentName: string | undefined, environments: Readonly<Record<string, PersonaEnvironment>>) => string | null;
+export declare const virtualUserEnvironmentRefusal: (id: string, virtualUser: VirtualUserEnvironmentSubject, environmentName: string | undefined, environments: Readonly<Record<string, VirtualUserEnvironment>>) => string | null;

package/dist/wirings/{persona/persona-environments.js → virtual-user/virtual-user-environments.js}

@@ -1,45 +1,45 @@
 import { PRODUCTION_DISPOSITION, } from '../virtual-user/virtual-user.types.js';
 /**
- * The environments a persona may target, resolved.
+ * The environments a virtual user may target, resolved.
  *
  * An omitted `environments` means every configured environment **except** the
  * production ones: production is opt-in for everybody, so nothing reaches it by
  * being forgotten.
  */
-export const resolvePersonaEnvironments = (persona, environments) => {
-    if (persona.environments) {
-        return [...persona.environments];
+export const resolveVirtualUserEnvironments = (virtualUser, environments) => {
+    if (virtualUser.environments) {
+        return [...virtualUser.environments];
     }
     return Object.entries(environments)
         .filter(([, env]) => !env.production)
         .map(([name]) => name);
 };
 /**
- * The declaration check, as a list of messages. Empty means the persona's
+ * The declaration check, as a list of messages. Empty means the virtual user's
  * `environments` are coherent with the config and its disposition.
  *
  * An unknown environment name is an error rather than a shrug: a typo silently
- * narrowing a persona to nothing is the same class of bug as the one this whole
+ * narrowing a virtual user to nothing is the same class of bug as the one this whole
  * rule exists to prevent, only quieter.
  */
-export const personaEnvironmentErrors = (id, persona, environments) => {
-    if (!persona.environments) {
+export const virtualUserEnvironmentErrors = (id, virtualUser, environments) => {
+    if (!virtualUser.environments) {
         return [];
     }
     const errors = [];
     const known = Object.keys(environments);
-    for (const name of persona.environments) {
+    for (const name of virtualUser.environments) {
         const env = environments[name];
         if (!env) {
-            errors.push(`Persona '${id}' names environment '${name}', which is not configured. ` +
+            errors.push(`VirtualUser '${id}' names environment '${name}', which is not configured. ` +
                 (known.length
                     ? `Configured environments: ${known.join(', ')}.`
                     : `Declare it under 'environments' in pikku.config.json.`));
             continue;
         }
-        if (env.production && persona.disposition !== PRODUCTION_DISPOSITION) {
-            errors.push(`Persona '${id}' names production environment '${name}' with disposition ` +
-                `'${persona.disposition ?? 'realistic'}'. ` +
+        if (env.production && virtualUser.disposition !== PRODUCTION_DISPOSITION) {
+            errors.push(`VirtualUser '${id}' names production environment '${name}' with disposition ` +
+                `'${virtualUser.disposition ?? 'realistic'}'. ` +
                 `Only '${PRODUCTION_DISPOSITION}' may run against production — every other ` +
                 `disposition exists to find out what the product does wrong, which is not a ` +
                 `thing to do to real data. Either give '${id}' disposition '${PRODUCTION_DISPOSITION}', ` +
@@ -57,24 +57,24 @@ export const personaEnvironmentErrors = (id, persona, environments) => {
  * artifact than the one running, so treating "I don't know where I am" as
  * permission is exactly backwards.
  */
-export const personaEnvironmentRefusal = (id, persona, environmentName, environments) => {
+export const virtualUserEnvironmentRefusal = (id, virtualUser, environmentName, environments) => {
     if (!environmentName) {
-        return (`Refusing to sign in persona '${id}': no environment is resolved. ` +
+        return (`Refusing to sign in virtual user '${id}': no environment is resolved. ` +
             `Set PIKKU_ENV to one of the configured environments (${Object.keys(environments).join(', ') || 'none are configured'}).`);
     }
     const env = environments[environmentName];
     if (!env) {
-        return (`Refusing to sign in persona '${id}': environment '${environmentName}' is not configured. ` +
+        return (`Refusing to sign in virtual user '${id}': environment '${environmentName}' is not configured. ` +
             `Configured environments: ${Object.keys(environments).join(', ') || 'none'}.`);
     }
-    if (env.production && persona.disposition !== PRODUCTION_DISPOSITION) {
-        return (`Refusing to sign in persona '${id}' against production environment '${environmentName}': ` +
-            `its disposition is '${persona.disposition ?? 'realistic'}', and only ` +
+    if (env.production && virtualUser.disposition !== PRODUCTION_DISPOSITION) {
+        return (`Refusing to sign in virtual user '${id}' against production environment '${environmentName}': ` +
+            `its disposition is '${virtualUser.disposition ?? 'realistic'}', and only ` +
             `'${PRODUCTION_DISPOSITION}' may act on real data.`);
     }
-    const allowed = resolvePersonaEnvironments(persona, environments);
+    const allowed = resolveVirtualUserEnvironments(virtualUser, environments);
     if (!allowed.includes(environmentName)) {
-        return (`Refusing to sign in persona '${id}' against '${environmentName}': ` +
+        return (`Refusing to sign in virtual user '${id}' against '${environmentName}': ` +
             `it declares environments ${allowed.join(', ') || 'none'}.`);
     }
     return null;

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

@@ -68,11 +68,11 @@ export declare class IntentStack {
     private resumeSuspended;
 }
 /**
- * The intents a persona may be given: those whose source names them, plus every
+ * The intents a virtual user may be given: those whose source names them, plus every
  * source that names nobody.
  *
  * This is a free lookup rather than new authoring — scenario meta already
- * records which personas each scenario runs as.
+ * records which virtual users each scenario runs as.
  */
-export declare const intentsForPersona: (sources: readonly IntentSource[], personaId: string) => IntentSource[];
+export declare const intentsForVirtualUser: (sources: readonly IntentSource[], virtualUserId: string) => IntentSource[];
 export {};

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

@@ -133,10 +133,10 @@ export class IntentStack {
     }
 }
 /**
- * The intents a persona may be given: those whose source names them, plus every
+ * The intents a virtual user may be given: those whose source names them, plus every
  * source that names nobody.
  *
  * This is a free lookup rather than new authoring — scenario meta already
- * records which personas each scenario runs as.
+ * records which virtual users each scenario runs as.
  */
-export const intentsForPersona = (sources, personaId) => sources.filter((source) => !source.personas?.length || source.personas.includes(personaId));
+export const intentsForVirtualUser = (sources, virtualUserId) => sources.filter((source) => !source.virtualUsers?.length || source.virtualUsers.includes(virtualUserId));

package/dist/wirings/{persona/persona-mailbox.d.ts → virtual-user/virtual-user-mailbox.d.ts}

@@ -1,4 +1,4 @@
-/** One email a persona received. */
+/** One email a virtual user received. */
 export interface ReceivedEmail {
     to: string;
     from: string;
@@ -8,7 +8,7 @@ export interface ReceivedEmail {
      * Links found in the body, already extracted.
      *
      * Extracted rather than handed over as text on purpose — see
-     * {@link PersonaMailbox}. A magic link is the only part of most emails a
+     * {@link VirtualUserMailbox}. A magic link is the only part of most emails a
      * virtual user needs, and it is checkable in a way prose is not.
      */
     links: string[];
@@ -30,7 +30,7 @@ export interface ReceivedEmail {
     body?: string;
 }
 /**
- * Where a persona reads its mail.
+ * Where a virtual user reads its mail.
  *
  * Capturing inbound mail is platform-specific — on Cloudflare an Email Worker
  * on the test domain, elsewhere whatever the stage can receive with — so pikku
@@ -41,7 +41,7 @@ export interface ReceivedEmail {
  * user's address is real and deliverable, so anyone who learns it can send it
  * instructions, and the run holds a live session against a real stage.
  */
-export interface PersonaMailbox {
+export interface VirtualUserMailbox {
     /**
      * Wait for a matching email, or reject on timeout.
      *

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

@@ -16,7 +16,7 @@ import type { IntentRecord, StepRecord, VirtualUserDisposition, VirtualUserFindi
  */
 export interface VirtualUserRunRecord {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     /** What makes a run replayable at all — a finding without it is an anecdote. */
     seed: number;
@@ -59,7 +59,7 @@ export interface VirtualUserRunRecord {
 }
 /** What a run is created with — everything else is filled in by the outcome. */
 export interface VirtualUserRunStart {
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     goals?: readonly string[];
@@ -101,9 +101,9 @@ export interface VirtualUserRunStore {
     /** Marks a run `failed`. The run itself broke; it has no findings. */
     fail(runId: string, error: string): Promise<void>;
     get(runId: string): Promise<VirtualUserRunRecord | null>;
-    /** Newest first. `persona` narrows to one persona's history. */
+    /** Newest first. `virtualUserId` narrows to one virtual user's history. */
     list(options?: {
-        persona?: string;
+        virtualUserId?: string;
         limit?: number;
         offset?: number;
     }): Promise<VirtualUserRunRecord[]>;

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

@@ -1,10 +1,11 @@
+import { type InProcessAuth } from '../../services/virtual-user-sign-in.js';
 import type { Logger } from '../../services/logger.js';
 import type { MetaService } from '../../services/meta-service.js';
 import type { VariablesService } from '../../services/variables-service.js';
 import type { AgentRunnerService } from '../../services/agent-runner-service.js';
-import type { HttpPersonasConfig } from '../../services/http-personas.js';
-import type { ResolvedPersona, ScenarioPersonas } from '../../services/personas-service.js';
-import type { PersonaEnvironment } from '../persona/persona-environments.js';
+import type { HttpVirtualUsersConfig } from '../../services/http-virtual-users.js';
+import type { ResolvedVirtualUser, ScenarioVirtualUsers } from '../../services/virtual-users-service.js';
+import type { VirtualUserEnvironment } from '../virtual-user/virtual-user-environments.js';
 import type { StepRecord, VirtualUserDisposition } from './virtual-user.types.js';
 import type { VirtualUserRunRecord, VirtualUserRunStore } from './virtual-user-run-store.js';
 import type { VirtualUserScheduleRecord, VirtualUserScheduleStore } from './virtual-user-schedule-store.js';
@@ -20,11 +21,11 @@ import type { VirtualUserTickResult } from './virtual-user-schedule.js';
  * once rather than in every generated copy of it.
  *
  * What an application does supply arrives as a parameter — its declared
- * personas, its `createPersonas`, its config — because those are the only
+ * virtual users, its `createVirtualUsers`, its config — because those are the only
  * things codegen knows that this cannot.
  */
-/** Persona id → the declaration, which is what `personaConfigs` is. */
-export type ScaffoldPersonas = Record<string, ResolvedPersona>;
+/** Virtual user id → the declaration, which is what `virtualUserConfigs` is. */
+export type ScaffoldVirtualUsers = Record<string, ResolvedVirtualUser>;
 /**
  * The variables a scaffolded run reads.
  *
@@ -39,48 +40,27 @@ export declare const VIRTUAL_USER_VARIABLES: {
      * somewhere it only assumed was itself.
      */
     readonly apiUrl: 'VIRTUAL_USER_API_URL';
-    readonly secret: 'SCENARIO_ACTOR_SECRET';
     readonly model: 'VIRTUAL_USER_MODEL';
     /**
-     * The same two variables a scenario run reads, because a virtual user signs
-     * in and calls through exactly the doors a scenario does. An app that mounts
-     * auth somewhere other than the root — `/api/auth` is the common one — has no
-     * other way to say so, and without them the run signs in against a 404 and
-     * spends its whole budget thinking about why nothing works.
+     * Where the app serves its exposed RPCs, as a scenario run reads it. An app
+     * that mounts them somewhere other than `/rpc` has no other way to say so.
      */
-    readonly signInPath: 'SCENARIO_SIGN_IN_PATH';
     readonly rpcPath: 'SCENARIO_RPC_PATH';
-    /**
-     * The deployed way in. A Fabric operator token is asymmetric — a stage can
-     * verify one and can never mint one — so unlike the actor secret it is safe
-     * for a run against a real environment. Read from the environment only as the
-     * fallback for a run nobody handed a token to, which is what a schedule is.
-     */
-    readonly operatorToken: 'FABRIC_OPERATOR_TOKEN';
 };
 /**
- * Which door under the auth mount, given the credential in hand.
- *
- * Both are better-auth plugins mounted side by side, so `SCENARIO_SIGN_IN_PATH`
- * names the mount and the last segment is ours to pick — an app that moved auth
- * to `/api/auth` says so once and both paths follow. A path that names neither
- * plugin is left alone, since it was configured deliberately.
- */
-export declare const signInPathFor: (configured: string | undefined, plugin: 'actor' | 'fabric') => string | undefined;
-/**
- * The declared persona behind an id, refused unless it is one a run may be.
+ * The declared virtual user behind an id, refused unless it is one a run may be.
  *
- * An acted-upon persona has no session of its own, and running one would race
+ * An acted-upon virtual user has no session of its own, and running one would race
  * whatever scenario acts on it.
  */
-export declare const runnablePersona: (personas: ScaffoldPersonas, personaId: string) => ResolvedPersona;
+export declare const runnableVirtualUser: (virtualUsers: ScaffoldVirtualUsers, virtualUserId: string) => ResolvedVirtualUser;
 /** The store, or the error naming the one to wire. */
 export declare const requireVirtualUserRunStore: (store: VirtualUserRunStore | undefined, reading?: boolean) => VirtualUserRunStore;
 export declare const requireVirtualUserScheduleStore: (store: VirtualUserScheduleStore | undefined) => VirtualUserScheduleStore;
 /** What a caller asked for, before the declaration fills in what it left out. */
 export interface StartVirtualUserRunParams {
     store: VirtualUserRunStore | undefined;
-    personas: ScaffoldPersonas;
+    virtualUsers: ScaffoldVirtualUsers;
     /**
      * The app's config, read only for `nodeEnv` — structural because an
      * application's Config is its own interface and need not declare it at all.
@@ -89,11 +69,11 @@ export interface StartVirtualUserRunParams {
     config: {
         nodeEnv?: string;
     } | undefined;
-    /** `environments` from pikku.config.json, as generated beside the personas. */
-    environments?: Readonly<Record<string, PersonaEnvironment>>;
+    /** `environments` from pikku.config.json, as generated beside the virtual users. */
+    environments?: Readonly<Record<string, VirtualUserEnvironment>>;
     /** Which of them this process is. Defaults to `PIKKU_ENV`. */
     environment?: string;
-    persona: string;
+    virtualUserId: string;
     disposition?: string;
     seed?: number;
     goals?: string[];
@@ -104,7 +84,7 @@ export interface StartVirtualUserRunParams {
 /** The recorded run, and the values the dispatch has to carry unchanged. */
 export interface StartedVirtualUserRun {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     goals: string[];
@@ -117,7 +97,7 @@ export interface StartedVirtualUserRun {
  * scheduled tick have in common. The dispatch that follows is typed off the
  * app's RPC map, so it stays in the generated wiring.
  */
-export declare const startVirtualUserRun: ({ store, personas, config, environments, environment, persona: personaId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }: StartVirtualUserRunParams) => Promise<StartedVirtualUserRun>;
+export declare const startVirtualUserRun: ({ store, virtualUsers, config, environments, environment, virtualUserId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }: StartVirtualUserRunParams) => Promise<StartedVirtualUserRun>;
 /**
  * One run on the wire.
  *
@@ -127,7 +107,7 @@ export declare const startVirtualUserRun: ({ store, personas, config, environmen
  */
 export declare const serializeVirtualUserRun: (run: VirtualUserRunRecord) => {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     status: "completed" | "failed" | "running";
@@ -175,8 +155,8 @@ export declare const serializeVirtualUserSteps: (steps: readonly StepRecord[]) =
  * takes; the engine's own duration also accepts `'30m'`, which nothing on this
  * side ever writes.
  */
-export declare const serializeVirtualUserSchedule: (schedule: VirtualUserScheduleRecord, personas: ScaffoldPersonas) => {
-    persona: string;
+export declare const serializeVirtualUserSchedule: (schedule: VirtualUserScheduleRecord, virtualUsers: ScaffoldVirtualUsers) => {
+    virtualUserId: string;
     enabled: boolean;
     disposition: VirtualUserDisposition;
     goals: string[];
@@ -197,8 +177,8 @@ export declare const serializeVirtualUserSchedule: (schedule: VirtualUserSchedul
 };
 export interface WriteVirtualUserScheduleParams {
     store: VirtualUserScheduleStore | undefined;
-    personas: ScaffoldPersonas;
-    persona: string;
+    virtualUsers: ScaffoldVirtualUsers;
+    virtualUserId: string;
     enabled?: boolean;
     disposition?: string;
     goals?: string[];
@@ -214,25 +194,25 @@ export interface WriteVirtualUserScheduleParams {
     config?: {
         nodeEnv?: string;
     };
-    environments?: Readonly<Record<string, PersonaEnvironment>>;
+    environments?: Readonly<Record<string, VirtualUserEnvironment>>;
     environment?: string;
 }
 /**
- * Writes a persona's cadence.
+ * Writes a virtual user's cadence.
  *
  * Applies the same rules `startVirtualUserRun` enforces, at the point the row is
- * written rather than every hour afterwards: an acted-upon persona has no
- * session, and an enabled cadence whose disposition production refuses, so
- * either is a tick that can only ever fail to start, with nobody watching.
+ * written rather than every hour afterwards: an acted-upon virtual user has no
+ * session, and production refuses every run, so either is a tick that can only
+ * ever fail to start, with nobody watching.
  *
- * The disposition checked is the one the row will hold, since a field left out
- * keeps what it had: enabling a row saved earlier as adversarial is refused
- * just as saving one would be.
+ * Whether the row is enabled is the one thing checked, since a field left out
+ * keeps what it had: enabling a row saved earlier is refused just as saving a
+ * new one would be.
  */
-export declare const writeVirtualUserSchedule: ({ store, personas, persona, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment, }: WriteVirtualUserScheduleParams) => Promise<VirtualUserScheduleRecord>;
+export declare const writeVirtualUserSchedule: ({ store, virtualUsers, virtualUserId, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment, }: WriteVirtualUserScheduleParams) => Promise<VirtualUserScheduleRecord>;
 /** What a due schedule asks `runVirtualUser` for. */
 export declare const virtualUserScheduleRunInput: (schedule: VirtualUserScheduleRecord) => {
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     goals: string[];
     budget: {
@@ -245,7 +225,7 @@ export declare const virtualUserScheduleRunInput: (schedule: VirtualUserSchedule
  * What a tick did.
  *
  * Logged rather than returned: the caller is a cron, and a run this started is
- * otherwise the only trace that a persona is still out there working.
+ * otherwise the only trace that a virtual user is still out there working.
  */
 export declare const logVirtualUserTick: (logger: Logger, result: VirtualUserTickResult) => void;
 export interface ExecuteVirtualUserRunParams {
@@ -254,11 +234,11 @@ export interface ExecuteVirtualUserRunParams {
     agentRunner: AgentRunnerService | undefined;
     variables: VariablesService;
     logger: Logger;
-    personas: ScaffoldPersonas;
-    /** The app's generated `createPersonas`, which knows its own persona ids. */
-    createPersonas: (options: Omit<HttpPersonasConfig, 'personas'>) => ScenarioPersonas;
+    virtualUsers: ScaffoldVirtualUsers;
+    /** The app's generated `createVirtualUsers`, which knows its own virtual user ids. */
+    createVirtualUsers: (options: Omit<HttpVirtualUsersConfig, 'virtualUsers'>) => ScenarioVirtualUsers;
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: string;
     goals: string[];
     memory: Record<string, string>;
@@ -268,16 +248,17 @@ export interface ExecuteVirtualUserRunParams {
         mutations?: number;
         durationMs?: number;
     };
-    operatorToken?: string;
+    /** The app's auth instance, which a run signs in through without a credential. */
+    auth: InProcessAuth | undefined;
 }
 /**
  * The run itself.
  *
  * Everything it needs is derived through `metaService` and the generated
- * personas — the same public surface any consumer has. Nothing reaches into
+ * virtual users — the same public surface any consumer has. Nothing reaches into
  * pikku's internals, because an app could not, and a feature built on what only
  * the framework can see would not be this feature.
  */
-export declare const executeVirtualUserRun: ({ runStore, metaService, agentRunner, variables, logger, personas, createPersonas, runId, persona: personaId, disposition, goals, memory, seed, budget, operatorToken, }: ExecuteVirtualUserRunParams) => Promise<{
+export declare const executeVirtualUserRun: ({ runStore, metaService, agentRunner, variables, logger, virtualUsers, createVirtualUsers, runId, virtualUserId, disposition, goals, memory, seed, budget, auth, }: ExecuteVirtualUserRunParams) => Promise<{
     findings: number;
 }>;