feat(ts-transformers): Support single-parameter recipe() calls

Add transformer support for recipe() calls without explicit type arguments.
When recipe() is called with just a function parameter that has a type
annotation, the transformer now infers and injects the schema automatically.

Examples:
- recipe((state: State) => ...) → recipe(toSchema(State), (state) => ...)
- recipe("name", (state: State) => ...) → recipe(toSchema(State), (state) => ...)

This change maintains backward compatibility by only transforming when
an explicit type annotation is present on the function parameter.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: seefeldb

packages/ts-transformers/src/transformers/schema-injection.ts

@@ -170,9 +170,10 @@ export class SchemaInjectionTransformer extends Transformer {
       const callKind = detectCallKind(node, checker);
 
       if (callKind?.kind === "builder" && callKind.builderName === "recipe") {
+        const factory = transformation.factory;
         const typeArgs = node.typeArguments;
+
         if (typeArgs && typeArgs.length >= 1) {
-          const factory = transformation.factory;
           const schemaArgs = typeArgs.map((typeArg) => typeArg).map((
             typeArg,
           ) => createToSchemaCall(context, typeArg));
@@ -194,6 +195,43 @@ export class SchemaInjectionTransformer extends Transformer {
 
           return ts.visitEachChild(updated, visit, transformation);
         }
+
+        // Handle single-parameter recipe() calls without type arguments
+        // Only transform if the function parameter has a type annotation
+        const argsArray = Array.from(node.arguments);
+        let recipeFunction: ts.Expression | undefined;
+
+        if (argsArray.length === 1) {
+          // Single argument - must be the function
+          recipeFunction = argsArray[0];
+        } else if (argsArray.length === 2 && argsArray[0] && ts.isStringLiteral(argsArray[0])) {
+          // Two arguments with first being a string - second is the function
+          recipeFunction = argsArray[1];
+        }
+
+        if (
+          recipeFunction &&
+          (ts.isFunctionExpression(recipeFunction) ||
+            ts.isArrowFunction(recipeFunction))
+        ) {
+          const recipeFn = recipeFunction;
+          if (recipeFn.parameters.length >= 1) {
+            const inputParam = recipeFn.parameters[0];
+
+            // Only transform if there's an explicit type annotation
+            if (inputParam?.type) {
+              const toSchemaInput = createToSchemaCall(context, inputParam.type);
+
+              const updated = factory.createCallExpression(
+                node.expression,
+                undefined,
+                [toSchemaInput, recipeFn],
+              );
+
+              return ts.visitEachChild(updated, visit, transformation);
+            }
+          }
+        }
       }
 
       if (

packages/ts-transformers/test/fixtures/ast-transform/schema-generation-builders.expected.tsx

@@ -46,7 +46,20 @@ export default recipe({
           Add
         </button>
         <ul>
-          {state.items.map((item) => <li key={item}>{item}</li>)}
+          {state.items.mapWithPattern(__ctHelpers.recipe({
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            type: "object",
+            properties: {
+                element: {
+                    type: "string"
+                },
+                params: {
+                    type: "object",
+                    properties: {}
+                }
+            },
+            required: ["element", "params"]
+        } as const satisfies __ctHelpers.JSONSchema, ({ element: item, params: {} }) => <li key={item}>{item}</li>), {})}
         </ul>
       </div>),
     };

packages/ts-transformers/test/fixtures/closures/map-capture-cell-param-no-name.expected.tsx

@@ -0,0 +1,80 @@
+import * as __ctHelpers from "commontools";
+import { Cell, Default, handler, recipe, UI } from "commontools";
+interface Item {
+    text: Default<string, "">;
+}
+interface InputSchema {
+    items: Default<Item[], [
+    ]>;
+}
+const removeItem = handler(true as const satisfies __ctHelpers.JSONSchema, {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/Item"
+            },
+            asCell: true
+        },
+        index: {
+            type: "number"
+        }
+    },
+    required: ["items", "index"],
+    $defs: {
+        Item: {
+            type: "object",
+            properties: {
+                text: {
+                    type: "string",
+                    default: ""
+                }
+            },
+            required: ["text"]
+        }
+    }
+} as const satisfies __ctHelpers.JSONSchema, (_, _2) => {
+    // Not relevant for repro
+});
+export default recipe({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/Item"
+            },
+            default: []
+        }
+    },
+    required: ["items"],
+    $defs: {
+        Item: {
+            type: "object",
+            properties: {
+                text: {
+                    type: "string",
+                    default: ""
+                }
+            },
+            required: ["text"]
+        }
+    }
+} as const satisfies __ctHelpers.JSONSchema, ({ items }: InputSchema) => {
+    return {
+        [UI]: (<ul>
+          {items.map((_, index) => (<li key={index}>
+              <ct-button onClick={removeItem({ items, index })}>
+                Remove
+              </ct-button>
+            </li>))}
+        </ul>),
+    };
+});
+// @ts-ignore: Internals
+function h(...args: any[]) { return __ctHelpers.h.apply(null, args); }
+// @ts-ignore: Internals
+h.fragment = __ctHelpers.h.fragment;

packages/ts-transformers/test/fixtures/closures/map-capture-cell-param-no-name.input.tsx

@@ -0,0 +1,34 @@
+/// <cts-enable />
+import { Cell, Default, handler, recipe, UI } from "commontools";
+
+interface Item {
+  text: Default<string, "">;
+}
+
+interface InputSchema {
+  items: Default<Item[], []>;
+}
+
+const removeItem = handler<unknown, { items: Cell<Item[]>; index: number }>(
+  (_, _2) => {
+    // Not relevant for repro
+  },
+);
+
+export default recipe(
+  ({ items }: InputSchema) => {
+    return {
+      [UI]: (
+        <ul>
+          {items.map((_, index) => (
+            <li key={index}>
+              <ct-button onClick={removeItem({ items, index })}>
+                Remove
+              </ct-button>
+            </li>
+          ))}
+        </ul>
+      ),
+    };
+  },
+);

