@pikku/core 0.9.4 → 0.9.6

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## 0.9.0
 
+## 0.9.6
+
+### Patch Changes
+
+- 6059c87: refactor: move PikkuPermission to pikkuPermission and same for middleware for api consistency to to improve future features
+- 6db63bb: perf: changing http meta to a lookup map to reduce loops
+- 74f8634: perf: moving router externally to be able to swap them out, similar to hono
+- 766fef1: feat: adding caching for middleware and permissions
+
+## 0.9.5
+
+### Patch Changes
+
+- 7e1f5b3: feat: implement ordered middleware and permission execution system
+
+  ## New Features
+
+  ### Ordered Execution System
+
+  Both middleware and permissions now execute in a specific hierarchical order:
+
+  1. **Wiring Tags** - Tag-based middleware/permissions from wiring level (e.g., HTTP route tags)
+  2. **Wiring Middleware/Permissions** - Direct wiring-level middleware/permissions
+  3. **Function Middleware** - Function-level middleware
+  4. **Function Tags** - Tag-based middleware/permissions from function level
+
+- b443405: feat: adding middleware and functions by tags
+
 ## 0.9.4
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -1,8 +1,8 @@
-import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
+import { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from './functions.types.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any> | CorePikkuFunctionSessionless<any, any> | CorePikkuFunction<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;

package/dist/function/function-runner.js

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '../errors/errors.js';
-import { runMiddleware } from '../middleware-runner.js';
-import { verifyPermissions, getPermissionsForTags } from '../permissions.js';
+import { runMiddleware, combineMiddleware } from '../middleware-runner.js';
+import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 export const addFunction = (funcName, funcConfig) => {
@@ -16,7 +16,7 @@ export const runPikkuFuncDirectly = async (funcName, allServices, data, session)
     }
     return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags = [], }) => {
+export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices, data, session, permissions: wiringPermissions, middleware: wiringMiddleware, coerceDataFromSchema, tags = [], }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -38,32 +38,29 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
             coerceTopLevelDataFromSchema(inputSchemaName, data);
         }
     }
-    let permissioned = true;
-    // Check tagged permissions first - ALL must pass
-    const taggedPermissions = getPermissionsForTags([
-        ...tags,
-        ...(funcConfig.tags || []),
-    ]);
-    if (taggedPermissions.length > 0) {
-        const taggedResults = await Promise.all(taggedPermissions.map((permission) => permission(allServices, data, session)));
-        permissioned = taggedResults.every((result) => result);
-    }
-    // Only check function permissions if tagged permissions passed
-    if (permissioned && funcConfig.permissions) {
-        permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
-    }
-    if (!permissioned && transportPermissions) {
-        permissioned = await verifyPermissions(transportPermissions, allServices, data, session);
-    }
-    if (permissioned === false) {
-        throw new ForbiddenError('Permission denied');
-    }
-    if (transportMiddleware || funcConfig.middleware) {
+    // Run permission checks in the specified order
+    await runPermissions(wireType, wireId, {
+        wiringTags: tags,
+        wiringPermissions,
+        funcTags: funcConfig.tags,
+        funcPermissions: funcConfig.permissions,
+        allServices,
+        data,
+        session,
+    });
+    // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
+    const allMiddleware = combineMiddleware(wireType, wireId, {
+        wiringTags: tags,
+        wiringMiddleware,
+        funcMiddleware: funcConfig.middleware,
+        funcTags: funcConfig.tags,
+    });
+    if (allMiddleware.length > 0) {
         return (await runMiddleware(allServices, {
             http: allServices.http,
             mcp: allServices.mcp,
             rpc: allServices.rpc,
-        }, [...(transportMiddleware || []), ...(funcConfig.middleware || [])], async () => await funcConfig.func(allServices, data, session)));
+        }, allMiddleware, async () => await funcConfig.func(allServices, data, session)));
     }
     return (await funcConfig.func(allServices, data, session));
 };

package/dist/function/functions.types.d.ts

