@pikku/cli 0.12.104 → 0.12.107

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.js

@@ -1,19 +1,19 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializePublicRPC } from './serialize-public-rpc.js';
 import { resolveScaffoldFeature } from '../../../utils/resolve-scaffold-feature.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
-        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
-        if (deployCodegenFlag === '1') {
+        if (await isDeployCodegen(variables)) {
             return false;
         }
         if (config.scaffold?.rpc && config.publicRpcSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializePublicRPC(pathToPikkuTypes, resolveScaffoldFeature('rpc', config.scaffold.rpc).auth, config.globalHTTPPrefix || '');
+            const leaf = (name) => getLeafImportPath(config.publicRpcFile, name, config);
+            const { schemas, functions } = serializePublicRPC(leaf, resolveScaffoldFeature('rpc', config.scaffold.rpc).auth, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, config.publicRpcSchemasFile, schemas);
             await writeFileInDir(logger, config.publicRpcFile, functions);
             await removeLegacyScaffoldFile(config.publicRpcFile);

package/dist/src/functions/wirings/rpc/pikku-command-react-query.d.ts

@@ -1 +1 @@
-export declare const pikkuReactQuery: 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 pikkuReactQuery: 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/wirings/rpc/pikku-command-react-query.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.d.ts

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

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.js

@@ -1,18 +1,18 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
-        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
-        if (deployCodegenFlag === '1') {
+        if (await isDeployCodegen(variables)) {
             return false;
         }
         if (config.remoteRpcWorkersFile && config.remoteRpcSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializeRemoteRPC(pathToPikkuTypes);
+            const leaf = (name) => getLeafImportPath(config.remoteRpcWorkersFile, name, config);
+            const { schemas, functions } = serializeRemoteRPC(leaf);
             await writeFileInDir(logger, config.remoteRpcSchemasFile, schemas);
             await writeFileInDir(logger, config.remoteRpcWorkersFile, functions);
             await removeLegacyScaffoldFile(config.remoteRpcWorkersFile);

package/dist/src/functions/wirings/rpc/pikku-command-rpc-client.d.ts

@@ -1 +1 @@
-export declare const pikkuRPCClient: 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 pikkuRPCClient: 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/wirings/rpc/pikku-command-rpc-client.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/rpc/pikku-command-rpc-map.d.ts

@@ -1,7 +1,7 @@
-export declare const pikkuRPCInternalMap: 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 pikkuRPCExposedMap: 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 pikkuRPCInternalMap: 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>;
+export declare const pikkuRPCExposedMap: 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>;
 /**
  * The `remote: true` surface — what a `wireRemoteAddon` consumer imports.
  * Mirrors the exposed map but is fed from `rpc.remoteMeta`.
  */
-export declare const pikkuRPCRemoteMap: 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 pikkuRPCRemoteMap: 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/wirings/rpc/pikku-command-rpc-map.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';

package/dist/src/functions/wirings/rpc/pikku-command-rpc.d.ts

@@ -1,2 +1,2 @@
 export declare function filterInternalRPCMeta(internalMeta: Record<string, string>, functionsMeta: Record<string, unknown>): Record<string, string>;
-export declare const pikkuRPC: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuRPC: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/rpc/pikku-command-rpc.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
@@ -32,7 +32,7 @@ export const pikkuRPC = pikkuSessionlessFunc({
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
             const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -5,4 +5,4 @@ export interface PublicRPCGenOutput {
 /**
  * Generate public RPC HTTP endpoint
  */
-export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => PublicRPCGenOutput;
+export declare const serializePublicRPC: (leaf: (name: string) => string, requireAuth?: boolean, globalHTTPPrefix?: string) => PublicRPCGenOutput;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -1,7 +1,7 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
+export const serializePublicRPC = (leaf, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
     const schemas = `/**
  * Auto-generated public RPC endpoint schemas
@@ -18,7 +18,8 @@ export const RPCCall = z.object({
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireHTTP } from '${leaf('http')}'
 import { RPCCall } from './rpc-public.schemas.gen.js'
 
 export const rpcCaller = pikkuSessionlessFunc({

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.d.ts

@@ -5,4 +5,4 @@ export interface RemoteRPCGenOutput {
 /**
  * Generate remote internal RPC queue worker and HTTP endpoint
  */
-export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => RemoteRPCGenOutput;
+export declare const serializeRemoteRPC: (leaf: (name: string) => string) => RemoteRPCGenOutput;

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -1,7 +1,7 @@
 /**
  * Generate remote internal RPC queue worker and HTTP endpoint
  */
-export const serializeRemoteRPC = (pathToPikkuTypes) => {
+export const serializeRemoteRPC = (leaf) => {
     const schemas = `/**
  * Auto-generated remote internal RPC schemas
  * Do not edit manually - regenerate with 'npx pikku'
@@ -17,7 +17,9 @@ export const RemoteRPCCall = z.object({
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP, wireQueueWorker } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireHTTP } from '${leaf('http')}'
+import { wireQueueWorker } from '${leaf('queue')}'
 import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware'
 import { RemoteRPCCall } from './rpc-remote.schemas.gen.js'
 

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -59,7 +59,7 @@ ${generateAddonAgentImports(wireAddonDeclarations)}
 ${generateMergedAgentMap(wireAddonDeclarations)}
 
 import type { PikkuRPC } from '@pikku/core/rpc'
-import type { AIAgentInput } from '@pikku/core/ai-agent'
+import type { AgentInput } from '@pikku/core/agent'
 
 export type TypedStartWorkflow = <Name extends keyof FlattenedWorkflowMap>(
   name: Name,
@@ -78,17 +78,17 @@ export type TypedWorkflowStatus = (
 ) => Promise<{ id: string; status: 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled'; output?: unknown; error?: { message?: string } }>
 
 type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
-  ? (name: string, input: AIAgentInput) => Promise<any>
+  ? (name: string, input: AgentInput) => Promise<any>
   : <Name extends keyof FlattenedAgentMap>(
       name: Name,
-      input: AIAgentInput
+      input: AgentInput
     ) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
 
 type TypedAgentStream = [keyof FlattenedAgentMap] extends [never]
-  ? (name: string, input: AIAgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
+  ? (name: string, input: AgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
   : <Name extends keyof FlattenedAgentMap>(
       name: Name,
-      input: AIAgentInput,
+      input: AgentInput,
       options?: { requiresToolApproval?: 'all' | 'explicit' | false }
     ) => Promise<void>
 

package/dist/src/functions/wirings/scenarios/register-scenario-instrumentation.js

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { addFunction } from '@pikku/core/function';
-import { pikkuState } from '@pikku/core/ecosystem';
-import { getStubTracker, isTestRun, } from '@pikku/core/services';
-import { enableScoreSnapshots, getScoreSnapshot, gradeRun as coreGradeRun, } from '@pikku/core/ai-scorer';
+import { pikkuState } from '@pikku/core/state';
+import { isTestRun, getStubTracker, } from '@pikku/core/services';
+import { enableScoreSnapshots, getScoreSnapshot, gradeRun as coreGradeRun, } from '@pikku/core/agent-scorer';
 /**
  * The instrumentation `pikku scenario run` calls on the server under test:
  * snapshot/reset live coverage, and reset/read recorded stub calls.

package/dist/src/functions/wirings/scenarios/scenario-partition.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsMeta } from '@pikku/core';
+import type { FunctionsMeta } from '@pikku/core/services';
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
 export type WiringFileMap = Map<string, {
     path: string;

package/dist/src/functions/wirings/scenarios/scenario-schema-partition.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsMeta } from '@pikku/core';
+import type { FunctionsMeta } from '@pikku/core/services';
 /**
  * The schema names a set of functions validates against.
  *

package/dist/src/functions/wirings/scenarios/serialize-scenario-meta.js

@@ -23,8 +23,8 @@ export const serializeScenarioWorkflowMeta = (outputPath, metaDir, appMetaImport
     const metaEntries = sortedNames
         .map((name) => `  '${name}': ${sanitizeTypeName(name)}Meta,`)
         .join('\n');
-    return `import { pikkuState } from '@pikku/core/ecosystem'
-import type { WorkflowsRuntimeMeta } from '@pikku/core/workflow/types'
+    return `import { pikkuState } from '@pikku/core/state'
+import type { WorkflowsRuntimeMeta } from '@pikku/core/workflow'
 import '${appMetaImportPath}'
 ${imports ? `\n${imports}\n` : ''}
 const scenariosMeta = {
@@ -44,8 +44,8 @@ export const serializeScenarioFunctionMeta = (jsonImportPath, appMetaImportPath,
     const importStatement = supportsImportAttributes
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
-    return `import { pikkuState } from '@pikku/core/ecosystem'
-import type { FunctionsMeta } from '@pikku/core'
+    return `import { pikkuState } from '@pikku/core/state'
+import type { FunctionsMeta } from '@pikku/core/services'
 import '${appMetaImportPath}'
 ${importStatement}
 

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler-types.d.ts

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: 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 pikkuSchedulerTypes: 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/wirings/scheduler/pikku-command-scheduler-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -7,7 +7,10 @@ export const pikkuSchedulerTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { schedulersTypesFile, functionTypesFile, packageMappings } = config;
         const functionTypesImportPath = getFileImportRelativePath(schedulersTypesFile, functionTypesFile, packageMappings);
-        const content = serializeSchedulerTypes(functionTypesImportPath);
+        const middlewareTypesImportPath = getFileImportRelativePath(schedulersTypesFile, config.middlewareTypesFile, packageMappings);
+        const content = serializeSchedulerTypes(functionTypesImportPath, middlewareTypesImportPath, {
+            addon: !!config.addon,
+        });
         await writeFileInDir(logger, schedulersTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.d.ts

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

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/scheduler/serialize-scheduler-types.d.ts

@@ -1,4 +1,6 @@
 /**
  * Generates type definitions for scheduler wirings
  */
-export declare const serializeSchedulerTypes: (functionTypesImportPath: string) => string;
+export declare const serializeSchedulerTypes: (functionTypesImportPath: string, middlewareTypesImportPath: string, { addon }?: {
+    addon?: boolean;
+}) => string;

package/dist/src/functions/wirings/scheduler/serialize-scheduler-types.js

@@ -1,20 +1,25 @@
 /**
  * Generates type definitions for scheduler wirings
  */
-export const serializeSchedulerTypes = (functionTypesImportPath) => {
+export const serializeSchedulerTypes = (functionTypesImportPath, middlewareTypesImportPath, { addon = false } = {}) => {
     return `/**
  * Scheduler-specific type definitions for tree-shaking optimization
  */
 
-import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
-import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+${addon ? '' : `import { wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'\n`}${addon
+        ? ''
+        : `import { CoreScheduledTask } from '@pikku/core/scheduler'
+import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { PikkuMiddleware } from '${middlewareTypesImportPath}'
 
 /**
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
 type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
-
+`}${addon
+        ? ''
+        : `
 /**
  * Registers a scheduled task with the Pikku framework.
  * Tasks run based on cron expressions and are sessionless.
@@ -24,5 +29,5 @@ type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'sessio
 export const wireScheduler = (task: SchedulerWiring) => {
   wireSchedulerCore(task as any)
 }
-`;
+`}`;
 };

package/dist/src/functions/wirings/scopes/pikku-command-scopes.d.ts

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

package/dist/src/functions/wirings/scopes/pikku-command-scopes.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeScopesTypes } from './serialize-scopes-types.js';
@@ -9,9 +9,10 @@ export const pikkuScopes = pikkuSessionlessFunc({
         if (!scopesFile) {
             return;
         }
-        // On a cold .pikku this runs before pikku-types.gen.ts exists, so it must
+        // On a cold .pikku this runs before the function leaf exists, so it must
         // take the zero state rather than a full inspect — inspecting here would
-        // try to import the project's zod schemas, which resolve '#pikku' and fail.
+        // try to import the project's zod schemas, which resolve '#pikku/function'
+        // and fail.
         // The file only has to exist so function types can import ScopeId; the real
         // Scopes step regenerates it with the declarations once setup has run.
         const bootstrap = data?.bootstrap ?? false;

package/dist/src/functions/wirings/secrets/pikku-command-secrets.d.ts

@@ -1 +1 @@
-export declare const pikkuSecrets: 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 pikkuSecrets: 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/wirings/secrets/pikku-command-secrets.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeSecretsTypes } from './serialize-secrets-types.js';

package/dist/src/functions/wirings/secrets/serialize-secrets-types.js

@@ -31,16 +31,23 @@ export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile,
                     schemaImports.set(schemaRef.sourceFile, new Set());
                 }
                 schemaImports.get(schemaRef.sourceFile).add(schemaRef.variableName);
-                mapEntries.push(`  '${meta.secretId}': z.infer<typeof ${schemaRef.variableName}>`);
-                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${literal(meta.displayName)} }`);
+                mapEntries.push(`  '${meta.secretId}'${meta.optional ? '?' : ''}: z.infer<typeof ${schemaRef.variableName}>`);
+                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: ${literal(meta.displayName)}${meta.optional ? ', optional: true' : ''} }`);
             }
         }
     }
     const imports = [];
-    imports.push(`import { TypedSecretService as CoreTypedSecretService, type CredentialMeta } from '@pikku/core/services'`);
+    imports.push(`import { TypedSecretService as CoreTypedSecretService } from '@pikku/core/services'
+import type { CredentialMeta } from '@pikku/core/services'`);
     imports.push(`import type { SecretService } from '@pikku/core/services'`);
-    imports.push(`import type { SecretDefinitionsMeta } from '@pikku/core/secret'`);
-    imports.push(`import secretsMeta from './pikku-secrets-meta.gen.json' with { type: 'json' }`);
+    imports.push(`/**
+ * Side-effect import of the metadata sidecar, so that tsc emits the .json
+ * alongside this file. An addon publishes only its compiled output, and a host
+ * reads that .json off disk to discover the addon's declared secrets — an
+ * uncopied sidecar leaves them invisible to the host. Nothing binds it: the
+ * sidecar is not part of \`#pikku/secrets\`.
+ */
+import './pikku-secrets-meta.gen.json' with { type: 'json' }`);
     if (needsZod) {
         imports.push(`import type { z } from 'zod'`);
     }
@@ -54,23 +61,10 @@ export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile,
     }
     return `${imports.join('\n')}
 
-/**
- * Every secret declared in this package.
- *
- * Read from the metadata sidecar rather than inlined, so that the import above
- * forces tsc to emit the .json alongside this file. An addon publishes only its
- * compiled output, and a host reads that .json to discover the addon's declared
- * secrets — an uncopied sidecar leaves them invisible to the host.
- */
-export const SECRETS_META: SecretDefinitionsMeta =
-  secretsMeta as SecretDefinitionsMeta
-
-export interface CredentialsMap {
+export type CredentialsMap = {
 ${mapEntries.join('\n')}
 }
 
-export type SecretId = keyof CredentialsMap
-
 const CREDENTIALS_META: Record<string, CredentialMeta> = {
 ${metaEntries.join(',\n')}
 }

package/dist/src/functions/wirings/setup/serialize-setup-types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates the setup surface — the three factories a project declares exactly
+ * once, at the point the application is brought up. Grouping them apart from
+ * the function types keeps `#pikku/function` to what a feature imports every
+ * day and `#pikku/setup` to what bootstrap imports and never touches again.
+ */
+export declare const serializeSetupTypes: (functionTypesImportPath: string, configTypeImport: string, configTypeName: string | undefined, requiredServicesTypeImport: string) => string;

package/dist/src/functions/wirings/setup/serialize-setup-types.js

@@ -0,0 +1,111 @@
+/**
+ * Generates the setup surface — the three factories a project declares exactly
+ * once, at the point the application is brought up. Grouping them apart from
+ * the function types keeps `#pikku/function` to what a feature imports every
+ * day and `#pikku/setup` to what bootstrap imports and never touches again.
+ */
+export const serializeSetupTypes = (functionTypesImportPath, configTypeImport, configTypeName, requiredServicesTypeImport) => {
+    return `/**
+ * Config and service factory definitions, declared once per application
+ */
+
+import { pikkuState as __pikkuState } from '@pikku/core/state'
+import { CreateWireServices } from '@pikku/core/types'
+import type { SingletonServices } from '${functionTypesImportPath}'
+${configTypeImport}
+${requiredServicesTypeImport}
+${!configTypeName ? 'export type Config = any' : configTypeName === 'Config' ? 'export type { Config }' : `export type { ${configTypeName} as Config }`}
+
+/**
+ * Creates a Pikku config factory.
+ * Use this to define your application's configuration factory.
+ *
+ * @param func - Config factory function that returns your application's config
+ * @returns The config factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createConfig = pikkuConfig(async () => {
+ *   return {
+ *     apiUrl: process.env.API_URL || 'http://localhost:3000',
+ *     dbUrl: process.env.DATABASE_URL
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuConfig = (
+  func: (variables?: any, ...args: any[]) => Promise<Config>
+) => func
+
+/**
+ * Creates a Pikku singleton services factory.
+ * Use this to define services that are created once and shared across all requests.
+ *
+ * @param func - Singleton services factory function
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuServices(async (config, existingServices) => {
+ *   return {
+ *     config,
+ *     logger: new CustomLogger(),
+ *     db: await createDatabaseConnection(config.dbUrl)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuServices = (
+  func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<Partial<Omit<RequiredSingletonServices, 'auth'>>>
+) => {
+  return async (config: Config, existingServices: Partial<SingletonServices> = {}) => {
+    const createdServices = await func(config, existingServices)
+    const services = { ...existingServices, ...createdServices }
+    const authFactory = __pikkuState(null, 'package', 'authFactory')
+    if (authFactory) {
+      let authInstance: Promise<unknown> | undefined
+      ;(services as any).auth = () => {
+        authInstance ??= Promise.resolve()
+          .then(() => authFactory(services as any))
+          .catch((error) => {
+            authInstance = undefined
+            throw error
+          })
+        return authInstance
+      }
+    }
+    const resolved = services as RequiredSingletonServices
+    __pikkuState(null, 'package', 'singletonServices', resolved as any)
+    return resolved
+  }
+}
+
+/**
+ * Creates a Pikku wire services factory.
+ * Use this to define services that are created per-request/session.
+ *
+ * @param func - Wire services factory function
+ * @returns The wire services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createWireServices = pikkuWireServices(async (services, wire) => {
+ *   const session = await wire.session?.get()
+ *   return {
+ *     userCache: new UserCache(session?.userId)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuWireServices = (
+  func: (
+    services: SingletonServices,
+    wire: any
+  ) => Promise<RequiredWireServices>
+): CreateWireServices => {
+  const factories = __pikkuState(null, 'package', 'factories')
+  __pikkuState(null, 'package', 'factories', { ...factories, createWireServices: func as any })
+  return func as unknown as CreateWireServices
+}
+`;
+};

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.d.ts

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

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -12,7 +12,7 @@ export const pikkuTriggerTypes = pikkuSessionlessFunc({
             throw new Error('SingletonServices type not found');
         }
         const singletonServicesTypeImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(triggersTypesFile, singletonServicesType.typePath, packageMappings)}'`;
-        const content = serializeTriggerTypes(singletonServicesTypeImport, singletonServicesType.type);
+        const content = serializeTriggerTypes(singletonServicesTypeImport, singletonServicesType.type, { addon: !!config.addon });
         await writeFileInDir(logger, triggersTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/triggers/pikku-command-trigger.d.ts

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