packages/ts-transformers/test/fixtures/closures/map-handler-reference-no-name.expected.tsx

@@ -0,0 +1,74 @@
+import * as __ctHelpers from "commontools";
+import { recipe, UI, handler, Cell } from "commontools";
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            "ct-button": any;
+        }
+    }
+}
+// Event handler defined at module scope
+const handleClick = handler(true as const satisfies __ctHelpers.JSONSchema, {
+    type: "object",
+    properties: {
+        count: {
+            type: "number",
+            asCell: true
+        }
+    },
+    required: ["count"]
+} as const satisfies __ctHelpers.JSONSchema, (_, { count }) => {
+    count.set(count.get() + 1);
+});
+interface Item {
+    id: number;
+    name: string;
+}
+interface State {
+    items: Item[];
+    count: Cell<number>;
+}
+export default recipe({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                $ref: "#/$defs/Item"
+            }
+        },
+        count: {
+            type: "number",
+            asCell: true
+        }
+    },
+    required: ["items", "count"],
+    $defs: {
+        Item: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "number"
+                },
+                name: {
+                    type: "string"
+                }
+            },
+            required: ["id", "name"]
+        }
+    }
+} as const satisfies __ctHelpers.JSONSchema, (state: State) => {
+    return {
+        [UI]: (<div>
+        {/* Map callback references handler - should NOT capture it */}
+        {state.items.map((item) => (<ct-button onClick={handleClick({ count: state.count })}>
+            {item.name}
+          </ct-button>))}
+      </div>),
+    };
+});
+// @ts-ignore: Internals
+function h(...args: any[]) { return __ctHelpers.h.apply(null, args); }
+// @ts-ignore: Internals
+h.fragment = __ctHelpers.h.fragment;

packages/ts-transformers/test/fixtures/closures/map-handler-reference-no-name.input.tsx

@@ -0,0 +1,40 @@
+/// <cts-enable />
+import { recipe, UI, handler, Cell } from "commontools";
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      "ct-button": any;
+    }
+  }
+}
+
+// Event handler defined at module scope
+const handleClick = handler<unknown, { count: Cell<number> }>((_, { count }) => {
+  count.set(count.get() + 1);
+});
+
+interface Item {
+  id: number;
+  name: string;
+}
+
+interface State {
+  items: Item[];
+  count: Cell<number>;
+}
+
+export default recipe((state: State) => {
+  return {
+    [UI]: (
+      <div>
+        {/* Map callback references handler - should NOT capture it */}
+        {state.items.map((item) => (
+          <ct-button onClick={handleClick({ count: state.count })}>
+            {item.name}
+          </ct-button>
+        ))}
+      </div>
+    ),
+  };
+});

packages/ts-transformers/test/fixtures/closures/map-single-capture-no-name.expected.tsx

@@ -0,0 +1,46 @@
+import * as __ctHelpers from "commontools";
+import { recipe, UI } from "commontools";
+interface State {
+    items: Array<{
+        price: number;
+    }>;
+    discount: number;
+}
+export default recipe({
+    type: "object",
+    properties: {
+        items: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    price: {
+                        type: "number"
+                    }
+                },
+                required: ["price"]
+            }
+        },
+        discount: {
+            type: "number"
+        }
+    },
+    required: ["items", "discount"]
+} as const satisfies __ctHelpers.JSONSchema, (state: State) => {
+    return {
+        [UI]: (<div>
+        {state.items.map((item) => (<span>{__ctHelpers.derive({
+                item: {
+                    price: item.price
+                },
+                state: {
+                    discount: state.discount
+                }
+            }, ({ item, state }) => item.price * state.discount)}</span>))}
+      </div>),
+    };
+});
+// @ts-ignore: Internals
+function h(...args: any[]) { return __ctHelpers.h.apply(null, args); }
+// @ts-ignore: Internals
+h.fragment = __ctHelpers.h.fragment;

packages/ts-transformers/test/fixtures/closures/map-single-capture-no-name.input.tsx

@@ -0,0 +1,19 @@
+/// <cts-enable />
+import { recipe, UI } from "commontools";
+
+interface State {
+  items: Array<{ price: number }>;
+  discount: number;
+}
+
+export default recipe((state: State) => {
+  return {
+    [UI]: (
+      <div>
+        {state.items.map((item) => (
+          <span>{item.price * state.discount}</span>
+        ))}
+      </div>
+    ),
+  };
+});

packages/ts-transformers/test/fixtures/closures/map-with-array-param-no-name.expected.tsx

@@ -1,6 +1,6 @@
 import * as __ctHelpers from "commontools";
 import { cell, recipe, UI } from "commontools";
-export default recipe((_state: any) => {
+export default recipe(true as const satisfies __ctHelpers.JSONSchema, (_state: any) => {
     const items = cell([1, 2, 3, 4, 5]);
     return {
         [UI]: (<div>

packages/ts-transformers/test/fixtures/jsx-expressions/map-nested-conditional-no-name.expected.tsx

@@ -1,6 +1,6 @@
 import * as __ctHelpers from "commontools";
 import { cell, recipe, UI } from "commontools";
-export default recipe((_state: any) => {
+export default recipe(true as const satisfies __ctHelpers.JSONSchema, (_state: any) => {
     const items = cell([{ name: "apple" }, { name: "banana" }]);
     const showList = cell(true);
     return {