@pikku/core 0.12.71 → 0.12.74

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

@@ -0,0 +1,134 @@
+import { hasScopes } from '../../scopes.js';
+/**
+ * Endpoint names that only read, by convention. Used when nobody annotated
+ * `readonly` — which in a real project is most of them.
+ */
+const READ_PREFIXES = [
+    'get',
+    'list',
+    'lookup',
+    'search',
+    'find',
+    'read',
+    'fetch',
+    'check',
+    'count',
+    'query',
+    'preview',
+    'describe',
+    'has',
+    'is',
+];
+/**
+ * Whether a call only reads.
+ *
+ * An explicit annotation always wins. Without one, the name decides — because
+ * an unannotated function means "nobody said", not "safe", and silently
+ * treating 395 unannotated endpoints as read-only is how a virtual user
+ * deploys something. {@link catalogueClassification} reports how much of the
+ * catalogue rests on this guess so the gap is visible rather than assumed.
+ */
+export const isReadOnly = (entry) => {
+    if (typeof entry.readonly === 'boolean')
+        return entry.readonly;
+    const name = entry.name;
+    return READ_PREFIXES.some((prefix) => name.startsWith(prefix) &&
+        (name.length === prefix.length ||
+            name[prefix.length] === name[prefix.length]?.toUpperCase()));
+};
+/** How much of a catalogue's read/write split is annotation and how much is guess. */
+export const catalogueClassification = (entries) => {
+    const annotated = entries.filter((entry) => typeof entry.readonly === 'boolean').length;
+    return {
+        total: entries.length,
+        annotated,
+        inferred: entries.length - annotated,
+    };
+};
+/** One catalogue line: `name(inputKeys) -> outputKeys — description`. */
+const renderEntry = (entry) => {
+    const inputs = (entry.inputKeys ?? []).join(',');
+    const outputs = (entry.outputKeys ?? []).join(',');
+    const description = entry.description
+        ? ` — ${entry.description.split('\n')[0].slice(0, 120)}`
+        : '';
+    return `${entry.name}(${inputs})${outputs ? ` -> ${outputs}` : ''}${description}`;
+};
+/**
+ * The whole reachable API as one compact index, for the instructions.
+ *
+ * Every endpoint is listed rather than retrieved against. Measured on a 430-RPC
+ * project this is ~8k tokens, cached for the life of the run — cheaper than any
+ * retrieval step, and it hides nothing. A ranking function would make the
+ * virtual user only as adventurous as the ranking, which loses exactly the
+ * endpoints worth stumbling into.
+ */
+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.
+ *
+ * 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
+ * denied still going through is a finding rather than a bug in the filter.
+ */
+export const reachableCatalogue = (entries, { readOnly = false, allowApprovalRequired = false, scopes, } = {}) => entries.filter((entry) => {
+    if (entry.approvalRequired && !allowApprovalRequired)
+        return false;
+    if (readOnly && !isReadOnly(entry))
+        return false;
+    if (scopes && entry.scopes?.length) {
+        return hasScopes(entry.scopes, scopes);
+    }
+    return true;
+});
+/**
+ * Endpoints this persona 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
+ * only thing that decides who may call what.
+ */
+export const unreachableCatalogue = (entries, scopes) => entries.filter((entry) => !!entry.scopes?.length && !hasScopes(entry.scopes, scopes));
+/** Index a catalogue by name for the engine's lookups. */
+export const catalogueIndex = (entries) => new Map(entries.map((entry) => [entry.name, entry]));
+/**
+ * Find an entry by the name a model gave, forgiving the signature it just read.
+ *
+ * The catalogue renders as `name(inputs) -> outputs`, and a model that has the
+ * line in front of it will sometimes hand the whole line back — `whoAmI() ->
+ * userId,scopes` instead of `whoAmI`. Measured on a live run, 8 of 24 steps
+ * went that way and every one of them was answered with "there is no endpoint
+ * called that", which is true and useless.
+ *
+ * Forgiving it is not the same as guessing: an rpc name never contains a
+ * bracket, so everything from the first one is the signature the catalogue
+ * printed, and taking it off is unambiguous.
+ */
+export const catalogueLookup = (index, rpcName) => {
+    const exact = index.get(rpcName);
+    if (exact) {
+        return exact;
+    }
+    const [head] = rpcName.trim().split('(');
+    return head && head !== rpcName ? index.get(head.trim()) : undefined;
+};
+/**
+ * What `describe` hands back: the full schemas, so the next call can be made
+ * correctly rather than guessed at.
+ *
+ * Guessing field names is unproductive fuzz — every 400 becomes a typo and
+ * nothing is learned from any of them. Reading the schema first is also what a
+ * person does, since the form tells them the fields. It makes a subsequent 400
+ * mean something: either the schema and the implementation disagree, or the
+ * misuse is genuine and worth seeing.
+ */
+export const describeEntry = (entry) => ({
+    name: entry.name,
+    description: entry.description,
+    readonly: isReadOnly(entry),
+    approvalRequired: entry.approvalRequired ?? false,
+    input: entry.inputSchema ?? { type: 'object', properties: {} },
+    output: entry.outputSchema ?? null,
+});

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

