@pikku/cli 0.9.16-next.0 → 0.10.0

package/dist/.pikku/cli/pikku-cli-channel.gen.js

@@ -0,0 +1,33 @@
+/**
+ * This file was generated by @pikku/cli@0.10.0
+ */
+/**
+ * WebSocket channel backend for 'pikku' CLI commands
+ */
+import { wireChannel } from '../channel/pikku-channel-types.gen.js';
+import { all } from '../../src/functions/commands/all.js';
+import { pikkuSchemas } from '../../src/functions/wirings/functions/schemas.js';
+import { pikkuFetch } from '../../src/functions/wirings/fetch/index.js';
+import { pikkuWebSocketTyped } from '../../src/functions/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuRPCClient } from '../../src/functions/wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuQueueService } from '../../src/functions/wirings/queue/pikku-command-queue-service.js';
+import { pikkuOpenAPI } from '../../src/functions/wirings/http/pikku-command-openapi.js';
+import { pikkuNext } from '../../src/functions/runtimes/nextjs/pikku-command-nextjs.js';
+wireChannel({
+    name: 'pikku-cli',
+    route: '/cli/pikku',
+    auth: false,
+    onMessageWiring: {
+        command: {
+            'all': all,
+            'schemas': pikkuSchemas,
+            'fetch': pikkuFetch,
+            'websocket': pikkuWebSocketTyped,
+            'rpc': pikkuRPCClient,
+            'queue-service': pikkuQueueService,
+            'openapi': pikkuOpenAPI,
+            'nextjs': pikkuNext
+        }
+    },
+    tags: ['cli', 'pikku']
+});

package/dist/.pikku/cli/pikku-cli-client.gen.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.10.0
+ */
+import '../pikku-bootstrap.gen.js';
+/**
+ * Pikku CLI Client (via WebSocket Channel)
+ * Executes CLI commands over a WebSocket connection
+ */
+export declare function PikkuCLIClient(url: string, args?: string[]): Promise<void>;
+export default PikkuCLIClient;

package/dist/.pikku/cli/pikku-cli-client.gen.js

@@ -0,0 +1,34 @@
+/**
+ * This file was generated by @pikku/cli@0.10.0
+ */
+import { executeCLIViaChannel } from '@pikku/core/cli/channel';
+import { CorePikkuWebsocket } from '@pikku/websocket';
+import '../pikku-bootstrap.gen.js';
+import { clientCLIRenderer } from '../../src/services.js';
+/**
+ * Pikku CLI Client (via WebSocket Channel)
+ * Executes CLI commands over a WebSocket connection
+ */
+export async function PikkuCLIClient(url, args) {
+    // Create WebSocket connection
+    const pikkuWS = new CorePikkuWebsocket(url);
+    // Register renderers for CLI commands
+    const renderers = {};
+    await executeCLIViaChannel({
+        programName: 'pikku',
+        pikkuWS,
+        args,
+        renderers,
+        defaultRenderer: clientCLIRenderer,
+    });
+}
+// Export as default for easy importing
+export default PikkuCLIClient;
+// For direct execution (if this file is run directly)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const url = process.env.PIKKU_WS_URL || 'ws://localhost:3000/cli/pikku';
+    PikkuCLIClient(url, process.argv.slice(2)).catch(error => {
+        console.error('Fatal error:', error.message);
+        process.exit(1);
+    });
+}

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

@@ -1,11 +1,11 @@
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
 /**
- * This file was generated by the @pikku/cli
+
  * CLI-specific type definitions for tree-shaking optimization
  */
-import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core';
+import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli';
 import type { PikkuFunctionConfig, PikkuMiddleware } from '../function/pikku-function-types.gen.js';
 import type { UserSession } from '../../types/application-types.d.js';
 import type { SingletonServices } from '../../types/application-types.d.js';
@@ -22,18 +22,14 @@ type PikkuCLIRender<Data, RequiredServices extends SingletonServices = Singleton
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<any, any>> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>>;
-/**
- * Result type for CLI command configuration
- */
-type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandConfig<Func>;
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>;
 /**
  * Type definition for CLI applications with commands and global options.
  *
  * @template Commands - Type describing the command structure
  * @template GlobalOptions - Type for global CLI options
  */
