@pikku/cli 0.12.99 → 0.12.102

package/dist/src/functions/commands/scenario-browser.d.ts

@@ -16,6 +16,7 @@ export interface ScenarioBrowserDriverOptions {
     actors: Record<string, ResolvedPersona>;
     signInPath?: string;
     failureDir?: string;
+    capture?: ScenarioCaptureOptions;
     config: unknown;
 }
 /**
@@ -43,6 +44,21 @@ export interface ScenarioBrowserDriver {
         apiUrl: string;
     }) => unknown;
 }
+/**
+ * Artifacts a run may produce. Mirrors the driver's own CaptureOptions rather
+ * than importing it: the CLI must not depend on a driver package it resolves
+ * dynamically, and this shape is the contract between them.
+ */
+export interface ScenarioCaptureOptions {
+    /** Root directory for the run's artifacts. */
+    dir: string;
+    /** The invocation these artifacts belong to. */
+    runId: string;
+    /** Record a video per scenario. */
+    video?: boolean;
+    /** Re-encode with ffmpeg when available. Defaults on — the footage is nearly static. */
+    compress?: boolean;
+}
 export interface ResolveScenarioBrowserProviderOptions {
     /** The environment name, for error messages that tell the user what to edit. */
     environment: string;
@@ -53,6 +69,12 @@ export interface ResolveScenarioBrowserProviderOptions {
     signInPath?: string;
     /** Where failure screenshots are written. */
     failureDir: string;
+    /**
+     * Artifacts for this run — named screenshots, and optionally a video per
+     * scenario. Undefined leaves capture off, which is the default: most runs
+     * ask a pass/fail question and writing video to answer it is waste.
+     */
+    capture?: ScenarioCaptureOptions;
     /** The scenarios that declared browser steps, named in the missing-driver error. */
     browserScenarios: string[];
     /** Package to drive the browser. Defaults to `@pikku/playwright`. */
@@ -71,13 +93,14 @@ export interface ResolveScenarioBrowserProviderOptions {
  * because a run against a placeholder URL is worse than one that refuses to
  * start.
  */
-export declare const resolveScenarioBrowserProvider: ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, browserScenarios, driver, importDriver, }: ResolveScenarioBrowserProviderOptions) => Promise<ScenarioBrowserProvider>;
+export declare const resolveScenarioBrowserProvider: ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, capture, browserScenarios, driver, importDriver, }: ResolveScenarioBrowserProviderOptions) => Promise<ScenarioBrowserProvider>;
 /**
  * The three calls the run loop makes, safe against a run with no browser and
  * against a driver that implements neither optional member.
  */
 export interface ScenarioBrowserLifecycle {
     reset(): Promise<void>;
+    beginScenario(scenario: string): void;
     captureFailure(label: string): Promise<ScenarioBrowserFailure[]>;
     close(): Promise<void>;
 }

package/dist/src/functions/commands/scenario-browser.js

@@ -12,7 +12,7 @@ export const DEFAULT_BROWSER_DRIVER = '@pikku/playwright';
  * because a run against a placeholder URL is worse than one that refuses to
  * start.
  */
