@pikku/inspector 0.9.6-next.0 → 0.10.1

package/dist/add/add-middleware.js

@@ -2,6 +2,8 @@ import * as ts from 'typescript';
 import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
 import { extractMiddlewarePikkuNames } from '../utils/middleware.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 /**
  * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
  */
@@ -15,23 +17,46 @@ export const addMiddleware = (logger, node, checker, state) => {
     }
     // Handle pikkuMiddleware(...) - individual middleware function definition
     if (expression.text === 'pikkuMiddleware') {
-        const handlerNode = args[0];
-        if (!handlerNode)
+        const arg = args[0];
+        if (!arg)
             return;
-        if (!ts.isArrowFunction(handlerNode) &&
-            !ts.isFunctionExpression(handlerNode)) {
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuMiddleware({ func: ..., name: '...', description: '...' })
+        if (ts.isObjectLiteralExpression(arg)) {
+            // Extract name and description metadata
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            // Extract the func property
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuMiddleware object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
             logger.error(`• Handler for pikkuMiddleware is not a function.`);
             return;
         }
-        const services = extractServicesFromFunction(handlerNode);
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
         state.middleware.meta[pikkuFuncName] = {
             services,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
+            name,
+            description,
         };
-        logger.debug(`• Found middleware with services: ${services.services.join(', ')}`);
+        logger.debug(`• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
     // Handle pikkuMiddlewareFactory(...) - middleware factory function
@@ -46,6 +71,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // Extract services by looking inside the factory function body
         // The factory should return pikkuMiddleware(...), so we need to find that call
+        // If no wrapper is found, extract from the factory's returned function directly
         let services = { optimized: false, services: [] };
         const findPikkuMiddlewareCall = (node) => {
             if (ts.isCallExpression(node)) {
@@ -64,7 +90,20 @@ export const addMiddleware = (logger, node, checker, state) => {
                 services = extractServicesFromFunction(middlewareHandler);
             }
         }
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        else {
+            // No pikkuMiddleware wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, interaction, next) => { ... }
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                // Check if the body is an arrow function (direct return)
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
         state.middleware.meta[pikkuFuncName] = {
             services,
             sourceFile: node.getSourceFile().fileName,
@@ -99,7 +138,7 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
         if (middlewareNames.length === 0) {
             logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`);
             return;
@@ -139,7 +178,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // If not a factory, get export name from the call expression itself
         if (!isFactory) {
-            const extracted = extractFunctionName(node, checker);
+            const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
         // Log warning if not using factory pattern
@@ -186,7 +225,7 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
         if (middlewareNames.length === 0) {
             logger.warn(`• addHTTPMiddleware('${pattern}', ...) has empty middleware array`);
             return;
@@ -225,7 +264,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // If not a factory, get export name from the call expression itself
         if (!isFactory) {
-            const extracted = extractFunctionName(node, checker);
+            const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
         // Log warning if not using factory pattern

package/dist/add/add-permission.d.ts

@@ -1,6 +1,5 @@
 import { AddWiring } from '../types.js';
 /**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */
 export declare const addPermission: AddWiring;

package/dist/add/add-permission.js

@@ -1,36 +1,292 @@
 import * as ts from 'typescript';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { extractPermissionPikkuNames } from '../utils/permissions.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 /**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */
 export const addPermission = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
-    // only handle calls like pikkuPermission(...)
+    // only handle specific function calls
     if (!ts.isIdentifier(expression)) {
         return;
     }
-    if (expression.text !== 'pikkuPermission') {
+    // Handle pikkuPermission(...) - individual permission function definition
+    if (expression.text === 'pikkuPermission') {
+        const arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuPermission({ func: ..., name: '...', description: '...' })
+        if (ts.isObjectLiteralExpression(arg)) {
+            // Extract name and description metadata
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            // Extract the func property
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuPermission object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuPermission is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            name,
+            description,
+        };
+        logger.debug(`• Found permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    const handlerNode = args[0];
-    if (!handlerNode)
+    // Handle pikkuPermissionFactory(...) - permission factory function
+    if (expression.text === 'pikkuPermissionFactory') {
+        const factoryNode = args[0];
+        if (!factoryNode)
+            return;
+        if (!ts.isArrowFunction(factoryNode) &&
+            !ts.isFunctionExpression(factoryNode)) {
+            logger.error(`• Handler for pikkuPermissionFactory is not a function.`);
+            return;
+        }
+        // Extract services by looking inside the factory function body
+        // The factory should return pikkuPermission(...), so we need to find that call
+        // If no wrapper is found, extract from the factory's returned function directly
+        let services = { optimized: false, services: [] };
+        const findPikkuPermissionCall = (node) => {
+            if (ts.isCallExpression(node)) {
+                const expr = node.expression;
+                if (ts.isIdentifier(expr) && expr.text === 'pikkuPermission') {
+                    return node;
+                }
+            }
+            return ts.forEachChild(node, findPikkuPermissionCall);
+        };
+        const pikkuPermissionCall = findPikkuPermissionCall(factoryNode);
+        if (pikkuPermissionCall && pikkuPermissionCall.arguments[0]) {
+            const permissionHandler = pikkuPermissionCall.arguments[0];
+            if (ts.isArrowFunction(permissionHandler) ||
+                ts.isFunctionExpression(permissionHandler)) {
+                services = extractServicesFromFunction(permissionHandler);
+            }
+        }
+        else {
+            // No pikkuPermission wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, data, session) => { ... }
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                // Check if the body is an arrow function (direct return)
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            factory: true,
+        };
+        logger.debug(`• Found permission factory with services: ${services.services.join(', ')}`);
         return;
-    if (!ts.isArrowFunction(handlerNode) &&
-        !ts.isFunctionExpression(handlerNode)) {
-        logger.error(`• Handler for pikkuPermission is not a function.`);
+    }
+    // Handle addPermission('tag', [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addPermission('tag', [...])  (factory - tree-shakeable)
+    // 2. export const x = addPermission('tag', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addPermission') {
+        const tagArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!tagArg || !permissionsArrayArg)
+            return;
+        // Extract tag name
+        let tag;
+        if (ts.isStringLiteral(tagArg)) {
+            tag = tagArg.text;
+        }
+        if (!tag) {
+            logger.warn(`• addPermission call without valid tag string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addPermission('${tag}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addPermission('${tag}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        // We need to walk up the tree to see if the parent is: const x = () => addPermission(...)
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addPermission(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiTagPermissions = () => addPermission(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addPermission('${tag}', [...])`);
+        }
+        // Store group metadata
+        state.permissions.tagPermissions.set(tag, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+    // Handle addHTTPPermission(pattern, [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addHTTPPermission('*', [...])  (factory - tree-shakeable)
+    // 2. export const x = addHTTPPermission('*', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addHTTPPermission') {
+        const patternArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!patternArg || !permissionsArrayArg)
+            return;
+        // Extract route pattern
+        let pattern;
+        if (ts.isStringLiteral(patternArg)) {
+            pattern = patternArg.text;
+        }
+        if (!pattern) {
+            logger.warn(`• addHTTPPermission call without valid pattern string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addHTTPPermission('${pattern}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addHTTPPermission(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiRoutePermissions = () => addHTTPPermission(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• HTTP permission group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addHTTPPermission('${pattern}', [...])`);
+        }
+        // Store group metadata
+        state.http.routePermissions.set(pattern, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
-    const services = extractServicesFromFunction(handlerNode);
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
-    state.permissions.meta[pikkuFuncName] = {
-        services,
-        sourceFile: node.getSourceFile().fileName,
-        position: node.getStart(),
-        exportedName,
-    };
-    logger.debug(`• Found permission with services: ${services.services.join(', ')}`);
 };

package/dist/add/add-queue-worker.js

@@ -1,10 +1,10 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
 export const addQueueWorker = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -23,25 +23,23 @@ export const addQueueWorker = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const queueName = getPropertyValue(obj, 'queueName');
         const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'Queue worker', queueName, logger);
         // --- find the referenced function ---
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for queue processor '${queueName}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for queue processor '${queueName}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
         if (!queueName) {
-            console.error(`• No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.queue, name: queueName, filePath }, logger)) {
-            console.info(`• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`);
+            logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
             return;
         }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
         state.queueWorkers.files.add(node.getSourceFile().fileName);
         state.queueWorkers.meta[queueName] = {
             pikkuFuncName,

package/dist/add/add-schedule.js

@@ -1,10 +1,10 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
 export const addSchedule = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -24,22 +24,21 @@ export const addSchedule = (logger, node, checker, state, options) => {
         const nameValue = getPropertyValue(obj, 'name');
         const scheduleValue = getPropertyValue(obj, 'schedule');
         const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'Scheduler', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for scheduled task '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for scheduled task '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
         if (!nameValue || !scheduleValue) {
             return;
         }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.scheduler, name: nameValue, filePath }, logger)) {
-            return;
-        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
             pikkuFuncName,

package/dist/error-codes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Error code system for Pikku CLI and Inspector
+ *
+ * Each error has a unique code and links to documentation at pikku.dev
+ *
+ * Error codes use random 3-digit numbers to avoid implying a sequential order.
+ * Each code links to detailed documentation and troubleshooting steps.
+ */
+export declare enum ErrorCode {
+    MISSING_NAME = "PKU111",
+    MISSING_DESCRIPTION = "PKU123",
+    MISSING_URI = "PKU220",
+    MISSING_FUNC = "PKU236",
+    INVALID_TAGS_TYPE = "PKU247",
+    INVALID_HANDLER = "PKU300",
+    MISSING_TITLE = "PKU370",
+    MISSING_QUEUE_NAME = "PKU384",
+    MISSING_CHANNEL_NAME = "PKU400",
+    CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
+    CONFIG_TYPE_NOT_FOUND = "PKU426",
+    CONFIG_TYPE_UNDEFINED = "PKU427",
+    SCHEMA_NO_ROOT = "PKU431",
+    SCHEMA_GENERATION_ERROR = "PKU456",
+    SCHEMA_LOAD_ERROR = "PKU488",
+    FUNCTION_METADATA_NOT_FOUND = "PKU559",
+    HANDLER_NOT_RESOLVED = "PKU568",
+    MIDDLEWARE_HANDLER_INVALID = "PKU685",
+    MIDDLEWARE_TAG_INVALID = "PKU715",
+    MIDDLEWARE_EMPTY_ARRAY = "PKU736",
+    MIDDLEWARE_PATTERN_INVALID = "PKU787",
+    PERMISSION_HANDLER_INVALID = "PKU835",
+    PERMISSION_TAG_INVALID = "PKU836",
+    PERMISSION_EMPTY_ARRAY = "PKU937",
+    PERMISSION_PATTERN_INVALID = "PKU975"
+}

package/dist/error-codes.js

@@ -0,0 +1,40 @@
+/**
+ * Error code system for Pikku CLI and Inspector
+ *
+ * Each error has a unique code and links to documentation at pikku.dev
+ *
+ * Error codes use random 3-digit numbers to avoid implying a sequential order.
+ * Each code links to detailed documentation and troubleshooting steps.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Validation errors
+    ErrorCode["MISSING_NAME"] = "PKU111";
+    ErrorCode["MISSING_DESCRIPTION"] = "PKU123";
+    ErrorCode["MISSING_URI"] = "PKU220";
+    ErrorCode["MISSING_FUNC"] = "PKU236";
+    ErrorCode["INVALID_TAGS_TYPE"] = "PKU247";
+    ErrorCode["INVALID_HANDLER"] = "PKU300";
+    ErrorCode["MISSING_TITLE"] = "PKU370";
+    ErrorCode["MISSING_QUEUE_NAME"] = "PKU384";
+    ErrorCode["MISSING_CHANNEL_NAME"] = "PKU400";
+    ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
+    // Configuration errors
+    ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
+    ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";
+    ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
+    ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
+    ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
+    // Function errors
+    ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
+    ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";
+    // Middleware/Permission errors
+    ErrorCode["MIDDLEWARE_HANDLER_INVALID"] = "PKU685";
+    ErrorCode["MIDDLEWARE_TAG_INVALID"] = "PKU715";
+    ErrorCode["MIDDLEWARE_EMPTY_ARRAY"] = "PKU736";
+    ErrorCode["MIDDLEWARE_PATTERN_INVALID"] = "PKU787";
+    ErrorCode["PERMISSION_HANDLER_INVALID"] = "PKU835";
+    ErrorCode["PERMISSION_TAG_INVALID"] = "PKU836";
+    ErrorCode["PERMISSION_EMPTY_ARRAY"] = "PKU937";
+    ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
+})(ErrorCode || (ErrorCode = {}));

package/dist/index.d.ts

@@ -4,3 +4,7 @@ export type { TypesMap } from './types-map.js';
 export type * from './types.js';
 export type { InspectorState } from './types.js';
 export type { FilesAndMethods, FilesAndMethodsErrors, } from './utils/get-files-and-methods.js';
+export { ErrorCode } from './error-codes.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export type { SerializableInspectorState } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';

package/dist/index.js

@@ -1,2 +1,5 @@
 export { inspect } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export { ErrorCode } from './error-codes.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';