@@ -34,6 +34,10 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
+/**
+ * Factory function for creating permissions with tree-shaking support
+ */
+export declare const pikkuPermission: <In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession>(permission: CorePikkuPermission<In, Services, Session>) => CorePikkuPermission<In, Services, Session>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
 export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>> = {
     name?: string;

package/dist/function/functions.types.js

@@ -1 +1,6 @@
-export {};
+/**
+ * Factory function for creating permissions with tree-shaking support
+ */
+export const pikkuPermission = (permission) => {
+    return permission;
+};

package/dist/index.d.ts

@@ -18,11 +18,11 @@ export * from './wirings/queue/index.js';
 export * from './wirings/mcp/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
-export * from './time-utils.js';
 export * from './utils.js';
+export * from './time-utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
-export { addPermission, getPermissionsForTags } from './permissions.js';
+export { addMiddleware, runMiddleware } from './middleware-runner.js';
+export { addPermission } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/index.js

@@ -18,11 +18,11 @@ export * from './wirings/queue/index.js';
 export * from './wirings/mcp/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
-export * from './time-utils.js';
 export * from './utils.js';
+export * from './time-utils.js';
 export { pikkuState } from './pikku-state.js';
-export { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
-export { addPermission, getPermissionsForTags } from './permissions.js';
+export { addMiddleware, runMiddleware } from './middleware-runner.js';
+export { addPermission } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/middleware-runner.d.ts

@@ -1,5 +1,5 @@
 import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './types/core.types.js';
+import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware, PikkuWiringTypes } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -19,7 +19,7 @@ import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './
  */
 export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
     userSession?: UserSessionService<any>;
-}, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
+}, interaction: PikkuInteraction, middlewares: readonly Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
 /**
  * Adds global middleware for a specific tag.
  *
@@ -62,23 +62,32 @@ export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware
  */
 export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddleware[];
 /**
- * Combines tag-based middleware with wiring-specific middleware.
+ * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
  * This helper function gets middleware for tags and combines it with any
- * wiring-specific middleware, avoiding the need for manual spreading.
+ * wiring-specific middleware and function-level middleware, avoiding the need for manual spreading.
  *
- * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
- * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @param {object} options - Configuration object for combining middleware.
+ * @param {CorePikkuMiddleware[] | undefined} options.wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} options.wiringTags - Array of wiring-level tags to look up middleware for.
+ * @param {CorePikkuMiddleware[] | undefined} options.funcMiddleware - Function-level middleware.
+ * @param {string[] | undefined} options.funcTags - Array of function-level tags to look up middleware for.
  * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
  *
  * @example
  * ```typescript
- * // Instead of:
- * const taggedMiddleware = getMiddlewareForTags(tags)
- * const combined = [...taggedMiddleware, ...(middleware || [])]
- *
- * // Use:
- * const combined = addMiddlewareForTags(middleware, tags)
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
  * ```
  */
-export declare const addMiddlewareForTags: (wiringMiddleware?: CorePikkuMiddleware[], tags?: string[]) => CorePikkuMiddleware[];
+export declare const combineMiddleware: (wireType: PikkuWiringTypes, uid: string, { httpMiddleware, wiringMiddleware, wiringTags, funcMiddleware, funcTags, }?: {
+    httpMiddleware?: CorePikkuMiddleware[];
+    wiringMiddleware?: CorePikkuMiddleware[];
+    wiringTags?: string[];
+    funcMiddleware?: CorePikkuMiddleware[];
+    funcTags?: string[];
+}) => readonly CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -1,4 +1,6 @@
+import { PikkuWiringTypes, } from './types/core.types.js';
 import { pikkuState } from './pikku-state.js';
+import { freezeDedupe } from './utils.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -18,11 +20,10 @@ import { pikkuState } from './pikku-state.js';
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
     // Deduplicate middleware using Set to avoid running the same middleware multiple times