-type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>;
+type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>;
 /**
  * Registers a CLI application with the Pikku framework.
  * Creates command-line interfaces with type-safe commands and options.
@@ -42,14 +38,15 @@ type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMi
  * @template GlobalOptions - Type for global CLI options
  * @param cli - CLI definition with program name, commands, and global options
  */
-export declare const wireCLI: <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions>(cli: CLIWiring<Commands, GlobalOptions>) => void;
+export declare const wireCLI: <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions>(cli: CLIWiring<Commands, GlobalOptions>) => void;
 /**
  * Creates a CLI command definition with automatic option inference from the function's input type.
  * This allows TypeScript to automatically derive CLI options from the function signature.
  *
- * @template Func - The Pikku function config type to create a CLI command for
+ * @template FuncConfig - The Pikku function config type
+ * @template Params - The parameters string literal type
  * @param config - CLI command configuration
  * @returns CLI command configuration with inferred types
  */
-export declare const pikkuCLICommand: <Func extends PikkuFunctionConfig<any, any>>(config: CLICommandConfig<Func>) => CLICommandResult<Func>;
+export declare const pikkuCLICommand: <FuncConfig extends PikkuFunctionConfig<any, any>, Params extends string>(config: CLICommandConfig<FuncConfig, any, any, Params>) => CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string>;
 export {};

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

@@ -1,11 +1,11 @@
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
 /**
- * This file was generated by the @pikku/cli
+
  * CLI-specific type definitions for tree-shaking optimization
  */
-import { wireCLI as wireCLICore } from '@pikku/core';
+import { wireCLI as wireCLICore } from '@pikku/core/cli';
 /**
  * Registers a CLI application with the Pikku framework.
  * Creates command-line interfaces with type-safe commands and options.
@@ -21,7 +21,8 @@ export const wireCLI = (cli) => {
  * Creates a CLI command definition with automatic option inference from the function's input type.
  * This allows TypeScript to automatically derive CLI options from the function signature.
  *
- * @template Func - The Pikku function config type to create a CLI command for
+ * @template FuncConfig - The Pikku function config type
+ * @template Params - The parameters string literal type
  * @param config - CLI command configuration
  * @returns CLI command configuration with inferred types
  */

package/dist/.pikku/cli/pikku-cli-wirings-meta.gen.js

@@ -1,5 +1,145 @@
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
 import { pikkuState } from '@pikku/core';
