@pikku/inspector 0.12.10 → 0.12.11

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.11
+
+### Patch Changes
+
+- 033d172: Log a critical inspector error when multiple functions resolve to the same `pikku` function name, instead of silently allowing routing map collisions. This may cause builds to fail if multiple functions previously resolved to the same `pikku` function name.
+- Updated dependencies [b9ed73e]
+  - @pikku/core@0.12.19
+
 ## 0.12.0
 
 ## 0.12.10
@@ -32,7 +40,6 @@
 ### Patch Changes
 
 - 624097e: Add deploy pipeline with provider-agnostic architecture
-
   - Add MetaService with explicit typed API, absorb WiringService reads
   - Add deployment service, traceId propagation, scoped logger
   - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
@@ -79,7 +86,6 @@
 
 - 5866b66: Add critical error (PKU490) when Zod schemas and wiring calls (wireHTTPRoutes, addPermission, addHTTPMiddleware) coexist in the same file. The CLI uses tsImport to extract Zod schemas at runtime, which executes all top-level code — wiring side-effects crash in this context because pikku state metadata doesn't exist. Schemas and wirings must be in separate files.
 - e412b4d: Optimize CLI codegen performance: 12x faster `pikku all`
-
   - Reuse schemas across re-inspections (skip redundant `ts-json-schema-generator` runs)
   - Cache TS schemas to disk (`.pikku/schema-cache.json`) for cross-run reuse
   - Pass `oldProgram` to `ts.createProgram` for incremental TS compilation
@@ -208,14 +214,12 @@
 - 1967172: Update code generation to support channel middleware enhancements
 
   **Code Generation Updates:**
-
   - Update channel type serialization to include middleware support
   - Improve WebSocket wrapper generation for middleware handling
   - Update CLI channel client generation with better type support
   - Enhance services and schema generation for channel configurations
 
   **Inspector Updates:**
-
   - Improve channel metadata extraction for middleware
   - Better type analysis for channel lifecycle functions
   - Enhanced post-processing for channel configurations
@@ -223,19 +227,16 @@
 - 753481a: Add bootstrap command, performance optimizations, and CLI improvements
 
   **New Features:**
-
   - Add `pikku bootstrap` command for type-only generation (~13.5% faster than `pikku all`)
   - Add configurable `ignoreFiles` option to pikku.config.json with sensible defaults (_.gen.ts, _.test.ts, \*.spec.ts)
   - Export pikkuCLIRender helper from serialize-cli-types.ts with JSDoc documentation
 
   **Performance Improvements:**
-
   - Add aggressive TypeScript compiler options (skipDefaultLibCheck, types: []) - ~37% faster TypeScript setup
   - Add detailed performance timing to inspector phases (--logLevel=debug)
   - Optimize file inspection with ignore patterns - ~10-20% faster overall
 
   **Enhancements:**
-
   - Fix --logLevel flag to properly apply log level to logger
   - Update middleware logging to use structured log format
   - Improve CLI renderers to consistently use destructured logger service
@@ -336,7 +337,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 ### Patch Changes
 
 - 44e3ff4: feat: enhance CLI filtering with type and directory filters
-
   - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
   - Add --directories filter to filter by file paths/directories
   - All filters (tags, types, directories) now work together with AND logic
@@ -347,7 +347,6 @@ For complete details, see https://pikku.dev/changelogs/0_10_0.md
 - 7c592b8: feat: support for required services and improved service configuration
 
   This release includes several enhancements to service management and configuration:
-
   - Added support for required services configuration
   - Improved service discovery and registration
   - Added typed RPC clients for service communication

package/dist/add/add-functions.js

@@ -3,7 +3,7 @@ import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { extractUsedWires } from '../utils/extract-services.js';
-import { formatVersionedId } from '@pikku/core';
+import { formatVersionedId, parseVersionedId } from '@pikku/core';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
@@ -209,6 +209,19 @@ function unwrapPromise(checker, type) {
     }
     return type;
 }
+const resolveExistingFunctionSource = (state, pikkuFuncId) => {
+    return (state.functions.meta[pikkuFuncId]?.sourceFile ||
+        state.rpc.internalFiles.get(pikkuFuncId)?.path ||
+        null);
+};
+const areCompatibleFunctionIds = (existingId, incomingId) => {
+    if (existingId === incomingId) {
+        return true;
+    }
+    const existingParsed = parseVersionedId(existingId);
+    const incomingParsed = parseVersionedId(incomingId);
+    return existingParsed.baseName === incomingParsed.baseName;
+};
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
@@ -400,6 +413,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         pikkuFuncId = formatVersionedId(baseName, version);
     }
     const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc';
