@@ -30,13 +30,14 @@ A slot recipe takes the config of a
 and with an object of styles keyed by slot name wherever a style recipe
 takes a style:
 
-| Property           | Description                                                                        |
-| ------------------ | ---------------------------------------------------------------------------------- |
-| `slots`            | The names of the slots, in the order of the result.                                |
-| `base`             | Optional. The style each slot always has.                                          |
-| `variants`         | For each variant name, the style of each slot for each of its options.             |
-| `compoundVariants` | Optional. Styles added to some slots, under `styles`, when several variants match. |
-| `defaultVariants`  | Optional. The option each variant uses when a selection leaves it out.             |
+| Property           | Description                                                                                                                  |
+| ------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
+| `slots`            | The names of the slots, in the order of the result.                                                                          |
+| `base`             | Optional. The style each slot always has.                                                                                    |
+| `variants`         | For each variant name, the style of each slot for each of its options.                                                       |
+| `compoundVariants` | Optional. Styles added to some slots, under `styles`, when several variants match.                                           |
+| `defaultVariants`  | Optional. The option each variant uses when a selection leaves it out.                                                       |
+| `cache`            | Optional. Whether the slot recipe caches its styles. Defaults to `true`. Without the cache, every call returns a new object. |
 
 An option or compound variant gives styles only to the slots it names.
 Each slot's style is merged in the order of a style recipe: its base
 
@@ -19,12 +19,13 @@ style={badge({ tone })} />`.
 
 ## The config
 
-| Property           | Description                                                                                      |
-| ------------------ | ------------------------------------------------------------------------------------------------ |
-| `base`             | Optional. The style the element always has.                                                      |
-| `variants`         | For each variant name, the style of each of its options.                                         |
-| `compoundVariants` | Optional. Styles added when several variants have particular options at the same time, in order. |
-| `defaultVariants`  | Optional. The option each variant uses when a selection leaves it out.                           |
+| Property           | Description                                                                                                            |
+| ------------------ | ---------------------------------------------------------------------------------------------------------------------- |
+| `base`             | Optional. The style the element always has.                                                                            |
+| `variants`         | For each variant name, the style of each of its options.                                                               |
+| `compoundVariants` | Optional. Styles added when several variants have particular options at the same time, in order.                       |
+| `defaultVariants`  | Optional. The option each variant uses when a selection leaves it out.                                                 |
+| `cache`            | Optional. Whether the recipe caches its style. Defaults to `true`. Without the cache, every call returns a new object. |
 
 Every style is checked against the styles of React Native, as in
 `StyleSheet.create` (see [TypeScript](/recipe/native-recipe/typescript/)).
 
@@ -19,7 +19,9 @@ selection merges its style and caches it under that integer; every later
 call with the same variants reads the option of each variant and returns
 the cached style. Create each recipe once, at the top level of a module,
 so that its cache lasts. The cache grows with the selections the recipe is
-called with, up to one entry per combination of declared options.
+called with, up to one entry per combination of declared options. A recipe
+whose config sets `cache: false` builds a new style on every call, which
+changes the `style` prop on every render, so leave the cache on.
 
 ## The order of styles
 
 
@@ -122,6 +122,9 @@ function Badge({ tone }: BadgeProps) {
 ```
 
 The same holds for `createThemedRecipes`: call it once, in one module.
+Leave the `cache` of a recipe's config unset: with `cache: false`, the
+recipe returns a new object on every call, like a recipe created inside a
+component.
 
 ### Put every choice a component offers in a variant
 
 