-    const uniqueMiddleware = Array.from(new Set(middlewares));
     let result;
     const dispatch = async (index) => {
-        if (uniqueMiddleware && index < uniqueMiddleware.length) {
-            return await uniqueMiddleware[index](services, interaction, () => dispatch(index + 1));
+        if (middlewares && index < middlewares.length) {
+            return await middlewares[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -93,27 +94,54 @@ export const getMiddlewareForTags = (tags) => {
     }
     return applicableMiddleware;
 };
+const middlewareCache = {
+    [PikkuWiringTypes.http]: {},
+    [PikkuWiringTypes.rpc]: {},
+    [PikkuWiringTypes.channel]: {},
+    [PikkuWiringTypes.queue]: {},
+    [PikkuWiringTypes.scheduler]: {},
+    [PikkuWiringTypes.mcp]: {},
+};
 /**
- * Combines tag-based middleware with wiring-specific middleware.
+ * Combines tag-based middleware with wiring-specific middleware and function-level middleware.
  *
  * This helper function gets middleware for tags and combines it with any
- * wiring-specific middleware, avoiding the need for manual spreading.
+ * wiring-specific middleware and function-level middleware, avoiding the need for manual spreading.
  *
- * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
- * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @param {object} options - Configuration object for combining middleware.
+ * @param {CorePikkuMiddleware[] | undefined} options.wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} options.wiringTags - Array of wiring-level tags to look up middleware for.
+ * @param {CorePikkuMiddleware[] | undefined} options.funcMiddleware - Function-level middleware.
+ * @param {string[] | undefined} options.funcTags - Array of function-level tags to look up middleware for.
  * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
  *
  * @example
  * ```typescript
- * // Instead of:
- * const taggedMiddleware = getMiddlewareForTags(tags)
- * const combined = [...taggedMiddleware, ...(middleware || [])]
- *
- * // Use:
- * const combined = addMiddlewareForTags(middleware, tags)
+ * const combined = combineMiddleware({
+ *   wiringMiddleware: httpRoute.middleware,
+ *   wiringTags: httpRoute.tags,
+ *   funcMiddleware: funcConfig.middleware,
+ *   funcTags: funcConfig.tags
+ * })
  * ```
  */
-export const addMiddlewareForTags = (wiringMiddleware, tags) => {
-    const taggedMiddleware = getMiddlewareForTags(tags);
-    return [...taggedMiddleware, ...(wiringMiddleware || [])];
+export const combineMiddleware = (wireType, uid, { httpMiddleware, wiringMiddleware, wiringTags, funcMiddleware, funcTags, } = {}) => {
+    if (middlewareCache[wireType][uid]) {
+        return middlewareCache[wireType][uid];
+    }
+    // Run middleware in specific order:
+    // 1) wiringTags middleware
+    // 2) wiringMiddleware
+    // 3) funcMiddleware
+    // 4) funcTags middleware
+    const wiringTaggedMiddleware = getMiddlewareForTags(wiringTags);
+    const funcTaggedMiddleware = getMiddlewareForTags(funcTags);
+    middlewareCache[wireType][uid] = freezeDedupe([
+        ...(httpMiddleware || []),
+        ...wiringTaggedMiddleware,
+        ...(wiringMiddleware || []),
+        ...(funcMiddleware || []),
+        ...funcTaggedMiddleware,
+    ]);
+    return middlewareCache[wireType][uid];
 };

package/dist/permissions.d.ts

@@ -1,5 +1,5 @@
-import { CoreServices, CoreUserSession } from './types/core.types.js';
-import { CorePermissionGroup } from './function/functions.types.js';
+import { CoreServices, CoreUserSession, PikkuWiringTypes } from './types/core.types.js';
+import { CorePermissionGroup, CorePikkuPermission } from './function/functions.types.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
  * @param services - The core services required for permission validation.
@@ -31,7 +31,7 @@ export declare const verifyPermissions: (permissions: CorePermissionGroup, servi
  * addPermission('api', [readPermission])
  * ```
  */
-export declare const addPermission: (tag: string, permissions: any[]) => void;
+export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => void;
 /**
  * Retrieves permissions for a given set of tags.
  *
@@ -47,4 +47,20 @@ export declare const addPermission: (tag: string, permissions: any[]) => void;
  * const permissions = getPermissionsForTags(['api', 'auth'])
  * ```
  */
-export declare const getPermissionsForTags: (tags?: string[]) => any[];
+export declare const getPermissionsForTags: (tags?: string[]) => readonly (CorePermissionGroup | CorePikkuPermission)[];
+/**
+ * Runs permission checks in the specified order:
+ * 1) wiring tag permissions - at least one must pass if any exist
+ * 2) wiring permissions - must pass if defined
+ * 3) function tag permissions - at least one must pass if any exist
+ * 4) function permissions - must pass if defined
+ */
+export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wiringTags, wiringPermissions, funcTags, funcPermissions, allServices, data, session, }: {
+    wiringTags?: string[];
+    wiringPermissions?: CorePermissionGroup;
+    funcTags?: string[];
+    funcPermissions?: CorePermissionGroup;
+    allServices: CoreServices;
+    data: any;
+    session?: CoreUserSession;
+}) => Promise<void>;

package/dist/permissions.js

@@ -1,4 +1,6 @@
+import { PikkuWiringTypes, } from './types/core.types.js';
 import { pikkuState } from './pikku-state.js';
+import { ForbiddenError } from './errors/errors.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
  * @param services - The core services required for permission validation.
@@ -62,6 +64,7 @@ export const addPermission = (tag, permissions) => {
     }
     permissionsStore[tag] = permissions;
 };
+const EMPTY = [];
 /**
  * Retrieves permissions for a given set of tags.
  *
@@ -79,7 +82,7 @@ export const addPermission = (tag, permissions) => {
  */
 export const getPermissionsForTags = (tags) => {
     if (!tags || tags.length === 0) {
-        return [];
+        return EMPTY;
     }
     const permissionsStore = pikkuState('misc', 'permissions');
     const applicablePermissions = [];
@@ -87,8 +90,87 @@ export const getPermissionsForTags = (tags) => {
     for (const tag of new Set(tags)) {
         const tagPermissions = permissionsStore[tag];
         if (tagPermissions) {
-            applicablePermissions.push(...tagPermissions);
+            if (Array.isArray(tagPermissions)) {
+                applicablePermissions.push(...tagPermissions);
+            }
+            else {
+                applicablePermissions.push(tagPermissions);
+            }
         }
     }
     return applicablePermissions;
 };
+const permissionCache = {
+    [PikkuWiringTypes.http]: {},
+    [PikkuWiringTypes.rpc]: {},
+    [PikkuWiringTypes.channel]: {},
+    [PikkuWiringTypes.queue]: {},
+    [PikkuWiringTypes.scheduler]: {},
+    [PikkuWiringTypes.mcp]: {},
+};
+/**
+ * Runs permission checks in the specified order:
+ * 1) wiring tag permissions - at least one must pass if any exist
+ * 2) wiring permissions - must pass if defined
+ * 3) function tag permissions - at least one must pass if any exist
+ * 4) function permissions - must pass if defined
+ */
+export const runPermissions = async (wireType, uid, { wiringTags, wiringPermissions, funcTags, funcPermissions, allServices, data, session, }) => {
+    let cachedPermission = permissionCache[wireType][uid];
+    if (!cachedPermission) {
+        cachedPermission = {
+            wiringTags: getPermissionsForTags(wiringTags),
+            funcTags: getPermissionsForTags(funcTags),
+        };
+        permissionCache[wireType][uid] = cachedPermission;
+    }
+    let permissioned = true;
+    // 1. Wiring tag permissions - at least one must pass if any exist
+    const wiringTaggedPermissions = cachedPermission.wiringTags;
+    if (wiringTaggedPermissions.length > 0) {
+        permissioned = false; // Start false, need at least one to pass
+        for (const permissions of wiringTaggedPermissions) {
+            const result = await verifyPermissions(typeof permissions === 'function' ? { permissions } : permissions, allServices, data, session);
+            if (result) {
+                permissioned = true;
+                break; // At least one passed, we're good at this level
+            }
+        }
+        if (!permissioned) {
+            allServices.logger.debug('Permission denied - wiring tag permissions');
+            throw new ForbiddenError('Permission denied');
+        }
+    }
+    // 2. Wiring permissions - must pass if defined
+    if (wiringPermissions) {
+        permissioned = await verifyPermissions(wiringPermissions, allServices, data, session);
+        if (!permissioned) {
+            allServices.logger.debug('Permission denied - wiring permissions');
+            throw new ForbiddenError('Permission denied');
+        }
+    }
+    // 3. Function tag permissions - at least one must pass if any exist
+    const funcTaggedPermissions = cachedPermission.funcTags;
+    if (funcTaggedPermissions.length > 0) {
+        permissioned = false; // Start false, need at least one to pass
+        for (const permissions of funcTaggedPermissions) {
+            const result = await verifyPermissions(typeof permissions === 'function' ? { permissions } : permissions, allServices, data, session);
+            if (result) {
+                permissioned = true;
+                break; // At least one passed, we're good at this level
+            }
+        }
+        if (!permissioned) {
+            allServices.logger.debug('Permission denied - function tag permissions');
+            throw new ForbiddenError('Permission denied');
+        }
+    }
+    // 4. Function permissions - must pass if defined
+    if (funcPermissions) {
+        permissioned = await verifyPermissions(funcPermissions, allServices, data, session);
+        if (!permissioned) {
+            allServices.logger.debug('Permission denied - function permissions');
+            throw new ForbiddenError('Permission denied');
+        }
+    }
+};

package/dist/pikku-state.d.ts

@@ -3,7 +3,7 @@ import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/h
 import { FunctionsMeta, CorePikkuMiddleware } from './types/core.types.js';
 import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
-import { CorePikkuFunctionConfig } from './function/functions.types.js';
+import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './function/functions.types.js';
 import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 interface PikkuState {
@@ -19,10 +19,8 @@ interface PikkuState {
         }>;
     };
     http: {
-        middleware: Array<{
-            route: string;
-            middleware: CorePikkuMiddleware[];
-        }>;
+        middleware: Map<string, CorePikkuMiddleware<any, any>[]>;
+        permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>;
         routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
         meta: HTTPWiringsMeta;
     };
@@ -50,7 +48,7 @@ interface PikkuState {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;
         middleware: Record<string, CorePikkuMiddleware[]>;
-        permissions: Record<string, any[]>;
+        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -9,9 +9,10 @@ export const resetPikkuState = () => {
             files: new Map(),
         },
         http: {
-            middleware: [],
+            permissions: new Map(),
+            middleware: new Map(),
             routes: new Map(),
-            meta: [],
+            meta: {},
         },
         channel: {
             channels: new Map(),
@@ -35,9 +36,9 @@ export const resetPikkuState = () => {
         },
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
-            schemas: globalThis.pikkuState?.misc?.schema || new Map(),
-            middleware: globalThis.pikkuState?.misc?.middleware || {},
-            permissions: globalThis.pikkuState?.misc?.permissions || {},
+            schemas: new Map(),
+            middleware: {},
+            permissions: {},
         },
     };
 };

package/dist/schema.js

@@ -27,13 +27,15 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
     const routesMeta = pikkuState('http', 'meta');
     const validators = schemaService.getSchemaNames();
     const missingSchemas = [];
-    for (const route of routesMeta) {
-        const inputs = pikkuState('function', 'meta')[route.pikkuFuncName]?.inputs;
-        const input = inputs?.[0];
-        if (!input || validators.has(input)) {
-            continue;
+    for (const routePaths of Object.values(routesMeta)) {
+        for (const meta of Object.values(routePaths)) {
+            const inputs = pikkuState('function', 'meta')[meta.pikkuFuncName]?.inputs;
+            const input = inputs?.[0];
+            if (!input || validators.has(input)) {
+                continue;
+            }
+            missingSchemas.push(input);
         }
-        missingSchemas.push(input);
     }
     if (missingSchemas.length > 0) {
         logger.error(`Error: Failed to load schemas:\n.${missingSchemas.join('\n')}`);

package/dist/types/core.types.d.ts

@@ -92,14 +92,13 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
-export type PikkuInteraction = Partial<{
-    http: PikkuHTTP;
+export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
+    http: PikkuHTTP<In>;
     mcp: PikkuMCP;
     rpc: PikkuRPC;
-    channel: PikkuChannel<unknown, unknown>;
+    channel: PikkuChannel<unknown, Out>;
     scheduledTask: PikkuScheduledTask;
     queue: PikkuQueue;
-    s: any;
 }>;
 /**
  * A function that can wrap an interaction and be called before or after
@@ -107,6 +106,10 @@ export type PikkuInteraction = Partial<{
 export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
     userSession: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+/**
+ * Factory function for creating middleware with tree-shaking support
+ */
+export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>(middleware: CorePikkuMiddleware<SingletonServices, UserSession>) => CorePikkuMiddleware<SingletonServices, UserSession>;
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */

package/dist/types/core.types.js

@@ -7,3 +7,9 @@ export var PikkuWiringTypes;
     PikkuWiringTypes["queue"] = "queue";
     PikkuWiringTypes["mcp"] = "mcp";
 })(PikkuWiringTypes || (PikkuWiringTypes = {}));
+/**
+ * Factory function for creating middleware with tree-shaking support
+ */
+export const pikkuMiddleware = (middleware) => {
+    return middleware;
+};

package/dist/utils.d.ts

@@ -2,3 +2,4 @@ import { Logger } from './services/logger.js';
 export declare const closeSessionServices: (logger: Logger, sessionServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
+export declare const freezeDedupe: <T extends Function>(arr?: readonly T[] | T[] | undefined) => readonly T[];

package/dist/utils.js

@@ -28,3 +28,20 @@ export const isSerializable = (data) => {
         data instanceof Float32Array ||
         data instanceof Float64Array);
 };
+const EMPTY_ARRAY = Object.freeze([]);
+export const freezeDedupe = (arr) => {
+    if (!arr || arr.length === 0)
+        return EMPTY_ARRAY;
+    if (arr.length === 1)
+        return Object.freeze([arr[0]]);
+    const seen = new Set();
+    const out = [];
+    for (let i = 0; i < arr.length; i++) {
+        const fn = arr[i];
+        if (!seen.has(fn)) {
+            seen.add(fn);
+            out.push(fn);
+        }
+    }
+    return Object.freeze(out);
+};

package/dist/wirings/channel/channel-handler.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
@@ -47,7 +48,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         const { pikkuFuncName } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
         const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
         const middleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
-        return await runPikkuFunc(pikkuFuncName, {
+        return await runPikkuFunc(PikkuWiringTypes.channel, channelConfig.name, pikkuFuncName, {
             getAllServices: () => ({
                 ...services,
                 channel: channelHandler.getChannel(),