-pikkuState('cli', 'meta', {});
+pikkuState('cli', 'meta', {
+    "programs": {
+        "pikku": {
+            "program": "pikku",
+            "commands": {
+                "all": {
+                    "pikkuFuncName": "all",
+                    "positionals": [],
+                    "options": {
+                        "tags": {
+                            "description": "Filter functions by tags (comma-separated)",
+                            "short": "t"
+                        },
+                        "types": {
+                            "description": "Filter functions by types (comma-separated)"
+                        },
+                        "directories": {
+                            "description": "Filter functions by directories (comma-separated)",
+                            "short": "d"
+                        },
+                        "httpMethods": {
+                            "description": "Filter HTTP routes by methods (comma-separated)"
+                        },
+                        "httpRoutes": {
+                            "description": "Filter HTTP routes by route patterns (comma-separated)"
+                        },
+                        "names": {
+                            "description": "Filter functions by name patterns (supports wildcards)",
+                            "short": "n"
+                        }
+                    },
+                    "description": "Generate all Pikku files (types, schemas, wirings, etc.)",
+                    "isDefault": true
+                },
+                "schemas": {
+                    "pikkuFuncName": "pikkuSchemas",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate JSON schemas for function input/output types"
+                },
+                "fetch": {
+                    "pikkuFuncName": "pikkuFetch",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate type-safe HTTP fetch client"
+                },
+                "websocket": {
+                    "pikkuFuncName": "pikkuWebSocketTyped",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate type-safe WebSocket client"
+                },
+                "rpc": {
+                    "pikkuFuncName": "pikkuRPCClient",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate RPC client wrappers"
+                },
+                "queue-service": {
+                    "pikkuFuncName": "pikkuQueueService",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate queue service wrapper"
+                },
+                "openapi": {
+                    "pikkuFuncName": "pikkuOpenAPI",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate OpenAPI specification from HTTP routes"
+                },
+                "nextjs": {
+                    "pikkuFuncName": "pikkuNext",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Generate Next.js backend and HTTP wrappers"
+                }
+            },
+            "options": {
+                "config": {
+                    "description": "Path to pikku.config.json file",
+                    "short": "c"
+                },
+                "logLevel": {
+                    "description": "Set log level",
+                    "short": "l",
+                    "choices": [
+                        "trace",
+                        "debug",
+                        "info",
+                        "warn",
+                        "error",
+                        "critical"
+                    ]
+                },
+                "userSessionType": {
+                    "description": "Specify which UserSession type to use (when multiple exist)"
+                },
+                "singletonServicesFactoryType": {
+                    "description": "Specify which singleton services factory to use"
+                },
+                "sessionServicesFactoryType": {
+                    "description": "Specify which session services factory to use"
+                },
+                "stateOutput": {
+                    "description": "Save inspector state to JSON file for reuse"
+                },
+                "stateInput": {
+                    "description": "Load inspector state from JSON file (skips inspection)"
+                }
+            },
+            "defaultRenderName": "clientCLIRenderer"
+        }
+    },
+    "renderers": {
+        "defaultCLIRenderer": {
+            "name": "defaultCLIRenderer",
+            "exportedName": "defaultCLIRenderer",
+            "services": {
+                "optimized": true,
+                "services": [
+                    "logger",
+                    "getInspectorState",
+                    "schema",
+                    "jwt",
+                    "config",
+                    "variables"
+                ]
+            },
+            "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"
+        },
+        "clientCLIRenderer": {
+            "name": "clientCLIRenderer",
+            "exportedName": "clientCLIRenderer",
+            "services": {
+                "optimized": true,
+                "services": []
+            },
+            "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"
+        }
+    }
+});

package/dist/.pikku/cli/pikku-cli-wirings.gen.d.ts

@@ -1,4 +1,5 @@
-export {};
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
+import '../../src/services.js';
+import '../../src/cli.wiring.js';

package/dist/.pikku/cli/pikku-cli-wirings.gen.js

@@ -1,5 +1,6 @@
-export {};
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
-/* The files with an wireCLI function call */ 
+/* The files with an wireCLI function call */
+import '../../src/services.js';
+import '../../src/cli.wiring.js';

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

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.10.0
+ */
+import '../pikku-bootstrap.gen.js';
+/**
+ * Pikku CLI function
+ * Handles command line arguments and executes the appropriate function
+ */
+export declare function PikkuCLI(args: string[]): Promise<void>;
+export default PikkuCLI;

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

@@ -0,0 +1,38 @@
+/**
+ * This file was generated by @pikku/cli@0.10.0
+ */
+import { executeCLI, CLIError } from '@pikku/core/cli';
+import { createConfig as createConfig } from '../../src/services.js';
+import { createSingletonServices as createSingletonServices } from '../../src/services.js';
+import { createSessionServices as createSessionServices } from '../../src/services.js';
+import '../pikku-bootstrap.gen.js';
+/**
+ * Pikku CLI function
+ * Handles command line arguments and executes the appropriate function
+ */
+export async function PikkuCLI(args) {
+    try {
+        await executeCLI({
+            programName: 'pikku',
+            args: args || process.argv.slice(2),
+            createConfig,
+            createSingletonServices,
+            createSessionServices,
+        });
+    }
+    catch (error) {
+        if (error instanceof CLIError) {
+            process.exit(error.exitCode);
+        }
+        throw error;
+    }
+}
+// Export as default for easy importing
+export default PikkuCLI;
+// For direct execution (if this file is run directly)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    PikkuCLI(process.argv.slice(2)).catch(error => {
+        console.error('Fatal error:', error.message);
+        process.exit(1);
+    });
+}

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

