@pikku/inspector 0.6.3 → 0.7.0

package/dist/add-functions.js

@@ -0,0 +1,260 @@
+import * as ts from 'typescript';
+import { extractFunctionName, getPropertyAssignmentInitializer, } from './utils.js';
+const isValidVariableName = (name) => {
+    const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    return regex.test(name);
+};
+const nullifyTypes = (type) => {
+    if (type === 'void' ||
+        type === 'undefined' ||
+        type === 'unknown' ||
+        type === 'any') {
+        return null;
+    }
+    return type;
+};
+const resolveTypeImports = (type, resolvedTypes, isCustom) => {
+    const types = [];
+    const visitType = (currentType) => {
+        const symbol = currentType.aliasSymbol || currentType.getSymbol();
+        if (symbol) {
+            const declarations = symbol.getDeclarations();
+            const declaration = declarations?.[0];
+            if (declaration) {
+                const sourceFile = declaration.getSourceFile();
+                const path = sourceFile.fileName;
+                // Skip built-in utility types or TypeScript lib types
+                if (!path.includes('node_modules/typescript') &&
+                    symbol.getName() !== '__type' &&
+                    !isPrimitiveType(currentType)) {
+                    const originalName = symbol.getName();
+                    // Check if the type is already in the map
+                    let uniqueName = resolvedTypes.exists(originalName, path);
+                    if (!uniqueName) {
+                        if (isCustom) {
+                            uniqueName = resolvedTypes.addUniqueType(originalName, path);
+                        }
+                        else {
+                            resolvedTypes.addType(originalName, path);
+                            uniqueName = originalName;
+                        }
+                    }
+                    types.push(uniqueName);
+                }
+            }
+        }
+        if (isCustom) {
+            // Handle nested utility types like Partial, Pick, etc.
+            if (currentType.aliasTypeArguments) {
+                currentType.aliasTypeArguments.forEach(visitType);
+            }
+            // Handle intersections and unions
+            if (currentType.isUnionOrIntersection()) {
+                currentType.types.forEach(visitType);
+            }
+            // Handle object types with type arguments
+            if (currentType.flags & ts.TypeFlags.Object &&
+                currentType.objectFlags & ts.ObjectFlags.Reference) {
+                const typeRef = currentType;
+                typeRef.typeArguments?.forEach(visitType);
+            }
+        }
+    };
+    visitType(type);
+    return types;
+};
+const resolveUnionTypes = (checker, type) => {
+    const types = [];
+    const names = [];
+    // Check if it's a union type AND not part of an intersection
+    if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
+        for (const t of type.types) {
+            const name = nullifyTypes(checker.typeToString(t));
+            if (name) {
+                types.push(t);
+                names.push(name);
+            }
+        }
+    }
+    else {
+        const name = nullifyTypes(checker.typeToString(type));
+        if (name) {
+            types.push(type);
+            names.push(name);
+        }
+    }
+    return { types, names };
+};
+const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
+    if (!type) {
+        return { names: [], types: [] };
+    }
+    // 1) Handle an explicit void (or undefined) type up front
+    if (type.flags & ts.TypeFlags.VoidLike) {
+        return {
+            names: ['void'],
+            types: [type],
+        };
+    }
+    // 2) For unions, resolve all member names/types
+    const { names: rawNames, types: rawTypes } = resolveUnionTypes(checker, type);
+    // If the union is exactly [void], we'd have caught it above.
+    // If it's e.g. [string, void], rawNames should already include 'void'.
+    // 3) If multiple names or the single name isn't a valid identifier,
+    //    we emit an alias type.
+    const firstName = rawNames[0];
+    if (rawNames.length > 1 || (firstName && !isValidVariableName(firstName))) {
+        const aliasType = rawNames.join(' | ');
+        const aliasName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + direction;
+        // record the alias in your TypesMap
+        const references = rawTypes
+            .map((t) => resolveTypeImports(t, typesMap, true))
+            .flat();
+        typesMap.addCustomType(aliasName, aliasType, references);
+        return {
+            names: [aliasName],
+            types: rawTypes,
+        };
+    }
+    // 4) Single, valid name → inline it
+    const uniqueNames = rawNames
+        .map((name, i) => {
+        const t = rawTypes[i];
+        if (!t) {
+            throw new Error(`Expected type for name "${name}" in ${funcName}`);
+        }
+        if (isPrimitiveType(t)) {
+            return name;
+        }
+        // non-primitive: import/alias it inline
+        return resolveTypeImports(t, typesMap, false);
+    })
+        .flat();
+    return {
+        names: uniqueNames,
+        types: rawTypes,
+    };
+};
+const isPrimitiveType = (type) => {
+    const primitiveFlags = ts.TypeFlags.Number |
+        ts.TypeFlags.String |
+        ts.TypeFlags.Boolean |
+        ts.TypeFlags.BigInt |
+        ts.TypeFlags.ESSymbol |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.VoidLike;
+    return (type.flags & primitiveFlags) !== 0;
+};
+/**
+ * If `type` is a `Promise<T>`, return `T`, otherwise return `type` itself.
+ */
+function unwrapPromise(checker, type) {
+    if (!type?.symbol)
+        return type;
+    const isPromise = type.symbol.name === 'Promise' &&
+        checker.getFullyQualifiedName(type.symbol).includes('Promise');
+    // aliasTypeArguments covers most Promise<T> cases
+    if (isPromise && type.aliasTypeArguments?.length === 1) {
+        return type.aliasTypeArguments[0];
+    }
+    // fallback for raw TypeReference
+    if (isPromise && type.typeArguments?.length === 1) {
+        return type.typeArguments[0];
+    }
+    return type;
+}
+/**
+ * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
+ * then push into state.functions.meta.
+ */
+export function addFunctions(node, checker, state, filters) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args, typeArguments } = node;
+    // only handle calls like pikkuFunc(...)
+    if (!ts.isIdentifier(expression) || !expression.text.startsWith('pikku')) {
+        return;
+    }
+    if (args.length === 0)
+        return;
+    const { pikkuFuncName, name } = extractFunctionName(node, checker);
+    // determine the actual handler expression:
+    // either the `func` prop or the first argument directly
+    let handlerNode = args[0];
+    if (ts.isObjectLiteralExpression(handlerNode)) {
+        const fnProp = getPropertyAssignmentInitializer(handlerNode, 'func', true, checker);
+        if (!fnProp ||
+            (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+            console.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+            return;
+        }
+        handlerNode = fnProp;
+    }
+    if (!ts.isArrowFunction(handlerNode) &&
+        !ts.isFunctionExpression(handlerNode)) {
+        console.error(`• Handler for TODO is not a function.`);
+        return;
+    }
+    const services = {
+        optimized: true,
+        services: [],
+    };
+    const firstParam = handlerNode.parameters[0];
+    if (firstParam) {
+        if (ts.isObjectBindingPattern(firstParam.name)) {
+            for (const elem of firstParam.name.elements) {
+                const original = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : ts.isIdentifier(elem.name)
+                        ? elem.name.text
+                        : undefined;
+                if (original) {
+                    services.services.push(original);
+                }
+            }
+        }
+        else if (ts.isIdentifier(firstParam.name) &&
+            !firstParam.name.text.startsWith('_')) {
+            services.optimized = false;
+        }
+    }
+    // --- Generics → ts.Type[], unwrapped from Promise ---
+    const genericTypes = (typeArguments ?? [])
+        .map((tn) => checker.getTypeFromTypeNode(tn))
+        .map((t) => unwrapPromise(checker, t));
+    // --- Input Extraction ---
+    let { names: inputNames, types: inputTypes } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+    if (inputTypes.length === 0) {
+        console.warn(`\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`);
+    }
+    // --- Output Extraction ---
+    let outputNames = [];
+    if (genericTypes.length >= 2) {
+        outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
+    }
+    else {
+        const sig = checker.getSignatureFromDeclaration(handlerNode);
+        if (sig) {
+            const rawRet = checker.getReturnTypeOfSignature(sig);
+            const unwrapped = unwrapPromise(checker, rawRet);
+            outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', pikkuFuncName, unwrapped).names;
+        }
+    }
+    // --- Record metadata ---
+    state.functions.files.add(node.getSourceFile().fileName);
+    if (inputNames.length > 1) {
+        console.warn('More than one input type detected, only the first one will be used as a schema.');
+    }
+    state.functions.meta[pikkuFuncName] = {
+        pikkuFuncName,
+        name,
+        services,
+        schemaName: inputNames[0] ?? null,
+        inputs: inputNames.filter((n) => n !== 'void') ?? null,
+        outputs: outputNames.filter((n) => n !== 'void') ?? null,
+    };
+}