@@ -0,0 +1,26 @@
+import type { FunctionsMeta } from '../../types/core.types.js';
+import type { WorkflowsMeta } from '../workflow/workflow.types.js';
+import type { ApiCatalogueEntry, IntentSource } from './virtual-user.types.js';
+/** A generated JSON schema, keyed by the name the function meta refers to. */
+export type SchemaMap = Record<string, Record<string, unknown> | undefined>;
+/**
+ * Every RPC a virtual user could reach, read off the meta a project already
+ * generates.
+ *
+ * Nothing here is new authoring, which is the whole point: the scopes, the
+ * `readonly` flags, the approval gates and the schemas were written for other
+ * reasons, and a virtual user is another reader of them. A project that has
+ * never heard of virtual users already ships everything one needs.
+ */
+export declare const deriveCatalogue: (functions: FunctionsMeta, schemas?: SchemaMap) => ApiCatalogueEntry[];
+/**
+ * The things a virtual user might want, read off the scenarios a project
+ * already declares.
+ *
+ * Only the prose survives the trip. A scenario knows which RPCs it calls and
+ * how their outputs feed each other, and none of that is passed on: finding
+ * the API is the behaviour under test, and a user handed the answer tests
+ * nothing. A step with no sentence to its name is dropped rather than
+ * described by its function name, which would leak exactly that answer.
+ */
+export declare const deriveIntents: (workflows: WorkflowsMeta, functions?: FunctionsMeta) => IntentSource[];

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

