@pikku/inspector 0.11.2 → 0.12.1

package/dist/add/add-channel.js

@@ -2,10 +2,12 @@ import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { resolveMiddleware } from '../utils/middleware.js';
+import { resolveMiddleware, resolveChannelMiddleware, } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
+import { resolveIdentifier } from '../utils/resolve-identifier.js';
+import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 /**
  * Safely get the "initializer" expression of a property-like AST node:
  * - for `foo: expr`, returns `expr`
@@ -44,25 +46,25 @@ function getHandlerNameFromExpression(expr, checker, rootDir) {
                         ts.isArrowFunction(decl.initializer) ||
                         ts.isFunctionExpression(decl.initializer)) {
                         // Extract function name from the declaration's initializer
-                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker, rootDir);
-                        return pikkuFuncName;
+                        const { pikkuFuncId } = extractFunctionName(decl.initializer, checker, rootDir);
+                        return pikkuFuncId;
                     }
                 }
                 // For function declarations, use directly
                 else if (ts.isFunctionDeclaration(decl)) {
-                    const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir);
-                    return pikkuFuncName;
+                    const { pikkuFuncId } = extractFunctionName(decl, checker, rootDir);
+                    return pikkuFuncId;
                 }
             }
         }
         // Fallback: try to extract directly from the identifier
-        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
-        return pikkuFuncName;
+        const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir);
+        return pikkuFuncId;
     }
     // Handle call expressions
     if (ts.isCallExpression(expr)) {
-        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
-        return pikkuFuncName;
+        const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir);
+        return pikkuFuncId;
     }
     // Handle object literals with 'func' property
     if (ts.isObjectLiteralExpression(expr)) {
@@ -85,8 +87,19 @@ export function addMessagesRoutes(logger, obj, state, checker) {
     if (!onMsgRouteProp || !ts.isObjectLiteralExpression(onMsgRouteProp))
         return result;
     for (const chanElem of onMsgRouteProp.properties) {
-        const chanInit = getInitializerOf(chanElem);
-        if (!chanInit || !ts.isObjectLiteralExpression(chanInit))
+        let chanInit = getInitializerOf(chanElem);
+        if (!chanInit)
+            continue;
+        // If the value is an identifier, resolve it (handles defineChannelRoutes)
+        if (ts.isIdentifier(chanInit)) {
+            const resolved = resolveIdentifier(chanInit, checker, [
+                'defineChannelRoutes',
+            ]);
+            if (resolved && ts.isObjectLiteralExpression(resolved)) {
+                chanInit = resolved;
+            }
+        }
+        if (!ts.isObjectLiteralExpression(chanInit))
             continue;
         const channelKey = chanElem.name.getText();
         result[channelKey] = {};
@@ -136,8 +149,8 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     if (ts.isArrowFunction(importDecl.initializer) ||
                                         ts.isFunctionExpression(importDecl.initializer) ||
                                         ts.isCallExpression(importDecl.initializer)) {
-                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker, state.rootDir);
-                                        const handlerName = pikkuFuncName;
+                                        const { pikkuFuncId } = extractFunctionName(importDecl.initializer, checker, state.rootDir);
+                                        const handlerName = pikkuFuncId;
                                         // Look up in the registry
                                         const fnMeta = state.functions.meta[handlerName];
                                         if (fnMeta) {
@@ -149,7 +162,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 ? resolveMiddleware(state, init, routeTags, checker)
                                                 : undefined;
                                             result[channelKey][routeKey] = {
-                                                pikkuFuncName: handlerName,
+                                                pikkuFuncId: handlerName,
                                                 middleware: routeMiddleware,
                                             };
                                             continue;
@@ -158,8 +171,8 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                 }
                                 else if (ts.isFunctionDeclaration(importDecl)) {
                                     // Extract from the function declaration
-                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker, state.rootDir);
-                                    const handlerName = pikkuFuncName;
+                                    const { pikkuFuncId } = extractFunctionName(importDecl, checker, state.rootDir);
+                                    const handlerName = pikkuFuncId;
                                     // Look up in the registry
                                     const fnMeta = state.functions.meta[handlerName];
                                     if (fnMeta) {
@@ -171,7 +184,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                             ? resolveMiddleware(state, init, routeTags, checker)
                                             : undefined;
                                         result[channelKey][routeKey] = {
-                                            pikkuFuncName: handlerName,
+                                            pikkuFuncId: handlerName,
                                             middleware: routeMiddleware,
                                         };
                                         continue;
@@ -192,8 +205,8 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                             const exportDecl = exportDecls[0];
                                             if (ts.isVariableDeclaration(exportDecl) &&
                                                 exportDecl.initializer) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker, state.rootDir);
-                                                const handlerName = pikkuFuncName;
+                                                const { pikkuFuncId } = extractFunctionName(exportDecl.initializer, checker, state.rootDir);
+                                                const handlerName = pikkuFuncId;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
@@ -204,15 +217,15 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                         ? resolveMiddleware(state, init, routeTags, checker)
                                                         : undefined;
                                                     result[channelKey][routeKey] = {
-                                                        pikkuFuncName: handlerName,
+                                                        pikkuFuncId: handlerName,
                                                         middleware: routeMiddleware,
                                                     };
                                                     continue;
                                                 }
                                             }
                                             else if (ts.isFunctionDeclaration(exportDecl)) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker, state.rootDir);
-                                                const handlerName = pikkuFuncName;
+                                                const { pikkuFuncId } = extractFunctionName(exportDecl, checker, state.rootDir);
+                                                const handlerName = pikkuFuncId;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
@@ -223,7 +236,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                         ? resolveMiddleware(state, init, routeTags, checker)
                                                         : undefined;
                                                     result[channelKey][routeKey] = {
-                                                        pikkuFuncName: handlerName,
+                                                        pikkuFuncId: handlerName,
                                                         middleware: routeMiddleware,
                                                     };
                                                     continue;
@@ -249,7 +262,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                 continue;
                             }
                             result[channelKey][routeKey] = {
-                                pikkuFuncName: possibleMatch,
+                                pikkuFuncId: possibleMatch,
                             };
                             continue;
                         }
@@ -274,8 +287,8 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                         // If we found the actual function, extract its name
                         if (actualFunction) {
                             // Extract the function name directly from the actual function
-                            const { pikkuFuncName } = extractFunctionName(actualFunction, checker, state.rootDir);
-                            const handlerName = pikkuFuncName;
+                            const { pikkuFuncId } = extractFunctionName(actualFunction, checker, state.rootDir);
+                            const handlerName = pikkuFuncId;
                             // Now use this handlerName to look up in the registry
                             const fnMeta = state.functions.meta[handlerName];
                             if (fnMeta) {
@@ -287,7 +300,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     ? resolveMiddleware(state, init, routeTags, checker)
                                     : undefined;
                                 result[channelKey][routeKey] = {
-                                    pikkuFuncName: handlerName,
+                                    pikkuFuncId: handlerName,
                                     middleware: routeMiddleware,
                                 };
                                 continue; // Skip the normal processing below
@@ -316,7 +329,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                 ? resolveMiddleware(state, init, routeTags, checker)
                 : undefined;
             result[channelKey][routeKey] = {
-                pikkuFuncName: handlerName,
+                pikkuFuncId: handlerName,
                 middleware: routeMiddleware,
             };
         }
@@ -349,7 +362,9 @@ export const addChannel = (logger, node, checker, state, options) => {
             .keys.filter((k) => k.type === 'param')
             .map((k) => k.name)
         : [];
-    const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Channel', name, logger);
+    const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'Channel', name, logger);
+    if (disabled)
+        return;
     const query = getPropertyValue(obj, 'query');
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
@@ -357,42 +372,62 @@ export const addChannel = (logger, node, checker, state, options) => {
     let message = null;
     const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', true, checker);
     if (onMsgProp) {
-        const { pikkuFuncName } = extractFunctionName(onMsgProp, checker, state.rootDir);
-        const fnMeta = state.functions.meta[pikkuFuncName];
+        const extracted = extractFunctionName(onMsgProp, checker, state.rootDir);
+        const msgFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+            ? makeContextBasedId('channel', name, 'message')
+            : extracted.pikkuFuncId;
+        const fnMeta = state.functions.meta[msgFuncId];
         if (!fnMeta) {
-            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for onMessage handler '${pikkuFuncName}'`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for onMessage handler '${msgFuncId}'`);
             return;
         }
         message = {
-            pikkuFuncName,
+            pikkuFuncId: msgFuncId,
         };
     }
     // nested message-routes
     const messageWirings = addMessagesRoutes(logger, obj, state, checker);
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker);
+    const channelMiddleware = resolveChannelMiddleware(state, obj, tags, checker);
     // --- track used functions/middleware for service aggregation ---
     // Track connect/disconnect/message handlers
+    let connectFuncId;
     if (connect) {
-        const connectFuncName = extractFunctionName(connect, checker, state.rootDir).pikkuFuncName;
-        state.serviceAggregation.usedFunctions.add(connectFuncName);
+        const extracted = extractFunctionName(connect, checker, state.rootDir);
+        connectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+            ? makeContextBasedId('channel', name, 'connect')
+            : extracted.pikkuFuncId;
+        state.serviceAggregation.usedFunctions.add(connectFuncId);
     }
+    let disconnectFuncId;
     if (disconnect) {
-        const disconnectFuncName = extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName;
-        state.serviceAggregation.usedFunctions.add(disconnectFuncName);
+        const extracted = extractFunctionName(disconnect, checker, state.rootDir);
+        disconnectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
+            ? makeContextBasedId('channel', name, 'disconnect')
+            : extracted.pikkuFuncId;
+        state.serviceAggregation.usedFunctions.add(disconnectFuncId);
     }
     if (message) {
-        state.serviceAggregation.usedFunctions.add(message.pikkuFuncName);
+        state.serviceAggregation.usedFunctions.add(message.pikkuFuncId);
     }
-    // Track message wiring handlers
     for (const channelHandlers of Object.values(messageWirings)) {
         for (const handler of Object.values(channelHandlers)) {
-            state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName);
+            state.serviceAggregation.usedFunctions.add(handler.pikkuFuncId);
         }
     }
-    // Track middleware
     extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
-    // record into state
+    // --- validate auth/sessionless ---
+    const handlersToValidate = [
+        connectFuncId,
+        disconnectFuncId,
+        message?.pikkuFuncId,
+    ].filter(Boolean);
+    for (const funcId of handlersToValidate) {
+        if (!validateAuthSessionless(logger, obj, state, funcId, `Channel '${name}'`)) {
+            return;
+        }
+    }
     state.channels.files.add(node.getSourceFile().fileName);
     state.channels.meta[name] = {
         name,
@@ -400,24 +435,8 @@ export const addChannel = (logger, node, checker, state, options) => {
         input: null,
         params: params.length ? params : undefined,
         query: query?.length ? query : undefined,
-        // inputTypes: getInputTypes(
-        //   state.channels.metaInputTypes,
-        //   'get',
-        //   null, // TODO
-        //   query,
-        //   params
-        // ),
-        connect: connect
-            ? {
-                pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
-                    .pikkuFuncName,
-            }
-            : null,
-        disconnect: disconnect
-            ? {
-                pikkuFuncName: extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName,
-            }
-            : null,
+        connect: connectFuncId ? { pikkuFuncId: connectFuncId } : null,
+        disconnect: disconnectFuncId ? { pikkuFuncId: disconnectFuncId } : null,
         message,
         messageWirings,
         summary,
@@ -425,5 +444,6 @@ export const addChannel = (logger, node, checker, state, options) => {
         errors,
         tags: tags ?? undefined,
         middleware,
+        channelMiddleware,
     };
 };

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

@@ -1,4 +1,4 @@
-import { AddWiring } from '../types.js';
+import type { AddWiring } from '../types.js';
 /**
  * Adds CLI command metadata to the inspector state
  */