@@ -1,17 +1,19 @@
 /**
- * This file was generated by the @pikku/cli
+ * This file was generated by @pikku/cli@0.10.0
  */
 /**
- * This file was generated by the @pikku/cli
  * Core function, middleware, and permission types for all wirings
  */
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware } from '@pikku/core';
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup } from '@pikku/core';
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function';
-import { PikkuChannel, PikkuMCP } from '@pikku/core';
+import { PikkuChannel } from '@pikku/core/channel';
+import { PikkuMCP } from '@pikku/core/mcp';
 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 } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
+import type { RequiredSingletonServices, RequiredSessionServices } from '../pikku-services.gen.js';
 type Session = UserSession;
 /**
  * Type-safe API permission definition that integrates with your application's session type.
@@ -28,31 +30,74 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  * @template RequiredServices - The services required for this middleware
  */
 export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>;
+/**
+ * Configuration object for creating a permission with metadata
+ */
+export type PikkuPermissionConfig<In = unknown, RequiredServices extends Services = Services> = {
+    /** 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.
- * This enables the bundler to detect which services your permission actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * ```typescript
+ * // Direct function syntax
  * const permission = pikkuPermission(({ logger }, data, session) => {
- *   return session?.isAdmin || false
+ *   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) => {
+ *     return session?.role === 'admin'
+ *   }
  * })
  * ```
  */
-export declare const pikkuPermission: <In>(func: PikkuPermission<In>) => PikkuPermission<In, Services>;
+export declare const pikkuPermission: <In>(permission: PikkuPermission<In> | PikkuPermissionConfig<In>) => PikkuPermission<In>;
+/**
+ * Configuration object for creating middleware with metadata
+ */
+export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = SingletonServices> = {
+    /** 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.
- * This enables the bundler to detect which services your middleware actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * ```typescript
+ * // Direct function syntax
  * const middleware = pikkuMiddleware(({ logger }, interactions, 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 }, interactions, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
  * ```
  */
-export declare const pikkuMiddleware: (func: PikkuMiddleware) => PikkuMiddleware<SingletonServices>;
+export declare const pikkuMiddleware: <RequiredServices extends SingletonServices = SingletonServices>(middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>) => PikkuMiddleware<RequiredServices>;
 /**
  * Factory function for creating middleware factories
  * Use this when your middleware needs configuration/input parameters
@@ -71,6 +116,26 @@ export declare const pikkuMiddleware: (func: PikkuMiddleware) => PikkuMiddleware
  * ```
  */
 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 sessionless API function that doesn't require user authentication.
  * Use this for public endpoints, health checks, or operations that don't need user context.
@@ -83,7 +148,7 @@ export declare const pikkuMiddlewareFactory: <In = any>(factory: (input: In) =>
  */
 export type PikkuFunctionSessionless<In = unknown, Out = never, ChannelData = null, // null means optional channel
 MCPData = null, // null means optional MCP
-RequiredServices extends Services = Services & {
+RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> & {
     rpc: TypedPikkuRPC;
 } & ([
     ChannelData
@@ -108,7 +173,7 @@ RequiredServices extends Services = Services & {
  */
 export type PikkuFunction<In = unknown, Out = never, ChannelData = null, // null means optional channel
 MCPData = null, // null means optional MCP
-RequiredServices extends Services = Omit<Services, 'rpc'> & {
+RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> & {
     rpc: TypedPikkuRPC;
 } & ([
     ChannelData
@@ -127,9 +192,11 @@ RequiredServices extends Services = Omit<Services, 'rpc'> & {
  *
  * @template In - The input type
  * @template Out - The output type
+ * @template ChannelData - Channel data type
+ * @template MCPData - MCP data type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
-export type PikkuFunctionConfig<In = unknown, Out = unknown, PikkuFunc extends PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out> = PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out>> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>;
+export type PikkuFunctionConfig<In = unknown, Out = unknown, ChannelData = unknown, MCPData = unknown, PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>;
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
@@ -151,13 +218,13 @@ export type PikkuFunctionConfig<In = unknown, Out = unknown, PikkuFunc extends P
  * })
  * \`\`\`
  */
-export declare const pikkuFunc: <In, Out = unknown>(func: PikkuFunction<In, Out> | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>>) => CorePikkuFunctionConfig<PikkuFunction<In, Out, null, null, Omit<Services, "rpc"> & {
+export declare const pikkuFunc: <In, Out = unknown>(func: PikkuFunction<In, Out> | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>) => CorePikkuFunctionConfig<PikkuFunction<In, Out, null, null, Omit<Services, "rpc" | "channel" | "mcp"> & {
     rpc: TypedPikkuRPC;
 } & {
     channel?: PikkuChannel<unknown, Out> | undefined;
 } & {
     mcp?: PikkuMCP;
-}>, PikkuPermission<In, Services>>;
+}>, PikkuPermission<In, Services>, PikkuMiddleware<SingletonServices>>;
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
@@ -178,7 +245,7 @@ export declare const pikkuFunc: <In, Out = unknown>(func: PikkuFunction<In, Out>
  * })
  * \`\`\`
  */
-export declare const pikkuSessionlessFunc: <In, Out = unknown>(func: PikkuFunctionSessionless<In, Out> | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>) => CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, null, null, Services & {
+export declare const pikkuSessionlessFunc: <In, Out = unknown>(func: PikkuFunctionSessionless<In, Out> | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>) => CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, null, null, Omit<Services, "rpc" | "channel" | "mcp"> & {
     rpc: TypedPikkuRPC;
 } & {
     channel?: PikkuChannel<unknown, Out> | undefined;
@@ -201,13 +268,67 @@ export declare const pikkuSessionlessFunc: <In, Out = unknown>(func: PikkuFuncti
  * })
  * \`\`\`
  */
-export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void> | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>) => CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, null, null, Services & {
+export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void> | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>) => CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, null, null, Omit<Services, "rpc" | "channel" | "mcp"> & {
     rpc: TypedPikkuRPC;
 } & {
     channel?: PikkuChannel<unknown, void> | undefined;
 } & {
     mcp?: PikkuMCP;
 }>, PikkuPermission<void, Services>>;
+/**
+ * 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<RequiredSingletonServices>) => (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>;
+/**
+ * Creates a Pikku session services factory.
+ * Use this to define services that are created per-request/session.
+ *
+ * @param func - Session services factory function
+ * @returns The session services factory function
+ *
+ * @example
+ * ```typescript
+ * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ *   return {
+ *     userCache: new UserCache(session?.userId)
+ *   }
+ * })
+ * ```
+ */
+export declare const pikkuSessionServices: (func: (services: SingletonServices, interaction: any, session: Session | undefined) => Promise<RequiredSessionServices>) => (services: SingletonServices, interaction: any, session: Session | undefined) => Promise<RequiredSessionServices>;
 /**
  * Adds global middleware for a specific tag.
  *
@@ -239,7 +360,7 @@ export declare const addMiddleware: (tag: string, middleware: PikkuMiddleware[])
  * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
  *
  * @param tag - The tag that the permissions should apply to.
- * @param permissions - The permissions array to apply for the specified tag.
+ * @param permissions - The permissions array or object to apply for the specified tag.
  *
  * @throws Error if permissions for the tag already exist.
  *
@@ -251,9 +372,9 @@ export declare const addMiddleware: (tag: string, middleware: PikkuMiddleware[])
  * // Add authentication permissions for auth endpoints
  * addPermission('auth', [authPermission])
  *
- * // Add read permissions for all API endpoints
- * addPermission('api', [readPermission])
+ * // Add read permissions for all API endpoints (as object)
+ * addPermission('api', { read: readPermission })
  * ```
  */
-export declare const addPermission: <In = unknown>(tag: string, permissions: PikkuPermission<In>[]) => void;
+export declare const addPermission: <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => void;
 export {};