@pikku/inspector 0.12.47 → 0.12.49

package/src/add/scenario-marker.test.ts

@@ -0,0 +1,89 @@
+/**
+ * The `scenario` / `scenarioStep` markers in the *function* meta are what every
+ * deployment boundary downstream reads: the codegen partition, the RPC meta
+ * filter, the schema split and the deploy analyzer. Asserting them on a real
+ * `pikkuScenario(...)` is what makes those filters mean anything — filters tested
+ * against hand-written meta would keep passing if extraction stopped setting it.
+ */
+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 type { InspectorLogger } from '../types.js'
+
+const logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  diagnostic: () => {},
+  critical: () => {},
+  hasCriticalErrors: () => false,
+} as unknown as InspectorLogger
+
+const STEPS = [
+  "import { pikkuScenarioStep } from '@pikku/core'",
+  'export const buysAnApple = pikkuScenarioStep({',
+  "  name: 'buysAnApple',",
+  "  description: 'buys an apple',",
+  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
+  '})',
+].join('\n')
+
+const APP = [
+  "import { pikkuFunc } from '@pikku/core'",
+  'export const createTodo = pikkuFunc({',
+  '  expose: true,',
+  '  func: async (_services, data: { title: string }) => ({ id: data.title }),',
+  '})',
+].join('\n')
+
+const SCENARIO = [
+  "import { pikkuScenario } from '@pikku/core/workflow'",
+  'export const shopFlow = pikkuScenario({',
+  "  title: 'Buys an apple',",
+  '  func: async (_services, _input, { scenario }: any) => {',
+  "    await scenario.when('buys an apple', 'buysAnApple', { qty: 1 })",
+  '    return { ok: true }',
+  '  },',
+  '})',
+].join('\n')
+
+describe('scenario markers in the function meta', () => {
+  test('a real pikkuScenario and pikkuScenarioStep are marked, an application function is not', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-marker-'))
+    const files = [
+      [join(rootDir, 'shop.steps.ts'), STEPS],
+      [join(rootDir, 'shop.scenario.ts'), SCENARIO],
+      [join(rootDir, 'todo.function.ts'), APP],
+    ] as const
+    await Promise.all(files.map(([path, source]) => writeFile(path, source)))
+
+    try {
+      const state = await inspect(
+        logger,
+        files.map(([path]) => path),
+        { rootDir }
+      )
+
+      const scenario = state.functions.meta['shopFlow']
+      assert.ok(scenario, 'the scenario body is a function and must have meta')
+      assert.equal(scenario.scenario, true)
+      assert.equal(scenario.scenarioStep, undefined)
+
+      const step = state.functions.meta['buysAnApple']
+      assert.ok(step)
+      assert.equal(step.scenarioStep, true)
+      assert.equal(step.scenario, undefined)
+
+      const app = state.functions.meta['createTodo']
+      assert.ok(app)
+      assert.equal(app.scenario, undefined)
+      assert.equal(app.scenarioStep, undefined)
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/scenario-not-extractable.test.ts

@@ -0,0 +1,159 @@
+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 type { InspectorLogger } from '../types.js'
+
+function makeLogger(
+  criticals: Array<{ code: string; message: string }>
+): InspectorLogger {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: ({ code, message }: any) => {
+      criticals.push({ code, message })
+    },
+    critical: (code: any, message: string) => {
+      criticals.push({ code, message })
+    },
+    hasCriticalErrors: () => criticals.length > 0,
+  } as InspectorLogger
+}
+
+const STEPS = [
+  "import { pikkuScenarioStep } from '@pikku/core'",
+  'export const buysAnApple = pikkuScenarioStep({',
+  "  name: 'buysAnApple',",
+  "  description: 'buys an apple',",
+  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
+  '})',
+].join('\n')
+
+const source = (wrapper: string, body: string[]) =>
+  [
+    `import { ${wrapper} } from '@pikku/core/workflow'`,
+    'declare const actors: Record<string, any>',
+    `export const shopFlow = ${wrapper}(async (_services, _input, { scenario, workflow }: any) => {`,
+    ...body.map((line) => `  ${line}`),
+    '  return { ok: true }',
+    '})',
+  ].join('\n')
+
+async function run(wrapper: string, body: string[]) {
+  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-extract-'))
+  const stepsFile = join(rootDir, 'shop.steps.ts')
+  const scenarioFile = join(rootDir, 'shop.scenario.ts')
+  await writeFile(stepsFile, STEPS)
+  await writeFile(scenarioFile, source(wrapper, body))
+  const criticals: Array<{ code: string; message: string }> = []
+  const state = await inspect(
+    makeLogger(criticals),
+    [stepsFile, scenarioFile],
+    {
+      rootDir,
+    }
+  )
+  return {
+    state,
+    criticals,
+    cleanup: () => rm(rootDir, { recursive: true, force: true }),
+  }
+}
+
+/**
+ * A scenario that fails DSL extraction silently registers with zero steps,
+ * because the fallback path (`getWorkflowInvocations`) understands `do`/`sleep`
+ * but not `step`/`given`/`when`/`then`. That is the PKU678 silent-drop class,
+ * and for scenarios it must be loud.
+ */
+describe('a scenario that cannot be extracted', () => {
+  test('a top-level try/catch is a PKU679 critical, not a silent zero-step scenario', async () => {
+    const { state, criticals, cleanup } = await run('pikkuScenario', [
+      'try {',
+      "  await scenario.given('buys an apple', 'buysAnApple', { qty: 1 }, { actor: actors.shopper })",
+      '} catch {}',
+    ])
+    try {
+      assert.equal(
+        state.workflows.meta.shopFlow,
+        undefined,
+        'an unextractable scenario must not register at all, rather than register empty'
+      )
+      assert.ok(
+        criticals.find((c) => c.code === 'PKU679'),
+        `expected a PKU679 critical for an unextractable scenario, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+
+  test('an extractable scenario raises no PKU679', async () => {
+    const { criticals, cleanup } = await run('pikkuScenario', [
+      "await scenario.given('buys an apple', 'buysAnApple', { qty: 1 }, { actor: actors.shopper })",
+    ])
+    try {
+      assert.equal(
+        criticals.filter((c) => c.code === 'PKU679').length,
+        0,
+        `a valid scenario must not raise PKU679, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+
+  test('a scenario that declares no input parameter is still extractable', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-noinput-'))
+    const scenarioFile = join(rootDir, 'fails.scenario.ts')
+    await writeFile(
+      scenarioFile,
+      [
+        "import { pikkuScenario } from '@pikku/core/workflow'",
+        'export const alwaysFails = pikkuScenario({',
+        "  title: 'Always fails (test fixture)',",
+        "  tags: ['scenario'],",
+        "  func: async () => { throw new Error('always fails') },",
+        '})',
+      ].join('\n')
+    )
+    const criticals: Array<{ code: string; message: string }> = []
+    const state = await inspect(makeLogger(criticals), [scenarioFile], {
+      rootDir,
+    })
+    try {
+      assert.ok(
+        state.workflows.meta.alwaysFails,
+        `a scenario that ignores its input must still register, got criticals: ${JSON.stringify(criticals)}`
+      )
+      assert.equal(
+        criticals.filter((c) => c.code === 'PKU679').length,
+        0,
+        `declaring no input parameter is legitimate, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('a complex workflow still falls back quietly — only scenarios are strict', async () => {
+    const { criticals, cleanup } = await run('pikkuWorkflowComplexFunc', [
+      'try {',
+      "  await workflow.do('buy', 'buysAnApple', { qty: 1 })",
+      '} catch {}',
+    ])
+    try {
+      assert.equal(
+        criticals.filter((c) => c.code === 'PKU679').length,
+        0,
+        `pikkuWorkflowComplexFunc legitimately falls back to basic extraction, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+})

package/src/add/scenario-services.test.ts

@@ -0,0 +1,103 @@
+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 type { InspectorLogger } from '../types.js'
+
+function makeLogger(
+  criticals: Array<{ code: string; message: string }>
+): InspectorLogger {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: ({ code, message }) => {
+      criticals.push({ code, message })
+    },
+    critical: (code: any, message: string) => {
+      criticals.push({ code, message })
+    },
+    hasCriticalErrors: () => criticals.length > 0,
+  }
+}
+
+const stepFile = (dir: string) => join(dir, 'my.steps.ts')
+const stepSource = [
+  "import { pikkuSessionlessFunc } from '@pikku/core'",
+  'export const getTodos = pikkuSessionlessFunc({',
+  '  func: async ({ logger }) => [{ done: true }],',
+  '})',
+].join('\n')
+
+describe('scenarios may only destructure logger/config', () => {
+  test('a scenario destructuring a real service is a PKU673 critical', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-sc-svc-'))
+    const scenarioFile = join(rootDir, 'my.scenario.ts')
+    await writeFile(stepFile(rootDir), stepSource)
+    await writeFile(
+      scenarioFile,
+      [
+        "import { pikkuScenario } from '@pikku/core/workflow'",
+        'declare const actors: Record<string, any>',
+        'export const badFlow = pikkuScenario(async ({ kysely }: any, _input, { workflow }) => {',
+        "  await workflow.do('Read todos', 'getTodos', {}, { actor: actors.pm })",
+        '  return { ok: true }',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: string; message: string }> = []
+    try {
+      await inspect(makeLogger(criticals), [stepFile(rootDir), scenarioFile], {
+        rootDir,
+      })
+      const pku673 = criticals.find((c) => c.code === 'PKU673')
+      assert.ok(
+        pku673,
+        `expected a PKU673 critical for a scenario destructuring 'kysely', got: ${JSON.stringify(criticals)}`
+      )
+      assert.ok(
+        pku673.message.includes('kysely'),
+        `PKU673 should name the offending service, got: ${pku673.message}`
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('a scenario destructuring only logger is allowed', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-sc-ok-'))
+    const scenarioFile = join(rootDir, 'my.scenario.ts')
+    await writeFile(stepFile(rootDir), stepSource)
+    await writeFile(
+      scenarioFile,
+      [
+        "import { pikkuScenario } from '@pikku/core/workflow'",
+        'declare const actors: Record<string, any>',
+        'export const goodFlow = pikkuScenario(async ({ logger }, _input, { workflow }) => {',
+        "  await workflow.do('Read todos', 'getTodos', {}, { actor: actors.pm })",
+        '  return { ok: true }',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: string; message: string }> = []
+    try {
+      const state = await inspect(
+        makeLogger(criticals),
+        [stepFile(rootDir), scenarioFile],
+        { rootDir }
+      )
+      assert.ok(
+        !criticals.some((c) => c.code === 'PKU673'),
+        `logger is allowed in a scenario; got: ${JSON.stringify(criticals)}`
+      )
+      assert.equal((state.workflows.meta as any).goodFlow?.scenario, true)
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/scenario-skip.test.ts

@@ -0,0 +1,83 @@
+/**
+ * A scenario can declare why it is held out of a default run. The reason has to
+ * reach the meta, because the runner reports skips from there — if it were
+ * dropped in extraction the scenario would silently run anyway, which is the
+ * opposite of what the author asked for.
+ */
+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 type { InspectorLogger } from '../types.js'
+
+const logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  diagnostic: () => {},
+  critical: () => {},
+  hasCriticalErrors: () => false,
+} as unknown as InspectorLogger
+
+const STEPS = [
+  "import { pikkuScenarioStep } from '@pikku/core'",
+  'export const buysAnApple = pikkuScenarioStep({',
+  "  name: 'buysAnApple',",
+  "  description: 'buys an apple',",
+  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
+  '})',
+].join('\n')
+
+const scenarioSource = (properties: string[]) =>
+  [
+    "import { pikkuScenario } from '@pikku/core/workflow'",
+    'export const shopFlow = pikkuScenario({',
+    ...properties.map((line) => `  ${line}`),
+    '  func: async (_services, _input, { scenario }: any) => {',
+    "    await scenario.when('buys an apple', 'buysAnApple', { qty: 1 })",
+    '    return { ok: true }',
+    '  },',
+    '})',
+  ].join('\n')
+
+async function inspectScenario(properties: string[]) {
+  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-skip-'))
+  const stepsFile = join(rootDir, 'shop.steps.ts')
+  const scenarioFile = join(rootDir, 'shop.scenario.ts')
+  await writeFile(stepsFile, STEPS)
+  await writeFile(scenarioFile, scenarioSource(properties))
+  const state = await inspect(logger, [stepsFile, scenarioFile], { rootDir })
+  return {
+    meta: state.workflows.meta['shopFlow'] as any,
+    cleanup: () => rm(rootDir, { recursive: true, force: true }),
+  }
+}
+
+describe('scenario skip', () => {
+  test('a declared skip reason reaches the meta', async () => {
+    const { meta, cleanup } = await inspectScenario([
+      "title: 'Installs an addon',",
+      "skip: 'mutates the project — needs a fresh server',",
+    ])
+    try {
+      assert.equal(meta.skip, 'mutates the project — needs a fresh server')
+    } finally {
+      await cleanup()
+    }
+  })
+
+  test('a scenario that declares none carries none', async () => {
+    const { meta, cleanup } = await inspectScenario([
+      "title: 'Installs an addon',",
+    ])
+    try {
+      assert.equal(meta.skip, undefined)
+      assert.equal(meta.scenario, true)
+    } finally {
+      await cleanup()
+    }
+  })
+})

package/src/error-codes.ts

@@ -22,6 +22,9 @@ export enum ErrorCode {
   CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = 'PKU672',
   SCENARIO_HAS_SERVICES = 'PKU673',
   EXPECT_EVENTUALLY_SCENARIO_ONLY = 'PKU675',
+  SCENARIO_BROWSER_STEP_NEEDS_ACTOR = 'PKU677',
+  SCENARIO_STEP_TARGET_NOT_STATIC = 'PKU678',
+  SCENARIO_NOT_EXTRACTABLE = 'PKU679',
   WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = 'PKU600',
   INVALID_DSL_WORKFLOW = 'PKU641',
   WORKFLOW_GRAPH_ADDON_NOT_WIRED = 'PKU642',

package/src/index.ts

@@ -5,6 +5,11 @@ export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js'
 export { ErrorCode } from './error-codes.js'
 export type { DiagnosticSeverity, CodedDiagnostic } from './error-codes.js'
 export { AUTH_HANDLER_FUNC_ID } from './add/add-auth.js'
+export {
+  SCENARIO_INSTRUMENTATION_FUNCTIONS,
+  isScenarioInstrumentationFunction,
+} from './add/scenario-instrumentation.js'
+export type { ScenarioInstrumentationFunction } from './add/scenario-instrumentation.js'
 export {
   serializeInspectorState,
   deserializeInspectorState,
@@ -27,6 +32,7 @@ export type {
   VersionManifest,
   VersionManifestEntry,
 } from './utils/contract-hashes.js'
+export type { InspectorFeature, InspectorFeatureEntry } from './types.js'
 export { serializeMCPJson } from './utils/serialize-mcp-json.js'
 export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js'
 export {

package/src/inspector.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript'
 import { performance } from 'perf_hooks'
-import { resolve } from 'path'
+import { dirname, resolve } from 'path'
 import { visitSetup, visitFunctions, visitRoutes } from './visit.js'
 import { TypesMap } from './types-map.js'
 import type {
@@ -27,6 +27,8 @@ import {
   computeRequiredSchemas,
   computeDiagnostics,
   validateSchemaWiringSeparation,
+  validateScenarioServices,
+  validateScenarioSteps,
   validateWorkflowGraphAddons,
 } from './utils/post-process.js'
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js'
@@ -121,6 +123,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       files: new Map(),
       graphMeta: {},
       graphFiles: new Map(),
+      featureFiles: new Map(),
       invokedWorkflows: new Set(),
     },
     rpc: {
@@ -240,6 +243,49 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
   }
 }
 
+/**
+ * The path mappings the inspector's program has to share with the project.
+ *
+ * The inspector builds its own program rather than reusing the project's, which
+ * is what keeps a cold run affordable — but a project that reaches its generated
+ * code through a tsconfig `paths` entry resolves that import through those
+ * mappings and nothing else. Without them the factory an inspected function is
+ * passed to resolves to `any`, so a function whose input type comes from the
+ * factory's contextual type (rather than an explicit generic or a named schema)
+ * silently records no input at all.
+ *
+ * Only resolution keys are copied. Type-inference options such as `strict` stay
+ * the inspector's own, because changing those would change the recorded types.
+ */
+const readProjectPathMappings = (
+  logger: InspectorLogger,
+  tsconfig: string | undefined
+): ts.CompilerOptions => {
+  if (!tsconfig) {
+    return {}
+  }
+  const configPath = resolve(tsconfig)
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
+  if (configFile.error || !configFile.config) {
+    logger.debug(
+      `Could not read ${configPath} for path mappings; imports that rely on them will not resolve`
+    )
+    return {}
+  }
+  const { options: projectOptions } = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    dirname(configPath)
+  )
+  const { baseUrl, paths, rootDirs, pathsBasePath } = projectOptions
+  return {
+    ...(baseUrl !== undefined ? { baseUrl } : {}),
+    ...(paths !== undefined ? { paths } : {}),
+    ...(rootDirs !== undefined ? { rootDirs } : {}),
+    ...(pathsBasePath !== undefined ? { pathsBasePath } : {}),
+  }
+}
+
 export const inspect = async (
   logger: InspectorLogger,
   routeFiles: string[],
@@ -247,6 +293,7 @@ export const inspect = async (
 ): Promise<InspectorState> => {
   const normalizedRouteFiles = routeFiles.map((file) => resolve(file))
   const compilerOptions: ts.CompilerOptions = {
+    ...readProjectPathMappings(logger, options.tsconfig),
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.Node16,
     skipLibCheck: true,
@@ -407,6 +454,8 @@ export const inspect = async (
     computeDiagnostics(state)
     validateSchemaWiringSeparation(logger, state)
     validateWorkflowGraphAddons(logger, state)
+    validateScenarioServices(logger, state)
+    validateScenarioSteps(logger, state)
 
     if (options.openAPI) {
       state.openAPISpec = await generateOpenAPISpec(

package/src/tsconfig-paths.test.ts

@@ -0,0 +1,90 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from './inspector.js'
+import type { InspectorLogger } from './types.js'
+
+const logger: InspectorLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  diagnostic: () => {},
+  critical: () => {},
+  hasCriticalErrors: () => false,
+}
+
+const FACTORY = [
+  'export type Config = {',
+  '  name: string',
+  '  func: (services: any, data: { qty: number }) => Promise<{ ok: boolean }>',
+  '}',
+  'export const pikkuSessionlessFunc = (config: Config): Config => config',
+].join('\n')
+
+// The parameter is deliberately unannotated: its type can only come from the
+// factory's contextual type, which is exactly what an unresolved import loses.
+const funcSource = (specifier: string) =>
+  [
+    `import { pikkuSessionlessFunc } from '${specifier}'`,
+    'export const buysAnApple = pikkuSessionlessFunc({',
+    "  name: 'buysAnApple',",
+    '  func: async (_services, data) => ({ ok: data.qty > 0 }),',
+    '})',
+  ].join('\n')
+
+const makeProject = async (specifier: string) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-tsconfig-paths-'))
+  await mkdir(join(rootDir, 'generated'))
+  await mkdir(join(rootDir, 'src'))
+  await writeFile(
+    join(rootDir, 'tsconfig.json'),
+    JSON.stringify({
+      compilerOptions: {
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        paths: { '#gen/*': ['./generated/*'] },
+      },
+    })
+  )
+  await writeFile(
+    join(rootDir, 'package.json'),
+    JSON.stringify({ type: 'module' })
+  )
+  await writeFile(join(rootDir, 'generated', 'factory.ts'), FACTORY)
+  const funcFile = join(rootDir, 'src', 'apple.func.ts')
+  await writeFile(funcFile, funcSource(specifier))
+  return { rootDir, funcFile, tsconfig: join(rootDir, 'tsconfig.json') }
+}
+
+describe('tsconfig path mappings', () => {
+  test('a relative import gives the function its input type', async () => {
+    const { rootDir, funcFile } = await makeProject('../generated/factory.js')
+    try {
+      const state = await inspect(logger, [funcFile], { rootDir })
+      const meta = state.functions.meta['buysAnApple']
+      assert.ok(meta, 'buysAnApple meta should exist')
+      assert.deepStrictEqual(meta!.inputs, ['BuysAnAppleInput'])
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('an import that only resolves through tsconfig paths keeps its input type', async () => {
+    const { rootDir, funcFile, tsconfig } = await makeProject('#gen/factory.js')
+    try {
+      const state = await inspect(logger, [funcFile], { rootDir, tsconfig })
+      const meta = state.functions.meta['buysAnApple']
+      assert.ok(meta, 'buysAnApple meta should exist')
+      assert.deepStrictEqual(
+        meta!.inputs,
+        ['BuysAnAppleInput'],
+        'without the project path mappings the factory resolves to `any`, and the input is silently dropped'
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})