@pikku/cli 0.12.104 → 0.12.107

package/dist/.pikku/pikku-services.gen.js

@@ -1,10 +1,10 @@
 // Singleton services map: true if required, false if available but unused
 export const requiredSingletonServices = {
     'agentRunService': false,
-    'aiAgentRunner': false,
+    'agentRunState': false,
+    'agentRunner': false,
+    'agentStorage': false,
     'aiEmbedding': false,
-    'aiRunState': false,
-    'aiStorage': false,
     'audit': false,
     'auditLog': false,
     'auth': false,

package/dist/.pikku/pikku-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.96
  */
 /**
  * Main type export hub - re-exports all wiring-specific types

package/dist/.pikku/pikku-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.96
  */
 /**
  * Main type export hub - re-exports all wiring-specific types

package/dist/.pikku/queue/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Subpath entry — `#pikku/queue` resolves here.
+ */
+export * from './pikku-queue-types.gen.js';

package/dist/.pikku/queue/index.js

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Subpath entry — `#pikku/queue` resolves here.
+ */
+export * from './pikku-queue-types.gen.js';

package/dist/.pikku/queue/pikku-queue-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 /**
  * Queue-specific type definitions for tree-shaking optimization

package/dist/.pikku/queue/pikku-queue-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 /**
  * Queue-specific type definitions for tree-shaking optimization

package/dist/.pikku/queue/pikku-queue-workers-wirings-meta.gen.js

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
-import { pikkuState } from '@pikku/core/ecosystem';
+import { pikkuState } from '@pikku/core/state';
 import metaData from './pikku-queue-workers-wirings-meta.gen.json' with { type: 'json' };
 pikkuState(null, 'queue', 'meta', metaData);

package/dist/.pikku/queue/pikku-queue-workers-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */

package/dist/.pikku/queue/pikku-queue-workers-wirings.gen.js

@@ -1,5 +1,5 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 /* The files with an addQueueWorkers function call */ 

package/dist/.pikku/rpc/pikku-rpc-wirings-meta.internal.gen.js

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
-import { pikkuState } from '@pikku/core/ecosystem';
+import { pikkuState } from '@pikku/core/state';
 import metaData from './pikku-rpc-wirings-meta.internal.gen.json' with { type: 'json' };
 pikkuState(null, 'rpc', 'meta', metaData);

package/dist/.pikku/rpc/pikku-rpc-wirings-meta.internal.gen.json

@@ -95,9 +95,11 @@
     "scenarioRun": "scenarioRun",
     "scopesAudit": "scopesAudit",
     "scopesPrune": "scopesPrune",
+    "pikkuSemver": "pikkuSemver",
     "serve": "serve",
     "pikkuSkillsList": "pikkuSkillsList",
     "pikkuSkillsInstall": "pikkuSkillsInstall",
+    "pikkuUpdate": "pikkuUpdate",
     "validate": "validate",
     "pikkuVersionsCheck": "pikkuVersionsCheck",
     "pikkuVersionsInit": "pikkuVersionsInit",
@@ -107,10 +109,10 @@
     "pikkuNext": "pikkuNext",
     "pikkuTanStackStart": "pikkuTanStackStart",
     "pikkuWebSocketTyped": "pikkuWebSocketTyped",
-    "pikkuAIAgentTypes": "pikkuAIAgentTypes",
-    "pikkuAIAgent": "pikkuAIAgent",
+    "pikkuAgentScorer": "pikkuAgentScorer",
+    "pikkuAgentTypes": "pikkuAgentTypes",
+    "pikkuAgent": "pikkuAgent",
     "pikkuPublicAgent": "pikkuPublicAgent",
-    "pikkuAIScorer": "pikkuAIScorer",
     "pikkuAuth": "pikkuAuth",
     "pikkuChannels": "pikkuChannels",
     "pikkuChannelTypes": "pikkuChannelTypes",
@@ -120,16 +122,17 @@
     "pikkuCLITypes": "pikkuCLITypes",
     "pikkuCLI": "pikkuCLI",
     "pikkuConsoleFunctions": "pikkuConsoleFunctions",
-    "pikkuNodeTypes": "pikkuNodeTypes",
     "pikkuNodesMeta": "pikkuNodesMeta",
     "pikkuCredentials": "pikkuCredentials",
     "pikkuEmails": "pikkuEmails",
+    "pikkuErrorTypes": "pikkuErrorTypes",
     "pikkuAddonTypes": "pikkuAddonTypes",
     "pikkuFunctionTypesSplit": "pikkuFunctionTypesSplit",
-    "pikkuFunctionTypes": "pikkuFunctionTypes",
     "pikkuFunctions": "pikkuFunctions",
+    "pikkuLeafIndexes": "pikkuLeafIndexes",
     "pikkuServices": "pikkuServices",
     "pikkuSchemas": "pikkuSchemas",
+    "pikkuGatewayTypes": "pikkuGatewayTypes",
     "pikkuGateway": "pikkuGateway",
     "pikkuGraphWirings": "pikkuGraphWirings",
     "pikkuHTTPMap": "pikkuHTTPMap",

package/dist/.pikku/scenarios/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Subpath entry — `#pikku/scenarios` resolves here.
+ */
+export * from './pikku-scenario-types.gen.js';

package/dist/.pikku/scenarios/index.js

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Subpath entry — `#pikku/scenarios` resolves here.
+ */
+export * from './pikku-scenario-types.gen.js';

package/dist/.pikku/scenarios/pikku-personas.gen.d.ts

@@ -0,0 +1,17 @@
+import type { HttpPersonasConfig } from '@pikku/core/persona';
+import type { ScenarioPersona } from '@pikku/core/services';
+import type { ResolvedPersona } from '@pikku/core/services';
+import type { AgentMap } from '../agent/pikku-agent-map.gen.d.js';
+import type { FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.gen.d.js';
+export declare const personaConfigs: {};
+export type PersonaName = keyof typeof personaConfigs;
+/**
+ * The same personas as a list, widened to `ResolvedPersona`. Iterating
+ * `personaConfigs` directly yields the literal type of each entry, on which an
+ * optional field a persona did not declare does not exist — so a seed reading
+ * `roles` off every persona needs this instead.
+ */
+export declare const personaList: ResolvedPersona[];
+export type AgentName = keyof AgentMap & string;
+export type TypedPersonas = Record<PersonaName, ScenarioPersona<AgentName, FlattenedRPCMap>>;
+export declare const createPersonas: (options: Omit<HttpPersonasConfig, "personas">) => TypedPersonas;

package/dist/.pikku/scenarios/pikku-personas.gen.js

@@ -0,0 +1,17 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/** Personas declared with definePersonas() */
+import { createHttpPersonas } from '@pikku/core/persona';
+export const personaConfigs = {};
+/**
+ * The same personas as a list, widened to `ResolvedPersona`. Iterating
+ * `personaConfigs` directly yields the literal type of each entry, on which an
+ * optional field a persona did not declare does not exist — so a seed reading
+ * `roles` off every persona needs this instead.
+ */
+export const personaList = Object.values(personaConfigs);
+export const createPersonas = (options) => createHttpPersonas({
+    ...options,
+    personas: personaConfigs,
+});

package/dist/.pikku/scenarios/pikku-scenario-functions-meta.gen.js

@@ -1,7 +1,7 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
-import { pikkuState } from '@pikku/core/ecosystem';
+import { pikkuState } from '@pikku/core/state';
 import '../function/pikku-functions-meta.gen.js';
 import metaData from './pikku-scenario-functions-meta.gen.json' with { type: 'json' };
 pikkuState(null, 'function', 'meta', {

package/dist/.pikku/scenarios/pikku-scenario-functions.gen.d.ts

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 export {};

package/dist/.pikku/scenarios/pikku-scenario-types.gen.d.ts

@@ -0,0 +1,310 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+import type { PikkuScenarioWire, ScenarioStepOptions } from '@pikku/core/scenario';
+import type { PikkuWorkflowWire } from '@pikku/core/workflow';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { PikkuError } from '@pikku/core/errors';
+import type { PikkuFunctionSessionless, PikkuFunctionConfig, WiredServices, InferSchemaOutput, NodeConfig, PikkuApprovalDescription } from '../function/pikku-function-types.gen.js';
+import type { PikkuMiddleware } from '../middleware/pikku-middleware-types.gen.js';
+import type { TypedWorkflow } from '../workflow/pikku-workflow-types.gen.js';
+import type { FlattenedScenarioStepMap } from '../workflow/pikku-scenario-step-map.gen.d.js';
+import type { TypedPersonas } from './pikku-personas.gen.js';
+export type { TypedPersonas };
+/**
+ * The scenario test surface, re-exported so a step file has one specifier to
+ * import from. These names are not generated — they come straight from core —
+ * but routing them through here means a scenario file never has to know
+ * whether the helper it wants is typed against this project or shipped by the
+ * framework.
+ */
+export { createCookieJar, createScenarioRunner, pollUntil, requireScenarioEnv, } from '@pikku/core/scenario';
+export type { PikkuBrowserWire, ScenarioSurface, TestIdSelector, } from '@pikku/core/scenario';
+export { postScenarioJson, readScenarioHttpResponse } from '@pikku/core/persona';
+export type { ScenarioHttpResponse } from '@pikku/core/scenario';
+/**
+ * The typed half of a scenario wire: `given`/`when`/`then`, narrowed to the
+ * names declared by `pikkuScenarioStep` in this project. `given` and `when`
+ * differ only in the prose the reporter renders; `then` additionally makes the
+ * step's bindings witnesses rather than alternatives.
+ */
+export interface TypedScenarioSteps {
+    given<K extends keyof FlattenedScenarioStepMap>(stepName: string, stepFunc: K, data?: FlattenedScenarioStepMap[K]['input'], options?: ScenarioStepOptions): Promise<FlattenedScenarioStepMap[K]['output']>;
+    when<K extends keyof FlattenedScenarioStepMap>(stepName: string, stepFunc: K, data?: FlattenedScenarioStepMap[K]['input'], options?: ScenarioStepOptions): Promise<FlattenedScenarioStepMap[K]['output']>;
+    then<K extends keyof FlattenedScenarioStepMap>(stepName: string, stepFunc: K, data?: FlattenedScenarioStepMap[K]['input'], options?: ScenarioStepOptions): Promise<FlattenedScenarioStepMap[K]['output']>;
+}
+/** `Out` types `scenario.context`. */
+export type TypedScenario<Out = unknown> = TypedWorkflow & Omit<PikkuScenarioWire<Out>, keyof PikkuWorkflowWire | keyof TypedScenarioSteps> & TypedScenarioSteps;
+/**
+ * `Ctx` types `scenario.context`, defaulting to the body's own output. A hook
+ * returns void but shares the scenario's context, so it passes that scenario's
+ * output here instead.
+ */
+export type PikkuFunctionScenario<In = unknown, Out = never, Ctx = Out> = PikkuFunctionSessionless<In, Out, 'scenario' | 'actors', WiredServices, Ctx>;
+type PikkuScenarioConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    expose?: boolean;
+    internal?: boolean;
+    override?: string;
+    version?: number;
+    remote?: boolean;
+    mcp?: boolean;
+    readonly?: boolean;
+    approvalRequired?: boolean;
+    approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never;
+    middleware?: PikkuMiddleware[];
+    input?: InputSchema;
+    output?: OutputSchema;
+    node?: NodeConfig;
+    errors?: Array<typeof PikkuError>;
+    inline?: boolean;
+    func: PikkuFunctionScenario<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>;
+    /**
+     * Runs before the scenario body. Same signature as `func`, but its return
+     * value is discarded — a hook is setup, not a step, so it is never recorded
+     * on the ladder. Throwing skips the body and fails the run; `after` still
+     * runs.
+     */
+    before?: PikkuScenarioHook<InputSchema, OutputSchema>;
+    /**
+     * Always runs after the scenario body, in a `finally`, whether it passed or
+     * failed. Throwing fails a run that would otherwise have passed; on an
+     * already-failed run it attaches as the `cause` and never replaces the
+     * original error. Reads `scenario.context` for whatever the body managed to
+     * record before it stopped.
+     */
+    after?: PikkuScenarioHook<InputSchema, OutputSchema>;
+    /**
+     * Why this scenario is held out of a default run, stated where the scenario
+     * is. The scenario still appears in the plan and is reported as skipped
+     * rather than quietly omitted; naming it directly with `--flows` runs it
+     * anyway.
+     */
+    skip?: string;
+};
+/**
+ * A scenario lifecycle hook: the scenario's own `(services, data, wire)`
+ * signature with its result discarded. `OutputSchema` types
+ * `scenario.context` while the return type stays `void`.
+ */
+export type PikkuScenarioHook<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = PikkuFunctionScenario<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, void, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>;
+/**
+ * Declares a scenario hook. Returns the function verbatim — a hook is never
+ * registered, so this exists purely to give an inline hook a call site to be
+ * contextually typed from, the way every other pikku primitive is.
+ */
+export declare function pikkuScenarioHook<In = unknown, Ctx = unknown>(hook: PikkuFunctionScenario<In, void, Ctx>): PikkuFunctionScenario<In, void, Ctx>;
+/**
+ * A scenario: a complex workflow that drives the app the way users do.
+ * Steps run as actors over the REAL transport — `scenario.do(step, rpc,
+ * data, { actor: actors.yasser })` — so flows double as e2e tests and
+ * staged/production health checks (no state reset; scope what you create).
+ */
+export declare function pikkuScenario<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuScenarioConfigWithSchema<InputSchema, OutputSchema>): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenario' | 'actors', PikkuFunctionScenario<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>, InputSchema, OutputSchema>;
+export declare function pikkuScenario<In, Out = unknown>(func: PikkuFunctionScenario<In, Out> | PikkuFunctionConfig<In, Out, 'scenario' | 'actors', PikkuFunctionScenario<In, Out>>): PikkuFunctionConfig<In, Out, 'scenario' | 'actors'>;
+/**
+ * A scenario as a feature references it. Any `pikkuScenario` export is
+ * assignable; `In` is recovered from it so the paired form's `data` is
+ * checked against that scenario's own input.
+ */
+export type PikkuScenarioRef<In = any, Out = any> = PikkuFunctionConfig<In, Out, 'scenario' | 'actors', PikkuFunctionScenario<In, Out>, any, any>;
+/**
+ * One entry in a feature's `scenarios` list, validated against itself: a bare
+ * scenario, or a scenario paired with the input to run it with. The paired form
+ * is gherkin's `Examples:` written as an ordinary loop.
+ */
+export type PikkuFeatureEntry<Entry> = Entry extends {
+    scenario: PikkuScenarioRef<infer In>;
+} ? {
+    scenario: PikkuScenarioRef<In>;
+    data: In;
+} : Entry extends PikkuScenarioRef ? Entry : never;
+type PikkuFeatureConfig<Scenarios extends readonly unknown[]> = {
+    /** Human-readable name. The export identifier is the id. */
+    name: string;
+    description?: string;
+    tags?: string[];
+    scenarios: {
+        [K in keyof Scenarios]: PikkuFeatureEntry<Scenarios[K]>;
+    };
+    /**
+     * Runs ONCE before the whole group — not before each scenario. Per-scenario
+     * setup is the scenario's own `before`; gherkin's `Background:` is
+     * deliberately not expressible here.
+     */
+    before?: PikkuScenarioHook;
+    after?: PikkuScenarioHook;
+};
+/**
+ * A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔
+ * Scenario structure. Scenarios are referenced by imported identifier, so a
+ * renamed or deleted scenario is a compile error rather than a silent skip.
+ *
+ * A scenario does not have to belong to a feature — a void-input scenario
+ * still runs standalone.
+ *
+ * ```ts
+ * export const credentialFeature = pikkuFeature({
+ *   name: 'Credential API',
+ *   tags: ['credential'],
+ *   before: startsMockOAuthServer,
+ *   after: stopsMockOAuthServer,
+ *   scenarios: [
+ *     credentialLazyLoadScenario,
+ *     ...['stripe', 'google'].map((name) => ({
+ *       scenario: credentialRoundTripScenario,
+ *       data: { name },
+ *     })),
+ *   ],
+ * })
+ * ```
+ */
+export declare function pikkuFeature<const Scenarios extends readonly unknown[]>(config: PikkuFeatureConfig<Scenarios>): PikkuFeatureConfig<Scenarios>;
+/**
+ * One surface's implementation of a step.
+ *
+ * Each binding is typed independently, so a browser binding gets a non-optional
+ * `wire.browser` and a cli binding a non-optional `wire.cli` without either
+ * leaking into the other.
+ */
+export type PikkuFunctionScenarioStep<In = unknown, Out = never, Surface extends 'browser' | 'cli' | 'default' = 'default', HasActor extends boolean = false> = PikkuFunctionSessionless<In, Out, 'scenarioStep' | (Surface extends 'default' ? never : Surface) | (HasActor extends true ? 'actor' : never)>;
+type PikkuScenarioStepConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined, HasActor extends boolean = false> = {
+    /** Registered name — this is the string `scenario.given()` references. */
+    name: string;
+    /**
+     * This step is driven by a persona, so `wire.actor` is injected and
+     * non-optional inside every binding, and the runner refuses to dispatch it
+     * without one.
+     *
+     * A `browser` binding implies it — a window is opened as somebody. Declare it
+     * for a server-side step that calls RPCs as its actor. Leave it off for a step
+     * that has no persona to be: an assertion over a value an earlier step
+     * returned, or one that posts credentials precisely because it must not reuse
+     * an actor's session.
+     */
+    actor?: HasActor;
+    /**
+     * What this step does, for the console and for whoever reads the source. It
+     * is also the fallback prose when no `template` is declared, in which case a
+     * reporter renders "Given the shopper buys an apple". Defaults to the call
+     * site's step name.
+     */
+    description?: string;
+    /**
+     * The prose a reporter renders for this step, with `{placeholders}` filled
+     * from the input the step was called with — `'sees {packageName}'` reports as
+     * "Then the admin sees @pikku/addon-todos". Every input field should appear,
+     * so the report names the values under test rather than repeating one
+     * sentence per call site.
+     */
+    template?: string;
+    title?: string;
+    tags?: string[];
+    input?: InputSchema;
+    output?: OutputSchema;
+    errors?: Array<typeof PikkuError>;
+    /**
+     * Drive this step through a real browser, as a human would. The runner
+     * provisions a window for the step's actor first — which makes an actor
+     * mandatory — and `wire.browser` is non-optional inside it.
+     *
+     * Compose shared utilities here rather than writing raw clicks: the step says
+     * what the actor is doing, the utilities say how.
+     */
+    browser?: PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'browser', true>;
+    /** Drive this step remotely, over the websocket. */
+    cli?: PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'cli', HasActor>;
+    /**
+     * The server-side path — the fast suite, and the floor every other surface
+     * falls back to.
+     *
+     * On a `then`, this is not an alternative to the other bindings but a second
+     * **witness**: the run executes every binding it has and fails if they
+     * disagree, because "the row says paid" and "the page says paid" are different
+     * claims and the gap between them is the bug nobody catches.
+     */
+    default?: PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default', HasActor>;
+};
+type PikkuScenarioStepConfig<In, Out, HasActor extends boolean = false> = Omit<PikkuScenarioStepConfigWithSchema<undefined, undefined, HasActor>, 'browser' | 'cli' | 'default' | 'input' | 'output'> & {
+    browser?: PikkuFunctionScenarioStep<In, Out, 'browser', true>;
+    cli?: PikkuFunctionScenarioStep<In, Out, 'cli', HasActor>;
+    default?: PikkuFunctionScenarioStep<In, Out, 'default', HasActor>;
+};
+/**
+ * A named, reusable scenario step, declaring one implementation per surface an
+ * actor can drive it through.
+ *
+ * The step's identity is what the actor is trying to do; which surface carries
+ * it out is a binding. That is what lets one ladder run through a real browser,
+ * over the websocket, or entirely server-side — and what makes "how much of this
+ * flow can a human actually reach" a number rather than a guess.
+ *
+ * Steps are deliberately NOT registered as RPCs: a browser-driving step must
+ * never be network-callable.
+ */
+export declare function pikkuScenarioStep<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema, true> & {
+    actor: true;
+}): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep' | 'browser' | 'cli', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'browser' | 'cli' | 'default'>, InputSchema, OutputSchema>;
+export declare function pikkuScenarioStep<In, Out = unknown>(config: PikkuScenarioStepConfig<In, Out, true> & {
+    actor: true;
+}): PikkuFunctionConfig<In, Out, 'scenarioStep' | 'browser' | 'cli'>;
+export declare function pikkuScenarioStep<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema, true> & {
+    browser: {};
+}): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep' | 'browser' | 'cli', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'browser' | 'cli' | 'default'>, InputSchema, OutputSchema>;
+export declare function pikkuScenarioStep<In, Out = unknown>(config: PikkuScenarioStepConfig<In, Out, true> & {
+    browser: {};
+}): PikkuFunctionConfig<In, Out, 'scenarioStep' | 'browser' | 'cli'>;
+export declare function pikkuScenarioStep<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema>): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep' | 'browser' | 'cli', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'browser' | 'cli' | 'default'>, InputSchema, OutputSchema>;
+export declare function pikkuScenarioStep<In, Out = unknown>(config: PikkuScenarioStepConfig<In, Out>): PikkuFunctionConfig<In, Out, 'scenarioStep' | 'browser' | 'cli'>;
+/**
+ * What a step declares when nobody drives it: one implementation, and no
+ * surfaces to choose between.
+ *
+ * `func` rather than `default` is the point. `default` means *the fallback when
+ * no other surface applies*, which implies others could exist; `func` says
+ * structurally that there is one way this happens. That also keeps the phase
+ * rule coherent — an assertion runs every witness it has and fails if they
+ * disagree, and this has exactly one by construction.
+ */
+type PikkuSubjectScenarioStepConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = Omit<PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema>, 'browser' | 'cli' | 'default' | 'actor'> & {
+    func: PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default'>;
+};
+type PikkuSubjectScenarioStepConfig<In, Out> = Omit<PikkuScenarioStepConfig<In, Out>, 'browser' | 'cli' | 'default' | 'actor'> & {
+    func: PikkuFunctionScenarioStep<In, Out, 'default'>;
+};
+/**
+ * A step in which the app acts on itself — "Given the platform has expired the
+ * trial".
+ *
+ * The grammatical subject of that sentence is not a user of your app; it **is**
+ * your app, which is why it is its own declaration rather than a persona with an
+ * asterisk. A persona is a person.
+ *
+ * Local-test-only, and never in a virtual user's catalogue: a virtual user that
+ * could expire its own trial is manufacturing the outcome it exists to discover.
+ */
+export declare function pikkuPlatformScenarioStep<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuSubjectScenarioStepConfigWithSchema<InputSchema, OutputSchema>): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default'>, InputSchema, OutputSchema>;
+export declare function pikkuPlatformScenarioStep<In, Out = unknown>(config: PikkuSubjectScenarioStepConfig<In, Out>): PikkuFunctionConfig<In, Out, 'scenarioStep'>;
+/**
+ * A step in which a third-party system acts — "Given Stripe's webhook arrives",
+ * "When Mailgun bounces it".
+ *
+ * `addon` names the addon that wraps that service, the same name its
+ * `wireAddon` declares. These steps *are* the mock its consumers currently
+ * hand-write: shipped by the addon author, maintained with the addon, and the
+ * same artifact that appears in the prose.
+ *
+ * Note that arranging and asserting are different — "Stripe's webhook arrives"
+ * stubs, "Then Stripe was charged" asserts, and only the first is a stub.
+ *
+ * Local-test-only, and never in a virtual user's catalogue: one that could
+ * invoke this would forge its own payment success.
+ */
+export declare function pikkuAddonScenarioStep<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuSubjectScenarioStepConfigWithSchema<InputSchema, OutputSchema> & {
+    addon: string;
+}): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default'>, InputSchema, OutputSchema>;
+export declare function pikkuAddonScenarioStep<In, Out = unknown>(config: PikkuSubjectScenarioStepConfig<In, Out> & {
+    addon: string;
+}): PikkuFunctionConfig<In, Out, 'scenarioStep'>;