@@ -0,0 +1,137 @@
+import { composeStepProse } from '../workflow/scenario-prose.js';
+const topLevelKeys = (schema) => {
+    const properties = schema?.properties;
+    if (!properties || typeof properties !== 'object')
+        return undefined;
+    const keys = Object.keys(properties);
+    return keys.length ? keys : undefined;
+};
+/**
+ * Every RPC a virtual user could reach, read off the meta a project already
+ * generates.
+ *
+ * Nothing here is new authoring, which is the whole point: the scopes, the
+ * `readonly` flags, the approval gates and the schemas were written for other
+ * reasons, and a virtual user is another reader of them. A project that has
+ * never heard of virtual users already ships everything one needs.
+ */
+export const deriveCatalogue = (functions, schemas = {}) => {
+    const entries = [];
+    for (const [name, meta] of Object.entries(functions ?? {})) {
+        // Scenario bodies and their steps are never network-callable — they are
+        // held out of every deployed unit — so offering one would only ever waste
+        // a turn on a 404.
+        //
+        // For a platform or addon step this is not an efficiency argument but the
+        // oracle: a virtual user's findings are worth something only because it
+        // cannot manufacture the outcomes it is meant to discover. One that could
+        // invoke "Stripe's webhook arrives" would forge its own payment success,
+        // and every finding downstream of that is worthless. Same class of argument
+        // as `allowApprovalRequired` defaulting to false — and enforced here, at
+        // derivation, rather than by convention.
+        if (meta.scenario || meta.scenarioStep || meta.scenarioStepKind)
+            continue;
+        // `expose: true` is what puts a function on the rpc transport, and that is
+        // what the shipped target calls over. Absent is not permissive: an unexposed
+        // function 404s, and offering one spends a step to learn nothing about the
+        // product. Measured on the e2e app, 34 of its 72 functions are in exactly
+        // that state — nearly half a catalogue that cannot be called.
+        if (meta.expose !== true)
+            continue;
+        const inputSchema = meta.inputSchemaName
+            ? schemas[meta.inputSchemaName]
+            : undefined;
+        const outputSchema = meta.outputSchemaName
+            ? schemas[meta.outputSchemaName]
+            : undefined;
+        entries.push({
+            name,
+            description: meta.description ?? meta.summary ?? meta.title,
+            readonly: meta.readonly,
+            approvalRequired: meta.approvalRequired,
+            scopes: meta.scopes?.length ? [...new Set(meta.scopes)] : undefined,
+            tags: meta.tags?.length ? meta.tags : undefined,
+            inputKeys: topLevelKeys(inputSchema),
+            outputKeys: topLevelKeys(outputSchema),
+            inputSchema,
+            outputSchema,
+        });
+    }
+    return entries;
+};
+/**
+ * The same scenario, spelled either way.
+ *
+ * One scenario has two meta shapes and both reach this function: the runner
+ * hands over the inspector's DSL meta, where steps are a `steps[]` of
+ * `scenarioStep`s, while the console reads what was written to disk through
+ * `getWorkflowMeta()`, where the same steps are the graph's `nodes` and the
+ * scenario declares itself with `source` rather than `scenario`. Reading only
+ * the first shape is not a narrower reading — it is an empty one, and a screen
+ * built on it shows every user wanting nothing at all.
+ */
+const scenarioSteps = (meta) => {
+    if (meta.steps?.length) {
+        return meta.steps.flatMap((step) => step.type === 'scenarioStep'
+            ? [{ stepFunc: step.stepFunc, phase: step.phase, actor: step.actor }]
+            : []);
+    }
+    // Insertion order is the order the CLI wrote the nodes in, which is the order
+    // the scenario declares them. Following `next` instead would buy an ordering
+    // that is already true and cost a traversal that has to decide what a branch
+    // means to a reader who will never take one.
+    return Object.values(meta.nodes ?? {}).flatMap((node) => {
+        const { rpcName, scenarioStepPhase, actor } = (node ?? {});
+        if (!rpcName || !scenarioStepPhase)
+            return [];
+        return [{ stepFunc: rpcName, phase: scenarioStepPhase, actor }];
+    });
+};
+/**
+ * The things a virtual user might want, read off the scenarios a project
+ * already declares.
+ *
+ * Only the prose survives the trip. A scenario knows which RPCs it calls and
+ * how their outputs feed each other, and none of that is passed on: finding
+ * the API is the behaviour under test, and a user handed the answer tests
+ * nothing. A step with no sentence to its name is dropped rather than
+ * described by its function name, which would leak exactly that answer.
+ */
+export const deriveIntents = (workflows, functions = {}) => {
+    const intents = [];
+    for (const [name, meta] of Object.entries(workflows ?? {})) {
+        if (!meta.scenario && meta.source !== 'scenario')
+            continue;
+        // A quarantined scenario is one someone decided not to run. Driving real
+        // traffic with it would be a louder version of the same mistake.
+        if (meta.skip)
+            continue;
+        const steps = [];
+        for (const step of scenarioSteps(meta)) {
+            const stepMeta = functions[step.stepFunc];
+            const template = stepMeta?.scenarioStepTemplate;
+            const description = stepMeta?.description ?? stepMeta?.summary;
+            if (!template && !description)
+                continue;
+            steps.push(composeStepProse({
+                phase: step.phase,
+                // The template goes in unfilled, braces and all. A reporter fills its
+                // placeholders from a run that happened; there is no run yet, and
+                // "invites {email}" tells a user to pick someone where the filled-in
+                // form would have told it whom — which is the scenario's answer, not
+                // the user's own.
+                description: template ?? description ?? '',
+                actor: step.actor,
+            }));
+        }
+        intents.push({
+            id: name,
+            title: meta.title ?? meta.summary ?? name,
+            description: meta.description,
+            steps: steps.length ? steps : undefined,
+            tags: meta.tags?.length ? meta.tags : undefined,
+            personas: meta.actors?.length ? meta.actors : undefined,
+        });
+    }
+    return intents;
+};

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

