@pikku/cli 0.12.105 → 0.12.109

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

@@ -1,6 +1,6 @@
 import type { ScenarioSurface } from '@pikku/core/scenario';
-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<{
+export declare const scenarioList: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const scenarioRun: import("#pikku/function").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
     features?: string;
@@ -13,10 +13,10 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     environment: string;
     flows?: string;
     features?: string;
@@ -29,10 +29,10 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     environment: string;
     flows?: string;
     features?: string;
@@ -45,7 +45,7 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     keepAlive?: boolean;
     trace?: boolean;
     screenshots?: boolean;
-    video?: boolean;
+    video?: "off" | "failed" | "all";
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,15 +1,14 @@
 import { randomUUID } from 'node:crypto';
 import { resolve, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { InMemoryWorkflowService } from '@pikku/core/services';
-import { createHttpPersonas } from '@pikku/core/ecosystem/persona';
-import { PikkuScenarioService } from '@pikku/core/ecosystem/scenario';
-import { pikkuState, getAllPackageStates } from '@pikku/core/ecosystem';
-import { resolveFeatureScenarios } from '@pikku/core/ecosystem/scenario';
+import { FileScenarioRunStore } from '@pikku/core/services';
+import { createHttpPersonas } from '@pikku/core/persona';
+import { PikkuScenarioService, resolveFeatureScenarios, SCENARIO_SURFACES, } from '@pikku/core/scenario';
+import { pikkuState, getAllPackageStates } from '@pikku/core/state';
 import { loadScenarioBootstrap } from './load-user-project.js';
 import { collectScenarioStepProse, scenarioBrowserSteps, scenarioFailureFromSteps, scenarioStepRows, scenarioStepsWithoutBinding, scenarioSurfaceCoverage, } from './scenario-ladder.js';
-import { SCENARIO_SURFACES } from '@pikku/core/ecosystem/scenario';
 import { formatScenarioReport } from './scenario-formatter.js';
 import { resolveScenarioBrowserProvider, scenarioBrowserLifecycle, } from './scenario-browser.js';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
@@ -88,7 +87,7 @@ export const scenarioList = pikkuSessionlessFunc({
     },
 });
 export const scenarioRun = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, screenshots = false, video = false, apiUrl, appUrl, }) => {
+    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, screenshots = false, video = 'failed', apiUrl, appUrl, }) => {
         if (!SCENARIO_SURFACES.includes(runSurface)) {
             throw new Error(`Unknown --run surface '${runSurface}'. Expected one of: ${SCENARIO_SURFACES.join(', ')}.`);
         }
@@ -280,28 +279,30 @@ export const scenarioRun = pikkuSessionlessFunc({
         // drive and nothing to pay for.
         const needsBrowser = runSurface === '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.
+        // is one folder to open, keep or delete.
         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 capture = {
+            dir: captureDir,
+            runId: captureRunId,
+            screenshots,
+            video,
+            compress: true,
+        };
         const browserLifecycle = scenarioBrowserLifecycle(needsBrowser
             ? await (async () => {
                 const provider = await resolveScenarioBrowserProvider({
                     environment,
                     apiUrl: env.apiUrl,
                     appUrl: env.appUrl,
+                    appUrls: env.appUrls,
                     secret,
                     actors: scenarioActors,
                     signInPath: env.signInPath,
-                    failureDir,
                     capture,
                     browserScenarios: [...browserStepsByFlow.keys()],
                     driver: config.scenarios?.browserDriver,
@@ -311,6 +312,21 @@ export const scenarioRun = pikkuSessionlessFunc({
             })()
             : undefined);
         const results = [];
+        // Opened before the first scenario and written to as each one finishes, so
+        // a suite that dies on its fortieth still leaves the thirty-nine behind —
+        // and the console can show a run while it is still going.
+        const runStore = new FileScenarioRunStore({ dir: captureDir });
+        const startedAtIso = new Date().toISOString();
+        await runStore.start({
+            runId: captureRunId,
+            environment,
+            surface: runSurface,
+            status: 'running',
+            startedAt: startedAtIso,
+            results: [],
+            skipped,
+            hookFailures: [],
+        });
         /**
          * The step ladder is read back off the recorded run, so it needs no live
          * step events — it is the same data the console renders. Joining it to the
@@ -373,7 +389,22 @@ export const scenarioRun = pikkuSessionlessFunc({
             });
         };
         const hookFailures = [];
-        const runEntry = async (label, scenarioName, data) => {
+        /**
+         * What a result carries beyond its own outcome: which registration ran,
+         * which feature grouped it, and the tags it was selected by. Snapshotted
+         * into the record because a run read back next week is describing a suite
+         * whose source has moved on.
+         */
+        const identify = (result, scenarioName, feature) => {
+            const tags = state.workflows?.meta?.[scenarioName]?.tags;
+            return {
+                ...result,
+                scenarioName,
+                ...(feature ? { feature } : {}),
+                ...(tags?.length ? { tags } : {}),
+            };
+        };
+        const runEntry = async (label, scenarioName, data, feature) => {
             const startedAt = Date.now();
             // Before the scenario, not after it: the last scenario's window is left
             // open for headed debugging, while this one still starts clean.
@@ -447,6 +478,11 @@ export const scenarioRun = pikkuSessionlessFunc({
                     browser: await browserLifecycle.captureFailure(label),
                 };
             }
+            // Told here, acted on at the next scenario's reset — that is what closes
+            // these windows and finalises the video this outcome decides the fate of.
+            browserLifecycle.endScenario(result.status);
+            Object.assign(result, identify(result, scenarioName, feature));
+            await runStore.recordScenario(captureRunId, result);
             if (coverageActive) {
                 const report = await invokeCoverage('pikkuScenarioTakeLiveCoverage');
                 if (report) {
@@ -479,17 +515,19 @@ export const scenarioRun = pikkuSessionlessFunc({
                     // Setup failed, so nothing in the group ran. Reporting them as failed
                     // rather than skipped is the honest reading: they did not pass.
                     for (const entry of group.entries) {
-                        results.push({
+                        const result = identify({
                             name: label(entry),
                             status: 'failed',
                             durationMs: 0,
                             error: `feature '${groupName}' before hook failed: ${beforeError?.message ?? beforeError}`,
-                        });
+                        }, entry.scenarioName, groupName);
+                        results.push(result);
+                        await runStore.recordScenario(captureRunId, result);
                     }
                 }
                 else {
                     for (const entry of group.entries) {
-                        await runEntry(label(entry), entry.scenarioName, entry.data);
+                        await runEntry(label(entry), entry.scenarioName, entry.data, groupName);
                     }
                 }
             }
@@ -505,10 +543,23 @@ 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) {
+        // Collected after the browser has closed, because a video is only finalised
+        // when its context is — and renamed again by the encode that close() runs.
+        // This is the first moment the answer is complete.
+        const artifacts = browserLifecycle.artifacts();
+        await runStore.attachArtifacts(captureRunId, artifacts);
+        const failed = results.filter((r) => r.status === 'failed');
+        await runStore.finish(captureRunId, {
+            status: failed.length > 0 || hookFailures.length > 0 ? 'failed' : 'passed',
+            finishedAt: new Date().toISOString(),
+            skipped,
+            hookFailures,
+        });
+        // A capture nobody can find is a capture nobody looks at, and looking at
+        // them is the entire point of the flags. Announced only when the run
+        // actually filed something: every run leaves a record behind, and most of
+        // them have no images or footage to go with it.
+        if (artifacts.length > 0) {
             logger.info(`Captures → ${join(capture.dir, capture.runId)}`);
         }
         if (coverage && Object.keys(scenarioCoverage).length > 0) {
@@ -559,7 +610,6 @@ export const scenarioRun = pikkuSessionlessFunc({
             logger.error(`${unrunnable.length} scenario(s) could not run on '${runSurface}' — no binding for that surface and no default to fall back to. ` +
                 `Run them on the surface they are written for (--run browser), or hold them back explicitly with --exclude-tags.`);
         }
-        const failed = results.filter((r) => r.status === 'failed');
         if (failed.length > 0 ||
             hookFailures.length > 0 ||
             unrunnable.length > 0 ||

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, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scopesAudit: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scopes-audit.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredScopes, openScopeService, reportStaleScopes, } from './scopes-shared.js';
 export const scopesAudit = pikkuSessionlessFunc({
     remote: true,

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

@@ -5,10 +5,10 @@
  * This revokes access, so it never runs implicitly — not at boot, not as part
  * of `pikku all`. Without `--yes` it only reports the blast radius.
  */
-export declare const scopesPrune: import("#pikku").PikkuFunctionConfig<{
+export declare const scopesPrune: import("#pikku/function").PikkuFunctionConfig<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scopes-prune.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredScopes, openScopeService, reportStaleScopes, } from './scopes-shared.js';
 /**
  * Removes scopes that are no longer declared in code, cascading them out of

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

@@ -1,5 +1,5 @@
 import type { Kysely } from 'kysely';
-import type { FlatScope } from '@pikku/core/ecosystem/scope';
+import type { FlatScope } from '@pikku/core/scope';
 import { KyselyScopeService } from '@pikku/kysely';
 import type { KyselyPikkuDB } from '@pikku/kysely';
 type Logger = {

package/dist/src/functions/commands/scopes-shared.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { flattenScopeDefinitions } from '@pikku/core/ecosystem/scope';
+import { flattenScopeDefinitions } from '@pikku/core/scope';
 import { KyselyScopeService } from '@pikku/kysely';
 import { createKysely, resolveDb } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';

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

@@ -22,4 +22,4 @@ export type SemverResult = {
     mode: 'compare';
     written: string;
 } & SurfaceChanges);
-export declare const pikkuSemver: import("#pikku").PikkuFunctionConfig<SemverInput, SemverResult, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<SemverInput, SemverResult, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<SemverInput, SemverResult, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuSemver: import("#pikku/function").PikkuFunctionConfig<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,6 +1,6 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadManifest } from '../../utils/contract-versions.js';
 import { loadSurface, readSurface } from '../../utils/surface.js';
 import { computeSurfaceDiff, } from '../../utils/surface-diff.js';

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

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

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

@@ -1,18 +1,19 @@
 import { join, resolve } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
-import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, QueueWebhookService, } from '@pikku/core/services';
-import { InMemoryAgentRunStateService } from '@pikku/core/ecosystem/services';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { InMemoryQueueService, QueueWebhookService } from '@pikku/core/services';
+import { ConsoleLogger, LocalEmailService, InMemoryAgentRunStateService, } from '@pikku/core/services';
+import { InMemoryTriggerService } from '@pikku/core/services';
+import { InMemoryWorkflowService } from '@pikku/core/services';
 import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
-import { stopSingletonServices } from '@pikku/core';
-import { pikkuState } from '@pikku/core/ecosystem';
-import { wireAgentScorerQueueWorkers } from '@pikku/core/ecosystem/agent-scorer';
+import { stopSingletonServices } from '@pikku/core/utils';
+import { pikkuState } from '@pikku/core/state';
+import { wireAgentScorerQueueWorkers } from '@pikku/core/agent-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 { createDevAgentRunner } from './dev-agent-runner.js';
 import { resolveConsoleMount } from './serve-console.js';
 import { serverReadyLine } from '../../server/server-ready.js';
@@ -40,7 +41,7 @@ export const serve = pikkuSessionlessFunc({
         // 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);
+            registerScenarioInstrumentation();
         }
         const workflowService = new InMemoryWorkflowService();
         const configModule = await loadUserModule(pikkuConfigFactory.file);

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

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

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

@@ -2,7 +2,7 @@ import { readdir, mkdir, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { dirname, join, sep } from 'path';
 import { listSkillFiles, listSkillNames, readSkillFile } from '@pikku/skills';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 /**
  * Write one skill's files out to `dest`, reading through @pikku/skills rather
  * than off a directory we resolved ourselves. That package reads from its own

package/dist/src/functions/commands/start-coverage.d.ts

@@ -1,4 +1,4 @@
-import type { CoverageService } from '@pikku/core/ecosystem/services';
+import type { CoverageService } from '@pikku/core/services';
 interface CoverageLogger {
     info(message: string): void;
     warn(message: string): void;

package/dist/src/functions/commands/start-coverage.js

@@ -1,5 +1,5 @@
-import { V8CoverageService } from '@pikku/core/ecosystem/services/v8-coverage';
-import { IstanbulCoverageService } from '@pikku/core/ecosystem/services/istanbul-coverage';
+import { V8CoverageService } from '@pikku/core/services/v8-coverage';
+import { IstanbulCoverageService } from '@pikku/core/services/istanbul-coverage';
 import { registerBunCoverageLoader } from './bun-coverage-loader.js';
 import { mapPreciseCoverage, mapLineHitsToReport, } from '../../utils/precise-coverage-map.js';
 const isBunRuntime = () => typeof globalThis.Bun !== 'undefined';

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

@@ -96,4 +96,4 @@ export declare const runUpdate: ({ rootDir, apply, updatePeers, install, tag, re
     registry: string;
     fetchPackument?: FetchPackument;
 }) => Promise<UpdateResult>;
-export declare const pikkuUpdate: import("#pikku").PikkuFunctionConfig<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuUpdate: import("#pikku/function").PikkuFunctionConfig<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<UpdateInput, UpdateResult, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -3,7 +3,7 @@ import { dirname, join, relative, resolve, sep } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { glob } from 'tinyglobby';
 import semver from 'semver';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 const DEPENDENCY_FIELDS = [
     'dependencies',
     'devDependencies',

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

@@ -1,5 +1,5 @@
 import { renderValidate } from '../validate/validate.js';
-export declare const validate: import("#pikku").PikkuFunctionConfig<Record<string, never>, {
+export declare const validate: import("#pikku/function").PikkuFunctionConfig<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -14,7 +14,7 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<Record<string, never>, {
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -29,7 +29,7 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<Record<string, never>, {
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<Record<string, never>, {
     ok: boolean;
     root: string;
     ran: {
@@ -44,5 +44,5 @@ export declare const validate: import("#pikku").PikkuFunctionConfig<Record<strin
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 export { renderValidate };

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 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.',

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, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVersionsCheck: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-check.js

@@ -1,5 +1,5 @@
 import { join } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { ErrorCode } from '@pikku/inspector';
 function hashArrow(prev, curr) {
     const p = (prev ?? 'unknown').slice(0, 8);

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

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

package/dist/src/functions/commands/versions-init.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 export const pikkuVersionsInit = pikkuSessionlessFunc({
     func: async ({ logger, config }, { force }) => {

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, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVersionsUpdate: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/versions-update.js

@@ -1,5 +1,5 @@
 import { join } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { ErrorCode } from '@pikku/inspector';
 import { saveManifest } from '../../utils/contract-versions.js';
 export const pikkuVersionsUpdate = pikkuSessionlessFunc({

package/dist/src/functions/commands/virtual-user-formatter.d.ts

@@ -10,7 +10,7 @@
  * reporter is: a second formatter (JSON for fabric, JUnit for CI) is then one
  * function rather than an unpicking of the runner.
  */
-import type { VirtualUserRunResult } from '@pikku/core/ecosystem/virtual-user';
+import type { VirtualUserRunResult } from '@pikku/core/virtual-user';
 export interface VirtualUserReportContext {
     persona: string;
     disposition: string;

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import chokidar from 'chokidar';
 import { pikkuDevReloader } from '@pikku/core/dev';
 export const watch = pikkuSessionlessFunc({

package/dist/src/functions/db/annotation-parser.d.ts

@@ -1,12 +1,20 @@
-import type { ColumnKind } from './coercion-plugin.js';
+import type { ColumnKind } from '@pikku/kysely';
 import { type ZodFormat } from './zod-codegen.js';
+/**
+ * The kinds a column may declare in `db/annotations.ts`. A strict superset of
+ * the runtime `ColumnKind`, which is the value type of the generated
+ * `CoercionMap`: `uuid` selects the generated `Uuid` TypeScript type but needs
+ * no runtime coercion (a UUID is a string in both Postgres and SQLite), so the
+ * codegen never emits it into `coercion.gen.ts`.
+ */
+export type AnnotationKind = ColumnKind | 'uuid';
 type Classification = 'public' | 'private' | 'pii' | 'secret';
 type AnonymizeStrategy = 'fake:email' | 'fake:name' | 'hash' | 'keep' | null;
 type ColumnForm = 'plain' | 'hashed' | 'wrapped' | 'sealed';
 export declare const COLUMN_FORMS: readonly ["plain", "hashed", "wrapped", "sealed"];
 export interface ColAnnotation {
     /** Column kind override: `date`, `bool`, `json`, or `uuid`. */
-    kind?: ColumnKind;
+    kind?: AnnotationKind;
     /** TypeScript type string that overrides the inferred column type, e.g. `string[]`. */
     tsType?: string;
     /**
@@ -32,7 +40,7 @@ export type AnnotationMap = Record<string, Record<string, ColAnnotation>>;
  * `kind` but none is declared in `db/annotations.ts`, so the developer can opt
  * in explicitly. Returns the *suggested* kind, or null.
  */
-export declare function nameSuggestsKind(colName: string): ColumnKind | null;
+export declare function nameSuggestsKind(colName: string): AnnotationKind | null;
 /**
  * Load annotations from the `db/annotations.gen.json` sidecar, which is
  * compiled from the developer-authored `db/annotations.ts` (`DbClassificationMap`)

package/dist/src/functions/db/better-auth-schema.js

@@ -3,7 +3,7 @@ import { pathToFileURL } from 'node:url';
 import { readdirSync, statSync, readFileSync, existsSync } from 'node:fs';
 import { join, extname, dirname } from 'node:path';
 import { PIKKU_BETTER_AUTH } from '@pikku/better-auth';
-import { createSecretValue } from '@pikku/core';
+import { createSecretValue } from '@pikku/core/classification';
 import { LocalVariablesService } from '@pikku/core/services';
 import { loadUserModule } from '../commands/load-user-project.js';
 let cachedGetMigrations = null;