@pikku/inspector 0.12.9 → 0.12.11

package/dist/utils/workflow/dsl/validation.js

@@ -12,7 +12,7 @@ import * as ts from 'typescript';
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
-export function validateNoDisallowedPatterns(node) {
+export function validateNoDisallowedPatterns(node, options) {
     const errors = [];
     function visitBlock(block) {
         for (const statement of block.statements) {
@@ -30,7 +30,7 @@ export function validateNoDisallowedPatterns(node) {
                 // Unknown/disallowed statement type
                 const nodeType = ts.SyntaxKind[statement.kind];
                 errors.push({
-                    message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+                    message: `Statement type '${nodeType}' is not allowed in DSL workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
                     node: statement,
                 });
             }
@@ -40,7 +40,7 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow while and do-while
         if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
             errors.push({
-                message: 'while and do-while loops are not allowed in simple workflows',
+                message: 'while and do-while loops are not allowed in DSL workflows',
                 node,
             });
             return;
@@ -48,13 +48,13 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow for and for-in loops
         if (ts.isForInStatement(node) || ts.isForStatement(node)) {
             errors.push({
-                message: 'for and for-in loops are not allowed in simple workflows. Use for-of instead.',
+                message: 'for and for-in loops are not allowed in DSL workflows. Use for-of instead.',
                 node,
             });
             return;
         }
         // Check for inline workflow.do
-        if (ts.isCallExpression(node)) {
+        if (!options?.allowInline && ts.isCallExpression(node)) {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 const propAccess = node.expression;
                 if (propAccess.name.text === 'do' &&
@@ -65,7 +65,7 @@ export function validateNoDisallowedPatterns(node) {
                         (ts.isArrowFunction(secondArg) ||
                             ts.isFunctionExpression(secondArg))) {
                         errors.push({
-                            message: 'Inline workflow.do with function argument is not allowed in simple workflows. Use RPC form instead.',
+                            message: 'Inline workflow.do with function argument is not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.',
                             node,
                         });
                         return;
@@ -97,11 +97,19 @@ export function validateAwaitedCalls(node) {
             if (propAccess.name.text === 'all' &&
                 ts.isIdentifier(propAccess.expression) &&
                 propAccess.expression.text === 'Promise') {
-                // console.log('[DEBUG] Found Promise.all, setting insidePromiseAll=true')
-                // Visit children with insidePromiseAll = true
                 ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
                 return;
             }
+            // .push() on an array — workflow.do() inside is collecting promises
+            if (propAccess.name.text === 'push') {
+                ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+                return;
+            }
+        }
+        // Array literal — workflow.do() inside is collecting promises
+        if (ts.isArrayLiteralExpression(node)) {
+            ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+            return;
         }
         // Now check for workflow calls
         if (ts.isCallExpression(node)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.9",
+  "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.16",
+    "@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.
@@ -339,6 +364,7 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
+  let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
   let version: number | undefined
@@ -422,6 +448,11 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
+    deploy = getPropertyValue(firstArg, 'deploy') as
+      | 'serverless'
+      | 'server'
+      | 'auto'
+      | undefined
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
@@ -540,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
@@ -612,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,
@@ -648,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,
@@ -725,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)
@@ -783,6 +911,7 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
+    deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
     version,
@@ -794,7 +923,7 @@ export const addFunctions: AddWiring = (
     middleware,
     permissions,
     isDirectFunction,
-    sourceFile: node.getSourceFile().fileName,
+    sourceFile,
     exportedName: exportedName || undefined,
   }
 
@@ -817,9 +946,7 @@ export const addFunctions: AddWiring = (
 
   if (mcpEnabled) {
     if (!description) {
-      logger.warn(
-        `MCP tool '${name}' is missing a description.`
-      )
+      logger.warn(`MCP tool '${name}' is missing a description.`)
     }
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
     state.mcpEndpoints.toolsMeta[name] = {

package/src/add/add-http-route.ts

@@ -18,6 +18,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'
@@ -204,6 +205,22 @@ export function registerHTTPRoute({
     funcName = makeContextBasedId('http', method, fullRoute)
   }
 
+  let refAddonTarget: string | null = 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,
@@ -212,6 +229,16 @@ export function registerHTTPRoute({
       )
     : 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,
@@ -222,7 +249,7 @@ export function registerHTTPRoute({
   )
 
   // Lookup existing function metadata
-  const fnMeta = state.functions.meta[funcName]
+  const fnMeta = resolveFunctionMeta(state, funcName)
   if (!fnMeta) {
     logger.critical(
       ErrorCode.FUNCTION_METADATA_NOT_FOUND,

package/src/add/add-workflow.ts

@@ -155,7 +155,7 @@ function getWorkflowInvocations(
 }
 
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export const addWorkflow: AddWiring = (logger, node, checker, state) => {
@@ -171,11 +171,11 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  let wrapperType: 'dsl' | 'regular' | null = null
+  let wrapperType: 'dsl' | 'complex' | null = null
   if (expression.text === 'pikkuWorkflowFunc') {
     wrapperType = 'dsl'
   } else if (expression.text === 'pikkuWorkflowComplexFunc') {
-    wrapperType = 'regular'
+    wrapperType = 'complex'
   } else {
     return
   }
@@ -267,7 +267,9 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
 
   // Try DSL workflow extraction first
   // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-  const result = extractDSLWorkflow(node, checker)
+  const result = extractDSLWorkflow(node, checker, {
+    allowInline: wrapperType === 'complex',
+  })
 
   if (result.status === 'ok' && result.steps) {
     // Extraction succeeded
@@ -305,7 +307,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
       getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
       logger.critical(
         ErrorCode.INVALID_DSL_WORKFLOW,
-        `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
+        `Workflow '${workflowName}' does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
       )
       return
     } else {
@@ -317,12 +319,10 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     }
   }
 
-  /**
-   * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
-   * to ensure all RPC invocations are tracked for function registration.
-   * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
-   */
-  if (!dsl || wrapperType === 'regular') {
+  // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
+  // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
+  // with identifier args, etc.) are still registered as invoked functions.
+  if (wrapperType === 'complex') {
     getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
   }
 

package/src/error-codes.ts

@@ -53,6 +53,7 @@ export enum ErrorCode {
 
   // Versioning errors
   DUPLICATE_FUNCTION_VERSION = 'PKU850',
+  DUPLICATE_FUNCTION_NAME = 'PKU851',
 
   // Contract versioning errors
   MANIFEST_MISSING = 'PKU860',

package/src/utils/extract-node-value.ts

@@ -27,6 +27,11 @@ export function extractStringLiteral(
     return result
   }
 
+  // Unwrap type assertions: `expr as Type` or `<Type>expr`
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    return extractStringLiteral(node.expression, checker)
+  }
+
   // Try to evaluate constant identifiers
   if (ts.isIdentifier(node)) {
     const symbol = checker.getSymbolAtLocation(node)

package/src/utils/schema-generator.ts

@@ -375,7 +375,7 @@ async function generateZodSchemas(
   const uniqueSourceFiles = [
     ...new Set([...schemaLookup.values()].map((ref) => ref.sourceFile)),
   ]
-  console.log(
+  logger.info(
     `[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`
   )
 
@@ -384,7 +384,7 @@ async function generateZodSchemas(
     logger,
     uniqueSourceFiles
   )
-  console.log(
+  logger.info(
     `[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`
   )
 
@@ -456,7 +456,7 @@ async function generateZodSchemas(
     }
   }
 
-  console.log(
+  logger.info(
     `[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`
   )
   return schemas

package/src/utils/validate-auth-sessionless.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript'
+import type * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
 import { ErrorCode } from '../error-codes.js'
 import type { InspectorLogger, InspectorState } from '../types.js'