@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+
+import { createSlotStyleRecipe } from "./slot-style-recipe.js";
+import { createStyleRecipe } from "./style-recipe.js";
+import { createThemedRecipes } from "./themed-recipes.js";
+
+describe("the cache setting of a style recipe's config", () => {
+  it("builds a new frozen style on every call without the cache", () => {
+    const uncached = createStyleRecipe({
+      cache: false,
+      variants: { size: { sm: { height: 32 } } },
+    });
+    const cached = createStyleRecipe({
+      variants: { size: { sm: { height: 32 } } },
+    });
+
+    expect(uncached({ size: "sm" })).not.toBe(uncached({ size: "sm" }));
+    expect(uncached({ size: "sm" })).toStrictEqual({ height: 32 });
+    expect(Object.isFrozen(uncached({ size: "sm" }))).toBe(true);
+    expect(cached({ size: "sm" })).toBe(cached({ size: "sm" }));
+  });
+
+  it("builds new styles on every call of a slot style recipe", () => {
+    const card = createSlotStyleRecipe({
+      cache: false,
+      slots: ["root"],
+      variants: { size: { sm: { root: { height: 32 } } } },
+    });
+
+    expect(card({ size: "sm" })).not.toBe(card({ size: "sm" }));
+    expect(card({ size: "sm" })).toStrictEqual({ root: { height: 32 } });
+  });
+
+  it("applies to the recipe of each theme", () => {
+    const theme: { readonly radius: number } = { radius: 8 };
+    const { createStyleRecipe: createThemedStyleRecipe } =
+      createThemedRecipes<typeof theme>();
+    const box = createThemedStyleRecipe((tokens) => ({
+      cache: false,
+      base: { borderRadius: tokens.radius },
+      variants: { size: { sm: { height: 32 } } },
+    }));
+
+    expect(box(theme, { size: "sm" })).not.toBe(box(theme, { size: "sm" }));
+    expect(box(theme, { size: "sm" })).toStrictEqual({
+      borderRadius: 8,
+      height: 32,
+    });
+  });
+
+  it("rejects a setting that is not a boolean", () => {
+    const box = createStyleRecipe({
+      // @ts-expect-error cache must be a boolean
+      cache: "no",
+      variants: { size: { sm: { height: 32 } } },
+    });
+    const card = createSlotStyleRecipe({
+      // @ts-expect-error cache must be a boolean
+      cache: "no",
+      slots: ["root"],
+      variants: { size: { sm: { root: { height: 32 } } } },
+    });
+
+    expect(box({ size: "sm" })).toStrictEqual({ height: 32 });
+    expect(card({ size: "sm" })).toStrictEqual({ root: { height: 32 } });
+  });
+});
@@ -17,6 +17,7 @@ interface LooseSlotStyleRecipeConfig {
       }[]
     | undefined;
   readonly defaultVariants?: LooseSelection | undefined;
+  readonly cache?: boolean | undefined;
 }
 
 type LooseSlotStyleRecipe = KindRecipe<
@@ -32,6 +33,7 @@ function buildSlotStyleRecipe(
 ): LooseSlotStyleRecipe {
   return slotStyleRecipe({
     base: config.base,
+    cache: config.cache,
     compoundVariants: (config.compoundVariants ?? []).map((compound) => ({
       value: compound.styles,
       variants: compound.variants,
 
@@ -16,6 +16,7 @@ interface LooseStyleRecipeConfig {
       }[]
     | undefined;
   readonly defaultVariants?: LooseSelection | undefined;
+  readonly cache?: boolean | undefined;
 }
 
 type LooseStyleRecipe = KindRecipe<LooseSelection, LooseStyle>;
@@ -45,6 +46,7 @@ const styleRecipe = createRecipeKind(styleKind);
 function buildStyleRecipe(config: LooseStyleRecipeConfig): LooseStyleRecipe {
   return styleRecipe({
     base: config.base,
+    cache: config.cache,
     compoundVariants: (config.compoundVariants ?? []).map((compound) => ({
       value: compound.style,
       variants: compound.variants,
 
@@ -124,6 +124,11 @@ interface SlotStyleRecipeConfig<
   /** The option each variant uses when a recipe is called without it. */
   readonly defaultVariants?:
     DefaultVariants<Variants, DefaultedName> | undefined;
+  /**
+   * Whether the recipe caches the styles of each declared selection.
+   * Defaults to `true`.
+   */
+  readonly cache?: boolean | undefined;
 }
 
 /**
@@ -184,6 +189,8 @@ type RecipeSlotStyles<Slot extends string, Variants, Base, Compounds> = {
  * object, so calling a slot recipe again with the same variants returns the
  * same object, with the same style for each slot. Passing them to the
  * `style` prop of each element keeps the props unchanged between renders.
+ * With `cache: false`, the recipe builds a new object on every call
+ * instead.
  *
  * Every declared slot is present in the result, as an empty style when it
  * has none. A variant without a default is required, except a boolean
 
@@ -79,6 +79,11 @@ interface StyleRecipeConfig<
   /** The option each variant uses when a recipe is called without it. */
   readonly defaultVariants?:
     DefaultVariants<Variants, DefaultedName> | undefined;
+  /**
+   * Whether the recipe caches the style of each declared selection.
+   * Defaults to `true`.
+   */
+  readonly cache?: boolean | undefined;
 }
 
 /** Every style that a recipe's config declares, as a union. */
@@ -125,7 +130,8 @@ type StyleRecipe<Props, Style> = KindRecipe<Props, Style>;
  * so calling a recipe again with the same variants returns the same object.
  * Passing it to the `style` prop of a component keeps the prop unchanged
  * between renders, which lets React skip the style and a memoized child
- * skip rendering.
+ * skip rendering. With `cache: false`, the recipe builds a new object on
+ * every call instead.
  *
  * A variant without a default is required, except a boolean variant, whose
  * only options are `"true"` and `"false"` and which defaults to `false`. An