@pikku/core 0.12.141 → 0.12.142

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

@@ -8,20 +8,20 @@ export const APP_SCOPE_ROOT = 'app';
 /** `app:staff` for `staff`. */
 export const appScopeId = (app) => `${APP_SCOPE_ROOT}:${app}`;
 /**
- * The apps named across the declared personas, sorted and deduplicated.
+ * The apps named across the declared virtual users, sorted and deduplicated.
  *
- * The personas *are* the registry. There is no separate list of apps to keep in
+ * The virtual users *are* the registry. There is no separate list of apps to keep in
  * step, because a frontend nobody signs into is not a thing the auth layer has
  * an opinion about — and the moment somebody does sign into it, they are a
- * persona and they name it.
+ * virtual user and they name it.
  */
-export const declaredApps = (personas) => [
-    ...new Set(personas
-        .map((persona) => persona.app)
+export const declaredApps = (virtualUsers) => [
+    ...new Set(virtualUsers
+        .map((virtualUser) => virtualUser.app)
         .filter((app) => typeof app === 'string' && app !== '')),
 ].sort();
 /**
- * The `app` scope tree, synthesised from the personas that name an app.
+ * The `app` scope tree, synthesised from the virtual users that name an app.
  *
  * Which frontend a person may sign into is a different question from what they
  * may do once inside it, but it is the same *kind* of question — a grant that
@@ -33,15 +33,15 @@ export const declaredApps = (personas) => [
  *
  * Synthesised rather than written by hand because the declaration already
  * exists. Asking an app to also spell out `defineScope({ app: { staff: {} } })`
- * beside its personas invites the two to drift, and the failure that produces —
- * a persona provisioned with a grant the vocabulary no longer declares — is one
+ * beside its virtual users invites the two to drift, and the failure that produces —
+ * a virtual user provisioned with a grant the vocabulary no longer declares — is one
  * `pikku scopes prune` away from silently revoking sign-in.
  *
- * Null when no persona names an app, which is the single-frontend case: nothing
+ * Null when no virtual user names an app, which is the single-frontend case: nothing
  * to declare, and no empty root cluttering the console's grant list.
  */
-export const buildAppScopeDefinition = (personas) => {
-    const apps = declaredApps(personas);
+export const buildAppScopeDefinition = (virtualUsers) => {
+    const apps = declaredApps(virtualUsers);
     if (apps.length === 0) {
         return null;
     }

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

@@ -28,7 +28,7 @@ export declare const renderCatalogue: (entries: readonly ApiCatalogueEntry[]) =>
 /**
  * The entries a given user may reach: approval-gated calls dropped unless the
  * run opted in, mutations dropped for a read-only disposition, and anything the
- * actor's tier cannot satisfy dropped when the caller supplied one.
+ * virtual user's tier cannot satisfy dropped when the caller supplied one.
  *
  * This narrows *what is offered*, never what is enforced — the server is the
  * only thing that decides who may call what, and a call this filter would have
@@ -38,7 +38,7 @@ export declare const reachableCatalogue: (entries: readonly ApiCatalogueEntry[],
     readOnly?: boolean;
     allowApprovalRequired?: boolean;
     /**
-     * The scopes this persona holds, resolved from its roles. Omit to keep
+     * The scopes this virtual user holds, resolved from its roles. Omit to keep
      * every entry.
      *
      * Scopes rather than permission-function names: a function's `scopes` are
@@ -49,7 +49,7 @@ export declare const reachableCatalogue: (entries: readonly ApiCatalogueEntry[],
     scopes?: readonly string[];
 }) => ApiCatalogueEntry[];
 /**
- * Endpoints this persona is *not* entitled to reach.
+ * Endpoints this virtual user is *not* entitled to reach.
  *
  * The adversarial oracle. Withheld from the catalogue, so reaching one takes
  * initiative — and a 2xx from one is the finding, because the server is the

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

@@ -67,7 +67,7 @@ export const renderCatalogue = (entries) => entries.map(renderEntry).join('\n');
 /**
  * The entries a given user may reach: approval-gated calls dropped unless the
  * run opted in, mutations dropped for a read-only disposition, and anything the
- * actor's tier cannot satisfy dropped when the caller supplied one.
+ * virtual user's tier cannot satisfy dropped when the caller supplied one.
  *
  * This narrows *what is offered*, never what is enforced — the server is the
  * only thing that decides who may call what, and a call this filter would have
@@ -84,7 +84,7 @@ export const reachableCatalogue = (entries, { readOnly = false, allowApprovalReq
     return true;
 });
 /**
- * Endpoints this persona is *not* entitled to reach.
+ * Endpoints this virtual user is *not* entitled to reach.
  *
  * The adversarial oracle. Withheld from the catalogue, so reaching one takes
  * initiative — and a 2xx from one is the finding, because the server is the

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

@@ -1,23 +1,23 @@
 import type { VirtualUserDisposition } from '../virtual-user/virtual-user.types.js';
 import type { VirtualUserTuning } from '../virtual-user/virtual-user-dispositions.js';
 /**
- * One login belonging to a persona.
+ * One login belonging to a virtual user.
  *
  * Deliberately near-empty in the common case: the address is computed from the
- * persona's name and the run id, and the password derives from
- * `SCENARIO_ACTOR_SECRET`, so there is nothing left to write down. It fills up
+ * virtual user's name and the run id, and sign-in needs no password, so there is
+ * nothing left to write down. It fills up
  * only for a provider login.
  *
  * Shaped after better-auth's `account` table, which is what most pikku apps are
  * actually running: `providerId` plus the provider's own id, and no email
  * column — the address belongs to the person, not the login.
  */
-export type CorePersonaAccount = {
+export type CoreVirtualUserAccount = {
     /**
      * The identity provider, e.g. `'google'`. Omit for email and password.
      *
      * A provider account is declarable but not runnable: driving its consent
-     * screen needs a human, so `pikku persona run` refuses rather than failing
+     * screen needs a human, so `pikku virtual-user run` refuses rather than failing
      * somewhere inside a browser.
      */
     provider?: string;
@@ -26,12 +26,12 @@ export type CorePersonaAccount = {
  * A person who uses your product: a name, a job, a temperament, and what they
  * are trying to get done.
  *
- * This is Cooper's persona — "a fictional character created to represent a user
+ * This is Cooper's virtual user — "a fictional character created to represent a user
  * type" — with the two things a synthetic user additionally needs: the roles
- * that say what they may do, and the account they log in with. A persona while
+ * that say what they may do, and the account they log in with. A virtual user while
  * running is a virtual user; there is no second declaration for that.
  */
-export type CorePersona = {
+export type CoreVirtualUser = {
     /** The person's name, as a person would give it. */
     name: string;
     jobTitle?: string;
@@ -41,14 +41,14 @@ export type CorePersona = {
      * serves, an asset on a CDN, a Gravatar link.
      *
      * Optional because it is decoration. Omitted, the console draws a colour and
-     * an icon derived from the persona's id, which is stable, needs no network and
+     * an icon derived from the virtual user's id, which is stable, needs no network and
      * is more legible than the identicon a synthetic address would resolve to —
      * which is also why nothing is derived here.
      */
     avatarUrl?: string;
     /**
      * The roles this person holds. Only system roles may be named — a custom
-     * role can be deleted from the console, so a persona pinned to one silently
+     * role can be deleted from the console, so a virtual user pinned to one silently
      * stops testing what it claims to.
      *
      * These are granted, not merely recorded: the generated seed applies them,
@@ -74,15 +74,15 @@ export type CorePersona = {
     /** Fixture paths this person may upload, relative to the project root. */
     fixtures?: string[];
     /** Their login. `{}` — email and password — is the normal case. */
-    account?: CorePersonaAccount;
+    account?: CoreVirtualUserAccount;
     /**
      * Further logins belonging to the same human, keyed by name.
      *
-     * Rare, and shaped that way on purpose. All of them share the persona's one
+     * Rare, and shaped that way on purpose. All of them share the virtual user's one
      * computed address: better-auth's `allowDifferentEmails` defaults to false,
      * so distinct addresses would be refused linking by the library under test.
      */
-    linkedAccounts?: Record<string, CorePersonaAccount>;
+    linkedAccounts?: Record<string, CoreVirtualUserAccount>;
     /**
      * The environments this person may run against, by config key.
      *
@@ -100,7 +100,7 @@ export type CorePersona = {
      *
      * An assertion, not something inferred from the absence of a disposition:
      * `target` *must not* run, because a run signing in as her would race the
-     * scenario banning her. "Nobody has given this persona a disposition yet" is
+     * scenario banning her. "Nobody has given this virtual user a disposition yet" is
      * a different state, and collapsing the two turns a deliberate constraint
      * into a flaky suite.
      */
@@ -110,20 +110,20 @@ export type CorePersona = {
      *
      * A person uses one of them — staff their app, customers theirs — and that is
      * what decides where a browser step navigates: `/dashboard` is a different
-     * page in each, so the actor settles which one without the scenario saying.
+     * page in each, so the virtual user settles which one without the scenario saying.
      * The runner takes the base url per app (`--app-url <app>=<url>`, or
-     * `appUrls` on the environment) and each actor browses against its own.
+     * `appUrls` on the environment) and each virtual user browses against its own.
      *
      * Omitted is the normal case: one app, one url, nothing to say.
      */
     app?: string;
 };
-/** Personas to declare, keyed by id. */
-export type CorePersonas = Record<string, CorePersona>;
-export type PersonaAccountMeta = {
+/** Virtual users to declare, keyed by id. */
+export type CoreVirtualUsers = Record<string, CoreVirtualUser>;
+export type VirtualUserAccountMeta = {
     provider?: string;
 };
-export type PersonaMeta = {
+export type VirtualUserMeta = {
     /** The key it was declared under. */
     id: string;
     name: string;
@@ -137,8 +137,8 @@ export type PersonaMeta = {
     disposition?: VirtualUserDisposition;
     tuning?: VirtualUserTuning;
     fixtures?: string[];
-    account?: PersonaAccountMeta;
-    linkedAccounts?: Record<string, PersonaAccountMeta>;
+    account?: VirtualUserAccountMeta;
+    linkedAccounts?: Record<string, VirtualUserAccountMeta>;
     /** Absent means "everywhere but production", which is resolved, not stored. */
     environments?: string[];
     runnable: boolean;
@@ -146,5 +146,5 @@ export type PersonaMeta = {
     app?: string;
     sourceFile?: string;
 };
-export type PersonaDefinitions = PersonaMeta[];
-export type PersonasMeta = Record<string, PersonaMeta>;
+export type VirtualUserDefinitions = VirtualUserMeta[];
+export type VirtualUsersMeta = Record<string, VirtualUserMeta>;

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

@@ -25,9 +25,9 @@ export const deriveCatalogue = (functions, schemas = {}) => {
         if (meta.expose !== true)
             continue;
         // A virtual user is not offered the machinery that runs virtual users. A
-        // persona whose role carries `virtualUser:*` would otherwise be able to
+        // virtual user whose role carries `virtualUser:*` would otherwise be able to
         // start further runs, read every run's findings — an adversarial run's
-        // transcript is working exploits against this same app — and put a persona
+        // transcript is working exploits against this same app — and put a virtual user
         // on a schedule that outlives it. Same reasoning as the scenario-step rule
         // above: the tool is about the run, not about the product being explored.
         if (meta.scopes?.some((scope) => scope.split(':')[0] === 'virtualUser')) {
@@ -68,15 +68,21 @@ export const deriveCatalogue = (functions, schemas = {}) => {
 const scenarioSteps = (meta) => {
     if (meta.steps?.length) {
         return meta.steps.flatMap((step) => step.type === 'scenarioStep'
-            ? [{ stepFunc: step.stepFunc, phase: step.phase, actor: step.actor }]
+            ? [
+                {
+                    stepFunc: step.stepFunc,
+                    phase: step.phase,
+                    virtualUser: step.virtualUser,
+                },
+            ]
             : []);
     }
     // knowledge: decisions/internals/virtual-user-step-order-comes-from-insertion-order.md
     return Object.values(meta.nodes ?? {}).flatMap((node) => {
-        const { rpcName, scenarioStepPhase, actor } = (node ?? {});
+        const { rpcName, scenarioStepPhase, virtualUser } = (node ?? {});
         if (!rpcName || !scenarioStepPhase)
             return [];
-        return [{ stepFunc: rpcName, phase: scenarioStepPhase, actor }];
+        return [{ stepFunc: rpcName, phase: scenarioStepPhase, virtualUser }];
     });
 };
 /**
@@ -109,7 +115,7 @@ export const deriveIntents = (workflows, functions = {}) => {
                 phase: step.phase,
                 // knowledge: decisions/internals/a-scenario-step-template-is-offered-unfilled.md
                 description: template ?? description ?? '',
-                actor: step.actor,
+                virtualUser: step.virtualUser,
             }));
         }
         intents.push({
@@ -118,7 +124,7 @@ export const deriveIntents = (workflows, functions = {}) => {
             description: meta.description,
             steps: steps.length ? steps : undefined,
             tags: meta.tags?.length ? meta.tags : undefined,
-            personas: meta.actors?.length ? meta.actors : undefined,
+            virtualUsers: meta.virtualUsers?.length ? meta.virtualUsers : undefined,
         });
     }
     return intents;

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

@@ -5,7 +5,7 @@ import type { VirtualUserDisposition } from './virtual-user.types.js';
  * behaviour the dials cannot express on their own.
  */
 export interface DispositionProfile {
-    /** Appended to the persona instructions. Behaviour, never identity. */
+    /** Appended to the virtual user instructions. Behaviour, never identity. */
     instructions: string;
     /**
      * Relative weights for the scheduler's four moves. `continue` dominating is

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.
      *