+    const isListFunc = expression.text === 'pikkuListFunc';
     const mcpEnabled = mcp || isMCPToolFunc;
     // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
     const handler = resolvedFunc &&
@@ -461,7 +475,22 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, inputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 1 && genericTypes[0]) {
+    else if (isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+        const inputAliasName = `${capitalizedName}Input`;
+        const filterType = genericTypes[0];
+        const filterTypeText = checker.typeToString(filterType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(filterType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(inputAliasName, `{ cursor?: string; limit?: number; sort?: Array<{ column: string; direction: 'asc' | 'desc' }>; filter?: unknown; search?: string; } & ${filterTypeText}`, [...new Set(refs)]);
+        inputNames = [inputAliasName];
+        const secondParam = handler.parameters[1];
+        if (secondParam) {
+            inputTypes = [checker.getTypeAtLocation(secondParam)];
+        }
+        else {
+            inputTypes = [filterType];
+        }
+    }
+    else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
         // Fall back to extracting from generic type arguments
         const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
         inputNames = result.names;
@@ -485,7 +514,15 @@ export const addFunctions = (logger, node, checker, state, options) => {
         state.schemaLookup.set(schemaName, outputSchemaRef);
         state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
     }
-    else if (genericTypes.length >= 2) {
+    else if (isListFunc && genericTypes.length >= 2 && genericTypes[1]) {
+        const outputAliasName = `${capitalizedName}Output`;
+        const rowType = genericTypes[1];
+        const rowTypeText = checker.typeToString(rowType, undefined, ts.TypeFormatFlags.NoTruncation);
+        const refs = resolveTypeImports(rowType, state.functions.typesMap, true, checker);
+        state.functions.typesMap.addCustomType(outputAliasName, `{ rows: Array<${rowTypeText}>; nextCursor: string | null; totalCount?: number; }`, [...new Set(refs)]);
+        outputNames = [outputAliasName];
+    }
+    else if (!isListFunc && genericTypes.length >= 2) {
         outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
     }
     else {
@@ -539,6 +576,36 @@ export const addFunctions = (logger, node, checker, state, options) => {
     if (inputTypes.length > 0) {
         state.typesLookup.set(pikkuFuncId, inputTypes);
     }
+    const sourceFile = node.getSourceFile().fileName;
+    const existingFunction = state.functions.meta[pikkuFuncId];
+    if (existingFunction &&
+        existingFunction.sourceFile &&
+        existingFunction.sourceFile !== sourceFile) {
+        logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+            `'${pikkuFuncId}' is already defined in '${existingFunction.sourceFile}' and cannot be redefined in '${sourceFile}'.`);
+        return;
+    }
+    if (exportedName || explicitName) {
+        const existingInternal = state.rpc.internalMeta[name];
+        if (existingInternal &&
+            !areCompatibleFunctionIds(existingInternal, pikkuFuncId)) {
+            const existingSource = resolveExistingFunctionSource(state, existingInternal) || 'unknown file';
+            logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Function name '${name}' is not unique. ` +
+                `It already points to '${existingInternal}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+            return;
+        }
+        if (expose) {
+            const existingExposed = state.rpc.exposedMeta[name];
+            if (existingExposed &&
+                !areCompatibleFunctionIds(existingExposed, pikkuFuncId)) {
+                const existingSource = resolveExistingFunctionSource(state, existingExposed) ||
+                    'unknown file';
+                logger.critical(ErrorCode.DUPLICATE_FUNCTION_NAME, `Exposed function name '${name}' is not unique. ` +
+                    `It already points to '${existingExposed}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`);
+                return;
+            }
+        }
+    }
     // --- resolve middleware ---
     let middleware = objectNode
         ? resolveMiddleware(state, objectNode, tags, checker)
@@ -597,7 +664,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         middleware,
         permissions,
         isDirectFunction,
-        sourceFile: node.getSourceFile().fileName,
+        sourceFile,
         exportedName: exportedName || undefined,
     };
     // Populate node metadata if node config is present

package/dist/add/add-http-route.js

@@ -7,6 +7,7 @@ import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
 import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
 import { ErrorCode } from '../error-codes.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
@@ -113,12 +114,30 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     if (funcName.startsWith('__temp_')) {
         funcName = makeContextBasedId('http', method, fullRoute);
     }
+    let refAddonTarget = null;
+    if (ts.isCallExpression(funcInitializer) &&
+        ts.isIdentifier(funcInitializer.expression) &&
+        funcInitializer.expression.text === 'ref') {
+        const [firstArg] = funcInitializer.arguments;
+        if (firstArg &&
+            ts.isStringLiteral(firstArg) &&
+            firstArg.text.includes(':')) {
+            refAddonTarget = firstArg.text;
+        }
+    }
     const packageName = ts.isIdentifier(funcInitializer)
         ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
         : null;
+    if (refAddonTarget) {
+        const targetMeta = resolveFunctionMeta(state, refAddonTarget);
+        if (!targetMeta) {
+            logger.warn(`Skipping route '${fullRoute}': addon function metadata for '${refAddonTarget}' is not available yet.`);
+            return;
+        }
+    }
     ensureFunctionMetadata(state, funcName, fullRoute, funcInitializer, checker, extracted.isHelper);
     // Lookup existing function metadata
-    const fnMeta = state.functions.meta[funcName];
+    const fnMeta = resolveFunctionMeta(state, funcName);
     if (!fnMeta) {
         logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;

package/dist/error-codes.d.ts

@@ -41,6 +41,7 @@ export declare enum ErrorCode {
     PERMISSION_EMPTY_ARRAY = "PKU937",
     PERMISSION_PATTERN_INVALID = "PKU975",
     DUPLICATE_FUNCTION_VERSION = "PKU850",
+    DUPLICATE_FUNCTION_NAME = "PKU851",
     MANIFEST_MISSING = "PKU860",
     FUNCTION_VERSION_MODIFIED = "PKU861",
     CONTRACT_CHANGED_REQUIRES_BUMP = "PKU862",

package/dist/error-codes.js

@@ -48,6 +48,7 @@ export var ErrorCode;
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
     // Versioning errors
     ErrorCode["DUPLICATE_FUNCTION_VERSION"] = "PKU850";
+    ErrorCode["DUPLICATE_FUNCTION_NAME"] = "PKU851";
     // Contract versioning errors
     ErrorCode["MANIFEST_MISSING"] = "PKU860";
     ErrorCode["FUNCTION_VERSION_MODIFIED"] = "PKU861";

package/dist/utils/schema-generator.js

@@ -258,10 +258,10 @@ async function generateZodSchemas(logger, schemaLookup, typesMap) {
     const uniqueSourceFiles = [
         ...new Set([...schemaLookup.values()].map((ref) => ref.sourceFile)),
     ];
-    console.log(`[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`);
+    logger.info(`[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`);
     const importStart = performance.now();
     const importedModules = await batchImportWithRegister(logger, uniqueSourceFiles);
-    console.log(`[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`);
+    logger.info(`[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`);
     const processStart = performance.now();
     // Track schemas that need per-file tsImport fallback
     const fallbackSchemas = [];
@@ -302,7 +302,7 @@ async function generateZodSchemas(logger, schemaLookup, typesMap) {
             }
         }
     }
-    console.log(`[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`);
+    logger.info(`[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`);
     return schemas;
 }
 export async function generateAllSchemas(logger, config, state) {

package/dist/utils/validate-auth-sessionless.d.ts

@@ -1,3 +1,3 @@
-import * as ts from 'typescript';
+import type * as ts from 'typescript';
 import type { InspectorLogger, InspectorState } from '../types.js';
 export declare function validateAuthSessionless(logger: InspectorLogger, obj: ts.ObjectLiteralExpression, state: InspectorState, funcName: string, wireDescription: string, inheritedAuth?: boolean): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.10",
+  "version": "0.12.11",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.18",
+    "@pikku/core": "^0.12.19",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.test.ts

@@ -0,0 +1,169 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import { ErrorCode } from '../error-codes.js'
+import type { InspectorLogger } from '../types.js'
+
+describe('addFunctions duplicate name handling', () => {
+  test('logs a critical error when function name is duplicated across files', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-duplicate-function-'))
+    const fileA = join(rootDir, 'a.ts')
+    const fileB = join(rootDir, 'b.ts')
+
+    await writeFile(
+      fileA,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    await writeFile(
+      fileB,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    const logger: InspectorLogger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      critical: (code: ErrorCode, message: string) => {
+        criticals.push({ code, message })
+      },
+      hasCriticalErrors: () => criticals.length > 0,
+    }
+
+    try {
+      const state = await inspect(logger, [fileA, fileB], { rootDir })
+      const nameCollision = criticals.find(
+        (entry) => entry.code === ErrorCode.DUPLICATE_FUNCTION_NAME
+      )
+      assert.ok(nameCollision)
+      assert.match(nameCollision!.message, /createUser/)
+      assert.strictEqual(state.rpc.internalMeta['createUser'], 'createUser')
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('allows same base function name across files when versions differ', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-versioned-function-'))
+    const fileA = join(rootDir, 'a.ts')
+    const fileB = join(rootDir, 'b.ts')
+
+    await writeFile(
+      fileA,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  version: 1,',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    await writeFile(
+      fileB,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  version: 2,',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    const logger: InspectorLogger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      critical: (code: ErrorCode, message: string) => {
+        criticals.push({ code, message })
+      },
+      hasCriticalErrors: () => criticals.length > 0,
+    }
+
+    try {
+      const state = await inspect(logger, [fileA, fileB], { rootDir })
+      const nameCollision = criticals.find(
+        (entry) => entry.code === ErrorCode.DUPLICATE_FUNCTION_NAME
+      )
+      assert.equal(nameCollision, undefined)
+      assert.strictEqual(state.rpc.internalMeta['createUser'], 'createUser@v2')
+      assert.ok(state.functions.meta['createUser@v1'])
+      assert.ok(state.functions.meta['createUser@v2'])
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('logs a critical error when exposed function name is duplicated across files', async () => {
+    const rootDir = await mkdtemp(
+      join(tmpdir(), 'pikku-exposed-duplicate-function-')
+    )
+    const fileA = join(rootDir, 'a.ts')
+    const fileB = join(rootDir, 'b.ts')
+
+    await writeFile(
+      fileA,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  expose: true,',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    await writeFile(
+      fileB,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const createUser = pikkuFunc({',
+        '  expose: true,',
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    const logger: InspectorLogger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      critical: (code: ErrorCode, message: string) => {
+        criticals.push({ code, message })
+      },
+      hasCriticalErrors: () => criticals.length > 0,
+    }
+
+    try {
+      await inspect(logger, [fileA, fileB], { rootDir })
+      const nameCollision = criticals.find(
+        (entry) => entry.code === ErrorCode.DUPLICATE_FUNCTION_NAME
+      )
+      assert.ok(nameCollision)
+      assert.match(
+        nameCollision!.message,
+        /Function name 'createUser' is not unique/
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/add-functions.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { AddWiring, SchemaRef } from '../types.js'
+import type { AddWiring, InspectorState, SchemaRef } from '../types.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
 import type { TypesMap } from '../types-map.js'
 import {
@@ -9,7 +9,7 @@ import {
 import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { extractUsedWires } from '../utils/extract-services.js'
 import type { FunctionServicesMeta } from '@pikku/core'
-import { formatVersionedId } from '@pikku/core'
+import { formatVersionedId, parseVersionedId } from '@pikku/core'
 import {
   getPropertyValue,
   getCommonWireMetaData,
@@ -287,6 +287,31 @@ function unwrapPromise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
   return type
 }
 
+const resolveExistingFunctionSource = (
+  state: InspectorState,
+  pikkuFuncId: string
+): string | null => {
+  return (
+    state.functions.meta[pikkuFuncId]?.sourceFile ||
+    state.rpc.internalFiles.get(pikkuFuncId)?.path ||
+    null
+  )
+}
+
+const areCompatibleFunctionIds = (
+  existingId: string,
+  incomingId: string
+): boolean => {
+  if (existingId === incomingId) {
+    return true
+  }
+
+  const existingParsed = parseVersionedId(existingId)
+  const incomingParsed = parseVersionedId(incomingId)
+
+  return existingParsed.baseName === incomingParsed.baseName
+}
+
 /**
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
@@ -546,6 +571,7 @@ export const addFunctions: AddWiring = (
   }
 
   const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc'
+  const isListFunc = expression.text === 'pikkuListFunc'
   const mcpEnabled = mcp || isMCPToolFunc
 
   // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
@@ -618,7 +644,33 @@ export const addFunctions: AddWiring = (
     inputNames = [schemaName]
     state.schemaLookup.set(schemaName, inputSchemaRef)
     state.functions.typesMap.addCustomType(schemaName, 'unknown', [])
-  } else if (genericTypes.length >= 1 && genericTypes[0]) {
+  } else if (isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+    const inputAliasName = `${capitalizedName}Input`
+    const filterType = genericTypes[0]
+    const filterTypeText = checker.typeToString(
+      filterType,
+      undefined,
+      ts.TypeFormatFlags.NoTruncation
+    )
+    const refs = resolveTypeImports(
+      filterType,
+      state.functions.typesMap,
+      true,
+      checker
+    )
+    state.functions.typesMap.addCustomType(
+      inputAliasName,
+      `{ cursor?: string; limit?: number; sort?: Array<{ column: string; direction: 'asc' | 'desc' }>; filter?: unknown; search?: string; } & ${filterTypeText}`,
+      [...new Set(refs)]
+    )
+    inputNames = [inputAliasName]
+    const secondParam = handler.parameters[1]
+    if (secondParam) {
+      inputTypes = [checker.getTypeAtLocation(secondParam)]
+    } else {
+      inputTypes = [filterType]
+    }
+  } else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
     // Fall back to extracting from generic type arguments
     const result = getNamesAndTypes(
       checker,
@@ -654,7 +706,27 @@ export const addFunctions: AddWiring = (
     outputNames = [schemaName]
     state.schemaLookup.set(schemaName, outputSchemaRef)
     state.functions.typesMap.addCustomType(schemaName, 'unknown', [])
-  } else if (genericTypes.length >= 2) {
+  } else if (isListFunc && genericTypes.length >= 2 && genericTypes[1]) {
+    const outputAliasName = `${capitalizedName}Output`
+    const rowType = genericTypes[1]
+    const rowTypeText = checker.typeToString(
+      rowType,
+      undefined,
+      ts.TypeFormatFlags.NoTruncation
+    )
+    const refs = resolveTypeImports(
+      rowType,
+      state.functions.typesMap,
+      true,
+      checker
+    )
+    state.functions.typesMap.addCustomType(
+      outputAliasName,
+      `{ rows: Array<${rowTypeText}>; nextCursor: string | null; totalCount?: number; }`,
+      [...new Set(refs)]
+    )
+    outputNames = [outputAliasName]
+  } else if (!isListFunc && genericTypes.length >= 2) {
     outputNames = getNamesAndTypes(
       checker,
       state.functions.typesMap,
@@ -731,6 +803,56 @@ export const addFunctions: AddWiring = (
     state.typesLookup.set(pikkuFuncId, inputTypes)
   }
 
+  const sourceFile = node.getSourceFile().fileName
+  const existingFunction = state.functions.meta[pikkuFuncId]
+  if (
+    existingFunction &&
+    existingFunction.sourceFile &&
+    existingFunction.sourceFile !== sourceFile
+  ) {
+    logger.critical(
+      ErrorCode.DUPLICATE_FUNCTION_NAME,
+      `Function name '${name}' is not unique. ` +
+        `'${pikkuFuncId}' is already defined in '${existingFunction.sourceFile}' and cannot be redefined in '${sourceFile}'.`
+    )
+    return
+  }
+
+  if (exportedName || explicitName) {
+    const existingInternal = state.rpc.internalMeta[name]
+    if (
+      existingInternal &&
+      !areCompatibleFunctionIds(existingInternal, pikkuFuncId)
+    ) {
+      const existingSource =
+        resolveExistingFunctionSource(state, existingInternal) || 'unknown file'
+      logger.critical(
+        ErrorCode.DUPLICATE_FUNCTION_NAME,
+        `Function name '${name}' is not unique. ` +
+          `It already points to '${existingInternal}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`
+      )
+      return
+    }
+
+    if (expose) {
+      const existingExposed = state.rpc.exposedMeta[name]
+      if (
+        existingExposed &&
+        !areCompatibleFunctionIds(existingExposed, pikkuFuncId)
+      ) {
+        const existingSource =
+          resolveExistingFunctionSource(state, existingExposed) ||
+          'unknown file'
+        logger.critical(
+          ErrorCode.DUPLICATE_FUNCTION_NAME,
+          `Exposed function name '${name}' is not unique. ` +
+            `It already points to '${existingExposed}' in '${existingSource}', but '${pikkuFuncId}' in '${sourceFile}' tried to use the same name.`
+        )
+        return
+      }
+    }
+  }
+
   // --- resolve middleware ---
   let middleware = objectNode
     ? resolveMiddleware(state, objectNode, tags, checker)
@@ -801,7 +923,7 @@ export const addFunctions: AddWiring = (
     middleware,
     permissions,
     isDirectFunction,
-    sourceFile: node.getSourceFile().fileName,
+    sourceFile,
     exportedName: exportedName || undefined,
   }