package/dist/add-http-route.d.ts

@@ -1,4 +1,16 @@
 import * as ts from 'typescript';
-import { MetaInputTypes, InspectorState, InspectorFilters } from './types.js';
-export declare const getInputTypes: (metaTypes: MetaInputTypes, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
-export declare const addRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+import { InspectorState, InspectorFilters } from './types.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
+export declare const getInputTypes: (metaTypes: Map<string, {
+    query?: string[];
+    params?: string[];
+    body?: string[];
+}>, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
+/**
+ * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-http-route.js

@@ -1,93 +1,82 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { extractTypeKeys, getFunctionTypes, matchesFilters } from './utils.js';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
 export const getInputTypes = (metaTypes, methodType, inputType, queryValues, paramsValues) => {
-    if (!inputType) {
-        return undefined;
-    }
-    if (inputType) {
-        metaTypes.set(inputType, {
-            query: queryValues,
-            params: paramsValues,
-            body: ['post', 'put', 'patch'].includes(methodType)
-                ? [...new Set([...queryValues, ...paramsValues])]
-                : [],
-        });
-    }
-    return undefined;
+    if (!inputType)
+        return;
+    metaTypes.set(inputType, {
+        query: queryValues,
+        params: paramsValues,
+        body: ['post', 'put', 'patch'].includes(methodType)
+            ? [...new Set([...queryValues, ...paramsValues])]
+            : [],
+    });
+    return;
 };
-export const addRoute = (node, checker, state, filters) => {
-    if (!ts.isCallExpression(node)) {
+/**
+ * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export const addHTTPRoute = (node, checker, state, filters) => {
+    // only look at calls
+    if (!ts.isCallExpression(node))
         return;
-    }
-    const args = node.arguments;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'addHTTPRoute')
+        return;
+    // must pass an object literal
     const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to addRoute
-    if (!ts.isIdentifier(expression) || expression.text !== 'addRoute') {
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    const obj = firstArg;
+    // --- extract HTTP metadata ---
+    const route = getPropertyValue(obj, 'route');
+    if (!route)
+        return;
+    const keys = pathToRegexp(route).keys;
+    const params = keys.filter((k) => k.type === 'param').map((k) => k.name);
+    const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
+    const docs = getPropertyValue(obj, 'docs') || undefined;
+    const tags = getPropertyValue(obj, 'tags') || undefined;
+    const query = getPropertyValue(obj, 'query') || [];
+    if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
         return;
     }
-    if (!firstArg) {
+    // --- find the referenced function ---
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!funcInitializer) {
+        console.error(`• No valid 'func' property for route '${route}'.`);
         return;
     }
-    let docs;
-    let methodValue = null;
-    let paramsValues = [];
-    let queryValues = [];
-    let tags = [];
-    let routeValue = null;
-    // Check if the first argument is an object literal
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        routeValue = getPropertyValue(obj, 'route');
-        if (!routeValue) {
-            return;
-        }
-        const { keys } = pathToRegexp(routeValue);
-        paramsValues = keys.reduce((result, { type, name }) => {
-            if (type === 'param') {
-                result.push(name);
-            }
-            return result;
-        }, []);
-        docs = getPropertyValue(obj, 'docs') || undefined;
-        methodValue = getPropertyValue(obj, 'method');
-        queryValues = getPropertyValue(obj, 'query') || [];
-        tags = getPropertyValue(obj, 'tags') || undefined;
-        if (!matchesFilters(filters, { tags }, { type: 'http', name: routeValue })) {
-            return;
-        }
-        let { inputs, outputs, inputTypes } = getFunctionTypes(checker, obj, {
-            funcName: 'func',
-            inputIndex: 0,
-            outputIndex: 1,
-            typesMap: state.http.typesMap,
-        });
-        const input = inputs ? inputs[0] || null : null;
-        const output = outputs ? outputs[0] || null : null;
-        if (inputs && inputs?.length > 1) {
-            console.error(`Only one input type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${inputs.join('\n\t')}`);
-        }
-        if (outputs && outputs?.length > 1) {
-            console.error(`Only one output type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${outputs.join('\n\t')}`);
-        }
-        if (inputTypes[0] && !['post', 'put', 'patch'].includes(methodValue)) {
-            queryValues = [
-                ...new Set([...queryValues, ...extractTypeKeys(inputTypes[0])]),
-            ].filter((query) => !paramsValues?.includes(query));
-        }
-        state.http.files.add(node.getSourceFile().fileName);
-        state.http.meta.push({
-            route: routeValue,
-            method: methodValue,
-            input,
-            output,
-            params: paramsValues.length > 0 ? paramsValues : undefined,
-            query: queryValues.length > 0 ? queryValues : undefined,
-            inputTypes: getInputTypes(state.http.metaInputTypes, methodValue, input, queryValues, paramsValues),
-            docs,
-            tags,
-        });
+    const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[funcName];
+    if (!fnMeta) {
+        console.log(Object.keys(state.functions.meta));
+        console.error(`• No function metadata found for '${funcName}'.`);
+        return;
     }
+    const input = fnMeta.inputs?.[0] || null;
+    const output = fnMeta.outputs?.[0] || null;
+    // --- compute inputTypes (body/query/params) ---
+    const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
+    // --- record route ---
+    state.http.files.add(node.getSourceFile().fileName);
+    state.http.meta.push({
+        pikkuFuncName: funcName,
+        route,
+        method: method,
+        input,
+        output,
+        params: params.length > 0 ? params : undefined,
+        query: query.length > 0 ? query : undefined,
+        inputTypes,
+        docs,
+        tags,
+    });
 };

package/dist/add-schedule.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
 import { InspectorFilters, InspectorState } from './types.js';
-export declare const addSchedule: (node: ts.Node, _checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+export declare const addSchedule: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-schedule.js

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
-import { matchesFilters } from './utils.js';
-export const addSchedule = (node, _checker, state, filters) => {
+import { extractFunctionName, matchesFilters } from './utils.js';
+export const addSchedule = (node, checker, state, filters) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -21,6 +21,15 @@ export const addSchedule = (node, _checker, state, filters) => {
         const scheduleValue = getPropertyValue(obj, 'schedule');
         const docs = getPropertyValue(obj, 'docs') || undefined;
         const tags = getPropertyValue(obj, 'tags') || undefined;
+        // --- find the referenced function ---
+        const funcProp = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+            ts.isIdentifier(p.name) &&
+            p.name.text === 'func');
+        if (!funcProp || !ts.isIdentifier(funcProp.initializer)) {
+            console.error(`• No valid 'func' property for scheduled task '${nameValue}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcProp.initializer, checker).pikkuFuncName;
         if (!nameValue || !scheduleValue) {
             return;
         }
@@ -28,11 +37,12 @@ export const addSchedule = (node, _checker, state, filters) => {
             return;
         }
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
-        state.scheduledTasks.meta.push({
+        state.scheduledTasks.meta[nameValue] = {
+            pikkuFuncName,
             name: nameValue,
             schedule: scheduleValue,
             docs,
             tags,
-        });
+        };
     }
 };

package/dist/events/add-channel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/events/add-channel.js

@@ -0,0 +1,170 @@
+// import * as ts from 'typescript'
+// import { getPropertyValue } from './get-property-value.js'
+// import { pathToRegexp } from 'path-to-regexp'
+// import { APIDocs } from '@pikku/core'
+// import { getInputTypes } from './add-http-route.js'
+// import {
+//   getPropertyAssignment,
+//   matchesFilters,
+// } from './utils.js'
+// import { ChannelMeta } from '@pikku/core/channel'
+// import { TypesMap } from './types-map.js'
+// import { InspectorFilters, InspectorState } from './types.js'
+export {};
+// const addMessagesRoutes = (
+//   obj: ts.ObjectLiteralExpression,
+//   checker: ts.TypeChecker,
+//   typesMap: TypesMap
+// ) => {
+//   const messageTypes: ChannelMeta['messageRoutes'] = {}
+//   // Find the onMessageRoute property
+//   const messagesProperty = obj.properties.find(
+//     (p) =>
+//       ts.isPropertyAssignment(p) &&
+//       ts.isIdentifier(p.name) &&
+//       p.name.text === 'onMessageRoute'
+//   )
+//   if (!messagesProperty || !ts.isPropertyAssignment(messagesProperty)) {
+//     console.log(
+//       'onMessageRoute property not found or is not a valid assignment.'
+//     )
+//     return {}
+//   }
+//   const initializer = messagesProperty.initializer
+//   // Ensure initializer is an object literal expression
+//   if (!ts.isObjectLiteralExpression(initializer)) {
+//     console.log('onMessageRoute is not an object literal.')
+//     return {}
+//   }
+//   // Iterate over the first level properties (like 'event')
+//   initializer.properties.forEach((property) => {
+//     const channel = property.name!.getText()
+//     messageTypes[channel] = {}
+//     if (ts.isPropertyAssignment(property)) {
+//       const nestedObject = property.initializer
+//       if (ts.isObjectLiteralExpression(nestedObject)) {
+//         const keys = nestedObject.properties.map((p) => p.name?.getText())
+//         for (const route of keys) {
+//           if (route) {
+//             const result = getFunctionTypesFromObject(
+//               checker,
+//               nestedObject,
+//               false,
+//               {
+//                 funcName: route,
+//                 inputIndex: 0,
+//                 outputIndex: 1,
+//                 typesMap,
+//               }
+//             )
+//             const inputs = result?.inputs || null
+//             const outputs = result?.outputs || null
+//             const type = result?.type || null
+//             messageTypes[channel][route] = { inputs, outputs, type }
+//           }
+//         }
+//       } else {
+//         console.warn('Nested property is not an object literal:', nestedObject)
+//       }
+//     } else {
+//       console.warn(
+//         `Property "${property.getText()}" is a ${ts.SyntaxKind[property.kind]}`
+//       )
+//     }
+//   })
+//   return messageTypes
+// }
+// export const addChannel = (
+//   node: ts.Node,
+//   checker: ts.TypeChecker,
+//   state: InspectorState,
+//   filters: InspectorFilters
+// ) => {
+//   if (!ts.isCallExpression(node)) {
+//     return
+//   }
+//   const args = node.arguments
+//   const firstArg = args[0]
+//   const expression = node.expression
+//   // Check if the call is to addRoute
+//   if (!ts.isIdentifier(expression) || expression.text !== 'addChannel') {
+//     return
+//   }
+//   if (!firstArg) {
+//     return
+//   }
+//   let docs: APIDocs | undefined
+//   let paramsValues: string[] | null = []
+//   let queryValues: string[] | [] = []
+//   let tags: string[] | undefined = undefined
+//   let inputType: string | null = null
+//   let route: string | null = null
+//   let name: string | null = null
+//   // Check if the first argument is an object literal
+//   if (ts.isObjectLiteralExpression(firstArg)) {
+//     const obj = firstArg
+//     name = getPropertyValue(obj, 'name') as string | null
+//     route = getPropertyValue(obj, 'route') as string | null
+//     if (!name) {
+//       console.error('Channel name is required')
+//       return
+//     }
+//     if (route) {
+//       const { keys } = pathToRegexp(route)
+//       paramsValues = keys.reduce((result, { type, name }) => {
+//         if (type === 'param') {
+//           result.push(name)
+//         }
+//         return result
+//       }, [] as string[])
+//     } else {
+//       route = ''
+//     }
+//     docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
+//     queryValues = (getPropertyValue(obj, 'query') as string[]) || []
+//     tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+//     const connect = !!getPropertyAssignment(obj, 'onConnect', false)
+//     const disconnect = !!getPropertyAssignment(obj, 'onDisconnect', false)
+//     const { inputs, outputs, type } = getFunctionTypesFromObject(
+//       checker,
+//       obj,
+//       false,
+//       {
+//         funcName: 'onMessage',
+//         inputIndex: 0,
+//         outputIndex: 1,
+//         typesMap: state.channels.typesMap,
+//       }
+//     )
+//     const message = { inputs, outputs, type }
+//     const messageRoutes = addMessagesRoutes(
+//       obj,
+//       checker,
+//       state.channels.typesMap
+//     )
+//     if (!matchesFilters(filters, { tags }, { type: 'channel', name })) {
+//       return
+//     }
+//     state.channels.files.add(node.getSourceFile().fileName)
+//     state.channels.meta.push({
+//       name,
+//       route,
+//       input: inputType,
+//       params: paramsValues.length > 0 ? paramsValues : undefined,
+//       query: queryValues.length > 0 ? queryValues : undefined,
+//       inputTypes: getInputTypes(
+//         state.channels.metaInputTypes,
+//         'get',
+//         inputType,
+//         queryValues,
+//         paramsValues
+//       ),
+//       connect,
+//       disconnect,
+//       message: message || undefined,
+//       messageRoutes,
+//       docs,
+//       tags,
+//     })
+//   }
+// }

package/dist/events/add-http-route.d.ts

@@ -0,0 +1,16 @@
+import * as ts from 'typescript';
+import { InspectorState, InspectorFilters } from '../types.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
+export declare const getInputTypes: (metaTypes: Map<string, {
+    query?: string[];
+    params?: string[];
+    body?: string[];
+}>, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
+/**
+ * Simplified addRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export declare const addRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;