feat(api): Allow recipe() to be called with just a function

The recipe() function now accepts just a function parameter without
requiring a name or schema. This provides a more ergonomic API for
simple recipes where the schema can be inferred from default values.

Changes:
- Added function-only overload to recipe() that accepts just a function
- Updated implementation to handle undefined argumentSchema
- Refactored schema creation logic to eliminate code duplication
- Schema generated from function-only recipes does not have a description field
- Added tests for function-only recipe syntax
- Added transformer fixtures for recipes without names

Usage:
  recipe((input: { x: any }) => {
    input.x.setDefault(42);
    return { result: input.x * 2 };
  });

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

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

Author: seefeldb

packages/api/index.ts

@@ -725,6 +725,11 @@ export interface BuiltInCompileAndRunState<T> {
 
 // Function type definitions
 export type RecipeFunction = {
+  // Function-only overload
+  <T, R>(
+    fn: (input: OpaqueRef<Required<T>>) => Opaque<R>,
+  ): RecipeFactory<T, R>;
+
   <S extends JSONSchema>(
     argumentSchema: S,
     fn: (input: OpaqueRef<Required<SchemaWithoutCell<S>>>) => any,

packages/runner/src/builder/recipe.ts

@@ -37,6 +37,10 @@ import { traverseValue } from "./traverse-utils.ts";
 import { sanitizeSchemaForLinks } from "../link-utils.ts";
 
 /** Declare a recipe
+ *
+ * @param fn A function that creates the recipe graph
+ *
+ * or
  *
  * @param description A human-readable description of the recipe
  * @param fn A function that creates the recipe graph
@@ -83,16 +87,27 @@ export function recipe<T, R>(
   resultSchema: JSONSchema,
   fn: (input: OpaqueRef<Required<T>>) => Opaque<R>,
 ): RecipeFactory<T, R>;
+// Function-only overload - must come after schema-based overloads
 export function recipe<T, R>(
-  argumentSchema: string | JSONSchema,
-  resultSchema:
+  fn: (input: OpaqueRef<Required<T>>) => Opaque<R>,
+): RecipeFactory<T, R>;
+export function recipe<T, R>(
+  argumentSchema:
+    | string
+    | JSONSchema
+    | ((input: OpaqueRef<Required<T>>) => Opaque<R>),
+  resultSchema?:
     | JSONSchema
-    | undefined
     | ((input: OpaqueRef<Required<T>>) => Opaque<R>),
   fn?: (input: OpaqueRef<Required<T>>) => Opaque<R>,
 ): RecipeFactory<T, R> {
-  // Cover the overload that just provides input schema
-  if (typeof resultSchema === "function") {
+  // Cover the overload that just provides a function
+  if (typeof argumentSchema === "function") {
+    fn = argumentSchema;
+    argumentSchema = undefined as any;
+    resultSchema = undefined;
+  } // Cover the overload that just provides input schema
+  else if (typeof resultSchema === "function") {
     fn = resultSchema;
     resultSchema = undefined;
   }
@@ -114,8 +129,8 @@ export function recipe<T, R>(
   applyInputIfcToOutput(inputs, outputs);
 
   const result = factoryFromRecipe<T, R>(
-    argumentSchema,
-    resultSchema,
+    argumentSchema as string | JSONSchema | undefined,
+    resultSchema as JSONSchema | undefined,
     inputs,
     outputs,
   );
@@ -125,7 +140,7 @@ export function recipe<T, R>(
 
 // Same as above, but assumes the caller manages the frame
 export function recipeFromFrame<T, R>(
-  argumentSchema: string | JSONSchema,
+  argumentSchema: string | JSONSchema | undefined,
   resultSchema: JSONSchema | undefined,
   fn: (input: OpaqueRef<Required<T>>) => Opaque<R>,
 ): RecipeFactory<T, R> {
@@ -140,7 +155,7 @@ export function recipeFromFrame<T, R>(
 }
 
 function factoryFromRecipe<T, R>(
-  argumentSchemaArg: string | JSONSchema,
+  argumentSchemaArg: string | JSONSchema | undefined,
   resultSchemaArg: JSONSchema | undefined,
   inputs: OpaqueRef<Required<T>>,
   outputs: Opaque<R>,
@@ -298,10 +313,14 @@ function factoryFromRecipe<T, R>(
 
   let argumentSchema: JSONSchema;
 
-  if (typeof argumentSchemaArg === "string") {
-    // Create a writable schema
+  if (typeof argumentSchemaArg === "string" || argumentSchemaArg === undefined) {
+    // Create a writable schema from defaults
     const writableSchema: JSONSchemaMutable = createJsonSchema(defaults, true);
-    writableSchema.description = argumentSchemaArg;
+
+    // Set description only if provided
+    if (typeof argumentSchemaArg === "string") {
+      writableSchema.description = argumentSchemaArg;
+    }
 
     delete (writableSchema.properties as any)?.[UI]; // TODO(seefeld): This should be a schema for views
     if (

packages/runner/test/recipe.test.ts

@@ -493,3 +493,45 @@ describe("recipe with mixed ifc properties", () => {
   // in such a way that it does not end up classified. For now, I've decided
   // not to do this, since I'm not confident enough that code can't get out.
 });
+
+describe("recipe with function-only syntax (no schema)", () => {
+  it("creates a recipe with just a function", () => {
+    const doubleRecipe = recipe((input: { x: any }) => {
+      const double = lift<number>((x) => x * 2);
+      return { double: double(input.x) };
+    });
+    expect(isRecipe(doubleRecipe)).toBe(true);
+  });
+
+  it("infers schema from default values", () => {
+    const doubleRecipe = recipe((input: { x: any }) => {
+      input.x.setDefault(42);
+      const double = lift<number>((x) => x * 2);
+      return { double: double(input.x) };
+    });
+
+    expect(isRecipe(doubleRecipe)).toBe(true);
+    expect(doubleRecipe.argumentSchema).toMatchObject({
+      type: "object",
+      properties: {
+        x: { type: "integer", default: 42 },
+      },
+    });
+    // Should not have a description field
+    expect(doubleRecipe.argumentSchema).not.toHaveProperty("description");
+  });
+
+  it("creates nodes correctly with function-only syntax", () => {
+    const doubleRecipe = recipe((input: { x: any }) => {
+      input.x.setDefault(1);
+      const double = lift<number>((x) => x * 2);
+      return { double: double(double(input.x)) };
+    });
+
+    const { nodes } = doubleRecipe;
+    expect(nodes.length).toBe(2);
+    expect(isModule(nodes[0].module) && nodes[0].module.type).toBe(
+      "javascript",
+    );
+  });
+});

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

@@ -0,0 +1,33 @@
+import * as __ctHelpers from "commontools";
+import { cell, recipe, UI } from "commontools";
+export default recipe((_state: any) => {
+    const items = cell([1, 2, 3, 4, 5]);
+    return {
+        [UI]: (<div>
+        {items.mapWithPattern(__ctHelpers.recipe({
+                $schema: "https://json-schema.org/draft/2020-12/schema",
+                type: "object",
+                properties: {
+                    element: {
+                        type: "number"
+                    },
+                    index: {
+                        type: "number"
+                    },
+                    array: true,
+                    params: {
+                        type: "object",
+                        properties: {}
+                    }
+                },
+                required: ["element", "params"]
+            } as const satisfies __ctHelpers.JSONSchema, ({ element: item, index: index, array: array, params: {} }) => (<div>
+            Item {item} at index {index} of {array.length} total items
+          </div>)), {})}
+      </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-with-array-param-no-name.input.tsx

@@ -0,0 +1,18 @@
+/// <cts-enable />
+import { cell, recipe, UI } from "commontools";
+
+export default recipe((_state: any) => {
+  const items = cell([1, 2, 3, 4, 5]);
+
+  return {
+    [UI]: (
+      <div>
+        {items.map((item, index, array) => (
+          <div>
+            Item {item} at index {index} of {array.length} total items
+          </div>
+        ))}
+      </div>
+    ),
+  };
+});

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

@@ -0,0 +1,24 @@
+import * as __ctHelpers from "commontools";
+import { cell, recipe, UI } from "commontools";
+export default recipe((_state: any) => {
+    const items = cell([{ name: "apple" }, { name: "banana" }]);
+    const showList = cell(true);
+    return {
+        [UI]: (<div>
+        {__ctHelpers.derive({
+            showList: showList,
+            items: items
+        }, ({ showList, items }) => showList && (<div>
+            {items.map((item) => (<div>
+                {__ctHelpers.derive({ item: {
+                    name: item.name
+                } }, ({ item }) => item.name && <span>{item.name}</span>)}
+              </div>))}
+          </div>))}
+      </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/jsx-expressions/map-nested-conditional-no-name.input.tsx

@@ -0,0 +1,23 @@
+/// <cts-enable />
+import { cell, recipe, UI } from "commontools";
+
+export default recipe((_state: any) => {
+  const items = cell([{ name: "apple" }, { name: "banana" }]);
+  const showList = cell(true);
+
+  return {
+    [UI]: (
+      <div>
+        {showList && (
+          <div>
+            {items.map((item) => (
+              <div>
+                {item.name && <span>{item.name}</span>}
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    ),
+  };
+});

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

@@ -0,0 +1,19 @@
+import * as __ctHelpers from "commontools";
+import { cell, recipe, UI } from "commontools";
+export default recipe((_state: any) => {
+    const people = cell([
+        { id: "1", name: "Alice" },
+        { id: "2", name: "Bob" },
+    ]);
+    return {
+        [UI]: (<div>
+        {__ctHelpers.derive(people, ({ people }) => people.length > 0 && (<ul>
+            {people.map((person) => (<li key={person.id}>{person.name}</li>))}
+          </ul>))}
+      </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/jsx-expressions/map-single-capture-no-name.input.tsx

@@ -0,0 +1,23 @@
+/// <cts-enable />
+import { cell, recipe, UI } from "commontools";
+
+export default recipe((_state: any) => {
+  const people = cell([
+    { id: "1", name: "Alice" },
+    { id: "2", name: "Bob" },
+  ]);
+
+  return {
+    [UI]: (
+      <div>
+        {people.length > 0 && (
+          <ul>
+            {people.map((person) => (
+              <li key={person.id}>{person.name}</li>
+            ))}
+          </ul>
+        )}
+      </div>
+    ),
+  };
+});