@@ -0,0 +1,79 @@
+import type { VirtualUserDisposition } from './virtual-user.types.js';
+/**
+ * The dials a disposition turns. Everything here changes what the engine does;
+ * `instructions` is the only field the model ever sees, and it describes
+ * behaviour the dials cannot express on their own.
+ */
+export interface DispositionProfile {
+    /** Appended to the persona instructions. Behaviour, never identity. */
+    instructions: string;
+    /**
+     * Relative weights for the scheduler's four moves. `continue` dominating is
+     * what makes a run look like work rather than channel-surfing.
+     */
+    moves: {
+        continue: number;
+        suspend: number;
+        resume: number;
+        abandon: number;
+    };
+    /** Sampling temperature for the model's own turns. */
+    temperature: number;
+    /** Chance of re-issuing the previous call unchanged — the double-click. */
+    repeatRate: number;
+    /** Chance of re-reading before acting instead of trusting memory. */
+    reReadRate: number;
+    /** Start with nothing remembered, whatever the caller seeded. */
+    emptyMemory: boolean;
+    /** Non-read calls are refused by the engine, not merely discouraged. */
+    readOnly: boolean;
+    /**
+     * A 2xx is a finding rather than a success. The engine cannot know *whose*
+     * resource an id belongs to, so it flags the success and leaves ownership to
+     * the app's classifier — the honest split, since ownership is app knowledge.
+     */
+    invertedOracle: boolean;
+}
+/**
+ * Per-user overrides for a disposition's dials.
+ *
+ * The six profiles below are starting points, not laws — the weights are a
+ * considered guess about how people behave, and your product is allowed to know
+ * better. A user that declares `disposition: 'careless'` with a higher
+ * `repeatRate` is still a careless user; it is the same behaviour tuned to a
+ * product where double-submits actually happen.
+ *
+ * `instructions` is the one field that appends rather than replaces. Everything
+ * else is a number the engine reads, so overriding it changes the run and
+ * nothing else; instructions are the model's sense of who it is, and letting a
+ * declaration replace them wholesale is how you end up with a `careless` user
+ * that is not careless — which makes the name, and every run labelled with it,
+ * a lie.
+ */
+export interface VirtualUserTuning {
+    /** Relative weights for the scheduler's moves. Merged over the profile's. */
+    moves?: Partial<DispositionProfile['moves']>;
+    temperature?: number;
+    repeatRate?: number;
+    reReadRate?: number;
+    emptyMemory?: boolean;
+    readOnly?: boolean;
+    invertedOracle?: boolean;
+    /** Extra behaviour, appended to the disposition's own instructions. */
+    instructions?: string;
+}
+/**
+ * The profiles, keyed by disposition. `careless` is the one worth reading twice:
+ * it is not malice, it is an ordinary person being interrupted and impatient,
+ * and it is where most production bugs actually live.
+ */
+export declare const DISPOSITIONS: Readonly<Record<VirtualUserDisposition, DispositionProfile>>;
+/**
+ * The profile for a disposition, defaulting to `realistic`, with any declared
+ * tuning merged over it.
+ *
+ * Every consumer resolves a profile through here — the engine, the CLI report
+ * and the console screen — so a tuned user reads as tuned everywhere rather
+ * than only behaving differently when it runs.
+ */
+export declare const dispositionProfile: (disposition?: VirtualUserDisposition, tuning?: VirtualUserTuning) => DispositionProfile;

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