package/dist/add/add-cli.js

@@ -3,6 +3,8 @@ import { extractFunctionName } from '../utils/extract-function-name.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
+import { resolveIdentifier } from '../utils/resolve-identifier.js';
+import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 // Track if we've warned about missing Config type to avoid duplicate warnings
 const configTypeWarningShown = new Set();
 /**
@@ -68,6 +70,9 @@ function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState,
     if (!programName) {
         return null;
     }
+    if (getPropertyValue(node, 'disabled') === true) {
+        return null;
+    }
     // Second pass: process other properties with program tags available
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop))
@@ -92,7 +97,7 @@ function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState,
                 break;
             case 'render':
                 // Extract the actual renderer function name
-                programMeta.defaultRenderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
+                programMeta.defaultRenderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
                 break;
         }
     }
@@ -105,6 +110,20 @@ function processCommands(logger, node, sourceFile, typeChecker, programName, ins
     const commands = {};
     let defaultCommandName = null;
     for (const prop of node.properties) {
+        // Handle spread assignments: { ...externalCommands }
+        if (ts.isSpreadAssignment(prop)) {
+            let spreadTarget = prop.expression;
+            if (ts.isIdentifier(prop.expression)) {
+                spreadTarget = resolveIdentifier(prop.expression, typeChecker, [
+                    'defineCLICommands',
+                ]);
+            }
+            if (spreadTarget && ts.isObjectLiteralExpression(spreadTarget)) {
+                const spreadCommands = processCommands(logger, spreadTarget, sourceFile, typeChecker, programName, inspectorState, options, programTags);
+                Object.assign(commands, spreadCommands);
+            }
+            continue;
+        }
         if (!ts.isPropertyAssignment(prop))
             continue;
         const commandName = getPropertyName(prop);
@@ -138,7 +157,7 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
         ts.isArrowFunction(node) ||
         ts.isFunctionExpression(node)) {
         return {
-            pikkuFuncName: extractFunctionName(node, typeChecker, inspectorState.rootDir).pikkuFuncName,
+            pikkuFuncId: extractFunctionName(node, typeChecker, inspectorState.rootDir).pikkuFuncId,
             positionals: [],
             options: {},
         };
@@ -160,12 +179,12 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
         return null;
     }
     const meta = {
-        pikkuFuncName: '',
+        pikkuFuncId: '',
         positionals: [],
         options: {},
     };
-    // First pass: extract pikkuFuncName and tags so we can use them when processing options/middleware
-    let pikkuFuncName;
+    // First pass: extract pikkuFuncId and tags so we can use them when processing options/middleware
+    let pikkuFuncId;
     let optionsNode;
     let tags;
     for (const prop of node.properties) {
@@ -175,8 +194,8 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             continue;
         const propName = prop.name.text;
         if (propName === 'func') {
-            pikkuFuncName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
-            meta.pikkuFuncName = pikkuFuncName;
+            pikkuFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+            meta.pikkuFuncId = pikkuFuncId;
         }
         else if (propName === 'options' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
@@ -220,12 +239,12 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                 // Already handled in first pass
                 break;
             case 'render':
-                meta.renderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
+                meta.renderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
                 break;
             case 'options':
-                // Process with pikkuFuncName from first pass
+                // Process with pikkuFuncId from first pass
                 if (optionsNode) {
-                    meta.options = processOptions(logger, optionsNode, typeChecker, inspectorState, options, pikkuFuncName);
+                    meta.options = processOptions(logger, optionsNode, typeChecker, inspectorState, options, pikkuFuncId);
                 }
                 break;
             case 'subcommands':
@@ -252,16 +271,20 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                 break;
         }
     }
+    // --- validate auth/sessionless ---
+    if (meta.pikkuFuncId &&
+        !validateAuthSessionless(logger, node, inspectorState, meta.pikkuFuncId, `CLI command '${name}'`)) {
+        return null;
+    }
     // --- track used functions/middleware for service aggregation ---
-    inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncName);
+    inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncId);
     extractWireNames(meta.middleware).forEach((name) => inspectorState.serviceAggregation.usedMiddleware.add(name));
-    // Note: subcommands are tracked recursively when they're processed
     return meta;
 }
 /**
  * Processes CLI options and extracts enum values from function input types
  */