-export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, browserScenarios, driver = DEFAULT_BROWSER_DRIVER, importDriver = (specifier) => import(specifier), }) => {
+export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appUrl, secret, actors, signInPath, failureDir, capture, browserScenarios, driver = DEFAULT_BROWSER_DRIVER, importDriver = (specifier) => import(specifier), }) => {
     const module = await importDriver(driver).catch(() => {
         const install = driver === DEFAULT_BROWSER_DRIVER
             ? `Run 'yarn add -D ${driver} @playwright/test'`
@@ -33,6 +33,7 @@ export const resolveScenarioBrowserProvider = async ({ environment, apiUrl, appU
         actors,
         signInPath,
         failureDir,
+        capture,
         config,
     };
     if (module.createScenarioBrowserProvider) {
@@ -52,6 +53,9 @@ export const scenarioBrowserLifecycle = (provider) => ({
     reset: async () => {
         await provider?.reset?.();
     },
+    beginScenario: (scenario) => {
+        provider?.beginScenario?.(scenario);
+    },
     captureFailure: async (label) => {
         try {
             return (await provider?.captureFailure?.(label)) ?? [];

package/dist/src/functions/commands/scenario.d.ts

@@ -1,5 +1,5 @@
 import type { ScenarioSurface } from '@pikku/core/workflow';
-export declare const scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
@@ -13,6 +13,8 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
+    screenshots?: boolean;
+    video?: boolean;
     apiUrl?: string;
     appUrl?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
@@ -28,9 +30,11 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
+    screenshots?: boolean;
+    video?: boolean;
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     environment: string;
     flows?: string;
     features?: string;
@@ -43,6 +47,8 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     spawn?: boolean;
     keepAlive?: boolean;
     trace?: boolean;
+    screenshots?: boolean;
+    video?: boolean;
     apiUrl?: string;
     appUrl?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scenario.js

@@ -1,10 +1,11 @@
+import { randomUUID } from 'node:crypto';
 import { resolve, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
 import { InMemoryWorkflowService } from '@pikku/core/services';
 import { createHttpPersonas } from '@pikku/core/persona';
 import { PikkuScenarioService } from '@pikku/core/scenario';
-import { pikkuState, getAllPackageStates } from '@pikku/core/internal';
+import { pikkuState, getAllPackageStates } from '@pikku/core/ecosystem';
 import { resolveFeatureScenarios } from '@pikku/core/workflow';
 import { loadScenarioBootstrap } from './load-user-project.js';
 import { collectScenarioStepProse, scenarioBrowserSteps, scenarioFailureFromSteps, scenarioStepRows, scenarioStepsWithoutBinding, scenarioSurfaceCoverage, } from './scenario-ladder.js';
@@ -87,7 +88,7 @@ export const scenarioList = pikkuSessionlessFunc({
     },
 });
 export const scenarioRun = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, browser = true, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, apiUrl, appUrl, }) => {
+    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, browser = true, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, screenshots = false, video = false, apiUrl, appUrl, }) => {
         if (!SCENARIO_SURFACES.includes(runSurface)) {
             throw new Error(`Unknown --run surface '${runSurface}'. Expected one of: ${SCENARIO_SURFACES.join(', ')}.`);
         }
@@ -254,11 +255,29 @@ export const scenarioRun = pikkuSessionlessFunc({
             workflowRunService: workflowService,
             ...(aiAgentRunner ? { aiAgentRunner } : {}),
         });
+        const refuseInternal = (rpcName) => {
+            throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
+                `in a scenario must carry { actor: actors.x } so it executes against ` +
+                `'${environment}' (${env.apiUrl}), not local services.`);
+        };
+        // `rpcWithWire` is named alongside `PikkuRPC` rather than left to it: the
+        // workflow runner reaches for that member through an internally untyped
+        // path, so it is the one the guard actually has to answer, and the type
+        // that declares it publicly arrives later in this stack.
         const guardRpc = {
-            rpcWithWire: async (rpcName) => {
-                throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
-                    `in a scenario must carry { actor: actors.x } so it executes against ` +
-                    `'${environment}' (${env.apiUrl}), not local services.`);
+            depth: 0,
+            global: false,
+            invoke: async (rpcName) => refuseInternal(rpcName),
+            remote: async (rpcName) => refuseInternal(rpcName),
+            exposed: async (rpcName) => refuseInternal(rpcName),
+            rpcWithWire: async (rpcName) => refuseInternal(rpcName),
+            startWorkflow: async (name) => refuseInternal(name),
+            agent: {
+                run: async (name) => refuseInternal(name),
+                stream: async (name) => refuseInternal(name),
+                resume: async (runId) => refuseInternal(runId),
+                approve: async (runId) => refuseInternal(runId),
+                interrupt: async (runId) => refuseInternal(runId),
             },
         };
         // Only a browser run launches one. Under `--run default` a step with a
@@ -267,6 +286,17 @@ export const scenarioRun = pikkuSessionlessFunc({
         const needsBrowser = effectiveSurface === 'browser' &&
             groups.some((group) => group.entries.some((entry) => browserStepsByFlow.has(entry.scenarioName)));
         const failureDir = join(resolve(config.rootDir, config.outDir), 'scenario-failures');
+        // Artifacts are filed under the run, not the scenario, so one run's output
+        // is one folder to open, keep or delete. `--video` implies capture is on:
+        // recording without somewhere to put it is not a thing anyone wants.
+        const captureDir = join(resolve(config.rootDir, config.outDir), 'scenario-runs');
+        // One id for the whole invocation, distinct from a scenario's own runId:
+        // reviewing artifacts means opening what `pikku scenario run` just produced,
+        // not hunting for one scenario's folder among many.
+        const captureRunId = randomUUID();
+        const capture = screenshots || video
+            ? { dir: captureDir, runId: captureRunId, video, compress: true }
+            : undefined;
         const browserLifecycle = scenarioBrowserLifecycle(needsBrowser
             ? await (async () => {
                 const provider = await resolveScenarioBrowserProvider({
@@ -277,6 +307,7 @@ export const scenarioRun = pikkuSessionlessFunc({
                     actors: scenarioActors,
                     signInPath: env.signInPath,
                     failureDir,
+                    capture,
                     browserScenarios: [...browserStepsByFlow.keys()],
                     driver: config.scenarios?.browserDriver,
                 });
@@ -334,10 +365,17 @@ export const scenarioRun = pikkuSessionlessFunc({
          * grouping, not something durable. It gets the same three arguments a
          * scenario body gets, the CLI's own singletons included, and its result is
          * discarded.
+         *
+         * Its context is *feature*-scoped — shared by that feature's `before` and
+         * `after`, and deliberately not the context the group's scenarios see:
+         * one bag across a group is the invisible coupling a Cucumber world had.
          */
         const singletonServices = pikkuState(null, 'package', 'singletonServices');
-        const runFeatureHook = async (hook) => {
-            await hook(singletonServices, undefined, { actors });
+        const runFeatureHook = async (hook, context) => {
+            await hook(singletonServices, undefined, {
+                actors,
+                scenario: { context },
+            });
         };
         const hookFailures = [];
         const runEntry = async (label, scenarioName, data) => {
@@ -345,6 +383,9 @@ export const scenarioRun = pikkuSessionlessFunc({
             // Before the scenario, not after it: the last scenario's window is left
             // open for headed debugging, while this one still starts clean.
             await browserLifecycle.reset();
+            // After the reset, which is what closes the previous scenario's context
+            // and finalises its video.
+            browserLifecycle.beginScenario(label);
             if (coverageActive) {
                 const reset = await invokeCoverage('pikkuScenarioResetLiveCoverage');
                 if (reset && reset.enabled === false) {
@@ -428,10 +469,11 @@ export const scenarioRun = pikkuSessionlessFunc({
                     ? `${groupName} › ${entry.scenarioName}${data}`
                     : entry.scenarioName;
             };
+            const featureContext = {};
             let beforeError;
             if (group.before) {
                 try {
-                    await runFeatureHook(group.before);
+                    await runFeatureHook(group.before, featureContext);
                 }
                 catch (e) {
                     beforeError = e;
@@ -459,7 +501,7 @@ export const scenarioRun = pikkuSessionlessFunc({
             finally {
                 if (group.after) {
                     try {
-                        await runFeatureHook(group.after);
+                        await runFeatureHook(group.after, featureContext);
                     }
                     catch (e) {
                         hookFailures.push(`feature '${groupName}' after hook failed: ${e?.message ?? e}`);
@@ -468,6 +510,12 @@ export const scenarioRun = pikkuSessionlessFunc({
             }
         }
         await browserLifecycle.close();
+        // Reported after the browser has closed, because video is only finalised
+        // when its context is. A capture nobody can find is a capture nobody
+        // looks at, and looking at them is the entire point of the flags.
+        if (capture) {
+            logger.info(`Captures → ${join(capture.dir, capture.runId)}`);
+        }
         if (coverage && Object.keys(scenarioCoverage).length > 0) {
             const coverageDir = join(resolve(config.rootDir, config.outDir), 'coverage');
             mkdirSync(coverageDir, { recursive: true });

package/dist/src/functions/commands/scopes-audit.d.ts

@@ -1 +1 @@
-export declare const scopesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scopesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scopes-prune.d.ts

@@ -9,6 +9,6 @@ export declare const scopesPrune: import("#pikku").PikkuFunctionConfig<{
     yes?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     yes?: boolean;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/serve.d.ts

@@ -1,10 +1,13 @@
 export declare const serve: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     console?: boolean;
+    model?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     console?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+    model?: string;
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     port?: string;
     console?: boolean;
+    model?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/serve.js

@@ -3,20 +3,25 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, QueueWebhookService, } from '@pikku/core/services';
 import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
-import { pikkuState } from '@pikku/core/internal';
+import { pikkuState } from '@pikku/core/ecosystem';
+import { wireAIScorerQueueWorkers } from '@pikku/core/ai-scorer';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
 import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+import { registerScenarioInstrumentation } from '../wirings/scenarios/register-scenario-instrumentation.js';
+import { resolveScaffoldFeature } from '../../utils/resolve-scaffold-feature.js';
 import { createDevAIAgentRunner } from './dev-ai-runner.js';
 import { resolveConsoleMount } from './serve-console.js';
 import { serverReadyLine } from '../../server/server-ready.js';
 import { createEphemeralContentSigningJWT } from '../../server/content-signing-jwt.js';
+import { applyModelAliasOverride } from '../../utils/model-alias-override.js';
 export const serve = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, console: serveConsole }) => {
+    func: async ({ logger, config, getInspectorState, variables, devServerRunner }, { port, console: serveConsole, model }) => {
         process.env.PIKKU_DEV_QUICK_LOGIN ??= 'true';
+        applyModelAliasOverride(logger, model, config.models);
         const resolvedPort = parseInt(port || '3000', 10);
         const hostname = 'localhost';
         const bindHostname = '127.0.0.1';
@@ -28,6 +33,14 @@ export const serve = pikkuSessionlessFunc({
             return;
         }
         await loadUserBootstrap(pikkuDir);
+        // Scenario instrumentation exists only on a locally served project: the
+        // runner calls it over RPC to reset and snapshot coverage and stub calls.
+        // It is registered here, after the app bootstrap, rather than generated
+        // into the project — an app bootstrap is what a deployed bundle imports,
+        // and coverage endpoints have no business in one.
+        if (config.scaffold?.scenarios) {
+            registerScenarioInstrumentation(resolveScaffoldFeature('scenarios', config.scaffold.scenarios).auth);
+        }
         const workflowService = new InMemoryWorkflowService();
         const configModule = await loadUserModule(pikkuConfigFactory.file);
         const servicesModule = await loadUserModule(singletonServicesFactory.file);
@@ -115,6 +128,7 @@ export const serve = pikkuSessionlessFunc({
         };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
+        wireAIScorerQueueWorkers();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
         const loadLifecycle = async () => {
             if (!serverLifecycleFactory)

package/dist/src/functions/commands/skills.d.ts

@@ -2,7 +2,7 @@ export declare const pikkuSkillsList: import("#pikku").PikkuFunctionConfig<{
     target?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     target?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     target?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuSkillsInstall: import("#pikku").PikkuFunctionConfig<{
@@ -17,7 +17,7 @@ export declare const pikkuSkillsInstall: import("#pikku").PikkuFunctionConfig<{
     core?: boolean;
     fabric?: boolean;
     update?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     agent?: string;
     only?: string;
     core?: boolean;

package/dist/src/functions/commands/{workspace-validate.d.ts → validate.d.ts}

@@ -1,7 +1,12 @@
-import { renderWorkspaceValidate } from '../validate/workspace-validate.js';
-export declare const workspaceValidate: import("#pikku").PikkuFunctionConfig<Record<string, never>, {
+import { renderValidate } from '../validate/validate.js';
+export declare const validate: import("#pikku").PikkuFunctionConfig<Record<string, never>, {
     ok: boolean;
     root: string;
+    ran: {
+        checkId: string;
+        subject: string;
+        target: string;
+    }[];
     findings: {
         id: string;
         severity: "warn" | "error" | "info";
@@ -12,6 +17,11 @@ export declare const workspaceValidate: import("#pikku").PikkuFunctionConfig<Rec
 }, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<Record<string, never>, {
     ok: boolean;
     root: string;
+    ran: {
+        checkId: string;
+        subject: string;
+        target: string;
+    }[];
     findings: {
         id: string;
         severity: "warn" | "error" | "info";
@@ -19,9 +29,14 @@ export declare const workspaceValidate: import("#pikku").PikkuFunctionConfig<Rec
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<Record<string, never>, {
+}, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<Record<string, never>, {
     ok: boolean;
     root: string;
+    ran: {
+        checkId: string;
+        subject: string;
+        target: string;
+    }[];
     findings: {
         id: string;
         severity: "warn" | "error" | "info";
@@ -30,4 +45,4 @@ export declare const workspaceValidate: import("#pikku").PikkuFunctionConfig<Rec
         fixHint: string;
     }[];
 }, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export { renderWorkspaceValidate };
+export { renderValidate };

package/dist/src/functions/commands/validate.js

@@ -0,0 +1,9 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { ValidateInput, ValidateOutput, renderValidate, runProjectValidate, } from '../validate/validate.js';
+export const validate = pikkuSessionlessFunc({
+    description: 'Check this project against every Pikku check that applies to it — app structure, and the published file set of any addon it contains. Prints what was checked, with fix hints for anything wrong.',
+    input: ValidateInput,
+    output: ValidateOutput,
+    func: async () => runProjectValidate(),
+});
+export { renderValidate };

package/dist/src/functions/commands/versions-check.d.ts

@@ -1 +1 @@
-export declare const pikkuVersionsCheck: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVersionsCheck: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-init.d.ts

@@ -2,6 +2,6 @@ export declare const pikkuVersionsInit: import("#pikku").PikkuFunctionConfig<{
     force?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     force?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     force?: boolean;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-update.d.ts

@@ -1 +1 @@
-export declare const pikkuVersionsUpdate: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVersionsUpdate: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/watch.d.ts

@@ -2,6 +2,6 @@ export declare const watch: import("#pikku").PikkuFunctionConfig<{
     hmr?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     hmr?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     hmr?: boolean;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/db/local-db.d.ts

@@ -40,7 +40,7 @@ export interface ResolvedPostgresDb extends ResolvedDbBase {
     devSeedFile: string;
     /**
      * Postgres extensions the embedded PGlite databases must load, as declared by
-     * `pgliteExtensions` in the project's config. See
+     * `db.pgliteExtensions` in the project's pikku.config.json. See
      * {@link loadPGliteExtensions}.
      *
      * Carried even in `url` mode: the shadow database the CLI migrates and
@@ -72,6 +72,7 @@ export declare function parseDatabaseUrl(url: string): Pick<UserConfigShape, 'sq
 export declare function resolveDb(userConfig: UserConfigShape, rootDir: string, outDir: string, runtimeDir?: string, dbConfig?: {
     schema?: string;
     defaultSchema?: string;
+    pgliteExtensions?: string[];
 } | string): ResolvedDb | null;
 /** @deprecated Use resolveDb(userConfig, ...) instead. */
 export declare function resolveLocalDb(sqliteDb: string | undefined, rootDir: string, outDir: string, runtimeDir?: string): ResolvedSqliteDb | null;

package/dist/src/functions/db/local-db.js

@@ -68,7 +68,7 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir, dbConfig) {
     if (userConfig.postgresUrl && userConfig.sqliteDb) {
         throw new Error('Both postgresUrl and sqliteDb are set. Configure exactly one database dialect.');
     }
-    const pgliteExtensions = userConfig.pgliteExtensions ?? [];
+    const pgliteExtensions = (typeof dbConfig === 'string' ? undefined : dbConfig?.pgliteExtensions) ?? [];
     if (userConfig.postgresUrl) {
         return {
             dialect: 'postgres',
@@ -268,7 +268,7 @@ function explainMissingExtension(error, declared) {
     return new Error(`The embedded PGlite database has no '${name}' extension. ` +
         `The CLI migrates a PGlite shadow database to type and diff your schema, ` +
         `so every extension your migrations use has to be declared as ` +
-        `pgliteExtensions in createConfig — e.g. pgliteExtensions: ['${name}'] ` +
+        `db.pgliteExtensions in pikku.config.json — e.g. "db": { "pgliteExtensions": ["${name}"] } ` +
         `for a PGlite contrib extension, or the package that publishes it ` +
         `('@electric-sql/pglite-pgvector' for pgvector).` +
         (declared.length > 0

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -1 +1 @@
-export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -1 +1 @@
-export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/runtimes/tanstack-start/pikku-command-tanstack-start.d.ts

@@ -1 +1 @@
-export declare const pikkuTanStackStart: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuTanStackStart: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/runtimes/websocket/pikku-command-websocket-typed.d.ts

@@ -1 +1 @@
-export declare const pikkuWebSocketTyped: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuWebSocketTyped: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/validate/addon-package-checks.d.ts

@@ -0,0 +1,26 @@
+import type { ValidateFinding as Finding } from './persona-checks.js';
+/**
+ * A package that publishes generated pikku output.
+ *
+ * The generated files carry relative imports to hand-written sources, so what
+ * the package ships and what it references have to agree — which is what the
+ * checks below are for.
+ *
+ * Having a `.pikku` directory is not enough on its own: an app's
+ * packages/functions has one too, and it is codegen output for that app rather
+ * than something anybody installs. The question is whether the package *ships*
+ * it, so the signal is a `files`/`exports` that carries it into the tarball.
+ * A private package is excluded for the same reason — nobody installs it, so
+ * its published file set is not a thing that can be wrong.
+ */
+export declare function isAddonPackage(pkgDir: string): Promise<boolean>;
+/**
+ * Every relative import in a shipped generated file must resolve to a file
+ * that is itself shipped.
+ *
+ * Stated as a property rather than as "the build script must copy types/",
+ * because the build script is not the only way to get this wrong and will not
+ * always be a `cp`. The generated files declare what they need; the check just
+ * holds the package to it.
+ */
+export declare function runAddonPackageChecks(pkgDir: string): Promise<Finding[]>;