kea-typegen 3.7.1 → 3.8.1

package/src/cache.ts

@@ -3,6 +3,7 @@ import * as path from 'path'
 import { AppOptions, ParsedLogic } from './types'
 import { Program } from 'typescript'
 import { visitProgram } from './visit/visit'
+import { isInlineFile } from './utils'
 
 export function cachePath(appOptions: AppOptions, fileName: string): string {
     return path.join(process.cwd(), '.typegen', path.relative(process.cwd(), fileName))
@@ -13,8 +14,16 @@ export function restoreCachedTypes(program: Program, appOptions: AppOptions, log
         return false
     }
     const parsedLogics = visitProgram(program, appOptions)
+    const parsedLogicsByFile: Record<string, ParsedLogic[]> = {}
+    for (const pl of parsedLogics) {
+        parsedLogicsByFile[pl.fileName] = [...(parsedLogicsByFile[pl.fileName] ?? []), pl]
+    }
     let restored = false
     for (const pl of parsedLogics) {
+        if (isInlineFile(appOptions, program.getSourceFile(pl.fileName), parsedLogicsByFile[pl.fileName])) {
+            // inline files have their types in the logic file itself, there is no logicType.ts to restore
+            continue
+        }
         if (!fs.existsSync(pl.typeFileName)) {
             const from = cachePath(appOptions, pl.typeFileName)
             if (fs.existsSync(from)) {
@@ -36,3 +45,13 @@ export function cacheWrittenFile(fileName: string, appOptions: AppOptions) {
     fs.mkdirSync(path.dirname(dest), { recursive: true })
     fs.copyFileSync(fileName, dest)
 }
+
+export function deleteCachedFile(fileName: string, appOptions: AppOptions) {
+    if (!appOptions.useCache) {
+        return
+    }
+    const dest = cachePath(appOptions, fileName)
+    if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest)
+    }
+}

package/src/cli/typegen.ts

@@ -39,6 +39,16 @@ yargs
     .option('delete', { describe: 'Delete logicType.ts files without a corresponding logic.ts', type: 'boolean' })
     .option('add-ts-nocheck', { describe: 'Add @ts-nocheck to top of logicType.ts files', type: 'boolean' })
     .option('convert-to-builders', { describe: 'Convert Kea 2.0 inputs to Kea 3.0 logic builders', type: 'boolean' })
+    .option('inline', {
+        describe: 'Write logic types as MakeLogicType blocks above each kea() call, instead of logicType.ts files',
+        type: 'boolean',
+    })
+    .option('inline-paths', {
+        describe:
+            'Like --inline, but only for logic files under these paths (relative to --root). ' +
+            'Everything else keeps its logicType.ts file.',
+        type: 'array',
+    })
     .option('import-global-types', {
         describe: 'Add import statements in logicType.ts files for global types (e.g. @types/node)',
         type: 'boolean',

package/src/print/print.ts

@@ -36,9 +36,11 @@ import { printSharedListeners } from './printSharedListeners'
 import { printListeners } from './printListeners'
 import { writePaths } from '../write/writePaths'
 import { writeTypeImports } from '../write/writeTypeImports'
+import { writeInlineLogicTypes } from '../write/writeInlineLogicTypes'
 import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
-import { cacheWrittenFile } from '../cache'
+import { cacheWrittenFile, deleteCachedFile } from '../cache'
+import { isInlineFile } from '../utils'
 
 const prettierConfigCache = new Map<string, Promise<prettier.Options | null>>()
 
@@ -77,9 +79,6 @@ export async function printToFiles(
             groupedByFile[parsedLogic.fileName] = []
         }
         groupedByFile[parsedLogic.fileName].push(parsedLogic)
-
-        // create the Nodes and gather referenced types
-        printLogicType(parsedLogic, appOptions)
     }
 
     // Automatically ignore imports from "node_modules/@types/node", if {types: ["node"]} in tsconfig.json
@@ -105,6 +104,11 @@ export async function printToFiles(
     const shouldIgnore = (absolutePath: string) =>
         !!doNotImportFromPaths.find((badPath) => absolutePath.startsWith(badPath))
 
+    const nodeModulesPath = path.join(
+        appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
+        'node_modules',
+    )
+
     let writtenFiles = 0
     let filesToWrite = 0
     let filesToModify = 0
@@ -112,6 +116,33 @@ export async function printToFiles(
     for (const [fileName, parsedLogics] of Object.entries(groupedByFile)) {
         const typeFileName = parsedLogics[0].typeFileName
 
+        if (isInlineFile(appOptions, program.getSourceFile(fileName), parsedLogics)) {
+            // write/update MakeLogicType blocks above the logics instead of writing a logicType.ts file
+            const inlineResponse = await writeInlineLogicTypes(
+                program,
+                appOptions,
+                fileName,
+                parsedLogics,
+                nodeModulesPath,
+                shouldIgnore,
+            )
+            filesToWrite += inlineResponse.filesToWrite
+            writtenFiles += inlineResponse.writtenFiles
+
+            // the logicType.ts file is superseded by the inline block
+            if (appOptions.delete && fs.existsSync(typeFileName)) {
+                log(`🗑️ Deleting: ${path.relative(process.cwd(), typeFileName)}`)
+                fs.unlinkSync(typeFileName)
+                deleteCachedFile(typeFileName, appOptions)
+            }
+            continue
+        }
+
+        // create the Nodes and gather referenced types
+        for (const parsedLogic of parsedLogics) {
+            printLogicType(parsedLogic, appOptions)
+        }
+
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
@@ -131,62 +162,12 @@ export async function printToFiles(
 
         const output = logicStrings.join('\n\n')
 
-        const nodeModulesPath = path.join(
-            appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
-            'node_modules',
+        const otherimports = buildTypeImportEntries(
+            parsedLogics[0].typeReferencesToImportFromFiles,
+            parsedLogics[0].typeFileName,
+            nodeModulesPath,
+            shouldIgnore,
         )
-
-        const otherimports = Object.entries(parsedLogics[0].typeReferencesToImportFromFiles)
-            .filter(([_, list]) => list.size > 0)
-            .map(([file, list]) => {
-                let finalPath = file
-
-                // Relative path? Get the absolute.
-                if (finalPath.startsWith('.')) {
-                    finalPath = path.resolve(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                }
-                if (finalPath.startsWith('node_modules/')) {
-                    finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
-                }
-                // clean up '../../node_modules/...'
-                if (finalPath.startsWith(nodeModulesPath)) {
-                    finalPath = finalPath.substring(nodeModulesPath.length + 1)
-                    if (finalPath.startsWith('.pnpm/')) {
-                        // node_modules/.pnpm/pkg@version/node_modules/* --> *
-                        const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
-                        const result = finalPath.match(regex)
-                        if (result && result.length > 1) {
-                            finalPath = result[1]
-                        }
-                    }
-                    if (finalPath.startsWith('@types/')) {
-                        finalPath = finalPath.substring(7)
-                    }
-                }
-
-                // Resolve absolute urls
-                if (finalPath.startsWith('/')) {
-                    finalPath = path.relative(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                    if (!finalPath.startsWith('.')) {
-                        finalPath = `./${finalPath}`
-                    }
-                }
-
-                // Remove extension
-                finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
-
-                // Remove "/index"
-                if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
-                    finalPath = finalPath.substring(0, finalPath.length - 6)
-                }
-
-                return {
-                    list: [...list].sort(),
-                    fullPath: file,
-                    finalPath,
-                }
-            })
-            .filter((entry) => !shouldIgnore(entry.fullPath))
             .map(({ list, finalPath }) => `import type { ${list.join(', ')} } from '${finalPath}'`)
             .join('\n')
 
@@ -306,6 +287,72 @@ export async function printToFiles(
     return { filesToWrite, writtenFiles, filesToModify }
 }
 
+export interface TypeImportEntry {
+    list: string[]
+    fullPath: string
+    finalPath: string
+}
+
+/** Resolve gathered type references into import specifiers, relative to the file they'll be imported into */
+export function buildTypeImportEntries(
+    typeReferencesToImportFromFiles: Record<string, Set<string>>,
+    importIntoFile: string,
+    nodeModulesPath: string,
+    shouldIgnore: (absolutePath: string) => boolean,
+): TypeImportEntry[] {
+    return Object.entries(typeReferencesToImportFromFiles)
+        .filter(([_, list]) => list.size > 0)
+        .map(([file, list]) => {
+            let finalPath = file
+
+            // Relative path? Get the absolute.
+            if (finalPath.startsWith('.')) {
+                finalPath = path.resolve(path.dirname(importIntoFile), finalPath)
+            }
+            if (finalPath.startsWith('node_modules/')) {
+                finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
+            }
+            // clean up '../../node_modules/...'
+            if (finalPath.startsWith(nodeModulesPath)) {
+                finalPath = finalPath.substring(nodeModulesPath.length + 1)
+                if (finalPath.startsWith('.pnpm/')) {
+                    // node_modules/.pnpm/pkg@version/node_modules/* --> *
+                    const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
+                    const result = finalPath.match(regex)
+                    if (result && result.length > 1) {
+                        finalPath = result[1]
+                    }
+                }
+                if (finalPath.startsWith('@types/')) {
+                    finalPath = finalPath.substring(7)
+                }
+            }
+
+            // Resolve absolute urls
+            if (finalPath.startsWith('/')) {
+                finalPath = path.relative(path.dirname(importIntoFile), finalPath)
+                if (!finalPath.startsWith('.')) {
+                    finalPath = `./${finalPath}`
+                }
+            }
+
+            // Remove extension
+            finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
+
+            // Remove "/index"
+            if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
+                finalPath = finalPath.substring(0, finalPath.length - 6)
+            }
+
+            return {
+                list: [...list].sort(),
+                fullPath: file,
+                finalPath,
+            }
+        })
+        .filter((entry) => !shouldIgnore(entry.fullPath))
+}
+
 export function nodeToString(node: Node): string {
     const printer = createPrinter({ newLine: NewLineKind.LineFeed })
     const sourceFile = createSourceFile('logic.ts', '', ScriptTarget.Latest, false, ScriptKind.TS)

package/src/types.ts

@@ -5,11 +5,15 @@ export interface ActionTransform {
     name: string
     parameters: ts.ParameterDeclaration[]
     returnTypeNode: ts.TypeNode
+    /** Name of the logic this action was connected from, e.g. "userLogic" */
+    sourceLogic?: string
 }
 
 export interface NameType {
     name: string
     typeNode: ts.TypeNode | ts.KeywordTypeNode | ts.ParenthesizedTypeNode
+    /** Name of the logic this value was connected from, e.g. "userLogic" */
+    sourceLogic?: string
 }
 
 export interface ReducerTransform extends NameType {}
@@ -18,6 +22,12 @@ export interface SelectorTransform extends NameType {
     functionTypes?: { name: string; type: ts.TypeNode }[]
 }
 
+/** A selector combiner parameter without a type annotation, plus the inferred type to write into the source */
+export interface SelectorParamAnnotation {
+    parameter: ts.ParameterDeclaration
+    typeNode: ts.TypeNode
+}
+
 export interface ListenerTransform {
     name: string
     action: ts.TypeNode | ts.KeywordTypeNode | ts.ParenthesizedTypeNode
@@ -46,6 +56,7 @@ export interface ParsedLogic {
     propsType?: ts.TypeNode
     keyType?: ts.TypeNode
     typeReferencesToImportFromFiles: Record<string, Set<string>>
+    selectorParamAnnotations: SelectorParamAnnotation[]
     interfaceDeclaration?: ts.InterfaceDeclaration
     extraActions: Record<string, ts.TypeNode>
     extraInput: Record<string, { typeNode: ts.TypeNode; withLogicFunction: boolean }>
@@ -78,6 +89,10 @@ export interface AppOptions {
     addTsNocheck?: boolean
     /** Convert kea 2.0 logic input to kea 3.0 builders */
     convertToBuilders?: boolean
+    /** Write logic types as MakeLogicType blocks above each kea() call, instead of into logicType.ts files */
+    inline?: boolean
+    /** Like `inline`, but only for logic files under these paths. Everything else keeps its logicType.ts file. */
+    inlinePaths?: string[]
     /** Show TypeScript errors */
     showTsErrors?: boolean
     /** Cache generated logic files into .typegen, use them if generating a logic type for the first time */

package/src/utils.ts

@@ -53,6 +53,128 @@ export function isKeaCall(node: ts.Node, checker: ts.TypeChecker) {
     return ts.isObjectLiteralExpression(input) || ts.isArrayLiteralExpression(input)
 }
 
+/** True if the node has a leading "kea-typegen" comment, marking it as generated by us */
+export function hasKeaTypegenMarker(node: ts.Node): boolean {
+    const sourceFile = node.getSourceFile()
+    const ranges = ts.getLeadingCommentRanges(sourceFile.text, node.pos) ?? []
+    return ranges.some(({ pos, end }) => sourceFile.text.slice(pos, end).includes('kea-typegen'))
+}
+
+const INLINE_BLOCK_SUFFIXES = ['Values', 'Actions', 'Props']
+
+/**
+ * The statements making up an inline logic type block: the `logicType` alias itself, plus any
+ * `logicValues` / `logicActions` / `logicProps` interfaces directly above it.
+ */
+export function getInlineBlockStatements(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): ts.Statement[] {
+    const statements = declaration.getSourceFile().statements
+    const index = statements.indexOf(declaration)
+    if (index === -1) {
+        return [declaration]
+    }
+    const generatedNames = new Set(INLINE_BLOCK_SUFFIXES.map((suffix) => `${logicName}${suffix}`))
+    const block: ts.Statement[] = [declaration]
+    for (let i = index - 1; i >= 0; i--) {
+        const statement = statements[i]
+        if (
+            (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) &&
+            generatedNames.has(statement.name.text)
+        ) {
+            block.unshift(statement)
+        } else {
+            break
+        }
+    }
+    return block
+}
+
+/** True if this local `logicType` declaration is part of a kea-typegen generated inline block */
+export function isGeneratedInlineBlock(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): boolean {
+    return getInlineBlockStatements(declaration, logicName).some(hasKeaTypegenMarker)
+}
+
+/** Find a top-level `type logicType = ...` or `interface logicType {...}` declaration in the file */
+export function findLogicTypeDeclaration(
+    sourceFile: ts.SourceFile,
+    logicTypeName: string,
+): ts.TypeAliasDeclaration | ts.InterfaceDeclaration | undefined {
+    return sourceFile.statements.find(
+        (statement): statement is ts.TypeAliasDeclaration | ts.InterfaceDeclaration =>
+            (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) &&
+            statement.name.text === logicTypeName,
+    )
+}
+
+/**
+ * Should this logic file get inline MakeLogicType blocks instead of a logicType.ts file?
+ * True when running with --inline, when the file sits under one of `inlinePaths`, or when the
+ * file already carries a generated inline block (so converted files stay inline, whatever the config).
+ */
+export function isInlineFile(
+    appOptions: AppOptions | undefined,
+    sourceFile: ts.SourceFile | undefined,
+    parsedLogics: ParsedLogic[],
+): boolean {
+    if (appOptions?.inline) {
+        return true
+    }
+    if (!sourceFile) {
+        return false
+    }
+    for (const inlinePath of appOptions?.inlinePaths ?? []) {
+        const resolvedPath = path.resolve(appOptions?.rootPath ?? '.', inlinePath)
+        const resolvedFileName = path.resolve(sourceFile.fileName)
+        if (resolvedFileName === resolvedPath || resolvedFileName.startsWith(resolvedPath + path.sep)) {
+            return true
+        }
+    }
+    return parsedLogics.some((parsedLogic) => {
+        const declaration = findLogicTypeDeclaration(sourceFile, parsedLogic.logicTypeName)
+        return declaration ? isGeneratedInlineBlock(declaration, parsedLogic.logicName) : false
+    })
+}
+
+/**
+ * True if the type argument in `kea<...>()` is a manually written type (e.g. `MakeLogicType<...>`
+ * or a custom interface), as opposed to a type that kea-typegen generates and keeps updated.
+ * Manually typed logics are skipped entirely.
+ */
+export function isManuallyTypedLogic(
+    typeArgument: ts.TypeNode,
+    logicTypeName: string,
+    checker: ts.TypeChecker,
+): boolean {
+    if (!ts.isTypeReferenceNode(typeArgument)) {
+        // e.g. kea<{ actions: ... }>(...)
+        return true
+    }
+    if (!ts.isIdentifier(typeArgument.typeName) || typeArgument.typeName.escapedText !== logicTypeName) {
+        // e.g. kea<MakeLogicType<Values, Actions>>(...) or kea<MyCustomLogicType>(...)
+        return true
+    }
+    const symbol = checker.getSymbolAtLocation(typeArgument.typeName)
+    const declaration = symbol?.getDeclarations()?.[0]
+    if (!declaration) {
+        // "logicType" that doesn't resolve --> a generated type that doesn't exist yet
+        return false
+    }
+    if (ts.isImportSpecifier(declaration)) {
+        // imported logic types are managed by kea-typegen
+        return false
+    }
+    if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
+        // local declarations are ours only if their block carries the kea-typegen marker (written by --inline mode)
+        return !isGeneratedInlineBlock(declaration, logicTypeName.replace(/Type$/, ''))
+    }
+    return true
+}
+
 export function getTypeNodeForNode(node: ts.Node, checker: ts.TypeChecker): ts.TypeNode {
     let typeNode
     if (node) {
@@ -92,7 +214,8 @@ export function getParameterDeclaration(param: ts.ParameterDeclaration) {
     return factory.createParameterDeclaration(
         undefined,
         undefined,
-        factory.createIdentifier(param.name.getText()),
+        // .getText() throws on synthetic nodes (e.g. from signatureToSignatureDeclaration)
+        factory.createIdentifier(ts.isIdentifier(param.name) ? param.name.text : param.name.getText()),
         param.initializer || param.questionToken ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
         cloneNodeSorted(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
         undefined,

package/src/visit/visit.ts

@@ -10,6 +10,7 @@ import {
     getLogicPathString,
     getTypeNodeForNode,
     isKeaCall,
+    isManuallyTypedLogic,
 } from '../utils'
 import { visitActions } from './visitActions'
 import { visitReducers } from './visitReducers'
@@ -216,6 +217,19 @@ export function visitKeaCalls(
         const keaTypeArguments = ts.isCallExpression(node.parent) ? node.parent.typeArguments : []
         const keaTypeArgument = keaTypeArguments?.[0]
 
+        // if the logic is already manually typed (e.g. kea<MakeLogicType<...>>(...)), leave it alone
+        if (keaTypeArgument && isManuallyTypedLogic(keaTypeArgument, logicTypeName, checker)) {
+            if (appOptions?.verbose) {
+                appOptions.log(
+                    `🩶 Skipping manually typed logic "${logicName}" in ${path.relative(
+                        process.cwd(),
+                        sourceFile.fileName,
+                    )}`,
+                )
+            }
+            return
+        }
+
         const pathString = getLogicPathString(appOptions, sourceFile.fileName)
         let typeFileName = sourceFile.fileName.replace(/\.[tj]sx?$/, 'Type.ts')
 
@@ -267,6 +281,7 @@ export function visitKeaCalls(
             hasKeyInLogic: false,
             hasPathInLogic: false,
             typeReferencesToImportFromFiles: {},
+            selectorParamAnnotations: [],
             extraActions: {},
             extraInput: {},
             extraLogicFields: {},

package/src/visit/visitConnect.ts

@@ -1,5 +1,6 @@
 import { ParsedLogic } from '../types'
 import * as ts from 'typescript'
+import { NodeBuilderFlags } from 'typescript'
 import { cloneNodeSorted, gatherImports, getParameterDeclaration } from '../utils'
 import { Expression, Type } from 'typescript'
 
@@ -47,6 +48,7 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
 
                 const symbol = checker.getSymbolAtLocation(logicReference)
                 const otherLogicType = checker.getTypeOfSymbolAtLocation(symbol, logicReference)
+                const sourceLogic = ts.isIdentifier(logicReference) ? logicReference.text : logicReference.getText()
 
                 if (loaderName === 'actions') {
                     const actionsForLogic = otherLogicType
@@ -85,12 +87,59 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
                                                 name: lookup[name],
                                                 returnTypeNode,
                                                 parameters,
+                                                sourceLogic,
                                             })
                                         }
                                     }
                                 }
                             }
                         }
+                    } else if (actionsForLogic) {
+                        // `actionCreators` is not a literal type node we can walk syntactically - e.g. the other
+                        // logic is typed with MakeLogicType, where actionCreators is a mapped type. Resolve the
+                        // connected action types semantically instead.
+                        const actionCreatorsType = checker.getTypeOfSymbolAtLocation(actionsForLogic, logicReference)
+                        for (const actionProperty of actionCreatorsType.getProperties()) {
+                            const name = actionProperty.getName()
+                            if (!lookup[name]) {
+                                continue
+                            }
+                            const actionCreatorType = checker.getTypeOfSymbolAtLocation(actionProperty, logicReference)
+                            const signature = actionCreatorType.getCallSignatures()[0]
+                            if (!signature) {
+                                continue
+                            }
+                            const signatureNode = checker.signatureToSignatureDeclaration(
+                                signature,
+                                ts.SyntaxKind.FunctionType,
+                                logicReference,
+                                NodeBuilderFlags.NoTruncation | NodeBuilderFlags.IgnoreErrors,
+                            ) as ts.FunctionTypeNode | undefined
+                            if (!signatureNode) {
+                                continue
+                            }
+                            const parameters = signatureNode.parameters.map((param) => getParameterDeclaration(param))
+                            let returnType: ts.TypeNode = signatureNode.type
+                            if (ts.isParenthesizedTypeNode(returnType)) {
+                                returnType = returnType.type
+                            }
+                            if (ts.isTypeLiteralNode(returnType)) {
+                                const payload = returnType.members.find(
+                                    (m) => m.name && ts.isIdentifier(m.name) && m.name.text === 'payload',
+                                )
+                                if (payload && ts.isPropertySignature(payload) && payload.type) {
+                                    const returnTypeNode = cloneNodeSorted(payload.type)
+                                    gatherImports(signatureNode, checker, parsedLogic)
+
+                                    parsedLogic.actions.push({
+                                        name: lookup[name],
+                                        returnTypeNode,
+                                        parameters,
+                                        sourceLogic,
+                                    })
+                                }
+                            }
+                        }
                     }
                 }
 
@@ -109,6 +158,7 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
                                         name: lookup[name],
                                         typeNode,
                                         functionTypes: [],
+                                        sourceLogic,
                                     })
                                 }
                             }

package/src/visit/visitSelectors.ts

@@ -14,8 +14,14 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
             const inputFunctionTypeNode = checker.getTypeAtLocation(inputFunction)
 
             const selectorInputFunctionType = inputFunctionTypeNode.getCallSignatures()[0]?.getReturnType() as ts.Type
+            // IgnoreErrors: the tuple may mention types not referenceable from the logic file
+            // (e.g. kea's internal Props); we only consume the elements' return types anyway
             const selectorInputTypeNode = selectorInputFunctionType
-                ? checker.typeToTypeNode(selectorInputFunctionType, inputFunction, NodeBuilderFlags.NoTruncation)
+                ? checker.typeToTypeNode(
+                      selectorInputFunctionType,
+                      inputFunction,
+                      NodeBuilderFlags.NoTruncation | NodeBuilderFlags.IgnoreErrors,
+                  )
                 : null
 
             let functionNames = []
@@ -75,6 +81,25 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
                     typeNode,
                     functionTypes,
                 })
+
+                // combiner parameters without a type annotation, e.g. `(counter) => counter * 2`.
+                // In inline mode these get their inferred types written into the source, since
+                // MakeLogicType's loose selector typing can no longer infer them contextually.
+                computedFunction.parameters.forEach((parameter, index) => {
+                    const functionType = functionTypes[index]
+                    if (
+                        !parameter.type &&
+                        !parameter.dotDotDotToken &&
+                        ts.isIdentifier(parameter.name) &&
+                        functionType &&
+                        functionType.type.kind !== ts.SyntaxKind.AnyKeyword
+                    ) {
+                        parsedLogic.selectorParamAnnotations.push({
+                            parameter,
+                            typeNode: functionType.type,
+                        })
+                    }
+                })
             }
         }
     }