-function processOptions(logger, node, typeChecker, inspectorState, inspectorOptions, pikkuFuncName) {
+function processOptions(logger, node, typeChecker, inspectorState, inspectorOptions, pikkuFuncId) {
     const options = {};
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop))
@@ -318,10 +341,10 @@ function processOptions(logger, node, typeChecker, inspectorState, inspectorOpti
                 }
             }
             // Extract enum values from the function input type if available
-            // Get the input type if we have a pikkuFuncName
+            // Get the input type if we have a pikkuFuncId
             let inputTypes;
-            if (pikkuFuncName) {
-                inputTypes = inspectorState.typesLookup.get(pikkuFuncName);
+            if (pikkuFuncId) {
+                inputTypes = inspectorState.typesLookup.get(pikkuFuncId);
             }
             let derivedChoices = null;
             if (inputTypes && inputTypes.length > 0) {
@@ -527,7 +550,7 @@ export const addCLIRenderers = (logger, node, typeChecker, inspectorState, optio
     if (args.length === 0)
         return;
     // Extract renderer name
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, typeChecker, inspectorState.rootDir);
+    const { pikkuFuncId, exportedName } = extractFunctionName(node, typeChecker, inspectorState.rootDir);
     // Get the source file path
     const sourceFile = node.getSourceFile();
     const filePath = sourceFile.fileName;
@@ -553,8 +576,8 @@ export const addCLIRenderers = (logger, node, typeChecker, inspectorState, optio
         }
     }
     // Store renderer metadata
-    inspectorState.cli.meta.renderers[pikkuFuncName] = {
-        name: pikkuFuncName,
+    inspectorState.cli.meta.renderers[pikkuFuncId] = {
+        name: pikkuFuncId,
         exportedName: exportedName ?? undefined,
         services,
         filePath,

package/dist/add/add-file-extends-core-type.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
-import { PathToNameAndType, InspectorState } from '../types.js';
+import type { PathToNameAndType, InspectorState } from '../types.js';
 export declare const addFileExtendsCoreType: (node: ts.Node, checker: ts.TypeChecker, methods: PathToNameAndType, expectedTypeName: string, state?: InspectorState) => void;

package/dist/add/add-file-with-config.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
-import { PathToNameAndType } from '../types.js';
+import type { PathToNameAndType } from '../types.js';
 export declare const addFileWithConfig: (node: ts.Node, checker: ts.TypeChecker, configs: PathToNameAndType) => void;

package/dist/add/add-file-with-factory.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
-import { PathToNameAndType, InspectorState } from '../types.js';
+import type { PathToNameAndType, InspectorState } from '../types.js';
 export declare const addFileWithFactory: (node: ts.Node, checker: ts.TypeChecker, methods: PathToNameAndType | undefined, expectedTypeName: string, state?: InspectorState) => void;

package/dist/add/add-file-with-factory.js

@@ -3,7 +3,9 @@ import { extractServicesFromFunction } from '../utils/extract-services.js';
 // Mapping of wrapper function names to their corresponding types
 const wrapperFunctionMap = {
     pikkuConfig: 'CreateConfig',
+    pikkuAddonConfig: 'CreateConfig',
     pikkuServices: 'CreateSingletonServices',
+    pikkuAddonServices: 'CreateSingletonServices',
     pikkuWireServices: 'CreateWireServices',
 };
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {

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

@@ -1,4 +1,4 @@
-import { AddWiring } from '../types.js';
+import type { AddWiring } from '../types.js';
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.