package/dist/.pikku/scenarios/pikku-scenario-types.gen.js

@@ -0,0 +1,71 @@
+/**
+ * The scenario test surface, re-exported so a step file has one specifier to
+ * import from. These names are not generated — they come straight from core —
+ * but routing them through here means a scenario file never has to know
+ * whether the helper it wants is typed against this project or shipped by the
+ * framework.
+ */
+export { createCookieJar, createScenarioRunner, pollUntil, requireScenarioEnv, } from '@pikku/core/scenario';
+export { postScenarioJson, readScenarioHttpResponse } from '@pikku/core/persona';
+/**
+ * Declares a scenario hook. Returns the function verbatim — a hook is never
+ * registered, so this exists purely to give an inline hook a call site to be
+ * contextually typed from, the way every other pikku primitive is.
+ */
+export function pikkuScenarioHook(hook) {
+    return hook;
+}
+export function pikkuScenario(func) {
+    return typeof func === 'function' ? { func } : func;
+}
+/**
+ * A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔
+ * Scenario structure. Scenarios are referenced by imported identifier, so a
+ * renamed or deleted scenario is a compile error rather than a silent skip.
+ *
+ * A scenario does not have to belong to a feature — a void-input scenario
+ * still runs standalone.
+ *
+ * ```ts
+ * export const credentialFeature = pikkuFeature({
+ *   name: 'Credential API',
+ *   tags: ['credential'],
+ *   before: startsMockOAuthServer,
+ *   after: stopsMockOAuthServer,
+ *   scenarios: [
+ *     credentialLazyLoadScenario,
+ *     ...['stripe', 'google'].map((name) => ({
+ *       scenario: credentialRoundTripScenario,
+ *       data: { name },
+ *     })),
+ *   ],
+ * })
+ * ```
+ */
+export function pikkuFeature(config) {
+    return config;
+}
+export function pikkuScenarioStep(config) {
+    const surfaces = ['browser', 'cli', 'default'].filter((surface) => typeof config[surface] === 'function');
+    if (surfaces.length === 0) {
+        throw new Error(`[scenario] step '${config.name}' declares no surface bindings. Add at least a \`default\` (server-side) implementation.`);
+    }
+    return {
+        ...config,
+        surfaces,
+        requiresActor: config.actor === true || surfaces.includes('browser'),
+        // The runner sets the surface on the wire and calls this once per binding it
+        // resolved — every witness of a `then`, exactly one for an action step.
+        func: (services, data, wire) => {
+            const surface = wire?.scenarioStep?.surface ?? 'default';
+            const binding = config[surface] ?? config.default;
+            return binding(services, data, wire);
+        },
+    };
+}
+export function pikkuPlatformScenarioStep(config) {
+    return { ...config, surfaces: ['default'] };
+}
+export function pikkuAddonScenarioStep(config) {
+    return { ...config, surfaces: ['default'] };
+}

package/dist/.pikku/scenarios/pikku-scenario-wirings-meta.gen.js

@@ -1,7 +1,7 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
-import { pikkuState } from '@pikku/core/ecosystem';
+import { pikkuState } from '@pikku/core/state';
 import '../workflow/pikku-workflow-wirings-meta.gen.js';
 const scenariosMeta = {};
 pikkuState(null, 'workflows', 'meta', {

package/dist/.pikku/scenarios/pikku-scenario-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 export {};

package/dist/.pikku/scenarios/schemas/register.gen.d.ts

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 export declare const empty: null;

package/dist/.pikku/scenarios/schemas/register.gen.js

@@ -1,4 +1,4 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 export const empty = null;

package/dist/.pikku/scheduler/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Subpath entry — `#pikku/scheduler` resolves here.
+ */
+export * from './pikku-scheduler-types.gen.js';