@@ -0,0 +1,128 @@
+const REALISTIC = {
+    instructions: [
+        'Work towards your current goal the way a competent user would.',
+        'Read an endpoint schema before you use it, and prefer values that a real person would plausibly enter.',
+    ].join(' '),
+    moves: { continue: 88, suspend: 6, resume: 5, abandon: 1 },
+    temperature: 0.7,
+    repeatRate: 0,
+    reReadRate: 0.1,
+    emptyMemory: false,
+    readOnly: false,
+    invertedOracle: false,
+};
+/**
+ * The profiles, keyed by disposition. `careless` is the one worth reading twice:
+ * it is not malice, it is an ordinary person being interrupted and impatient,
+ * and it is where most production bugs actually live.
+ */
+export const DISPOSITIONS = {
+    realistic: REALISTIC,
+    careless: {
+        ...REALISTIC,
+        instructions: [
+            'You are busy and easily distracted. You act on what you half-remember rather than checking first,',
+            'you sometimes submit the same thing twice because you are not sure it went through,',
+            'and you are comfortable entering odd-but-legal values — a very long name, an empty optional field, an emoji, a huge page size.',
+            'Stay within what the schema allows; you are careless, not malicious.',
+        ].join(' '),
+        moves: { continue: 62, suspend: 18, resume: 12, abandon: 8 },
+        temperature: 1,
+        repeatRate: 0.18,
+        reReadRate: 0.03,
+    },
+    newcomer: {
+        ...REALISTIC,
+        instructions: [
+            'This is your first time in this product. You know nothing about it and hold no ids or names in your head.',
+            'Find your way from whatever lists or lookups exist, and say plainly when there is no path forward from where you are.',
+        ].join(' '),
+        moves: { continue: 80, suspend: 8, resume: 6, abandon: 6 },
+        temperature: 0.8,
+        reReadRate: 0.4,
+        emptyMemory: true,
+    },
+    stale: {
+        ...REALISTIC,
+        instructions: [
+            'You used this product a while ago and are working from notes you took then.',
+            'Reach for the ids and names you already have rather than looking them up again — some of them are out of date, and finding out how the product tells you so is the point.',
+        ].join(' '),
+        moves: { continue: 84, suspend: 8, resume: 6, abandon: 2 },
+        temperature: 0.7,
+        reReadRate: 0.02,
+    },
+    auditor: {
+        ...REALISTIC,
+        instructions: [
+            'You are reconciling, not achieving. Pick one fact the product reports — a total, a count, a balance, a status —',
+            'and read it from every endpoint that claims to know it, then say whether they agree.',
+            'Report a disagreement precisely: which endpoints, which field, which two values.',
+            'Never change anything.',
+        ].join(' '),
+        moves: { continue: 92, suspend: 4, resume: 4, abandon: 0 },
+        temperature: 0.4,
+        reReadRate: 0.5,
+        readOnly: true,
+    },
+    adversarial: {
+        ...REALISTIC,
+        instructions: [
+            'You are testing whether this product actually enforces the boundaries it claims.',
+            'Try reaching resources that should not be yours, reusing identifiers you were given for one purpose in another,',
+            'and calling endpoints that look like they belong to someone with more authority than you.',
+            'You are probing authorization, not causing damage: never destroy data you can reach, and prefer reads over writes when either would prove the point.',
+        ].join(' '),
+        moves: { continue: 70, suspend: 10, resume: 8, abandon: 12 },
+        temperature: 0.9,
+        reReadRate: 0.2,
+        invertedOracle: true,
+    },
+    // The only disposition that is not testing anything. It is doing the job, so
+    // it abandons rarely, runs cool, and is told to stop and say so rather than
+    // guess — the failure mode here is a wrong action nobody asked for, not a
+    // missed bug.
+    accountable: {
+        ...REALISTIC,
+        instructions: [
+            'You are doing this job for real. What you change stays changed, and every call you make is recorded against your name.',
+            'Work towards your goals as the person you are, using the tools you have been given.',
+            'Where a specialist agent exists for part of the work, hand that part to it rather than reconstructing it yourself.',
+            'When you are unsure whether something is wanted, stop and say what you would do and why, rather than doing it and reporting afterwards.',
+            'Never guess at an identifier, an amount or a recipient — read it from the product first.',
+        ].join(' '),
+        moves: { continue: 94, suspend: 5, resume: 1, abandon: 0 },
+        temperature: 0.4,
+        repeatRate: 0,
+        reReadRate: 0.25,
+    },
+};
+/**
+ * The profile for a disposition, defaulting to `realistic`, with any declared
+ * tuning merged over it.
+ *
+ * Every consumer resolves a profile through here — the engine, the CLI report
+ * and the console screen — so a tuned user reads as tuned everywhere rather
+ * than only behaving differently when it runs.
+ */
+export const dispositionProfile = (disposition = 'realistic', tuning) => {
+    const base = DISPOSITIONS[disposition] ?? DISPOSITIONS.realistic;
+    if (!tuning) {
+        return base;
+    }
+    const { moves, instructions, ...dials } = tuning;
+    const profile = {
+        ...base,
+        // An explicit `undefined` is someone spreading an optional value, not a
+        // request to unset a dial — spreading `dials` straight in would erase it.
+        ...Object.fromEntries(Object.entries(dials).filter(([, value]) => value !== undefined)),
+        moves: {
+            ...base.moves,
+            ...Object.fromEntries(Object.entries(moves ?? {}).filter(([, value]) => value !== undefined)),
+        },
+    };
+    if (instructions) {
+        profile.instructions = `${base.instructions} ${instructions}`;
+    }
+    return profile;
+};

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

