@@ -53,7 +53,9 @@ an object of styles keyed by slot name.
 | `cache`            | Optional | Whether the recipe caches its styles. Defaults to `true`. With `false`, every call returns a new object, so leave it on in components.  |
 
 An option or a compound variant gives styles only to the slots it names.
-A style for a slot that `slots` does not declare is a type error.
+A style for a slot that `slots` does not declare is a type error. It is
+ignored, and the recipe warns about it when it is created (see
+[Names the config does not declare](/recipe/native-recipe/create-style-recipe/#names-the-config-does-not-declare)).
 Variants, defaults, boolean variants, and undeclared options work as in a
 style recipe (see [Variants](/recipe/native-recipe/variants/)).
 
 
@@ -56,6 +56,35 @@ recipe throws a `TypeError` that names what is wrong: no `variants`, a
 style that is not an object, or a compound variant without `variants` or
 `style`.
 
+### Names the config does not declare
+
+A default or a compound variant can name a variant or an option that the
+config does not declare, such as a misspelled one. TypeScript rejects it
+in a config written in the call, but a config declared before the call
+lets some through (see
+[A config declared before the call](/recipe/native-recipe/typescript/#a-config-declared-before-the-call)),
+and so does JavaScript. The recipe then adds no style for that name:
+
+- A default of an undeclared variant, or an option that its variant does
+  not declare, is ignored.
+- A compound variant's condition on an undeclared variant never matches.
+  An undeclared option in its list is ignored, so a condition left
+  without a declared option never matches either.
+- In a slot recipe, a style for a slot that `slots` does not name is
+  ignored.
+
+When it is created, the recipe warns about each such name with
+`console.warn`, in one message:
+
+```text
+A recipe's config names variants, options, or slots that it does not declare, so they add nothing:
+- Compound variant 0 names the variant "tonne".
+```
+
+The names of the recipes it composes count as declared. A recipe created
+again from a config with the same mistakes, such as a themed recipe for
+each theme, does not repeat the warning.
+
 A style that never changes does not need a recipe, though: keep it in
 `StyleSheet.create` (see
 [Building components](/recipe/native-recipe/building-components/#keep-static-styles-in-stylesheetcreate)).
@@ -80,9 +109,10 @@ compoundVariants: [
 ],
 ```
 
-The condition is checked after defaults apply. A compound variant that
-names an undeclared variant, or lists no declared option for a variant,
-never matches.
+The condition is checked after defaults apply. A condition on an
+undeclared variant never matches, and an undeclared option in a list is
+ignored; the recipe warns about both (see
+[Names the config does not declare](#names-the-config-does-not-declare)).
 
 ## The result
 
 
@@ -21,6 +21,16 @@ TypeScript reports `Property 'variants' is missing` (TS2741). In
 JavaScript, creating the recipe throws a `TypeError` that says so. See
 [createStyleRecipe](/recipe/native-recipe/create-style-recipe/#the-config).
 
+## Why does the console warn that a recipe's config names what it does not declare?
+
+A default, a compound variant, or a slot's style names a variant, an
+option, or a slot that the config does not declare, usually a typo in a
+config declared before the call, or returned by a themed recipe's
+function, where TypeScript does not catch every one. The recipe adds no
+style for that name. The message lists each one; fix the name, or
+declare it. See
+[Names the config does not declare](/recipe/native-recipe/create-style-recipe/#names-the-config-does-not-declare).
+
 ## Can I pass extra styles into a recipe call?
 
 No. A recipe takes only variants. Merge extra styles in the `style` prop,
 
@@ -12,19 +12,20 @@ that exports its recipes, or sets `isolatedDeclarations`, also needs
 
 ## A config declared before the call
 
-Declare a config before the call `as const`, so that the options named
-in its compound and default variants stay literal types. This holds for the `slots` of a slot recipe
-too: a list declared before the call without `as const` is a `string[]`,
-so the slot recipe takes any slot name, and a misspelled slot in `base`,
-in the variants, or in the result is not an error.
-
-TypeScript checks a declared config less than one written in the call:
-it reports a name that a type does not declare only in an object written
-where that type is expected. In a declared config, a misspelled variant
+Declare a config before the call `as const`, so that the options named in
+its compound and default variants stay literal types. The same holds for
+the `slots` of a slot recipe: a list declared without `as const` is a
+`string[]`, so the slot recipe takes any slot name, and a misspelled slot
+in `base`, in the variants, or in the result is not a type error.
+
+TypeScript also checks a declared config less than one written in the
+call, since it reports a name that a type does not declare only in an
+object written where that type is expected. In a declared config, and in
+the config that a themed recipe's function returns, a misspelled variant
 name next to a correct one in the variants that a compound variant names
-is not an error, and the compound variant never applies. Write the
-config in the call when nothing needs it declared, and test the styles of
-a declared config.
+is not a type error. The recipe warns about it when it is created, and
+the compound variant never matches; see
+[Names the config does not declare](/recipe/native-recipe/create-style-recipe/#names-the-config-does-not-declare).
 
 ## Checked styles
 
 
@@ -5,6 +5,15 @@ published on npm and as a
 [GitHub release](https://github.com/lynstack/recipe/releases) tagged
 `native-recipe@<version>`.
 
+## Unreleased
+
+- The recipe creators warn, once, with `console.warn`, about a default, a
+  compound variant, or a style that names a variant, an option, or a slot
+  that the config does not declare, such as a misspelled name in a config
+  declared before the call or returned by a themed recipe's function,
+  which TypeScript does not always report. Such a name still adds no
+  style.
+
 ## 1.6.0 — 2026-10-08
 
 A library of components can export and wrap its recipes: their
 
@@ -98,9 +98,11 @@ type BadgeProps = VariantsOf<typeof badge>; // also works on themed recipes
   the variants' styles.
 - A recipe ignores props that are not variants, so it can take all of a
   component's props.
-- Write the config inside the call. A config declared before the call
-  must be `as const`, and TypeScript checks it less: a misspelled variant
-  name next to a correct one in a compound variant is not an error.
+- Write the config inside the call, where TypeScript checks every name.
+  A config declared before the call must be `as const`, and TypeScript
+  lets some misspelled names through; the recipe then warns, when it is
+  created, that its config names what it does not declare. Fix every
+  such warning.
 - `composes: [other]` adds the config of another recipe of the same kind
   (style recipe or slot style recipe) before its own; see
   [Compose a shared recipe](#compose-a-shared-recipe-instead-of-copying-its-config).
@@ -332,4 +334,5 @@ no variants.
   size that a token exists for?
 - Is every theme object created once, or memoized, and passed unchanged?
 - Is any config declared before its call where it could be written in
-  the call, or declared without `as const`?
+  the call, or declared without `as const`? Does creating any recipe warn
+  that its config names what it does not declare?
@@ -172,7 +172,10 @@ type ComposedSlotStyleRecipe<
  * variant, whose only options are `"true"` and `"false"` and which defaults
  * to `false`. An option that the config does not declare adds no style, and
  * its styles are built on every call. Properties of the selection that are
- * not variants are ignored. Its `variantKeys`, `variantOptions`, and
+ * not variants are ignored. Creating it warns once, with `console.warn`,
+ * about a default, a compound variant, or a style that names a variant, an
+ * option, or a slot that the config does not declare, which adds no style.
+ * Its `variantKeys`, `variantOptions`, and
  * `defaultVariants` properties list its variants as those of
  * `createStyleRecipe` do.
  *
 
@@ -185,10 +185,12 @@ type ComposedStyleRecipe<
  * only options are `"true"` and `"false"` and which defaults to `false`. An
  * option that the config does not declare adds no style, and its style is
  * built on every call. Properties of the selection that are not variants
- * are ignored. The recipe's `variantKeys` property lists the names of its
- * variants, `variantOptions` the names of the options of each, and
- * `defaultVariants` the option each uses when the recipe is called without
- * it.
+ * are ignored. Creating the recipe warns once, with `console.warn`, about a
+ * default or a compound variant that names a variant or an option that the
+ * config does not declare, which adds no style. The recipe's `variantKeys`
+ * property lists the names of its variants, `variantOptions` the names of
+ * the options of each, and `defaultVariants` the option each uses when the
+ * recipe is called without it.
  *
  * A recipe composes the recipes listed in its config's `composes` as if
  * their configs and its own were one: their base styles first, then the
 
@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createStyleRecipe } from "./style-recipe.js";
+import { createThemedRecipes } from "./themed-recipes.js";
+
+const heading =
+  "A recipe's config names variants, options, or slots that it does not declare, so they add nothing:";
+
+/** Returns what `create` warns about, without printing it. */
+function warningsOf(create: () => unknown): readonly string[] {
+  const messages: string[] = [];
+  const warn = vi
+    .spyOn(console, "warn")
+    .mockImplementation((message: unknown) => {
+      messages.push(String(message));
+    });
+  try {
+    create();
+  } finally {
+    warn.mockRestore();
+  }
+  return messages;
+}
+
+interface Theme {
+  readonly gap: number;
+}
+
+describe("a config declared before the call", () => {
+  it("warns about a compound variant that names an undeclared variant", () => {
+    const boxConfig = {
+      compoundVariants: [
+        {
+          style: { borderWidth: 2 },
+          variants: { size: "sm", tonne: "danger" },
+        },
+      ],
+      variants: {
+        size: { md: { padding: 8 }, sm: { padding: 4 } },
+        tone: { danger: { opacity: 1 }, neutral: { opacity: 0.6 } },
+      },
+    } as const;
+
+    expect(warningsOf(() => createStyleRecipe(boxConfig))).toStrictEqual([
+      `${heading}\n- Compound variant 0 names the variant "tonne".`,
+    ]);
+    expect(
+      createStyleRecipe(boxConfig)({ size: "sm", tone: "danger" }),
+    ).toStrictEqual({ opacity: 1, padding: 4 });
+  });
+});
+
+describe("a themed recipe", () => {
+  it("warns once, whatever the number of themes", () => {
+    const { createStyleRecipe: createThemedStyleRecipe } =
+      createThemedRecipes<Theme>();
+    const chip = createThemedStyleRecipe((theme) => ({
+      compoundVariants: [
+        { style: { borderWidth: 1 }, variants: { dense: true, sise: "sm" } },
+      ],
+      variants: {
+        dense: { true: { padding: theme.gap } },
+        size: { sm: { height: 24 } },
+      },
+    }));
+
+    expect(
+      warningsOf(() => [
+        chip({ gap: 4 }, { size: "sm" }),
+        chip({ gap: 8 }, { size: "sm" }),
+      ]),
+    ).toStrictEqual([
+      `${heading}\n- Compound variant 0 names the variant "sise".`,
+    ]);
+  });
+});