@pikku/cli 0.12.104 → 0.12.107

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

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Error catalogue — `#pikku/error` resolves here.
+ */
+export * from '@pikku/core/errors';

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

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.107
+ */
+/**
+ * Error catalogue — `#pikku/error` resolves here.
+ */
+export * from '@pikku/core/errors';

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

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

package/dist/.pikku/function/index.js

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

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

@@ -1,23 +1,28 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 /**
- * Core function, middleware, and permission types for all wirings
+ * Core function types for all wirings
  */
-import type { CorePikkuMiddleware, CorePermissionGroup, ListInput, ListOutput, PikkuWire, PickRequired, SecretlessServices } from '@pikku/core';
-import type { CorePikkuFunctionConfig, CorePikkuSessionlessFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function';
-import { CreateWireServices } from '@pikku/core/ecosystem';
+import type { PickRequired } from '@pikku/core/utils';
+import type { ListInput, ListOutput } from '@pikku/core/function';
+import type { CorePermissionGroup } from '@pikku/core/function';
+import type { PikkuWire, SecretlessServices } from '@pikku/core/types';
+import type { CorePikkuFunctionConfig, CorePikkuSessionlessFunctionConfig, CorePikkuPermission } from '@pikku/core/function';
 import type { NodeType } from '@pikku/core/node';
+import type { PikkuMiddleware } from '../middleware/pikku-middleware-types.gen.js';
+import type { PikkuPermission } from '../auth/pikku-auth-types.gen.js';
 import type { ScopeId } from '../scopes/pikku-scopes.gen.js';
+type CredentialsMap = Record<string, unknown>;
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function';
 import type { UserSession } from '../../types/application-types.d.js';
 import type { SingletonServices } from '../../types/application-types.d.js';
 import type { Services } from '../../types/application-types.d.js';
-import type { Config } from '../../types/application-types.d.js';
 import type { TypedPikkuRPC, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
-import type { RequiredSingletonServices, RequiredWireServices } from '../pikku-services.gen.js';
-import type { TypedWorkflow, TypedScenario, TypedPersonas } from '../workflow/pikku-workflow-types.gen.js';
+import type { RequiredSingletonServices } from '../pikku-services.gen.js';
+import type { TypedWorkflow } from '../workflow/pikku-workflow-types.gen.js';
+import type { TypedScenario, TypedPersonas } from '../scenarios/pikku-scenario-types.gen.js';
 export type { SingletonServices as SingletonServices };
 export type { Services as Services };
 export type Session = UserSession;
@@ -31,8 +36,6 @@ export type Session = UserSession;
  */
 export type WiredSingletonServices = RequiredSingletonServices & SingletonServices;
 export type WiredServices = SecretlessServices<RequiredSingletonServices & Services>;
-/** `WiredSingletonServices` without `secrets`, for auth gates. */
-export type WiredAuthServices = SecretlessServices<WiredSingletonServices>;
 /**
  * Inline node configuration for function definitions.
  */
@@ -42,162 +45,6 @@ export type NodeConfig = {
     type: NodeType;
     errorOutput?: boolean;
 };
-/**
- * Type-safe API permission definition that integrates with your application's session type.
- * Use this to define authorization logic for your API endpoints.
- *
- * @template In - The input type that the permission check will receive
- * @template RequiredServices - The services required for this permission check
- */
-export type PikkuPermission<In = unknown, RequiredServices extends SecretlessServices<Services> = WiredServices> = CorePikkuPermission<In, RequiredServices, PikkuWire<In, never, false, Session>>;
-/**
- * Type-safe middleware definition that can access your application's services and session.
- * Use this to define reusable middleware that can be applied to multiple wirings.
- *
- * @template RequiredServices - The services required for this middleware
- */
-export type PikkuMiddleware<RequiredServices extends SingletonServices = WiredSingletonServices> = CorePikkuMiddleware<RequiredServices>;
-/**
- * Configuration object for creating a permission with metadata
- */
-export type PikkuPermissionConfig<In = unknown, RequiredServices extends SecretlessServices<Services> = WiredServices> = {
-    /** The permission function */
-    func: PikkuPermission<In, RequiredServices>;
-    /** Optional human-readable name for the permission */
-    name?: string;
-    /** Optional description of what the permission checks */
-    description?: string;
-};
-/**
- * Factory function for creating permissions with tree-shaking support.
- * Supports both direct function and configuration object syntax.
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * const permission = pikkuPermission(async ({ logger }, data, { session }) => {
- *   const session = await session?.get()
- *   return session?.role === 'admin'
- * })
- *
- * // Configuration object syntax with metadata
- * const adminPermission = pikkuPermission({
- *   name: 'Admin Permission',
- *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, { session }) => {
- *     const session = await session?.get()
- *     return session?.role === 'admin'
- *   }
- * })
- * ```
- */
-export declare const pikkuPermission: <In>(permission: PikkuPermission<In> | PikkuPermissionConfig<In>) => PikkuPermission<In>;
-/**
- * Type-safe auth-only permission that only needs services and session.
- * Use this for upfront authorization gates (MCP tools, AI agents, workflows)
- * where request data isn't available yet.
- *
- * @template RequiredServices - The services required for this auth check
- */
-export type PikkuAuth<RequiredServices extends SecretlessServices<SingletonServices> = WiredAuthServices> = CorePikkuAuth<RequiredServices, Session>;
-/**
- * Configuration object for creating an auth permission with metadata
- */
-export type PikkuAuthConfig<RequiredServices extends SecretlessServices<SingletonServices> = WiredAuthServices> = CorePikkuAuthConfig<RequiredServices, Session>;
-/**
- * Factory function for creating auth-only permissions with tree-shaking support.
- * Auth permissions only receive services and session (no request data),
- * making them evaluable before request data is available.
- *
- * @example
- * \`\`\`typescript
- * const isAuthenticated = pikkuAuth(async ({ logger }, session) => {
- *   return !!session
- * })
- *
- * const isAdmin = pikkuAuth({
- *   name: 'Admin Auth',
- *   description: 'Checks if user is an admin',
- *   func: async ({ logger }, session) => {
- *     return session?.role === 'admin'
- *   }
- * })
- * \`\`\`
- */
-export declare const pikkuAuth: <RequiredServices extends SecretlessServices<SingletonServices> = WiredAuthServices>(auth: PikkuAuth<RequiredServices> | PikkuAuthConfig<RequiredServices>) => PikkuPermission<any, any>;
-/**
- * Configuration object for creating middleware with metadata
- */
-export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = WiredSingletonServices> = {
-    /** The middleware function */
-    func: PikkuMiddleware<RequiredServices>;
-    /** Optional human-readable name for the middleware */
-    name?: string;
-    /** Optional description of what the middleware does */
-    description?: string;
-};
-/**
- * Factory function for creating middleware with tree-shaking support.
- * Supports both direct function and configuration object syntax.
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
- *   logger.info('Middleware executed')
- *   await next()
- * })
- *
- * // Configuration object syntax with metadata
- * const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
- *   description: 'Logs all incoming requests',
- *   func: async ({ logger }, wires, next) => {
- *     logger.info('Request started')
- *     await next()
- *   }
- * })
- * ```
- */
-export declare const pikkuMiddleware: <RequiredServices extends SingletonServices = WiredSingletonServices>(middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>) => PikkuMiddleware<RequiredServices>;
-/**
- * Factory function for creating middleware factories
- * Use this when your middleware needs configuration/input parameters
- *
- * @example
- * ```typescript
- * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
- *   message,
- *   level = 'info'
- * }) => {
- *   return pikkuMiddleware(async ({ logger }, next) => {
- *     logger[level](message)
- *     await next()
- *   })
- * })
- * ```
- */
-export declare const pikkuMiddlewareFactory: <In = any>(factory: (input: In) => PikkuMiddleware) => ((input: In) => PikkuMiddleware);
-/**
- * Factory function for creating permission factories
- * Use this when your permission needs configuration/input parameters
- *
- * @example
- * ```typescript
- * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
- *   role
- * }) => {
- *   return pikkuPermission(async ({ logger }, data, { session }) => {
- *     if (!session || session.role !== role) {
- *       logger.warn(`Permission denied: required role '${role}'`)
- *       return false
- *     }
- *     return true
- *   })
- * })
- * ```
- */
-export declare const pikkuPermissionFactory: <In = any>(factory: (input: In) => PikkuPermission<any>) => ((input: In) => PikkuPermission<any>);
 /**
  * A function that generates a human-readable description of a pending approval action.
  * Used by AI agents to show meaningful approval prompts instead of raw tool arguments.
@@ -232,7 +79,7 @@ export declare const pikkuApprovalDescription: <In = unknown, RequiredServices e
  *   type vary with its return type and cost a `func` written against the
  *   `PikkuFunction | PikkuFunctionSessionless` union its contextual typing.
  */
-export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices, ScenarioOut = unknown> = CorePikkuFunctionSessionless<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario<ScenarioOut>, TypedPersonas>, RequiredWires>>;
+export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices, ScenarioOut = unknown> = CorePikkuFunctionSessionless<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario<ScenarioOut>, TypedPersonas, CredentialsMap>, RequiredWires>>;
 /**
  * A session-aware API function that requires user authentication.
  * Use this for protected endpoints that need access to user session data.
@@ -241,7 +88,7 @@ export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires ex
  * @template Out - The output type that the function returns
  * @template RequiredServices - Services required by this function
  */
-export type PikkuFunction<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = 'session', RequiredServices extends SecretlessServices<Services> = WiredServices> = CorePikkuFunction<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario, TypedPersonas>, RequiredWires>>;
+export type PikkuFunction<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = 'session', RequiredServices extends SecretlessServices<Services> = WiredServices> = CorePikkuFunction<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow, unknown, TypedScenario, TypedPersonas, CredentialsMap>, RequiredWires>>;
 /**
  * Helper type to infer the output type from a Standard Schema
  */
@@ -254,12 +101,16 @@ export type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output>
  * @template Out - The output type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
-export type PikkuFunctionConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunction<In, Out, RequiredWires, any> | PikkuFunctionSessionless<In, Out, RequiredWires, any, any> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema, ScopeId>;
+export type PikkuFunctionConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunction<In, Out, RequiredWires, any> | PikkuFunctionSessionless<In, Out, RequiredWires, any, any> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = Omit<CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema, ScopeId>, 'node'> & {
+    node?: NodeConfig;
+};
 /**
  * {@link PikkuFunctionConfig} for a function that runs without a session.
  * Has no `scopes`: an anonymous caller holds none, so none can ever be met.
  */
-export type PikkuFunctionSessionlessConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunctionSessionless<In, Out, RequiredWires, any> = PikkuFunctionSessionless<In, Out, RequiredWires>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = CorePikkuSessionlessFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>;
+type PikkuFunctionSessionlessConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunctionSessionless<In, Out, RequiredWires, any> = PikkuFunctionSessionless<In, Out, RequiredWires>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = Omit<CorePikkuSessionlessFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>, 'node'> & {
+    node?: NodeConfig;
+};
 /**
  * Configuration object for Pikku functions with Zod schema validation.
  * Use this when you want to define input/output schemas using Zod.
@@ -270,10 +121,11 @@ type SchemaInferred<S, Fallback = unknown> = S extends StandardSchemaV1 ? InferS
  * Schema-overload variant for pikkuFunc. Derived from CorePikkuFunctionConfig
  * so adding a field on the core type automatically propagates here.
  */
-export type PikkuFunctionConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices> = Omit<CorePikkuFunctionConfig<PikkuFunction<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices> | PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>, CorePikkuPermission<any>, PikkuMiddleware, undefined, undefined, ScopeId>, 'func' | 'input' | 'output' | 'permissions' | 'approvalDescription'> & {
+type PikkuFunctionConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices> = Omit<CorePikkuFunctionConfig<PikkuFunction<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices> | PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>, CorePikkuPermission<any>, PikkuMiddleware, undefined, undefined, ScopeId>, 'func' | 'input' | 'output' | 'permissions' | 'approvalDescription' | 'node'> & {
     func: PikkuFunction<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices> | PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>;
     input?: InputSchema;
     output?: OutputSchema;
+    node?: NodeConfig;
     permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined;
     approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never;
 };
@@ -305,7 +157,6 @@ export type PikkuFunctionConfigWithSchema<InputSchema extends StandardSchemaV1 |
  */
 export declare function pikkuFunc<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>;
 export declare function pikkuFunc<In, Out = unknown>(func: PikkuFunction<In, Out, 'session' | 'rpc'> | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>;
-export type PikkuListFunction<F extends Record<string, unknown> = {}, Row = unknown, S extends string = never> = PikkuFunction<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'> | PikkuFunctionSessionless<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'>;
 export declare const pikkuListFunc: <F extends Record<string, unknown> = {}, Row = unknown, S extends string = never>(config: PikkuFunctionConfig<ListInput<F, S>, ListOutput<Row>, "session" | "rpc">) => PikkuFunctionConfig<ListInput<F, S>, ListOutput<Row>, "session" | "rpc">;
 /**
  * Configuration object for sessionless Pikku functions with Zod schema validation.
@@ -315,10 +166,11 @@ export declare const pikkuListFunc: <F extends Record<string, unknown> = {}, Row
  * CorePikkuSessionlessFunctionConfig to stay in sync with the generic-typed
  * config — so it has no `scopes` either.
  */
-export type PikkuFunctionSessionlessConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices> = Omit<CorePikkuSessionlessFunctionConfig<PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>>, 'func' | 'input' | 'output' | 'permissions' | 'approvalDescription'> & {
+type PikkuFunctionSessionlessConfigWithSchema<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never, RequiredServices extends SecretlessServices<Services> = WiredServices> = Omit<CorePikkuSessionlessFunctionConfig<PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>>, 'func' | 'input' | 'output' | 'permissions' | 'approvalDescription' | 'node'> & {
     func: PikkuFunctionSessionless<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, RequiredWires, RequiredServices>;
     input?: InputSchema;
     output?: OutputSchema;
+    node?: NodeConfig;
     permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined;
     approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never;
 };
@@ -364,7 +216,7 @@ export declare function pikkuSessionlessFunc<In, Out = unknown, RequiredServices
  * })
  * ```
  */
-export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void, "session" | "rpc"> | PikkuFunctionSessionlessConfig<void, void, "session" | "rpc">) => PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", PikkuFunctionSessionless<void, void, "rpc" | "session", WiredServices, unknown>, undefined, undefined>;
+export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void, "session" | "rpc"> | PikkuFunctionSessionlessConfig<void, void, "session" | "rpc">) => PikkuFunctionConfig<void, void, "session" | "rpc">;
 /**
  * References a registered function by name for use in any wiring.
  * Works for both local and addon functions — resolves via RPC at runtime.
@@ -402,90 +254,6 @@ export declare const ref: <Name extends keyof FlattenedRPCMap>(rpcName: Name) =>
  * ```
  */
 export declare function pikkuRemoteChannelFunc<InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: Omit<PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>, 'func'>): PikkuFunctionConfig<SchemaInferred<InputSchema>, SchemaInferred<OutputSchema>, 'session' | 'rpc'>;
-/**
- * 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 declare const pikkuConfig: (func: (variables?: any, ...args: any[]) => Promise<Config>) => (variables?: any, ...args: any[]) => Promise<Config>;
-/**
- * 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 declare const pikkuServices: (func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<Partial<Omit<RequiredSingletonServices, "auth">>>) => (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>;
-/**
- * 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 declare const pikkuWireServices: (func: (services: SingletonServices, wire: any) => Promise<RequiredWireServices>) => CreateWireServices;
-/**
- * Tag-scoped middleware. Applies to any wiring that carries the matching tag.
- *
- * @example
- * addTagMiddleware('admin', [adminMiddleware])
- */
-export declare const addTagMiddleware: (tag: string, middleware: PikkuMiddleware[]) => void;
-/**
- * Wire-agnostic global middleware. Runs at the top of every wiring's
- * middleware chain — before wire-, tag-, and function-level entries.
- *
- * Resolution order: global -> wire -> tag -> function.
- *
- * @example
- * addGlobalMiddleware([telemetryMiddleware])
- */
-export declare const addGlobalMiddleware: (middleware: PikkuMiddleware[]) => void;
-/**
- * Wire-agnostic global permissions. Runs at the top of every wiring's
- * permission resolution — before wire-, tag-, and function-level entries.
- *
- * Resolution order: global -> wire -> tag -> function.
- *
- * @example
- * addGlobalPermission([signedInUser])
- */
-export declare const addGlobalPermission: <In = unknown>(permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => void;
-export { wireAddon, wireRemoteAddon } from '@pikku/core/rpc';
-export type { WireAddonConfig, WireRemoteAddonConfig, RemoteAddonAuth } from '@pikku/core/rpc';
 /**
  * Addon contract references. Generated from each wired addon's published
  * contract metadata — no addon source is imported. Functions are proxied via

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

@@ -1,129 +1,9 @@
 /**
- * This file was generated by @pikku/cli@0.12.104
+ * This file was generated by @pikku/cli@0.12.107
  */
 /**
- * Core function, middleware, and permission types for all wirings
+ * Core function types for all wirings
  */
-import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function';
-import { addTagMiddleware as addTagMiddlewareCore, addGlobalMiddleware as addGlobalMiddlewareCore, addGlobalPermission as addGlobalPermissionCore, } from '@pikku/core/middleware';
-import { pikkuState as __pikkuState } from '@pikku/core/ecosystem';
-/**
- * Factory function for creating permissions with tree-shaking support.
- * Supports both direct function and configuration object syntax.
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * const permission = pikkuPermission(async ({ logger }, data, { session }) => {
- *   const session = await session?.get()
- *   return session?.role === 'admin'
- * })
- *
- * // Configuration object syntax with metadata
- * const adminPermission = pikkuPermission({
- *   name: 'Admin Permission',
- *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, { session }) => {
- *     const session = await session?.get()
- *     return session?.role === 'admin'
- *   }
- * })
- * ```
- */
-export const pikkuPermission = (permission) => {
-    return typeof permission === 'function' ? permission : permission.func;
-};
-/**
- * Factory function for creating auth-only permissions with tree-shaking support.
- * Auth permissions only receive services and session (no request data),
- * making them evaluable before request data is available.
- *
- * @example
- * \`\`\`typescript
- * const isAuthenticated = pikkuAuth(async ({ logger }, session) => {
- *   return !!session
- * })
- *
- * const isAdmin = pikkuAuth({
- *   name: 'Admin Auth',
- *   description: 'Checks if user is an admin',
- *   func: async ({ logger }, session) => {
- *     return session?.role === 'admin'
- *   }
- * })
- * \`\`\`
- */
-export const pikkuAuth = (auth) => {
-    return pikkuAuthCore(auth);
-};
-/**
- * Factory function for creating middleware with tree-shaking support.
- * Supports both direct function and configuration object syntax.
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
- *   logger.info('Middleware executed')
- *   await next()
- * })
- *
- * // Configuration object syntax with metadata
- * const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
- *   description: 'Logs all incoming requests',
- *   func: async ({ logger }, wires, next) => {
- *     logger.info('Request started')
- *     await next()
- *   }
- * })
- * ```
- */
-export const pikkuMiddleware = (middleware) => {
-    return typeof middleware === 'function' ? middleware : middleware.func;
-};
-/**
- * Factory function for creating middleware factories
- * Use this when your middleware needs configuration/input parameters
- *
- * @example
- * ```typescript
- * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
- *   message,
- *   level = 'info'
- * }) => {
- *   return pikkuMiddleware(async ({ logger }, next) => {
- *     logger[level](message)
- *     await next()
- *   })
- * })
- * ```
- */
-export const pikkuMiddlewareFactory = (factory) => {
-    return factory;
-};
-/**
- * Factory function for creating permission factories
- * Use this when your permission needs configuration/input parameters
- *
- * @example
- * ```typescript
- * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
- *   role
- * }) => {
- *   return pikkuPermission(async ({ logger }, data, { session }) => {
- *     if (!session || session.role !== role) {
- *       logger.warn(`Permission denied: required role '${role}'`)
- *       return false
- *     }
- *     return true
- *   })
- * })
- * ```
- */
-export const pikkuPermissionFactory = (factory) => {
-    return factory;
-};
 /**
  * Factory function for creating approval description functions with tree-shaking support.
  *
@@ -218,120 +98,6 @@ export function pikkuRemoteChannelFunc(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) => 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) => {
-    return async (config, existingServices = {}) => {
-        const createdServices = await func(config, existingServices);
-        const services = { ...existingServices, ...createdServices };
-        const authFactory = __pikkuState(null, 'package', 'authFactory');
-        if (authFactory) {
-            let authInstance;
-            services.auth = () => {
-                authInstance ??= Promise.resolve()
-                    .then(() => authFactory(services))
-                    .catch((error) => {
-                    authInstance = undefined;
-                    throw error;
-                });
-                return authInstance;
-            };
-        }
-        const resolved = services;
-        __pikkuState(null, 'package', 'singletonServices', resolved);
-        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) => {
-    const factories = __pikkuState(null, 'package', 'factories');
-    __pikkuState(null, 'package', 'factories', { ...factories, createWireServices: func });
-    return func;
-};
-/**
- * Tag-scoped middleware. Applies to any wiring that carries the matching tag.
- *
- * @example
- * addTagMiddleware('admin', [adminMiddleware])
- */
-export const addTagMiddleware = (tag, middleware) => {
-    addTagMiddlewareCore(tag, middleware, null);
-};
-/**
- * Wire-agnostic global middleware. Runs at the top of every wiring's
- * middleware chain — before wire-, tag-, and function-level entries.
- *
- * Resolution order: global -> wire -> tag -> function.
- *
- * @example
- * addGlobalMiddleware([telemetryMiddleware])
- */
-export const addGlobalMiddleware = (middleware) => {
-    addGlobalMiddlewareCore(middleware, null);
-};
-/**
- * Wire-agnostic global permissions. Runs at the top of every wiring's
- * permission resolution — before wire-, tag-, and function-level entries.
- *
- * Resolution order: global -> wire -> tag -> function.
- *
- * @example
- * addGlobalPermission([signedInUser])
- */
-export const addGlobalPermission = (permissions) => {
-    addGlobalPermissionCore(permissions, null);
-};
-export { wireAddon, wireRemoteAddon } from '@pikku/core/rpc';
 /**
  * Addon contract references. Generated from each wired addon's published
  * contract metadata — no addon source is imported. Functions are proxied via