@@ -0,0 +1,78 @@
+import type { DispositionProfile } from './virtual-user-dispositions.js';
+import type { VirtualUserRng } from './virtual-user-rng.js';
+import type { IntentRecord, IntentSource, IntentStatus } from './virtual-user.types.js';
+/** One intent as the stack tracks it. */
+interface TrackedIntent {
+    id: string;
+    source: IntentSource;
+    status: IntentStatus;
+    steps: number[];
+    suspensions: number;
+    summary?: string;
+}
+/** The move the scheduler rolled for a tick. */
+export type IntentMove = 'start' | 'continue' | 'suspend' | 'resume' | 'abandon';
+/** What the stack scheduled: which intent is active, and how it got there. */
+export interface ScheduledTick {
+    intent: TrackedIntent;
+    move: IntentMove;
+}
+/**
+ * The stack of things this user is in the middle of — and the whole of the
+ * engine's randomness.
+ *
+ * A real person does not run a flow end to end: they start something, get
+ * pulled away, do a bit of something else, come back to a world that moved
+ * underneath them, and sometimes never come back at all. Modelling that as a
+ * stack of partially-completed intents is what produces the bugs worth having —
+ * half-mutated state, a flow resumed against changed data, an invite accepted
+ * after the plan changed — none of which a scripted scenario can reach.
+ *
+ * Scheduling is the engine's job and the model's turns are not: the model
+ * decides what to do *within* the active intent, the stack decides which intent
+ * that is. Keeping the split there is what makes a run reproducible from a seed
+ * while the work inside it stays free.
+ *
+ * A feature is only where an intent comes from. Nothing here tracks whether one
+ * was "completed correctly", and the model is never told an intent boundary
+ * exists.
+ */
+export declare class IntentStack {
+    private readonly rng;
+    private readonly profile;
+    /** Cap on intents open at once, so a distractible user still finishes things. */
+    private readonly maxOpen;
+    private readonly tracked;
+    private readonly unstarted;
+    private active;
+    private counter;
+    constructor(sources: readonly IntentSource[], rng: VirtualUserRng, profile: DispositionProfile, 
+    /** Cap on intents open at once, so a distractible user still finishes things. */
+    maxOpen?: number);
+    /**
+     * Pick the intent for this tick, or `null` when there is nothing left to do.
+     *
+     * The first tick always starts something; after that the four moves are
+     * weighted by the disposition, and a move that has nowhere to go degrades to
+     * `continue` rather than stalling the run.
+     */
+    next(step: number): ScheduledTick | null;
+    /** Mark the active intent finished; the next tick schedules something else. */
+    complete(summary?: string): void;
+    /** Mark the active intent as one the user could not get through. */
+    stuck(reason?: string): void;
+    /** Every intent the run touched, in the order it first opened them. */
+    records(): IntentRecord[];
+    /** Prefer opening something new, falling back to picking a suspended one up. */
+    private startOrResume;
+    private resumeSuspended;
+}
+/**
+ * The intents a persona 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.
+ */
+export declare const intentsForPersona: (sources: readonly IntentSource[], personaId: string) => IntentSource[];
+export {};