@lynstack/recipe 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to `@lynstack/recipe`. Each version is published on
 npm and as a [GitHub release](https://github.com/lynstack/recipe/releases)
 tagged `recipe@<version>`.
 
+## 1.8.0 — 2026-10-08
+
+A recipe warns about the names its config gives without declaring them,
+which TypeScript lets through in a config declared before the call, and
+a library's function generic over the slot recipe it composes can name
+its own slots.
+
+- A slot recipe's config types the slots of the slot recipes it composes
+  apart from its own, so that a function generic over the slot recipe it
+  composes can name its own slots, and declarations print the slots of
+  `base` and of compound variants by name. Making library recipes
+  composable advises the same for a library's types.
+- Creating a recipe or a slot recipe warns, once, with `console.warn`,
+  about a default or a compound variant that names a variant or an option
+  that no config of the recipe declares, and, in a slot recipe, about a
+  value for a slot that no config lists in `slots`. The recipe ignores
+  such names, as before; TypeScript does not report every one in a config
+  declared before the call, as `isolatedDeclarations` requires.
+
+## 1.7.0 — 2026-10-08
+
+A library can type its own functions and exported recipes: a function
+generic over a config returns the recipe of its config, an exported
+recipe has a type to annotate it with for `isolatedDeclarations`, and
+the declarations of composed slot recipes stay small.
+
+- `KindRecipeOf<Value, Result, Config, Composed>` and `KindSlotRecipeOf`
+  are the types of the recipe and the slot recipe of a config declared
+  `as const`, which annotate an exported recipe where
+  `isolatedDeclarations` cannot infer the type of a call. A recipe that
+  composes others lists their types as the last parameter.
+- `KindSelection` is exported: a function generic over a config, such as
+  a library's own helper, returns
+  `KindRecipe<KindSelection<Variants, DefaultedName>, Result>`. Since
+  1.3.0, the type of a recipe could not be assigned to such a type while
+  the names of its defaults were a type parameter.
+- The declaration of a slot recipe that composes others lists the names
+  of its slots, instead of the types of the slot recipes it composes, so
+  that it grows linearly with the level of composition. Before, it grew
+  about 2.4 times with each level.
+
 ## 1.6.0 — 2026-10-07
 
 A config with the wrong shape fails with a message that names what is

package/README.md

@@ -25,8 +25,8 @@ package to create recipes for other values.
 npm install @lynstack/recipe
 ```
 
-Requires TypeScript 5.4 or newer for its types, and an ES2022 runtime. It
-ships as an ES module only.
+Requires TypeScript 5.4 or newer for its types, and Node.js 16.9, Bun 1.0,
+Deno 2.0, or another ES2022 runtime. It ships as an ES module only.
 
 ## Usage
 

package/dist/index.d.ts

@@ -92,17 +92,6 @@ type SelectionDefaults<Selection> = string extends keyof Selection ? Readonly<Re
  * ```
  */
 type VariantsOf<Recipe extends (props: never) => unknown> = Simplify<NonNullable<Parameters<Recipe>[0]>>;
-/**
- * Any selection, for variants whose names are not known at compile time,
- * such as `Record<string, Record<string, string>>`.
- */
-type AnySelection = Readonly<Record<string, unknown>>;
-/** The selection of a recipe, or any selection for unknown variant names. */
-type KindSelection<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : VariantSelection<Variants, DefaultedName>;
-/** The condition of a compound variant, or any for unknown variant names. */
-type KindCompoundCondition<Variants> = string extends keyof Variants ? AnySelection : CompoundCondition<Variants>;
-/** The default variants of a recipe, or any for unknown variant names. */
-type KindDefaultVariants<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : DefaultVariants<Variants, DefaultedName>;
 /**
  * How a kind of recipe turns the values of a selection into its result,
  * such as by joining class names or merging style objects.
@@ -175,7 +164,35 @@ interface RecipeKind<Value, Accumulator, Result> {
  * }
  * ```
  */
-type NoUnknownSlots<Variants, Slot extends string> = { readonly [Name in keyof Variants]: { readonly [Option in keyof Variants[Name]]: string extends keyof Variants[Name][Option] ? unknown : Readonly<Partial<Record<Exclude<keyof Variants[Name][Option], Slot>, never>>>; }; };
+type NoUnknownSlots<Variants, Slot extends string> = NoUnknownComposedSlots<Variants, Slot, never>;
+/**
+ * Rejects the slots of the variants' options that are neither `Slot` nor
+ * `InheritedSlot`. A recipe's own slots are excluded first, so that they
+ * are accepted even when the inherited slots are generic.
+ */
+type NoUnknownComposedSlots<Variants, Slot extends string, InheritedSlot extends string> = { readonly [Name in keyof Variants]: { readonly [Option in keyof Variants[Name]]: string extends keyof Variants[Name][Option] ? unknown : Readonly<Partial<Record<Exclude<Exclude<keyof Variants[Name][Option], Slot>, InheritedSlot>, never>>>; }; };
+//#endregion
+//#region src/kind-selection.d.ts
+/**
+ * Any selection, for variants whose names are not known at compile time,
+ * such as `Record<string, Record<string, string>>`.
+ */
+type AnySelection = Readonly<Record<string, unknown>>;
+/**
+ * The selection that a recipe made from a `RecipeKind` accepts: the
+ * {@link VariantSelection} of its variants, or any selection when the
+ * variant names are not known at compile time. A function generic over a
+ * config annotates the recipe it returns with it, as
+ * `KindRecipe<KindSelection<Variants, DefaultedName>, Result>`.
+ *
+ * @typeParam Variants - The variant definitions, keyed by variant name.
+ * @typeParam DefaultedName - The names of the variants that have a default.
+ */
+type KindSelection<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : VariantSelection<Variants, DefaultedName>;
+/** The condition of a compound variant, or any for unknown variant names. */
+type KindCompoundCondition<Variants> = string extends keyof Variants ? AnySelection : CompoundCondition<Variants>;
+/** The default variants of a recipe, or any for unknown variant names. */
+type KindDefaultVariants<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : DefaultVariants<Variants, DefaultedName>;
 //#endregion
 //#region src/composition.d.ts
 /**
@@ -238,6 +255,14 @@ type MergeVariants<Union> = { readonly [Name in KeyOfEach<Union>]: MergeEach<Val
  *   recipe's own config.
  */
 type ComposedDefaultedName<Composed extends readonly unknown[], DefaultedName> = DefaultedName | ComposedPart<Composed, "defaultedName">;
+/**
+ * The names of the variants that the recipes of `Composed` give a default,
+ * among the variants of a recipe that composes them with its own
+ * `Variants`. Kept apart from the recipe's own defaulted names, so that a
+ * recipe that composes nothing has exactly those, even when they are
+ * generic.
+ */
+type InheritedDefaultedName<Composed extends readonly unknown[], Variants> = Extract<ComposedPart<Composed, "defaultedName">, keyof ComposedVariants<Composed, Variants>>;
 /**
  * The slots of a slot recipe that composes the slot recipes of `Composed`:
  * those of each, and `Slot`.
@@ -246,6 +271,12 @@ type ComposedDefaultedName<Composed extends readonly unknown[], DefaultedName> =
  * @typeParam Slot - The names of the slots of the recipe's own config.
  */
 type ComposedSlot<Composed extends readonly unknown[], Slot extends string> = Slot | SlotOf<ComposedPart<Composed, "slots">>;
+/**
+ * The slots of the slot recipes of `Composed`, as indexed access rather
+ * than a conditional type, so that TypeScript relates a config to them
+ * while `Composed` is generic.
+ */
+type InheritedSlot<Composed extends readonly ComposableKindSlotRecipe<unknown>[]> = NonNullable<Composed[number]["~composition"]>["slots"][number];
 type SlotOf<Slots> = Slots extends readonly (infer Slot extends string)[] ? Slot : never;
 /**
  * A recipe that a recipe whose values are of type `Value` can compose: a
@@ -266,7 +297,7 @@ type ComposableKindSlotRecipe<Value> = Composable<RecipeComposition<object, Prop
  * The recipe of a config whose variants, once composed, are `Variants`, and
  * whose variants with a default are `DefaultedName`.
  */
-type ComposedKindRecipe<Variants, DefaultedName, Value, Result, Slots> = KindRecipe<KindSelection<Variants, Extract<DefaultedName, keyof Variants>>, Result, RecipeComposition<Variants, Extract<DefaultedName, keyof Variants>, Value, Slots>>;
+type ComposedKindRecipe<Variants, DefaultedName extends keyof Variants, Value, Result, Slots> = KindRecipe<KindSelection<Variants, DefaultedName>, Result, RecipeComposition<Variants, DefaultedName, Value, Slots>>;
 //#endregion
 //#region src/variants.d.ts
 /**
@@ -374,7 +405,7 @@ type KindRecipe<Selection, Result, Composition = unknown> = RecipeFunction<Selec
  *   variants of the recipe, and whether it caches its results.
  * @returns The recipe.
  */
-type CreateKindRecipe<Value, Result> = <const Variants extends KindVariants<Value>, const DefaultedName extends keyof ComposedVariants<Composed, Variants> = never, const Composed extends readonly ComposableKindRecipe<Value>[] = readonly []>(config: KindRecipeConfig<Value, Variants, DefaultedName, Composed>) => ComposedKindRecipe<ComposedVariants<Composed, Variants>, ComposedDefaultedName<Composed, DefaultedName>, Value, Result, undefined>;
+type CreateKindRecipe<Value, Result> = <const Variants extends KindVariants<Value>, const DefaultedName extends keyof ComposedVariants<Composed, Variants> = never, const Composed extends readonly ComposableKindRecipe<Value>[] = readonly []>(config: KindRecipeConfig<Value, Variants, DefaultedName, Composed>) => ComposedKindRecipe<ComposedVariants<Composed, Variants>, DefaultedName | InheritedDefaultedName<Composed, Variants>, Value, Result, undefined>;
 /**
  * Creates a kind of recipe from how it turns the values of a selection into
  * its result, and returns the function that creates recipes of that kind.
@@ -394,6 +425,11 @@ type CreateKindRecipe<Value, Result> = <const Variants extends KindVariants<Valu
  * each, and `defaultVariants` the option each uses when a selection leaves
  * it out, so that a library can list every selection of a recipe.
  *
+ * Creating a recipe warns once, with `console.warn`, about a default or a
+ * compound variant's condition that names a variant or an option that no
+ * config of the recipe declares. Such a default is ignored, and such a
+ * condition never matches.
+ *
  * With the cache, a recipe builds the result of each declared selection
  * once, and calling it again with the same variants returns the same
  * result. Freeze an object result in `kind.finish` so that callers cannot
@@ -476,7 +512,7 @@ declare function createRecipeKind<Value, Accumulator, Result = Accumulator>(kind
  * @typeParam Slot - The names of the slots.
  * @typeParam Value - The value of a slot.
  */
-type SlotValues<Slot extends string, Value> = Readonly<Partial<Record<Slot, Value | undefined>>>;
+type SlotValues<Slot extends string, Value> = { readonly [Name in Slot]?: Value | undefined; };
 /**
  * The variants of a {@link KindSlotRecipeConfig}: for each variant name,
  * the values of each slot for each of its options.
@@ -523,15 +559,15 @@ interface KindSlotRecipeConfig<Slot extends string, Value, Variants extends Kind
    */
   readonly slots: readonly Slot[];
   /** The value of each slot that the values of every selection are added to. */
-  readonly base?: SlotValues<NoInfer<ComposedSlot<Composed, Slot>>, Value> | undefined;
+  readonly base?: SlotValues<NoInfer<Slot> | InheritedSlot<Composed>, Value> | undefined;
   /** For each variant name, the values of each slot for each of its options. */
-  readonly variants: Variants & NoUnknownSlots<Variants, NoInfer<ComposedSlot<Composed, Slot>>>;
+  readonly variants: Variants & NoUnknownComposedSlots<Variants, NoInfer<Slot>, InheritedSlot<Composed>>;
   /**
    * Values added to some slots when several variants have particular
    * options at the same time, applied in order after the values of the
    * variants' options.
    */
-  readonly compoundVariants?: readonly KindSlotCompoundVariant<NoInfer<ComposedVariants<Composed, Variants>>, NoInfer<ComposedSlot<Composed, Slot>>, Value>[] | undefined;
+  readonly compoundVariants?: readonly KindSlotCompoundVariant<NoInfer<ComposedVariants<Composed, Variants>>, NoInfer<Slot> | InheritedSlot<Composed>, Value>[] | undefined;
   /** The option each variant uses when the recipe is called without it. */
   readonly defaultVariants?: KindDefaultVariants<ComposedVariants<Composed, Variants>, DefaultedName> | undefined;
   /** Whether the recipe caches its results. Defaults to the kind's `cache`. */
@@ -548,7 +584,7 @@ interface KindSlotRecipeConfig<Slot extends string, Value, Variants extends Kind
  *   and whether it caches its results.
  * @returns The slot recipe.
  */
-type CreateKindSlotRecipe<Value, Result> = <const Slot extends string, const Variants extends KindSlotVariants<Value>, const DefaultedName extends keyof ComposedVariants<Composed, Variants> = never, const Composed extends readonly ComposableKindSlotRecipe<Value>[] = readonly []>(config: KindSlotRecipeConfig<Slot, Value, Variants, DefaultedName, Composed>) => ComposedKindRecipe<ComposedVariants<Composed, Variants>, ComposedDefaultedName<Composed, DefaultedName>, Value, Readonly<Record<ComposedSlot<Composed, Slot>, Result>>, readonly ComposedSlot<Composed, Slot>[]>;
+type CreateKindSlotRecipe<Value, Result> = <const Slot extends string, const Variants extends KindSlotVariants<Value>, const DefaultedName extends keyof ComposedVariants<Composed, Variants> = never, const Composed extends readonly ComposableKindSlotRecipe<Value>[] = readonly []>(config: KindSlotRecipeConfig<Slot, Value, Variants, DefaultedName, Composed>) => ComposedKindRecipe<ComposedVariants<Composed, Variants>, DefaultedName | InheritedDefaultedName<Composed, Variants>, Value, Readonly<Record<Slot | Exclude<Composed[number]["~composition"], undefined>["slots"][number], Result>>, readonly (Slot | Exclude<Composed[number]["~composition"], undefined>["slots"][number])[]>;
 /**
  * Creates a kind of slot recipe from how it turns the values of each slot
  * into that slot's result, and returns the function that creates slot
@@ -570,9 +606,11 @@ type CreateKindSlotRecipe<Value, Result> = <const Slot extends string, const Var
  * in the order of `slots`. With the cache, a slot recipe builds it once for
  * each declared selection and returns the same object for the same
  * variants. The `cache` of a slot recipe's config overrides the kind's.
- * Variants, boolean variants, undeclared options, and the `variantKeys`,
- * `variantOptions`, and `defaultVariants` properties are as in
- * {@link createRecipeKind}.
+ * Variants, boolean variants, undeclared options, the warning about
+ * undeclared names, and the `variantKeys`, `variantOptions`, and
+ * `defaultVariants` properties are as in {@link createRecipeKind}. It also
+ * warns about a value for a slot that no config lists in `slots`, which is
+ * ignored.
  *
  * A slot recipe composes the slot recipes listed in `composes` as a recipe
  * composes recipes, and has the slots of each, theirs first. With
@@ -641,5 +679,128 @@ type CreateKindSlotRecipe<Value, Result> = <const Slot extends string, const Var
  */
 declare function createSlotRecipeKind<Value, Accumulator, Result = Accumulator>(kind: RecipeKind<Value, Accumulator, Result>): CreateKindSlotRecipe<Value, Result>;
 //#endregion
-export { type Composable, type ComposableKindRecipe, type ComposableKindSlotRecipe, type ComposedDefaultedName, type ComposedSlot, type ComposedVariants, type CompoundCondition, type CreateKindRecipe, type CreateKindSlotRecipe, type DefaultVariants, type KindCompoundVariant, type KindRecipe, type KindRecipeConfig, type KindSlotCompoundVariant, type KindSlotRecipeConfig, type KindSlotVariants, type KindVariants, type NoUnknownSlots, type RecipeComposition, type RecipeFunction, type RecipeKind, type SlotValues, type VariantKey, type VariantOption, type VariantSelection, type VariantsOf, createRecipeKind, createSlotRecipeKind };
+//#region src/recipe-of.d.ts
+/**
+ * The names of the variants with a default in a config of type `Config`:
+ * the keys of its `defaultVariants`, among its variants and those of the
+ * recipes of `Composed`.
+ */
+type DefaultedNameOf<Config, Composed extends readonly unknown[]> = Config extends {
+  readonly defaultVariants: infer Defaults;
+  readonly variants: infer Variants;
+} ? Extract<keyof Defaults, keyof ComposedVariants<Composed, Variants>> : never;
+/**
+ * The parts of a config that {@link KindRecipeOf} reads, without
+ * `composes`, which it takes as its own type parameter.
+ */
+interface KindRecipeConfigParts<Value> {
+  readonly composes?: never;
+  readonly variants: KindVariants<Value>;
+  readonly defaultVariants?: object | undefined;
+}
+/**
+ * The type of the recipe that a function of type
+ * `CreateKindRecipe<Value, Result>` returns for a config of type `Config`
+ * that composes the recipes of `Composed`. Annotate an exported recipe
+ * with it where each file's declarations are emitted on its own, as with
+ * `isolatedDeclarations`, which cannot infer the type of a call. A config
+ * that lists `composes` is rejected, so that the type cannot leave out the
+ * recipes it composes.
+ * It applies to a config whose type is known, not in a function generic
+ * over the whole config, from which the recipe's creator cannot infer the
+ * variants; make such a function generic over the variants instead.
+ *
+ * @typeParam Value - The value of an option, as in `CreateKindRecipe`.
+ * @typeParam Result - What a recipe of the kind returns, as in
+ *   `CreateKindRecipe`.
+ * @typeParam Config - The type of the config without `composes`: declare
+ *   the config `as const`, and annotate the recipe with its `typeof`.
+ * @typeParam Composed - The types of the recipes it composes, in the order
+ *   of `composes`. Defaults to none.
+ *
+ * @example
+ * ```ts
+ * const textConfig = {
+ *   variants: { size: { sm: { fontSize: 12 }, md: { fontSize: 16 } } },
+ *   defaultVariants: { size: "md" },
+ * } as const;
+ *
+ * export const text: KindRecipeOf<Style, Style, typeof textConfig> =
+ *   styleRecipe(textConfig);
+ *
+ * const headingConfig = {
+ *   variants: { size: { xl: { fontSize: 32 } } },
+ * } as const;
+ *
+ * export const heading: KindRecipeOf<
+ *   Style,
+ *   Style,
+ *   typeof headingConfig,
+ *   readonly [typeof text]
+ * > = styleRecipe({ ...headingConfig, composes: [text] });
+ *
+ * heading({ size: "xl" }); // => { fontSize: 32 }
+ * ```
+ */
+type KindRecipeOf<Value, Result, Config extends KindRecipeConfigParts<Value>, Composed extends readonly ComposableKindRecipe<Value>[] = readonly []> = ComposedKindRecipe<ComposedVariants<Composed, Config["variants"]>, DefaultedNameOf<Config, Composed> | InheritedDefaultedName<Composed, Config["variants"]>, Value, Result, undefined>;
+/**
+ * The parts of a config that {@link KindSlotRecipeOf} reads, without
+ * `composes`, which it takes as its own type parameter.
+ */
+interface KindSlotRecipeConfigParts<Value> {
+  readonly composes?: never;
+  readonly slots: readonly string[];
+  readonly variants: KindSlotVariants<Value>;
+  readonly defaultVariants?: object | undefined;
+}
+/**
+ * The type of the slot recipe that a function of type
+ * `CreateKindSlotRecipe<Value, Result>` returns for a config of type
+ * `Config` that composes the slot recipes of `Composed`. Annotate an
+ * exported slot recipe with it where each file's declarations are emitted
+ * on its own, as with `isolatedDeclarations`, which cannot infer the type
+ * of a call. A config that lists `composes` is rejected, so that the type
+ * cannot leave out the slot recipes it composes.
+ * It applies to a config whose type is known, not in a function generic
+ * over the whole config, from which the slot recipe's creator cannot
+ * infer the variants; make such a function generic over the variants
+ * instead.
+ *
+ * @typeParam Value - The value of a slot, as in `CreateKindSlotRecipe`.
+ * @typeParam Result - What a slot recipe of the kind returns for each
+ *   slot, as in `CreateKindSlotRecipe`.
+ * @typeParam Config - The type of the config without `composes`: declare
+ *   the config `as const`, and annotate the slot recipe with its `typeof`.
+ * @typeParam Composed - The types of the slot recipes it composes, in the
+ *   order of `composes`. Defaults to none.
+ *
+ * @example
+ * ```ts
+ * const cardConfig = {
+ *   slots: ["root", "title"],
+ *   variants: { tone: { dark: { root: { backgroundColor: "black" } } } },
+ * } as const;
+ *
+ * export const card: KindSlotRecipeOf<Style, Style, typeof cardConfig> =
+ *   slotStyleRecipe(cardConfig);
+ *
+ * const dialogConfig = {
+ *   slots: ["footer"],
+ *   variants: { tone: { dark: { footer: { borderColor: "white" } } } },
+ * } as const;
+ *
+ * export const dialog: KindSlotRecipeOf<
+ *   Style,
+ *   Style,
+ *   typeof dialogConfig,
+ *   readonly [typeof card]
+ * > = slotStyleRecipe({ ...dialogConfig, composes: [card] });
+ *
+ * dialog({ tone: "dark" });
+ * // => { root: { backgroundColor: "black" }, title: {}, footer: { borderColor: "white" } }
+ * ```
+ */
+type KindSlotRecipeOf<Value, Result, Config extends KindSlotRecipeConfigParts<Value>, Composed extends readonly ComposableKindSlotRecipe<Value>[] = readonly []> = ComposedKindRecipe<ComposedVariants<Composed, Config["variants"]>, DefaultedNameOf<Config, Composed> | InheritedDefaultedName<Composed, Config["variants"]>, Value, Readonly<Record<Config["slots"][number] | Exclude<Composed[number]["~composition"], undefined>["slots"][number], Result>>, readonly (Config["slots"][number] | Exclude<Composed[number]["~composition"], undefined>["slots"][number])[]>;
+//#endregion
+export { type Composable, type ComposableKindRecipe, type ComposableKindSlotRecipe, type ComposedDefaultedName, type ComposedSlot, type ComposedVariants, type CompoundCondition, type CreateKindRecipe, type CreateKindSlotRecipe, type DefaultVariants, type KindCompoundVariant, type KindRecipe, type KindRecipeConfig, type KindRecipeOf, type KindSelection, type KindSlotCompoundVariant, type KindSlotRecipeConfig, type KindSlotRecipeOf, type KindSlotVariants, type KindVariants, type NoUnknownSlots, type RecipeComposition, type RecipeFunction, type RecipeKind, type SlotValues, type VariantKey, type VariantOption, type VariantSelection, type VariantsOf, createRecipeKind, createSlotRecipeKind };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -48,7 +48,7 @@ function product(numbers) {
 	return numbers.reduce((result, number) => result * number, 1);
 }
 function withBooleanOptions(valuesByOption, noValue) {
-	if (!Object.keys(valuesByOption).some((option) => isBooleanName(option))) return valuesByOption;
+	if (!Object.keys(valuesByOption).some((option) => isBooleanName$1(option))) return valuesByOption;
 	return {
 		false: noValue,
 		true: noValue,
@@ -69,7 +69,7 @@ function compileCondition(indexByOption, variant, value) {
 	return [variant, toOptionNames(value).map((option) => indexes?.get(option)).filter((index) => index !== void 0)];
 }
 function isBooleanVariant(indexByOption) {
-	return indexByOption !== void 0 && indexByOption.size > 0 && [...indexByOption.keys()].every((option) => isBooleanName(option));
+	return indexByOption !== void 0 && indexByOption.size > 0 && [...indexByOption.keys()].every((option) => isBooleanName$1(option));
 }
 function toOptionName(value) {
 	if (typeof value === "string") return value;
@@ -104,7 +104,7 @@ function defaultVariantsOf(compiled) {
 	});
 	return Object.fromEntries(entries);
 }
-function isBooleanName(option) {
+function isBooleanName$1(option) {
 	return option === "true" || option === "false";
 }
 //#endregion
@@ -397,6 +397,81 @@ function createSelector(compiled, build, options) {
 	};
 }
 //#endregion
+//#region src/check-names.ts
+function declaredOptionsOf(layers) {
+	const optionsByName = /* @__PURE__ */ new Map();
+	for (const { variants } of layers) for (const [name, options] of Object.entries(variants)) {
+		const declared = [...optionsByName.get(name) ?? [], ...Object.keys(options)];
+		optionsByName.set(name, declared.some((option) => isBooleanName(option)) ? [
+			...declared,
+			"true",
+			"false"
+		] : declared);
+	}
+	return optionsByName;
+}
+function isBooleanName(option) {
+	return option === "true" || option === "false";
+}
+function unknownDefaults(defaultVariants, declared) {
+	return Object.entries(defaultVariants).flatMap(([name, value]) => {
+		if (value === void 0) return [];
+		const options = declared.get(name);
+		if (options === void 0) return [`\`defaultVariants\` names the variant "${name}".`];
+		const option = toOptionName(value);
+		return option !== void 0 && options.includes(option) ? [] : [`\`defaultVariants\` gives "${name}" the option ${JSON.stringify(value)}.`];
+	});
+}
+function unknownConditions(own, declared) {
+	return own.compoundVariants.flatMap(({ variants }, index) => Object.entries(variants).flatMap(([name, value]) => {
+		if (value === void 0) return [];
+		const options = declared.get(name);
+		if (options === void 0) return [`Compound variant ${String(index)} names the variant "${name}".`];
+		return toOptionNames(value).filter((option) => !options.includes(option)).map((option) => `Compound variant ${String(index)} names the option "${option}" of "${name}".`);
+	}));
+}
+function unknownSlotsIn(value, slots, where) {
+	if (typeof value !== "object" || value === null) return [];
+	return Object.keys(value).filter((slot) => !slots.includes(slot)).map((slot) => `${where} gives a value to the slot "${slot}".`);
+}
+function unknownSlots(own, slots) {
+	return [
+		...unknownSlotsIn(own.base, slots, "`base`"),
+		...Object.entries(own.variants).flatMap(([name, options]) => Object.entries(options).flatMap(([option, value]) => unknownSlotsIn(value, slots, `The option "${option}" of "${name}"`))),
+		...own.compoundVariants.flatMap(({ value }, index) => unknownSlotsIn(value, slots, `Compound variant ${String(index)}`))
+	];
+}
+/**
+* Returns the names in a recipe's own config that none of its layers
+* declares: a variant or option in its defaults or compound variants, and,
+* for a slot recipe, a slot that a value is given to. Such a default or
+* value is left out, and such a compound variant never matches. Each layer
+* was checked when its own recipe was created, so only `own` is checked.
+*/
+function unknownNames(own, layers, isSlotRecipe) {
+	const declared = declaredOptionsOf(layers);
+	return [
+		...unknownDefaults(own.defaultVariants, declared),
+		...unknownConditions(own, declared),
+		...isSlotRecipe ? unknownSlots(own, layers.flatMap(({ slots }) => slots)) : []
+	];
+}
+const warned = /* @__PURE__ */ new Set();
+/**
+* Warns once about the names that {@link unknownNames} returns, if any. A
+* warning already given is not repeated, so that a recipe created again
+* with the same config, such as a themed recipe for each theme, warns once.
+*/
+function warnUnknownNames(own, layers, isSlotRecipe) {
+	const problems = unknownNames(own, layers, isSlotRecipe);
+	if (problems.length === 0) return;
+	const warning = `A recipe's config names variants, options, or slots that it does not declare, so they add nothing:\n- ${problems.join("\n- ")}`;
+	if (!warned.has(warning)) {
+		warned.add(warning);
+		console.warn(warning);
+	}
+}
+//#endregion
 //#region src/recipe-kind.ts
 const recipes = createRegistry("recipe");
 function createRecipeKind(kind) {
@@ -404,6 +479,7 @@ function createRecipeKind(kind) {
 	return (config) => {
 		const own = layerOf(checkRecipeConfig(config), []);
 		const layers = recipes.layersOf(config.composes ?? [], own);
+		warnUnknownNames(own, layers, false);
 		const { compiled, build } = layers.length === 1 ? compileLayer(kind, own) : compileMergedLayers(kind, mergeLayers(layers));
 		const recipe = createSelector(compiled, build, { cache: config.cache ?? kindCache });
 		return recipes.withLayers(withVariants(recipe, compiled), layers);
@@ -513,6 +589,7 @@ function createSlotRecipeKind(kind) {
 	return (config) => {
 		const own = layerOf(checkSlotRecipeConfig(config), config.slots);
 		const layers = slotRecipes.layersOf(config.composes ?? [], own);
+		warnUnknownNames(own, layers, true);
 		const merged = mergeLayers(layers);
 		const compiled = compileVariants({
 			...merged,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["listOf","asResult"],"sources":["../src/variants.ts","../src/reduce-values.ts","../src/compose.ts","../src/build-recipe.ts","../src/check-config.ts","../src/selector.ts","../src/recipe-kind.ts","../src/slots.ts","../src/slot-recipe-kind.ts"],"sourcesContent":["/**\n * Variant definitions in the loose shape the runtime works with: for each\n * variant name, the value of each of its options.\n */\ntype LooseVariants<Value> = Readonly<\n  Record<string, Readonly<Record<string, Value>>>\n>;\n\n/** A selection in the loose shape the runtime works with. */\ntype SelectedVariants = Readonly<Record<string, unknown>>;\n\n/** A compound variant in the loose shape the runtime works with. */\ninterface LooseCompoundVariant<Value> {\n  readonly variants: SelectedVariants;\n  readonly value: Value;\n}\n\n/** The variant's index and the option indexes that a condition matches. */\ntype CompoundCondition = readonly [number, readonly number[]];\n\n/** A compound variant prepared for matching. */\ninterface Compound<Value> {\n  readonly conditions: readonly CompoundCondition[];\n  readonly value: Value;\n}\n\n/** What {@link compileVariants} prepares. */\ninterface VariantsConfig<Value> {\n  readonly variants: LooseVariants<Value>;\n  readonly defaultVariants: SelectedVariants;\n  readonly compoundVariants: readonly LooseCompoundVariant<Value>[];\n  /**\n   * The value of a variant without a selected option, and of a boolean\n   * option that the variant does not declare.\n   */\n  readonly noValue: Value;\n}\n\n/**\n * Variants prepared for selecting values. Each variant numbers its options\n * from 1, and 0 stands for no option, so a selection is a list of option\n * indexes. Read together as the digits of a mixed-radix number, they form\n * the selection's key.\n */\ninterface CompiledVariants<Value> {\n  readonly names: readonly string[];\n  readonly defaultOptions: readonly (string | undefined)[];\n  readonly indexByOption: readonly ReadonlyMap<string, number>[];\n  /** The value of each variant's options, by option index. */\n  readonly valuesByIndex: readonly (readonly Value[])[];\n  readonly strides: readonly number[];\n  readonly compounds: readonly Compound<Value>[];\n  /** Whether every selection's key is a safe integer. */\n  readonly isCacheable: boolean;\n}\n\n/** The option index of a variant without a selected option. */\nconst noOption = 0;\n\n/** The key of a selection with an option that a variant does not declare. */\nconst undeclared = -1;\n\nconst noProps: SelectedVariants = Object.freeze({});\n\n/**\n * Prepares variants for selecting values. A variant that declares an option\n * named `\"true\"` or `\"false\"` also declares the other one, with\n * `config.noValue`, and a variant whose only options are those defaults to\n * `\"false\"`. A compound variant that names an undeclared variant or option,\n * or lists no option for a variant, never matches and is left out.\n */\nfunction compileVariants<Value>(\n  config: VariantsConfig<Value>,\n): CompiledVariants<Value> {\n  const names = Object.keys(config.variants);\n  const optionValues = names.map((name) =>\n    withBooleanOptions(config.variants[name] ?? {}, config.noValue),\n  );\n  const indexByOption: readonly ReadonlyMap<string, number>[] =\n    optionValues.map(\n      (valuesByOption) =>\n        new Map(\n          Object.keys(valuesByOption).map((option, index) => [\n            option,\n            index + 1,\n          ]),\n        ),\n    );\n  const radixes = indexByOption.map((indexes) => indexes.size + 1);\n\n  return {\n    compounds: compileCompounds(config.compoundVariants, names, indexByOption),\n    defaultOptions: names.map(\n      (name, index) =>\n        toOptionName(config.defaultVariants[name]) ??\n        (isBooleanVariant(indexByOption[index]) ? \"false\" : undefined),\n    ),\n    indexByOption,\n    isCacheable: product(radixes) <= Number.MAX_SAFE_INTEGER,\n    names,\n    strides: radixes.map((_radix, index) => product(radixes.slice(0, index))),\n    valuesByIndex: valuesByIndexOf(optionValues, config.noValue),\n  };\n}\n\n/**\n * Writes the option index of each variant for `selected` into `indexes`\n * and returns the selection's key, or {@link undeclared} when an option is\n * not declared.\n */\nfunction select(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  indexes: Int32Array,\n): number {\n  let key = 0;\n  for (let variant = 0; variant < compiled.names.length; variant += 1) {\n    const index = selectIndex(compiled, selected, variant);\n    indexes[variant] = index ?? noOption;\n    key =\n      index === undefined || key === undeclared\n        ? undeclared\n        : key + index * (compiled.strides[variant] ?? 0);\n  }\n  return key;\n}\n\nfunction selectIndex(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  variant: number,\n): number | undefined {\n  const option =\n    toOptionName(selected[compiled.names[variant] ?? \"\"]) ??\n    compiled.defaultOptions[variant];\n  return option === undefined\n    ? noOption\n    : compiled.indexByOption[variant]?.get(option);\n}\n\nfunction valuesByIndexOf<Value>(\n  optionValues: readonly Readonly<Record<string, Value>>[],\n  noValue: Value,\n): Value[][] {\n  const valuesByIndex: Value[][] = [];\n  for (const valuesByOption of optionValues) {\n    valuesByIndex.push([noValue, ...Object.values(valuesByOption)]);\n  }\n  return valuesByIndex;\n}\n\nfunction product(numbers: readonly number[]): number {\n  return numbers.reduce((result, number) => result * number, 1);\n}\n\nfunction withBooleanOptions<Value>(\n  valuesByOption: Readonly<Record<string, Value>>,\n  noValue: Value,\n): Readonly<Record<string, Value>> {\n  const optionNames = Object.keys(valuesByOption);\n  if (!optionNames.some((option) => isBooleanName(option))) {\n    return valuesByOption;\n  }\n  return { false: noValue, true: noValue, ...valuesByOption };\n}\n\nfunction compileCompounds<Value>(\n  compoundVariants: readonly LooseCompoundVariant<Value>[],\n  names: readonly string[],\n  indexByOption: readonly ReadonlyMap<string, number>[],\n): Compound<Value>[] {\n  return compoundVariants.flatMap(({ variants, value }) => {\n    const conditions = Object.keys(variants)\n      .filter((name) => variants[name] !== undefined)\n      .map((name) =>\n        compileCondition(indexByOption, names.indexOf(name), variants[name]),\n      );\n    return conditions.every(([, indexes]) => indexes.length > 0)\n      ? [{ conditions, value }]\n      : [];\n  });\n}\n\nfunction compileCondition(\n  indexByOption: readonly ReadonlyMap<string, number>[],\n  variant: number,\n  value: unknown,\n): CompoundCondition {\n  const indexes = indexByOption[variant];\n  return [\n    variant,\n    toOptionNames(value)\n      .map((option) => indexes?.get(option))\n      .filter((index) => index !== undefined),\n  ];\n}\n\nfunction isBooleanVariant(\n  indexByOption: ReadonlyMap<string, number> | undefined,\n): boolean {\n  return (\n    indexByOption !== undefined &&\n    indexByOption.size > 0 &&\n    [...indexByOption.keys()].every((option) => isBooleanName(option))\n  );\n}\n\nfunction toOptionName(value: unknown): string | undefined {\n  if (typeof value === \"string\") {\n    return value;\n  }\n  return typeof value === \"number\" || typeof value === \"boolean\"\n    ? String(value)\n    : undefined;\n}\n\nfunction toOptionNames(value: unknown): readonly string[] {\n  const values: readonly unknown[] = Array.isArray(value) ? value : [value];\n  return values\n    .map((option) => toOptionName(option))\n    .filter((option) => option !== undefined);\n}\n\n/** A recipe function with the names, options, and defaults of its variants. */\ntype WithVariants<Recipe> = Recipe & {\n  readonly variantKeys: readonly string[];\n  readonly variantOptions: Readonly<Record<string, readonly string[]>>;\n  readonly defaultVariants: Readonly<Record<string, string>>;\n};\n\n/**\n * Adds the names of the compiled variants to `recipe` as `variantKeys`,\n * the names of their options as `variantOptions`, and the option each\n * variant uses when a selection leaves it out as `defaultVariants`.\n */\nfunction withVariants<Recipe extends object>(\n  recipe: Recipe,\n  compiled: CompiledVariants<unknown>,\n): WithVariants<Recipe> {\n  return Object.assign(recipe, {\n    defaultVariants: Object.freeze(defaultVariantsOf(compiled)),\n    variantKeys: Object.freeze([...compiled.names]),\n    variantOptions: Object.freeze(variantOptionsOf(compiled)),\n  });\n}\n\nfunction variantOptionsOf(\n  compiled: CompiledVariants<unknown>,\n): Record<string, readonly string[]> {\n  const entries = compiled.names.map((name, index) => {\n    const options = compiled.indexByOption[index]?.keys() ?? [];\n    return [name, Object.freeze([...options])] as const;\n  });\n  return Object.fromEntries(entries);\n}\n\nfunction defaultVariantsOf(\n  compiled: CompiledVariants<unknown>,\n): Record<string, string> {\n  const entries = compiled.names.flatMap((name, index) => {\n    const option = compiled.defaultOptions[index];\n    return option === undefined ? [] : [[name, option] as const];\n  });\n  return Object.fromEntries(entries);\n}\n\nfunction isBooleanName(option: string): boolean {\n  return option === \"true\" || option === \"false\";\n}\n\nexport { compileVariants, noOption, noProps, select, undeclared, withVariants };\nexport type {\n  CompiledVariants,\n  Compound,\n  LooseCompoundVariant,\n  LooseVariants,\n  SelectedVariants,\n  WithVariants,\n};\n","import type { CompiledVariants, Compound } from \"./variants.js\";\nimport { noOption } from \"./variants.js\";\n\n/** Whether every condition of `compound` matches the selected indexes. */\nfunction matches(compound: Compound<unknown>, indexes: Int32Array): boolean {\n  for (const [variant, matchingIndexes] of compound.conditions) {\n    if (!matchingIndexes.includes(indexes[variant] ?? noOption)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Reduces the values of a selection to an accumulator. */\ninterface Reducer<Value, Accumulator> {\n  /** Returns the accumulator to start from. */\n  readonly initial: () => Accumulator;\n  /** Adds a value to the accumulator and returns the accumulator. */\n  readonly reduce: (accumulator: Accumulator, value: Value) => Accumulator;\n}\n\n/**\n * Reduces the values that apply to a selection, in order of precedence: the\n * value of each variant's option, then the value of each matching compound\n * variant. A value that is undefined adds nothing.\n */\nfunction reduceValues<Value, Accumulator>(\n  compiled: CompiledVariants<Value | undefined>,\n  indexes: Int32Array,\n  reducer: Reducer<Value, Accumulator>,\n): Accumulator {\n  const { reduce } = reducer;\n  let accumulator = reducer.initial();\n  for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {\n    const value =\n      compiled.valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n    if (value !== undefined) {\n      accumulator = reduce(accumulator, value);\n    }\n  }\n  for (const compound of compiled.compounds) {\n    if (compound.value !== undefined && matches(compound, indexes)) {\n      accumulator = reduce(accumulator, compound.value);\n    }\n  }\n  return accumulator;\n}\n\n/**\n * Reduces the values that apply to a selection, as {@link reduceValues}\n * does, when each option and compound variant has a list of values, which\n * are reduced in order.\n */\nfunction reduceValueLists<Value, Accumulator>(\n  compiled: CompiledVariants<readonly Value[]>,\n  indexes: Int32Array,\n  reducer: Reducer<Value, Accumulator>,\n): Accumulator {\n  const { reduce } = reducer;\n  let accumulator = reducer.initial();\n  for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {\n    const values =\n      compiled.valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n    accumulator = reduceEach(accumulator, values ?? [], reduce);\n  }\n  for (const compound of compiled.compounds) {\n    if (matches(compound, indexes)) {\n      accumulator = reduceEach(accumulator, compound.value, reduce);\n    }\n  }\n  return accumulator;\n}\n\n/** Reduces `values` into `accumulator`, in order. */\nfunction reduceEach<Value, Accumulator>(\n  accumulator: Accumulator,\n  values: readonly Value[],\n  reduce: Reducer<Value, Accumulator>[\"reduce\"],\n): Accumulator {\n  let result = accumulator;\n  for (const value of values) {\n    result = reduce(result, value);\n  }\n  return result;\n}\n\nexport { matches, reduceEach, reduceValueLists, reduceValues };\n","import type {\n  LooseCompoundVariant,\n  LooseVariants,\n  SelectedVariants,\n} from \"./variants.js\";\n\n/** Whether a recipe has slots, which decides the recipes it composes. */\ntype RecipeType = \"recipe\" | \"slot recipe\";\n\n/**\n * The values of one config that a recipe is made of: its own config, or\n * that of a recipe it composes.\n */\ninterface Layer<Value> {\n  readonly slots: readonly string[];\n  readonly base: Value | undefined;\n  readonly variants: LooseVariants<Value>;\n  readonly compoundVariants: readonly LooseCompoundVariant<Value>[];\n  readonly defaultVariants: SelectedVariants;\n}\n\n/** What a recipe's config gives for its layer. */\ninterface LayerConfig<Value> {\n  readonly base?: Value | undefined;\n  readonly variants: LooseVariants<Value>;\n  readonly compoundVariants?:\n    readonly LooseCompoundVariant<Value>[] | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n}\n\n/**\n * Returns the layer of a recipe's own config, with copies of its records,\n * so that changing the config later changes no recipe that composes it.\n */\nfunction layerOf<Value>(\n  config: LayerConfig<Value>,\n  slots: readonly string[],\n): Layer<Value> {\n  return {\n    base: config.base,\n    compoundVariants: (config.compoundVariants ?? []).map(\n      ({ variants, value }) => ({ value, variants: { ...variants } }),\n    ),\n    defaultVariants: { ...config.defaultVariants },\n    slots: [...slots],\n    variants: Object.fromEntries(\n      Object.entries(config.variants).map(\n        ([name, options]: readonly [\n          string,\n          Readonly<Record<string, Value>>,\n        ]) => [name, { ...options }],\n      ),\n    ),\n  };\n}\n\n/** The layers of the recipes of one type, which the engine created. */\ninterface Registry<Value> {\n  /**\n   * Returns the layers of a recipe: those of each recipe it composes, in\n   * order, each only at its first occurrence, then its own.\n   *\n   * @throws TypeError when a recipe it composes is not in the registry.\n   */\n  readonly layersOf: (\n    composes: readonly unknown[],\n    own: Layer<Value>,\n  ) => readonly Layer<Value>[];\n  /** Records the layers of `recipe`, so that other recipes can compose it. */\n  readonly withLayers: <Recipe extends object>(\n    recipe: Recipe,\n    layers: readonly Layer<Value>[],\n  ) => Recipe;\n}\n\n/** Returns an empty registry of recipes of type `type`. */\nfunction createRegistry<Value>(type: RecipeType): Registry<Value> {\n  const layersByRecipe = new WeakMap<object, readonly Layer<Value>[]>();\n\n  const layersOfRecipe = (recipe: unknown): readonly Layer<Value>[] => {\n    const layers =\n      typeof recipe === \"function\" ? layersByRecipe.get(recipe) : undefined;\n    if (layers === undefined) {\n      throw new TypeError(\n        `A ${type} composes only ${type}s created by @lynstack/recipe. ` +\n          \"Check that the app installs one copy of @lynstack/recipe.\",\n      );\n    }\n    return layers;\n  };\n\n  return {\n    layersOf: (composes, own) => [\n      ...new Set([\n        ...composes.flatMap((recipe) => layersOfRecipe(recipe)),\n        own,\n      ]),\n    ],\n    withLayers: (recipe, layers) => {\n      layersByRecipe.set(recipe, layers);\n      return recipe;\n    },\n  };\n}\n\n/**\n * The layers of a recipe merged into one config, in which every option and\n * compound variant has the list of its values, in the order of the layers.\n */\ninterface MergedLayers<Value> {\n  /** The slots of every layer, each once, in order. */\n  readonly slots: readonly string[];\n  /** The base of each layer that has one. */\n  readonly bases: readonly Value[];\n  readonly variants: LooseVariants<readonly Value[]>;\n  readonly compoundVariants: readonly LooseCompoundVariant<readonly Value[]>[];\n  readonly defaultVariants: SelectedVariants;\n}\n\n/**\n * Merges layers into one config: the union of their slots, of their\n * variants, and of the options of each, the values of each option in the\n * order of the layers, their compound variants in order, and the default\n * of each variant from the last layer that gives one.\n */\nfunction mergeLayers<Value>(\n  layers: readonly Layer<Value>[],\n): MergedLayers<Value> {\n  const variantNames = unique(\n    layers.flatMap((layer) => Object.keys(layer.variants)),\n  );\n  return {\n    bases: layers.flatMap(({ base }) => listOf(base)),\n    compoundVariants: layers.flatMap((layer) =>\n      layer.compoundVariants.map(({ variants, value }) => ({\n        value: listOf(value),\n        variants,\n      })),\n    ),\n    defaultVariants: Object.fromEntries(\n      layers.flatMap((layer) =>\n        Object.entries(layer.defaultVariants).filter(\n          ([, option]: readonly [string, unknown]) => option !== undefined,\n        ),\n      ),\n    ),\n    slots: unique(layers.flatMap(({ slots }) => slots)),\n    variants: Object.fromEntries(\n      variantNames.map((name) => [name, mergeOptions(layers, name)]),\n    ),\n  };\n}\n\n/** The options of the variant `name` in any layer, with their values. */\nfunction mergeOptions<Value>(\n  layers: readonly Layer<Value>[],\n  name: string,\n): Readonly<Record<string, readonly Value[]>> {\n  const optionsOfLayers = layers.map(\n    (layer) => ownValue(layer.variants, name) ?? {},\n  );\n  const optionNames = unique(\n    optionsOfLayers.flatMap((options) => Object.keys(options)),\n  );\n  return Object.fromEntries(\n    optionNames.map((option) => [\n      option,\n      optionsOfLayers.flatMap((options) => listOf(ownValue(options, option))),\n    ]),\n  );\n}\n\n/**\n * Combines values, none of them undefined, into one with `combine`, in\n * order, or returns undefined when there are none.\n */\nfunction combineValues<Value>(\n  values: readonly Value[],\n  combine: (first: Value, second: Value) => Value,\n): Value | undefined {\n  let combined: Value | undefined = undefined;\n  for (const value of values) {\n    combined = combined === undefined ? value : combine(combined, value);\n  }\n  return combined;\n}\n\nfunction ownValue<Value>(\n  record: Readonly<Record<string, Value>>,\n  key: string,\n): Value | undefined {\n  return Object.hasOwn(record, key) ? record[key] : undefined;\n}\n\nfunction listOf<Value>(value: Value | undefined): readonly Value[] {\n  return value === undefined ? [] : [value];\n}\n\nfunction unique(names: readonly string[]): readonly string[] {\n  return [...new Set(names)];\n}\n\nexport { combineValues, createRegistry, layerOf, mergeLayers };\nexport type { Layer, MergedLayers, Registry };\n","import type { CompiledVariants, SelectedVariants } from \"./variants.js\";\nimport type { Layer, MergedLayers } from \"./compose.js\";\nimport { reduceEach, reduceValueLists, reduceValues } from \"./reduce-values.js\";\nimport type { KindVariants } from \"./recipe-kind.js\";\nimport { combineValues } from \"./compose.js\";\nimport { compileVariants } from \"./variants.js\";\n\n/** A recipe kind in the loose shape the runtime works with. */\ninterface LooseRecipeKind {\n  readonly initial: (base: unknown) => unknown;\n  readonly reduce: (accumulator: unknown, value: unknown) => unknown;\n  readonly combine?: ((first: unknown, second: unknown) => unknown) | undefined;\n  readonly finish?: ((accumulator: unknown) => unknown) | undefined;\n  readonly cache?: boolean | undefined;\n}\n\ninterface LooseKindRecipeConfig {\n  readonly composes?: readonly unknown[] | undefined;\n  readonly base?: unknown;\n  readonly variants: KindVariants<unknown>;\n  readonly compoundVariants?:\n    | readonly {\n        readonly variants: SelectedVariants;\n        readonly value: unknown;\n      }[]\n    | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n  readonly cache?: boolean | undefined;\n}\n\n/** The variants of a recipe, and how it builds the result of a selection. */\ninterface CompiledRecipe {\n  readonly compiled: CompiledVariants<unknown>;\n  readonly build: (indexes: Int32Array) => unknown;\n}\n\nconst asResult = (accumulator: unknown): unknown => accumulator;\n\nconst noValues: readonly unknown[] = Object.freeze([]);\n\nconst firstValue = (values: readonly unknown[]): unknown => values[0];\n\n/** Compiles a recipe that composes no other recipe. */\nfunction compileLayer(\n  kind: LooseRecipeKind,\n  layer: Layer<unknown>,\n): CompiledRecipe {\n  const { initial, reduce, finish } = kind;\n  const { base } = layer;\n  const compiled = compileVariants<unknown>({ ...layer, noValue: undefined });\n  const reducer = { initial: (): unknown => initial(base), reduce };\n  const build =\n    finish === undefined\n      ? (indexes: Int32Array): unknown =>\n          reduceValues(compiled, indexes, reducer)\n      : (indexes: Int32Array): unknown =>\n          finish(reduceValues(compiled, indexes, reducer));\n  return { build, compiled };\n}\n\n/**\n * Compiles a recipe from the merged layers of the recipes it composes and\n * its own. With `kind.combine`, it combines the bases and the values of\n * each option and compiles them as one config. Without it, its accumulator\n * starts from the first base, and the other bases are reduced into it\n * first; when no option or compound variant has more than one value, it\n * compiles them as one config.\n */\nfunction compileMergedLayers(\n  kind: LooseRecipeKind,\n  merged: MergedLayers<unknown>,\n): CompiledRecipe {\n  const { combine } = kind;\n  if (combine !== undefined) {\n    const combined = (values: readonly unknown[]): unknown =>\n      combineValues(values, combine);\n    return compileLayer(\n      kind,\n      layerOfMerged(merged, combined(merged.bases), combined),\n    );\n  }\n  const [base, ...otherBases] = merged.bases;\n  const kindOfBases =\n    otherBases.length === 0\n      ? kind\n      : {\n          ...kind,\n          initial: (): unknown =>\n            reduceEach(kind.initial(base), otherBases, kind.reduce),\n        };\n  return isSingleValued(merged)\n    ? compileLayer(kindOfBases, layerOfMerged(merged, base, firstValue))\n    : compileValueLists(kindOfBases, merged, base);\n}\n\n/** Whether no option or compound variant has more than one value. */\nfunction isSingleValued(merged: MergedLayers<unknown>): boolean {\n  const optionValues = Object.values(merged.variants).flatMap((options) =>\n    Object.values(options),\n  );\n  return (\n    optionValues.every((values) => hasOneValueAtMost(values)) &&\n    merged.compoundVariants.every(({ value }) => hasOneValueAtMost(value))\n  );\n}\n\n/**\n * Returns the merged layers as one config with `base`, the value of each\n * option and compound variant made by `valueOf` from its values.\n */\nfunction layerOfMerged(\n  merged: MergedLayers<unknown>,\n  base: unknown,\n  valueOf: (values: readonly unknown[]) => unknown,\n): Layer<unknown> {\n  return {\n    base,\n    compoundVariants: merged.compoundVariants.map(({ variants, value }) => ({\n      value: valueOf(value),\n      variants,\n    })),\n    defaultVariants: merged.defaultVariants,\n    slots: [],\n    variants: Object.fromEntries(\n      Object.entries(merged.variants).map(\n        ([name, options]: readonly [\n          string,\n          Readonly<Record<string, readonly unknown[]>>,\n        ]) => [\n          name,\n          Object.fromEntries(\n            Object.entries(options).map(\n              ([option, values]: readonly [string, readonly unknown[]]) => [\n                option,\n                valueOf(values),\n              ],\n            ),\n          ),\n        ],\n      ),\n    ),\n  };\n}\n\nfunction hasOneValueAtMost(values: readonly unknown[]): boolean {\n  return values.length <= 1;\n}\n\n/** Compiles a recipe whose options or compound variants have value lists. */\nfunction compileValueLists(\n  kind: LooseRecipeKind,\n  merged: MergedLayers<unknown>,\n  base: unknown,\n): CompiledRecipe {\n  const { initial, reduce, finish = asResult } = kind;\n  const compiled = compileVariants<readonly unknown[]>({\n    ...merged,\n    noValue: noValues,\n  });\n  const reducer = { initial: (): unknown => initial(base), reduce };\n  const build = (indexes: Int32Array): unknown =>\n    finish(reduceValueLists(compiled, indexes, reducer));\n  return { build, compiled };\n}\n\nexport { compileLayer, compileMergedLayers };\nexport type { LooseKindRecipeConfig, LooseRecipeKind };\n","type UncheckedRecord = Readonly<Record<string, unknown>>;\n\n/** Checks a value of a slot recipe, such as an option's value. */\ntype CheckValue = (value: unknown, describe: () => string) => void;\n\nconst anyValue: CheckValue = () => {\n  // A recipe's values have the type of its kind, which the engine cannot check.\n};\n\nfunction isRecord(value: unknown): value is UncheckedRecord {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/** Checks a value of a slot recipe: undefined, or a value for each slot. */\nconst slotValues: CheckValue = (value, describe) => {\n  if (value !== undefined && !isRecord(value)) {\n    throw new TypeError(\n      `${describe()} needs an object of the value of each slot.`,\n    );\n  }\n};\n\nfunction checkVariants(variants: unknown, checkValue: CheckValue): void {\n  if (!isRecord(variants)) {\n    throw new TypeError(\n      \"A recipe's config needs `variants`, an object of the options of each variant. Use `variants: {}` for a recipe without variants.\",\n    );\n  }\n  for (const [name, options] of Object.entries(variants)) {\n    if (!isRecord(options)) {\n      throw new TypeError(\n        `The variant \"${name}\" needs an object of its options.`,\n      );\n    }\n    for (const [option, value] of Object.entries(options)) {\n      checkValue(\n        value,\n        () => `The option \"${option}\" of the variant \"${name}\"`,\n      );\n    }\n  }\n}\n\nfunction checkCompoundVariants(\n  compoundVariants: unknown,\n  checkValue: CheckValue,\n): void {\n  if (compoundVariants === undefined) {\n    return;\n  }\n  if (!Array.isArray(compoundVariants)) {\n    throw new TypeError(\n      \"`compoundVariants` needs an array of compound variants.\",\n    );\n  }\n  for (const [index, compound] of compoundVariants.entries()) {\n    const { variants, value } = isRecord(compound) ? compound : {};\n    if (!isRecord(variants)) {\n      throw new TypeError(\n        `Compound variant ${String(index)} needs \\`variants\\`, an object of the options it matches.`,\n      );\n    }\n    checkValue(\n      value,\n      () => `The \\`value\\` of compound variant ${String(index)}`,\n    );\n  }\n}\n\nfunction checkLayer(config: unknown, checkValue: CheckValue): UncheckedRecord {\n  if (!isRecord(config)) {\n    throw new TypeError(\"A recipe needs a config object.\");\n  }\n  const { variants, compoundVariants } = config;\n  checkVariants(variants, checkValue);\n  checkCompoundVariants(compoundVariants, checkValue);\n  return config;\n}\n\n/**\n * Checks the shape of a recipe's config, which its types already check, so\n * that a config from untyped code fails when the recipe is created, with a\n * message that names what is wrong.\n *\n * @returns The config.\n * @throws {TypeError} When `variants` or a compound variant's `variants` is\n *   not an object.\n */\nfunction checkRecipeConfig<Config>(config: Config): Config {\n  checkLayer(config, anyValue);\n  return config;\n}\n\n/**\n * Checks the shape of a slot recipe's config, as {@link checkRecipeConfig}\n * does, and that `slots` is an array and each value is an object of the\n * value of each slot.\n *\n * @returns The config.\n * @throws {TypeError} When a part of the config has the wrong shape.\n */\nfunction checkSlotRecipeConfig<Config>(config: Config): Config {\n  const { slots, base } = checkLayer(config, slotValues);\n  if (!Array.isArray(slots)) {\n    throw new TypeError(\n      \"A slot recipe's config needs `slots`, an array of the names of its slots.\",\n    );\n  }\n  slotValues(base, () => \"The `base` of a slot recipe\");\n  return config;\n}\n\nexport { checkRecipeConfig, checkSlotRecipeConfig };\n","import type { CompiledVariants, SelectedVariants } from \"./variants.js\";\nimport { noProps, select, undeclared } from \"./variants.js\";\n\n/** How a selector computes its results. */\ninterface SelectorOptions {\n  /** Whether to cache the result of each declared selection. */\n  readonly cache: boolean;\n}\n\n/** Whether `results` holds `result`, read at `key`, even if it is undefined. */\nfunction isCached<Result>(\n  results: ReadonlyMap<number, Result>,\n  key: number,\n  result: Result | undefined,\n): result is Result {\n  return result !== undefined || results.has(key);\n}\n\n/**\n * Returns a function that builds the result of a selection from the option\n * index of each variant, and treats a missing selection as an empty one.\n * With `options.cache`, it builds the result of each declared selection\n * once and caches it by the selection's key.\n */\nfunction createSelector<Result>(\n  compiled: CompiledVariants<unknown>,\n  build: (indexes: Int32Array) => Result,\n  options: SelectorOptions,\n): (selected?: SelectedVariants | null) => Result {\n  const indexes = new Int32Array(compiled.names.length);\n  const results =\n    options.cache && compiled.isCacheable\n      ? new Map<number, Result>()\n      : undefined;\n\n  return (selected) => {\n    const key = select(compiled, selected ?? noProps, indexes);\n    if (key !== undeclared && results !== undefined) {\n      const cachedResult = results.get(key);\n      if (isCached(results, key, cachedResult)) {\n        return cachedResult;\n      }\n    }\n    const result = build(indexes);\n    if (key !== undeclared) {\n      results?.set(key, result);\n    }\n    return result;\n  };\n}\n\nexport { createSelector };\nexport type { SelectorOptions };\n","import type {\n  Composable,\n  ComposableKindRecipe,\n  ComposedDefaultedName,\n  ComposedKindRecipe,\n  ComposedVariants,\n} from \"./composition.js\";\nimport type {\n  KindCompoundCondition,\n  KindDefaultVariants,\n  RecipeFunction,\n  RecipeKind,\n  SelectionDefaults,\n  VariantKey,\n  VariantOptions,\n} from \"./types.js\";\nimport type { LooseKindRecipeConfig, LooseRecipeKind } from \"./build-recipe.js\";\nimport type {\n  LooseVariants,\n  SelectedVariants,\n  WithVariants,\n} from \"./variants.js\";\nimport { compileLayer, compileMergedLayers } from \"./build-recipe.js\";\nimport { createRegistry, layerOf, mergeLayers } from \"./compose.js\";\nimport { checkRecipeConfig } from \"./check-config.js\";\nimport { createSelector } from \"./selector.js\";\nimport { withVariants } from \"./variants.js\";\n\nconst recipes = createRegistry<unknown>(\"recipe\");\n\n/**\n * The variants of a {@link KindRecipeConfig}: for each variant name, the\n * value of each of its options.\n *\n * @typeParam Value - The value of an option.\n */\ntype KindVariants<Value> = LooseVariants<Value>;\n\n/**\n * A value added when several variants have particular options at the same\n * time.\n *\n * @typeParam Variants - The variant definitions of the recipe.\n * @typeParam Value - The value of an option.\n */\ninterface KindCompoundVariant<Variants, Value> {\n  /**\n   * The options that must all be selected for\n   * {@link KindCompoundVariant.value} to apply.\n   */\n  readonly variants: KindCompoundCondition<Variants>;\n  /** The value added when the condition matches. */\n  readonly value: Value;\n}\n\n/**\n * The configuration of a recipe made from a {@link RecipeKind}.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Variants - The variant definitions, keyed by variant name.\n * @typeParam DefaultedName - The names of the variants that have a default.\n * @typeParam Composed - The types of the recipes that the recipe composes.\n */\ninterface KindRecipeConfig<\n  Value,\n  Variants extends KindVariants<Value>,\n  DefaultedName extends keyof ComposedVariants<Composed, Variants>,\n  Composed extends readonly ComposableKindRecipe<Value>[] = readonly [],\n> {\n  /**\n   * Recipes whose config the recipe adds to its own, in order, as if it\n   * were written in one config: their bases first, the values of each of\n   * their options before its own, and their compound variants first. A\n   * recipe composed several times counts once.\n   */\n  readonly composes?: Composed | undefined;\n  /** The value that the values of every selection are added to. */\n  readonly base?: Value | undefined;\n  /** For each variant name, the value of each of its options. */\n  readonly variants: Variants;\n  /**\n   * Values added when several variants have particular options at the same\n   * time, applied in order after the values of the variants' options.\n   */\n  readonly compoundVariants?:\n    | readonly KindCompoundVariant<\n        NoInfer<ComposedVariants<Composed, Variants>>,\n        Value\n      >[]\n    | undefined;\n  /** The option each variant uses when the recipe is called without it. */\n  readonly defaultVariants?:\n    | KindDefaultVariants<ComposedVariants<Composed, Variants>, DefaultedName>\n    | undefined;\n  /** Whether the recipe caches its results. Defaults to the kind's `cache`. */\n  readonly cache?: boolean | undefined;\n}\n\n/**\n * A recipe made from a {@link RecipeKind}: a function that returns the\n * result of a selection of variants, with the names of those variants in\n * `variantKeys`, the names of their options in `variantOptions`, and the\n * option each uses when a selection leaves it out in `defaultVariants`.\n *\n * @typeParam Selection - The variants the recipe accepts.\n * @typeParam Result - What the recipe returns.\n * @typeParam Composition - What the recipe passes on to the recipes that\n *   compose it, a `RecipeComposition`. Without it, the type does not\n *   allow composing the recipe.\n */\ntype KindRecipe<Selection, Result, Composition = unknown> = RecipeFunction<\n  Selection,\n  Result\n> & {\n  /**\n   * The names of the recipe's variants, in the order of\n   * `Object.keys(config.variants)`, after those of the recipes it\n   * composes.\n   */\n  readonly variantKeys: readonly VariantKey<Selection>[];\n  /**\n   * The names of the options of each variant, as strings, in the order in\n   * which the recipe numbers them: integer names first, then `\"false\"` and\n   * `\"true\"`, which a variant that declares either one has, then the\n   * others in the order of the config. A frozen object, keyed in the order\n   * of `variantKeys`.\n   */\n  readonly variantOptions: VariantOptions<Selection>;\n  /**\n   * The option, as a string, that each variant uses when a selection\n   * leaves it out: its default, or `\"false\"` for a variant whose only\n   * options are `\"true\"` and `\"false\"`. A frozen object, keyed in the\n   * order of `variantKeys`, without the variants that have no default.\n   */\n  readonly defaultVariants: SelectionDefaults<Selection>;\n} & Composable<Composition>;\n\n/**\n * Creates recipes of one kind, the function that {@link createRecipeKind}\n * returns.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Result - What a recipe of this kind returns.\n * @param config - The base value, variants, compound variants, and default\n *   variants of the recipe, and whether it caches its results.\n * @returns The recipe.\n */\ntype CreateKindRecipe<Value, Result> = <\n  const Variants extends KindVariants<Value>,\n  const DefaultedName extends keyof ComposedVariants<Composed, Variants> =\n    never,\n  const Composed extends readonly ComposableKindRecipe<Value>[] = readonly [],\n>(\n  config: KindRecipeConfig<Value, Variants, DefaultedName, Composed>,\n) => ComposedKindRecipe<\n  ComposedVariants<Composed, Variants>,\n  ComposedDefaultedName<Composed, DefaultedName>,\n  Value,\n  Result,\n  undefined\n>;\n\ntype LooseKindRecipe = WithVariants<\n  (selection?: SelectedVariants | null) => unknown\n>;\n\n/**\n * Creates a kind of recipe from how it turns the values of a selection into\n * its result, and returns the function that creates recipes of that kind.\n * A recipe maps a selection of variants to a result, as `cva` of\n * `@lynstack/class-recipe` does for class names, for values of any type,\n * such as style objects.\n *\n * @remarks\n * For each selection, a recipe reduces the value of each variant's selected\n * option and the value of each matching compound variant, with\n * `kind.reduce`, into the accumulator that `kind.initial` returns for the\n * recipe's base, then passes it to `kind.finish`. A variant whose only\n * options are `\"true\"` and `\"false\"` defaults to `false`, an option that the\n * config does not declare adds no value, and properties of the selection\n * that are not variants are ignored. A recipe's `variantKeys` property lists\n * the names of its variants, `variantOptions` the names of the options of\n * each, and `defaultVariants` the option each uses when a selection leaves\n * it out, so that a library can list every selection of a recipe.\n *\n * With the cache, a recipe builds the result of each declared selection\n * once, and calling it again with the same variants returns the same\n * result. Freeze an object result in `kind.finish` so that callers cannot\n * change a result that later calls share. A selection with an undeclared\n * option is built on every call. A recipe keeps up to one result for each\n * combination of declared options; set `cache: false` in the config of a\n * recipe whose variants come from untrusted input, which overrides the kind.\n *\n * When the variant names are not known at compile time, as in a library\n * that passes on a config it received, a recipe accepts any selection.\n *\n * A recipe composes the recipes listed in its config's `composes`, of any\n * kind whose values have its type, as if their configs and its own were one:\n * the accumulator starts from the first base, and the other bases are\n * reduced first; every option of each is declared, with its values reduced\n * in the order of the recipes; their compound variants come before its own;\n * and a variant's default is the last one given. A recipe composed several\n * times counts once. With `kind.combine`, the bases, and the values that\n * the recipes give one option, are combined into one when the recipe is\n * created, so that it reduces one value for each.\n *\n * @typeParam Value - The value of an option, inferred from the `value`\n *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.\n * @typeParam Accumulator - What the values are reduced to, inferred from\n *   `kind.initial`.\n * @typeParam Result - What a recipe returns, inferred from `kind.finish`,\n *   or the accumulator without it.\n * @param kind - How a recipe turns the values of a selection into its\n *   result, and whether it caches the result.\n * @returns The function that creates recipes of this kind.\n *\n * @example\n * ```ts\n * type Style = Readonly<Record<string, string | number>>;\n *\n * const styleRecipe = createRecipeKind({\n *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),\n *   reduce: (style, value: Style) => Object.assign(style, value),\n *   combine: (first, second) => ({ ...first, ...second }),\n *   finish: (style): Style => Object.freeze(style),\n * });\n *\n * const text = styleRecipe({\n *   base: { color: \"black\" },\n *   variants: {\n *     size: { sm: { fontSize: 12 }, lg: { fontSize: 24 } },\n *     muted: { true: { opacity: 0.6 } },\n *   },\n *   compoundVariants: [\n *     { variants: { size: \"lg\", muted: true }, value: { fontWeight: 300 } },\n *   ],\n *   defaultVariants: { size: \"sm\" },\n * });\n *\n * text(); // => { color: \"black\", fontSize: 12 }\n *\n * text({ size: \"lg\", muted: true });\n * // => { color: \"black\", fontSize: 24, opacity: 0.6, fontWeight: 300 }\n *\n * text.variantKeys; // => [\"size\", \"muted\"]\n * text.variantOptions; // => { size: [\"sm\", \"lg\"], muted: [\"false\", \"true\"] }\n * text.defaultVariants; // => { size: \"sm\", muted: \"false\" }\n *\n * const heading = styleRecipe({\n *   composes: [text],\n *   base: { fontWeight: 700 },\n *   variants: { size: { xl: { fontSize: 32 } } },\n * });\n *\n * heading({ size: \"xl\" });\n * // => { color: \"black\", fontWeight: 700, fontSize: 32 }\n * ```\n */\nfunction createRecipeKind<Value, Accumulator, Result = Accumulator>(\n  kind: RecipeKind<Value, Accumulator, Result>,\n): CreateKindRecipe<Value, Result>;\n\nfunction createRecipeKind(kind: LooseRecipeKind): unknown {\n  const kindCache = kind.cache ?? true;\n\n  return (config: LooseKindRecipeConfig): LooseKindRecipe => {\n    const own = layerOf(checkRecipeConfig(config), []);\n    const layers = recipes.layersOf(config.composes ?? [], own);\n    const { compiled, build } =\n      layers.length === 1\n        ? compileLayer(kind, own)\n        : compileMergedLayers(kind, mergeLayers(layers));\n    const options = { cache: config.cache ?? kindCache };\n    const recipe = createSelector(compiled, build, options);\n    return recipes.withLayers(withVariants(recipe, compiled), layers);\n  };\n}\n\nexport { createRecipeKind };\nexport type {\n  CreateKindRecipe,\n  KindCompoundVariant,\n  KindRecipe,\n  KindRecipeConfig,\n  KindVariants,\n};\n","import type { CompiledVariants, Compound } from \"./variants.js\";\nimport { combineValues } from \"./compose.js\";\nimport { matches } from \"./reduce-values.js\";\nimport { noOption } from \"./variants.js\";\n\n/** Values for some slots, keyed by slot name, as the runtime takes them. */\ntype LooseSlotValues = Readonly<Record<string, unknown>>;\n\n/** The values of the `false` option a boolean variant of a slot recipe adds. */\nconst noSlotValues: readonly LooseSlotValues[] = Object.freeze([]);\n\n/** How the values of each slot are reduced, as a recipe kind gives it. */\ninterface SlotsKind {\n  readonly initial: (base: unknown) => unknown;\n  readonly reduce: (accumulator: unknown, value: unknown) => unknown;\n  readonly combine?: ((first: unknown, second: unknown) => unknown) | undefined;\n  readonly finish?: ((accumulator: unknown) => unknown) | undefined;\n}\n\n/** The slots of a slot recipe and their bases, in the order of its layers. */\ninterface SlotsConfig {\n  readonly slots: readonly string[];\n  readonly bases: readonly LooseSlotValues[];\n}\n\n/**\n * The values that one option or compound variant adds to its slots: the\n * index of each slot it gives a value, and that value at the same position.\n * Slots without a value are left out, so reducing skips them.\n */\ninterface SlotEntries {\n  readonly slots: readonly number[];\n  readonly values: readonly unknown[];\n}\n\n/**\n * The accumulator of each slot while a selection is reduced, which\n * {@link addEntries} updates in place.\n */\ninterface SlotAccumulators {\n  readonly length: number;\n  [slot: number]: unknown;\n}\n\nfunction valueOfSlot(\n  values: LooseSlotValues | undefined,\n  slot: string,\n): unknown {\n  return values !== undefined && Object.hasOwn(values, slot)\n    ? values[slot]\n    : undefined;\n}\n\n/**\n * Returns the values of each slot in a list of values for some slots, in\n * the order of the list, combined into one with `combine` when the kind\n * has it.\n */\nfunction slotValuesOf(\n  slots: readonly string[],\n  valuesList: readonly LooseSlotValues[],\n  combine: SlotsKind[\"combine\"],\n): readonly (readonly unknown[])[] {\n  return slots.map((slot) => {\n    const values = valuesList.flatMap((each) =>\n      listOf(valueOfSlot(each, slot)),\n    );\n    return combine === undefined\n      ? values\n      : listOf(combineValues(values, combine));\n  });\n}\n\n/**\n * Returns the entries of the values of each slot, by slot index, or\n * undefined when no slot has one.\n */\nfunction entriesBySlot(\n  valuesBySlot: readonly (readonly unknown[])[],\n): SlotEntries | undefined {\n  const slotIndexes = valuesBySlot.flatMap((values, slot) =>\n    values.map(() => slot),\n  );\n  return slotIndexes.length === 0\n    ? undefined\n    : { slots: slotIndexes, values: valuesBySlot.flat() };\n}\n\nfunction listOf(value: unknown): readonly unknown[] {\n  return value === undefined ? [] : [value];\n}\n\n/** Turns the slot values of each option and compound variant into entries. */\nfunction compileEntries(\n  compiled: CompiledVariants<readonly LooseSlotValues[]>,\n  slots: readonly string[],\n  combine: SlotsKind[\"combine\"],\n): CompiledVariants<SlotEntries | undefined> {\n  const entriesOf = (\n    valuesList: readonly LooseSlotValues[],\n  ): SlotEntries | undefined =>\n    entriesBySlot(slotValuesOf(slots, valuesList, combine));\n  return {\n    ...compiled,\n    compounds: compiled.compounds\n      .map((compound): Compound<SlotEntries | undefined> => ({\n        conditions: compound.conditions,\n        value: entriesOf(compound.value),\n      }))\n      .filter((compound) => compound.value !== undefined),\n    valuesByIndex: compiled.valuesByIndex.map((valuesOfVariant) =>\n      valuesOfVariant.map((values) => entriesOf(values)),\n    ),\n  };\n}\n\n/** Reduces the values of `added` into the accumulators of their slots. */\nfunction addEntries(\n  accumulators: SlotAccumulators,\n  added: SlotEntries,\n  reduce: SlotsKind[\"reduce\"],\n): void {\n  const { slots, values } = added;\n  for (let entry = 0; entry < slots.length; entry += 1) {\n    const slot = slots[entry] ?? 0;\n    accumulators[slot] = reduce(accumulators[slot], values[entry]);\n  }\n}\n\n/**\n * The names of a slot recipe's slots, and an object with a property for\n * each, which results copy so that assigning a slot named `__proto__` sets\n * that property instead of the prototype.\n */\ninterface SlotNames {\n  readonly names: readonly string[];\n  readonly template: Readonly<Record<string, unknown>>;\n}\n\n/** Returns the frozen result of each slot, keyed by slot name. */\nfunction resultsBySlot(\n  slots: SlotNames,\n  accumulators: SlotAccumulators,\n  finish: (accumulator: unknown) => unknown,\n): Readonly<Record<string, unknown>> {\n  const { names } = slots;\n  const results: Record<string, unknown> = { ...slots.template };\n  for (let slot = 0; slot < names.length; slot += 1) {\n    results[names[slot] ?? \"\"] = finish(accumulators[slot]);\n  }\n  return Object.freeze(results);\n}\n\nconst asResult = (accumulator: unknown): unknown => accumulator;\n\n/**\n * Returns the function that builds the result of a selection for each slot\n * of a slot recipe: each slot reduces its own values with `kind`, and the\n * results are frozen in an object keyed by slot name.\n *\n * It reduces the values in a loop of its own instead of through\n * `reduceValues`, which recipes share, so that its calls to `kind.reduce`\n * see only the reducers of slot recipes and can be inlined.\n */\nfunction createSlotsBuilder(\n  kind: SlotsKind,\n  compiled: CompiledVariants<readonly LooseSlotValues[]>,\n  config: SlotsConfig,\n): (indexes: Int32Array) => Readonly<Record<string, unknown>> {\n  const { initial, reduce, combine, finish = asResult } = kind;\n  const names = [...config.slots];\n  const slotNames: SlotNames = {\n    names,\n    template: Object.fromEntries(names.map((slot) => [slot, undefined])),\n  };\n  const basesBySlot = slotValuesOf(names, config.bases, combine);\n  const bases = basesBySlot.map(([base]: readonly unknown[]) => base);\n  const otherBases = entriesBySlot(\n    basesBySlot.map(([, ...others]: readonly unknown[]) => others),\n  );\n  const { valuesByIndex, compounds } = compileEntries(compiled, names, combine);\n\n  /** Returns the accumulator of each slot, with every base reduced. */\n  const initialAccumulators = (): SlotAccumulators => {\n    const accumulators = bases.map((base) => initial(base));\n    if (otherBases !== undefined) {\n      addEntries(accumulators, otherBases, reduce);\n    }\n    return accumulators;\n  };\n\n  return (indexes) => {\n    const accumulators = initialAccumulators();\n    for (let variant = 0; variant < valuesByIndex.length; variant += 1) {\n      const added = valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n      if (added !== undefined) {\n        addEntries(accumulators, added, reduce);\n      }\n    }\n    for (const compound of compounds) {\n      if (compound.value !== undefined && matches(compound, indexes)) {\n        addEntries(accumulators, compound.value, reduce);\n      }\n    }\n    return resultsBySlot(slotNames, accumulators, finish);\n  };\n}\n\nexport { createSlotsBuilder, noSlotValues };\nexport type { LooseSlotValues, SlotsKind };\n","import type {\n  ComposableKindSlotRecipe,\n  ComposedDefaultedName,\n  ComposedKindRecipe,\n  ComposedSlot,\n  ComposedVariants,\n} from \"./composition.js\";\nimport type {\n  KindCompoundCondition,\n  KindDefaultVariants,\n  NoUnknownSlots,\n  RecipeKind,\n} from \"./types.js\";\nimport type { LooseSlotValues, SlotsKind } from \"./slots.js\";\nimport type { SelectedVariants, WithVariants } from \"./variants.js\";\nimport { compileVariants, withVariants } from \"./variants.js\";\nimport { createRegistry, layerOf, mergeLayers } from \"./compose.js\";\nimport { createSlotsBuilder, noSlotValues } from \"./slots.js\";\nimport type { KindVariants } from \"./recipe-kind.js\";\nimport { checkSlotRecipeConfig } from \"./check-config.js\";\nimport { createSelector } from \"./selector.js\";\n\nconst slotRecipes = createRegistry<LooseSlotValues>(\"slot recipe\");\n\n/**\n * Values for some of a slot recipe's slots, keyed by slot name.\n *\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n */\ntype SlotValues<Slot extends string, Value> = Readonly<\n  Partial<Record<Slot, Value | undefined>>\n>;\n\n/**\n * The variants of a {@link KindSlotRecipeConfig}: for each variant name,\n * the values of each slot for each of its options.\n *\n * @typeParam Value - The value of a slot.\n */\ntype KindSlotVariants<Value> = KindVariants<SlotValues<string, Value>>;\n\n/**\n * Values added to some slots when several variants have particular options\n * at the same time.\n *\n * @typeParam Variants - The variant definitions of the slot recipe.\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n */\ninterface KindSlotCompoundVariant<Variants, Slot extends string, Value> {\n  /**\n   * The options that must all be selected for\n   * {@link KindSlotCompoundVariant.value} to apply.\n   */\n  readonly variants: KindCompoundCondition<Variants>;\n  /** The value added to each slot when the condition matches. */\n  readonly value: SlotValues<Slot, Value>;\n}\n\n/**\n * The configuration of a slot recipe made from a {@link RecipeKind}.\n *\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n * @typeParam Variants - The variant definitions, keyed by variant name.\n * @typeParam DefaultedName - The names of the variants that have a default.\n */\ninterface KindSlotRecipeConfig<\n  Slot extends string,\n  Value,\n  Variants extends KindSlotVariants<Value>,\n  DefaultedName extends keyof ComposedVariants<Composed, Variants>,\n  Composed extends readonly ComposableKindSlotRecipe<Value>[] = readonly [],\n> {\n  /**\n   * Slot recipes whose config the recipe adds to its own, in order, as if\n   * it were written in one config: their slots and bases first, the values\n   * of each of their options before its own, and their compound variants\n   * first. A slot recipe composed several times counts once.\n   */\n  readonly composes?: Composed | undefined;\n  /**\n   * The names of the slots, in the order of the recipe's result, after\n   * those of the slot recipes it composes.\n   */\n  readonly slots: readonly Slot[];\n  /** The value of each slot that the values of every selection are added to. */\n  readonly base?:\n    SlotValues<NoInfer<ComposedSlot<Composed, Slot>>, Value> | undefined;\n  /** For each variant name, the values of each slot for each of its options. */\n  readonly variants: Variants &\n    NoUnknownSlots<Variants, NoInfer<ComposedSlot<Composed, Slot>>>;\n  /**\n   * Values added to some slots when several variants have particular\n   * options at the same time, applied in order after the values of the\n   * variants' options.\n   */\n  readonly compoundVariants?:\n    | readonly KindSlotCompoundVariant<\n        NoInfer<ComposedVariants<Composed, Variants>>,\n        NoInfer<ComposedSlot<Composed, Slot>>,\n        Value\n      >[]\n    | undefined;\n  /** The option each variant uses when the recipe is called without it. */\n  readonly defaultVariants?:\n    | KindDefaultVariants<ComposedVariants<Composed, Variants>, DefaultedName>\n    | undefined;\n  /** Whether the recipe caches its results. Defaults to the kind's `cache`. */\n  readonly cache?: boolean | undefined;\n}\n\n/**\n * Creates slot recipes of one kind, the function that\n * {@link createSlotRecipeKind} returns.\n *\n * @typeParam Value - The value of a slot.\n * @typeParam Result - What a recipe of this kind returns for each slot.\n * @param config - The slot recipes it composes, and the slots, base values,\n *   variants, compound variants, and default variants of the slot recipe,\n *   and whether it caches its results.\n * @returns The slot recipe.\n */\ntype CreateKindSlotRecipe<Value, Result> = <\n  const Slot extends string,\n  const Variants extends KindSlotVariants<Value>,\n  const DefaultedName extends keyof ComposedVariants<Composed, Variants> =\n    never,\n  const Composed extends readonly ComposableKindSlotRecipe<Value>[] =\n    readonly [],\n>(\n  config: KindSlotRecipeConfig<Slot, Value, Variants, DefaultedName, Composed>,\n) => ComposedKindRecipe<\n  ComposedVariants<Composed, Variants>,\n  ComposedDefaultedName<Composed, DefaultedName>,\n  Value,\n  Readonly<Record<ComposedSlot<Composed, Slot>, Result>>,\n  readonly ComposedSlot<Composed, Slot>[]\n>;\n\ninterface LooseRecipeKind extends SlotsKind {\n  readonly cache?: boolean | undefined;\n}\n\ninterface LooseSlotRecipeConfig {\n  readonly composes?: readonly unknown[] | undefined;\n  readonly slots: readonly string[];\n  readonly base?: LooseSlotValues | undefined;\n  readonly variants: KindSlotVariants<unknown>;\n  readonly compoundVariants?:\n    | readonly {\n        readonly variants: SelectedVariants;\n        readonly value: LooseSlotValues;\n      }[]\n    | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n  readonly cache?: boolean | undefined;\n}\n\ntype LooseSlotRecipe = WithVariants<\n  (selection?: SelectedVariants | null) => Readonly<Record<string, unknown>>\n>;\n\n/**\n * Creates a kind of slot recipe from how it turns the values of each slot\n * into that slot's result, and returns the function that creates slot\n * recipes of that kind. A slot recipe maps a selection of variants to the\n * result of each of several slots, such as the class names or the styles of\n * the elements of a component, as `sva` of `@lynstack/class-recipe` does.\n *\n * @remarks\n * A slot recipe reduces the values of each slot as a recipe of the same\n * kind from {@link createRecipeKind} would: `kind.initial` returns the\n * accumulator for the slot's base value, `kind.reduce` adds the slot's\n * value of each variant's selected option, in the order of `variants`, and\n * of each matching compound variant, in the order of `compoundVariants`,\n * and `kind.finish` turns the accumulator into the slot's result. A slot\n * without values gets the result of its accumulator for an `undefined`\n * base, so every slot is in the result.\n *\n * The result is a frozen object of each slot's result, keyed by slot name\n * in the order of `slots`. With the cache, a slot recipe builds it once for\n * each declared selection and returns the same object for the same\n * variants. The `cache` of a slot recipe's config overrides the kind's.\n * Variants, boolean variants, undeclared options, and the `variantKeys`,\n * `variantOptions`, and `defaultVariants` properties are as in\n * {@link createRecipeKind}.\n *\n * A slot recipe composes the slot recipes listed in `composes` as a recipe\n * composes recipes, and has the slots of each, theirs first. With\n * `kind.combine`, the values of each slot are combined as a recipe's are.\n *\n * @typeParam Value - The value of a slot, inferred from the `value`\n *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.\n * @typeParam Accumulator - What the values of a slot are reduced to,\n *   inferred from `kind.initial`.\n * @typeParam Result - What a slot recipe returns for each slot, inferred\n *   from `kind.finish`, or the accumulator without it.\n * @param kind - How a slot recipe turns the values of each slot into its\n *   result, and whether it caches its results. The same kind can create\n *   recipes with {@link createRecipeKind}.\n * @returns The function that creates slot recipes of this kind.\n *\n * @example\n * ```ts\n * type Style = Readonly<Record<string, string | number>>;\n *\n * const styleKind = {\n *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),\n *   reduce: (style: Record<string, string | number>, value: Style) =>\n *     Object.assign(style, value),\n *   finish: (style: Record<string, string | number>): Style =>\n *     Object.freeze(style),\n * };\n *\n * const slotStyleRecipe = createSlotRecipeKind(styleKind);\n *\n * const card = slotStyleRecipe({\n *   slots: [\"root\", \"title\"],\n *   base: { root: { padding: 16 }, title: { fontSize: 18 } },\n *   variants: {\n *     tone: {\n *       light: { root: { backgroundColor: \"white\" } },\n *       dark: { root: { backgroundColor: \"black\" }, title: { color: \"white\" } },\n *     },\n *   },\n *   compoundVariants: [\n *     { variants: { tone: \"dark\" }, value: { title: { fontWeight: 600 } } },\n *   ],\n *   defaultVariants: { tone: \"light\" },\n * });\n *\n * card();\n * // => { root: { padding: 16, backgroundColor: \"white\" }, title: { fontSize: 18 } }\n *\n * card({ tone: \"dark\" });\n * // => {\n * //   root: { padding: 16, backgroundColor: \"black\" },\n * //   title: { fontSize: 18, color: \"white\", fontWeight: 600 },\n * // }\n *\n * card.variantOptions; // => { tone: [\"light\", \"dark\"] }\n * card.defaultVariants; // => { tone: \"light\" }\n *\n * const dialog = slotStyleRecipe({\n *   composes: [card],\n *   slots: [\"footer\"],\n *   variants: { tone: { dark: { footer: { borderColor: \"white\" } } } },\n * });\n *\n * dialog({ tone: \"dark\" }).footer; // => { borderColor: \"white\" }\n * ```\n */\nfunction createSlotRecipeKind<Value, Accumulator, Result = Accumulator>(\n  kind: RecipeKind<Value, Accumulator, Result>,\n): CreateKindSlotRecipe<Value, Result>;\n\nfunction createSlotRecipeKind(kind: LooseRecipeKind): unknown {\n  const kindCache = kind.cache ?? true;\n\n  return (config: LooseSlotRecipeConfig): LooseSlotRecipe => {\n    const own = layerOf(checkSlotRecipeConfig(config), config.slots);\n    const layers = slotRecipes.layersOf(config.composes ?? [], own);\n    const merged = mergeLayers(layers);\n    const compiled = compileVariants<readonly LooseSlotValues[]>({\n      ...merged,\n      noValue: noSlotValues,\n    });\n    const build = createSlotsBuilder(kind, compiled, merged);\n    const options = { cache: config.cache ?? kindCache };\n    const recipe = createSelector(compiled, build, options);\n    return slotRecipes.withLayers(withVariants(recipe, compiled), layers);\n  };\n}\n\nexport { createSlotRecipeKind };\nexport type {\n  CreateKindSlotRecipe,\n  KindSlotCompoundVariant,\n  KindSlotRecipeConfig,\n  KindSlotVariants,\n  SlotValues,\n};\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["isBooleanName","listOf","asResult"],"sources":["../src/variants.ts","../src/reduce-values.ts","../src/compose.ts","../src/build-recipe.ts","../src/check-config.ts","../src/selector.ts","../src/check-names.ts","../src/recipe-kind.ts","../src/slots.ts","../src/slot-recipe-kind.ts"],"sourcesContent":["/**\n * Variant definitions in the loose shape the runtime works with: for each\n * variant name, the value of each of its options.\n */\ntype LooseVariants<Value> = Readonly<\n  Record<string, Readonly<Record<string, Value>>>\n>;\n\n/** A selection in the loose shape the runtime works with. */\ntype SelectedVariants = Readonly<Record<string, unknown>>;\n\n/** A compound variant in the loose shape the runtime works with. */\ninterface LooseCompoundVariant<Value> {\n  readonly variants: SelectedVariants;\n  readonly value: Value;\n}\n\n/** The variant's index and the option indexes that a condition matches. */\ntype CompoundCondition = readonly [number, readonly number[]];\n\n/** A compound variant prepared for matching. */\ninterface Compound<Value> {\n  readonly conditions: readonly CompoundCondition[];\n  readonly value: Value;\n}\n\n/** What {@link compileVariants} prepares. */\ninterface VariantsConfig<Value> {\n  readonly variants: LooseVariants<Value>;\n  readonly defaultVariants: SelectedVariants;\n  readonly compoundVariants: readonly LooseCompoundVariant<Value>[];\n  /**\n   * The value of a variant without a selected option, and of a boolean\n   * option that the variant does not declare.\n   */\n  readonly noValue: Value;\n}\n\n/**\n * Variants prepared for selecting values. Each variant numbers its options\n * from 1, and 0 stands for no option, so a selection is a list of option\n * indexes. Read together as the digits of a mixed-radix number, they form\n * the selection's key.\n */\ninterface CompiledVariants<Value> {\n  readonly names: readonly string[];\n  readonly defaultOptions: readonly (string | undefined)[];\n  readonly indexByOption: readonly ReadonlyMap<string, number>[];\n  /** The value of each variant's options, by option index. */\n  readonly valuesByIndex: readonly (readonly Value[])[];\n  readonly strides: readonly number[];\n  readonly compounds: readonly Compound<Value>[];\n  /** Whether every selection's key is a safe integer. */\n  readonly isCacheable: boolean;\n}\n\n/** The option index of a variant without a selected option. */\nconst noOption = 0;\n\n/** The key of a selection with an option that a variant does not declare. */\nconst undeclared = -1;\n\nconst noProps: SelectedVariants = Object.freeze({});\n\n/**\n * Prepares variants for selecting values. A variant that declares an option\n * named `\"true\"` or `\"false\"` also declares the other one, with\n * `config.noValue`, and a variant whose only options are those defaults to\n * `\"false\"`. A compound variant that names an undeclared variant or option,\n * or lists no option for a variant, never matches and is left out.\n */\nfunction compileVariants<Value>(\n  config: VariantsConfig<Value>,\n): CompiledVariants<Value> {\n  const names = Object.keys(config.variants);\n  const optionValues = names.map((name) =>\n    withBooleanOptions(config.variants[name] ?? {}, config.noValue),\n  );\n  const indexByOption: readonly ReadonlyMap<string, number>[] =\n    optionValues.map(\n      (valuesByOption) =>\n        new Map(\n          Object.keys(valuesByOption).map((option, index) => [\n            option,\n            index + 1,\n          ]),\n        ),\n    );\n  const radixes = indexByOption.map((indexes) => indexes.size + 1);\n\n  return {\n    compounds: compileCompounds(config.compoundVariants, names, indexByOption),\n    defaultOptions: names.map(\n      (name, index) =>\n        toOptionName(config.defaultVariants[name]) ??\n        (isBooleanVariant(indexByOption[index]) ? \"false\" : undefined),\n    ),\n    indexByOption,\n    isCacheable: product(radixes) <= Number.MAX_SAFE_INTEGER,\n    names,\n    strides: radixes.map((_radix, index) => product(radixes.slice(0, index))),\n    valuesByIndex: valuesByIndexOf(optionValues, config.noValue),\n  };\n}\n\n/**\n * Writes the option index of each variant for `selected` into `indexes`\n * and returns the selection's key, or {@link undeclared} when an option is\n * not declared.\n */\nfunction select(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  indexes: Int32Array,\n): number {\n  let key = 0;\n  for (let variant = 0; variant < compiled.names.length; variant += 1) {\n    const index = selectIndex(compiled, selected, variant);\n    indexes[variant] = index ?? noOption;\n    key =\n      index === undefined || key === undeclared\n        ? undeclared\n        : key + index * (compiled.strides[variant] ?? 0);\n  }\n  return key;\n}\n\nfunction selectIndex(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  variant: number,\n): number | undefined {\n  const option =\n    toOptionName(selected[compiled.names[variant] ?? \"\"]) ??\n    compiled.defaultOptions[variant];\n  return option === undefined\n    ? noOption\n    : compiled.indexByOption[variant]?.get(option);\n}\n\nfunction valuesByIndexOf<Value>(\n  optionValues: readonly Readonly<Record<string, Value>>[],\n  noValue: Value,\n): Value[][] {\n  const valuesByIndex: Value[][] = [];\n  for (const valuesByOption of optionValues) {\n    valuesByIndex.push([noValue, ...Object.values(valuesByOption)]);\n  }\n  return valuesByIndex;\n}\n\nfunction product(numbers: readonly number[]): number {\n  return numbers.reduce((result, number) => result * number, 1);\n}\n\nfunction withBooleanOptions<Value>(\n  valuesByOption: Readonly<Record<string, Value>>,\n  noValue: Value,\n): Readonly<Record<string, Value>> {\n  const optionNames = Object.keys(valuesByOption);\n  if (!optionNames.some((option) => isBooleanName(option))) {\n    return valuesByOption;\n  }\n  return { false: noValue, true: noValue, ...valuesByOption };\n}\n\nfunction compileCompounds<Value>(\n  compoundVariants: readonly LooseCompoundVariant<Value>[],\n  names: readonly string[],\n  indexByOption: readonly ReadonlyMap<string, number>[],\n): Compound<Value>[] {\n  return compoundVariants.flatMap(({ variants, value }) => {\n    const conditions = Object.keys(variants)\n      .filter((name) => variants[name] !== undefined)\n      .map((name) =>\n        compileCondition(indexByOption, names.indexOf(name), variants[name]),\n      );\n    return conditions.every(([, indexes]) => indexes.length > 0)\n      ? [{ conditions, value }]\n      : [];\n  });\n}\n\nfunction compileCondition(\n  indexByOption: readonly ReadonlyMap<string, number>[],\n  variant: number,\n  value: unknown,\n): CompoundCondition {\n  const indexes = indexByOption[variant];\n  return [\n    variant,\n    toOptionNames(value)\n      .map((option) => indexes?.get(option))\n      .filter((index): index is number => index !== undefined),\n  ];\n}\n\nfunction isBooleanVariant(\n  indexByOption: ReadonlyMap<string, number> | undefined,\n): boolean {\n  return (\n    indexByOption !== undefined &&\n    indexByOption.size > 0 &&\n    [...indexByOption.keys()].every((option) => isBooleanName(option))\n  );\n}\n\nfunction toOptionName(value: unknown): string | undefined {\n  if (typeof value === \"string\") {\n    return value;\n  }\n  return typeof value === \"number\" || typeof value === \"boolean\"\n    ? String(value)\n    : undefined;\n}\n\nfunction toOptionNames(value: unknown): readonly string[] {\n  const values: readonly unknown[] = Array.isArray(value) ? value : [value];\n  return values\n    .map((option) => toOptionName(option))\n    .filter((option): option is string => option !== undefined);\n}\n\n/** A recipe function with the names, options, and defaults of its variants. */\ntype WithVariants<Recipe> = Recipe & {\n  readonly variantKeys: readonly string[];\n  readonly variantOptions: Readonly<Record<string, readonly string[]>>;\n  readonly defaultVariants: Readonly<Record<string, string>>;\n};\n\n/**\n * Adds the names of the compiled variants to `recipe` as `variantKeys`,\n * the names of their options as `variantOptions`, and the option each\n * variant uses when a selection leaves it out as `defaultVariants`.\n */\nfunction withVariants<Recipe extends object>(\n  recipe: Recipe,\n  compiled: CompiledVariants<unknown>,\n): WithVariants<Recipe> {\n  return Object.assign(recipe, {\n    defaultVariants: Object.freeze(defaultVariantsOf(compiled)),\n    variantKeys: Object.freeze([...compiled.names]),\n    variantOptions: Object.freeze(variantOptionsOf(compiled)),\n  });\n}\n\nfunction variantOptionsOf(\n  compiled: CompiledVariants<unknown>,\n): Record<string, readonly string[]> {\n  const entries = compiled.names.map((name, index) => {\n    const options = compiled.indexByOption[index]?.keys() ?? [];\n    return [name, Object.freeze([...options])] as const;\n  });\n  return Object.fromEntries(entries);\n}\n\nfunction defaultVariantsOf(\n  compiled: CompiledVariants<unknown>,\n): Record<string, string> {\n  const entries = compiled.names.flatMap((name, index) => {\n    const option = compiled.defaultOptions[index];\n    return option === undefined ? [] : [[name, option] as const];\n  });\n  return Object.fromEntries(entries);\n}\n\nfunction isBooleanName(option: string): boolean {\n  return option === \"true\" || option === \"false\";\n}\n\nexport {\n  compileVariants,\n  noOption,\n  noProps,\n  select,\n  toOptionName,\n  toOptionNames,\n  undeclared,\n  withVariants,\n};\nexport type {\n  CompiledVariants,\n  Compound,\n  LooseCompoundVariant,\n  LooseVariants,\n  SelectedVariants,\n  WithVariants,\n};\n","import type { CompiledVariants, Compound } from \"./variants.js\";\nimport { noOption } from \"./variants.js\";\n\n/** Whether every condition of `compound` matches the selected indexes. */\nfunction matches(compound: Compound<unknown>, indexes: Int32Array): boolean {\n  for (const [variant, matchingIndexes] of compound.conditions) {\n    if (!matchingIndexes.includes(indexes[variant] ?? noOption)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Reduces the values of a selection to an accumulator. */\ninterface Reducer<Value, Accumulator> {\n  /** Returns the accumulator to start from. */\n  readonly initial: () => Accumulator;\n  /** Adds a value to the accumulator and returns the accumulator. */\n  readonly reduce: (accumulator: Accumulator, value: Value) => Accumulator;\n}\n\n/**\n * Reduces the values that apply to a selection, in order of precedence: the\n * value of each variant's option, then the value of each matching compound\n * variant. A value that is undefined adds nothing.\n */\nfunction reduceValues<Value, Accumulator>(\n  compiled: CompiledVariants<Value | undefined>,\n  indexes: Int32Array,\n  reducer: Reducer<Value, Accumulator>,\n): Accumulator {\n  const { reduce } = reducer;\n  let accumulator = reducer.initial();\n  for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {\n    const value =\n      compiled.valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n    if (value !== undefined) {\n      accumulator = reduce(accumulator, value);\n    }\n  }\n  for (const compound of compiled.compounds) {\n    if (compound.value !== undefined && matches(compound, indexes)) {\n      accumulator = reduce(accumulator, compound.value);\n    }\n  }\n  return accumulator;\n}\n\n/**\n * Reduces the values that apply to a selection, as {@link reduceValues}\n * does, when each option and compound variant has a list of values, which\n * are reduced in order.\n */\nfunction reduceValueLists<Value, Accumulator>(\n  compiled: CompiledVariants<readonly Value[]>,\n  indexes: Int32Array,\n  reducer: Reducer<Value, Accumulator>,\n): Accumulator {\n  const { reduce } = reducer;\n  let accumulator = reducer.initial();\n  for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {\n    const values =\n      compiled.valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n    accumulator = reduceEach(accumulator, values ?? [], reduce);\n  }\n  for (const compound of compiled.compounds) {\n    if (matches(compound, indexes)) {\n      accumulator = reduceEach(accumulator, compound.value, reduce);\n    }\n  }\n  return accumulator;\n}\n\n/** Reduces `values` into `accumulator`, in order. */\nfunction reduceEach<Value, Accumulator>(\n  accumulator: Accumulator,\n  values: readonly Value[],\n  reduce: Reducer<Value, Accumulator>[\"reduce\"],\n): Accumulator {\n  let result = accumulator;\n  for (const value of values) {\n    result = reduce(result, value);\n  }\n  return result;\n}\n\nexport { matches, reduceEach, reduceValueLists, reduceValues };\n","import type {\n  LooseCompoundVariant,\n  LooseVariants,\n  SelectedVariants,\n} from \"./variants.js\";\n\n/** Whether a recipe has slots, which decides the recipes it composes. */\ntype RecipeType = \"recipe\" | \"slot recipe\";\n\n/**\n * The values of one config that a recipe is made of: its own config, or\n * that of a recipe it composes.\n */\ninterface Layer<Value> {\n  readonly slots: readonly string[];\n  readonly base: Value | undefined;\n  readonly variants: LooseVariants<Value>;\n  readonly compoundVariants: readonly LooseCompoundVariant<Value>[];\n  readonly defaultVariants: SelectedVariants;\n}\n\n/** What a recipe's config gives for its layer. */\ninterface LayerConfig<Value> {\n  readonly base?: Value | undefined;\n  readonly variants: LooseVariants<Value>;\n  readonly compoundVariants?:\n    readonly LooseCompoundVariant<Value>[] | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n}\n\n/**\n * Returns the layer of a recipe's own config, with copies of its records,\n * so that changing the config later changes no recipe that composes it.\n */\nfunction layerOf<Value>(\n  config: LayerConfig<Value>,\n  slots: readonly string[],\n): Layer<Value> {\n  return {\n    base: config.base,\n    compoundVariants: (config.compoundVariants ?? []).map(\n      ({ variants, value }) => ({ value, variants: { ...variants } }),\n    ),\n    defaultVariants: { ...config.defaultVariants },\n    slots: [...slots],\n    variants: Object.fromEntries(\n      Object.entries(config.variants).map(\n        ([name, options]: readonly [\n          string,\n          Readonly<Record<string, Value>>,\n        ]) => [name, { ...options }],\n      ),\n    ),\n  };\n}\n\n/** The layers of the recipes of one type, which the engine created. */\ninterface Registry<Value> {\n  /**\n   * Returns the layers of a recipe: those of each recipe it composes, in\n   * order, each only at its first occurrence, then its own.\n   *\n   * @throws TypeError when a recipe it composes is not in the registry.\n   */\n  readonly layersOf: (\n    composes: readonly unknown[],\n    own: Layer<Value>,\n  ) => readonly Layer<Value>[];\n  /** Records the layers of `recipe`, so that other recipes can compose it. */\n  readonly withLayers: <Recipe extends object>(\n    recipe: Recipe,\n    layers: readonly Layer<Value>[],\n  ) => Recipe;\n}\n\n/** Returns an empty registry of recipes of type `type`. */\nfunction createRegistry<Value>(type: RecipeType): Registry<Value> {\n  const layersByRecipe = new WeakMap<object, readonly Layer<Value>[]>();\n\n  const layersOfRecipe = (recipe: unknown): readonly Layer<Value>[] => {\n    const layers =\n      typeof recipe === \"function\" ? layersByRecipe.get(recipe) : undefined;\n    if (layers === undefined) {\n      throw new TypeError(\n        `A ${type} composes only ${type}s created by @lynstack/recipe. ` +\n          \"Check that the app installs one copy of @lynstack/recipe.\",\n      );\n    }\n    return layers;\n  };\n\n  return {\n    layersOf: (composes, own) => [\n      ...new Set([\n        ...composes.flatMap((recipe) => layersOfRecipe(recipe)),\n        own,\n      ]),\n    ],\n    withLayers: (recipe, layers) => {\n      layersByRecipe.set(recipe, layers);\n      return recipe;\n    },\n  };\n}\n\n/**\n * The layers of a recipe merged into one config, in which every option and\n * compound variant has the list of its values, in the order of the layers.\n */\ninterface MergedLayers<Value> {\n  /** The slots of every layer, each once, in order. */\n  readonly slots: readonly string[];\n  /** The base of each layer that has one. */\n  readonly bases: readonly Value[];\n  readonly variants: LooseVariants<readonly Value[]>;\n  readonly compoundVariants: readonly LooseCompoundVariant<readonly Value[]>[];\n  readonly defaultVariants: SelectedVariants;\n}\n\n/**\n * Merges layers into one config: the union of their slots, of their\n * variants, and of the options of each, the values of each option in the\n * order of the layers, their compound variants in order, and the default\n * of each variant from the last layer that gives one.\n */\nfunction mergeLayers<Value>(\n  layers: readonly Layer<Value>[],\n): MergedLayers<Value> {\n  const variantNames = unique(\n    layers.flatMap((layer) => Object.keys(layer.variants)),\n  );\n  return {\n    bases: layers.flatMap(({ base }) => listOf(base)),\n    compoundVariants: layers.flatMap((layer) =>\n      layer.compoundVariants.map(({ variants, value }) => ({\n        value: listOf(value),\n        variants,\n      })),\n    ),\n    defaultVariants: Object.fromEntries(\n      layers.flatMap((layer) =>\n        Object.entries(layer.defaultVariants).filter(\n          ([, option]: readonly [string, unknown]) => option !== undefined,\n        ),\n      ),\n    ),\n    slots: unique(layers.flatMap(({ slots }) => slots)),\n    variants: Object.fromEntries(\n      variantNames.map((name) => [name, mergeOptions(layers, name)]),\n    ),\n  };\n}\n\n/** The options of the variant `name` in any layer, with their values. */\nfunction mergeOptions<Value>(\n  layers: readonly Layer<Value>[],\n  name: string,\n): Readonly<Record<string, readonly Value[]>> {\n  const optionsOfLayers = layers.map(\n    (layer) => ownValue(layer.variants, name) ?? {},\n  );\n  const optionNames = unique(\n    optionsOfLayers.flatMap((options) => Object.keys(options)),\n  );\n  return Object.fromEntries(\n    optionNames.map((option) => [\n      option,\n      optionsOfLayers.flatMap((options) => listOf(ownValue(options, option))),\n    ]),\n  );\n}\n\n/**\n * Combines values, none of them undefined, into one with `combine`, in\n * order, or returns undefined when there are none.\n */\nfunction combineValues<Value>(\n  values: readonly Value[],\n  combine: (first: Value, second: Value) => Value,\n): Value | undefined {\n  let combined: Value | undefined = undefined;\n  for (const value of values) {\n    combined = combined === undefined ? value : combine(combined, value);\n  }\n  return combined;\n}\n\nfunction ownValue<Value>(\n  record: Readonly<Record<string, Value>>,\n  key: string,\n): Value | undefined {\n  return Object.hasOwn(record, key) ? record[key] : undefined;\n}\n\nfunction listOf<Value>(value: Value | undefined): readonly Value[] {\n  return value === undefined ? [] : [value];\n}\n\nfunction unique(names: readonly string[]): readonly string[] {\n  return [...new Set(names)];\n}\n\nexport { combineValues, createRegistry, layerOf, mergeLayers };\nexport type { Layer, MergedLayers, Registry };\n","import type { CompiledVariants, SelectedVariants } from \"./variants.js\";\nimport type { Layer, MergedLayers } from \"./compose.js\";\nimport { reduceEach, reduceValueLists, reduceValues } from \"./reduce-values.js\";\nimport type { KindVariants } from \"./recipe-kind.js\";\nimport { combineValues } from \"./compose.js\";\nimport { compileVariants } from \"./variants.js\";\n\n/** A recipe kind in the loose shape the runtime works with. */\ninterface LooseRecipeKind {\n  readonly initial: (base: unknown) => unknown;\n  readonly reduce: (accumulator: unknown, value: unknown) => unknown;\n  readonly combine?: ((first: unknown, second: unknown) => unknown) | undefined;\n  readonly finish?: ((accumulator: unknown) => unknown) | undefined;\n  readonly cache?: boolean | undefined;\n}\n\ninterface LooseKindRecipeConfig {\n  readonly composes?: readonly unknown[] | undefined;\n  readonly base?: unknown;\n  readonly variants: KindVariants<unknown>;\n  readonly compoundVariants?:\n    | readonly {\n        readonly variants: SelectedVariants;\n        readonly value: unknown;\n      }[]\n    | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n  readonly cache?: boolean | undefined;\n}\n\n/** The variants of a recipe, and how it builds the result of a selection. */\ninterface CompiledRecipe {\n  readonly compiled: CompiledVariants<unknown>;\n  readonly build: (indexes: Int32Array) => unknown;\n}\n\nconst asResult = (accumulator: unknown): unknown => accumulator;\n\nconst noValues: readonly unknown[] = Object.freeze([]);\n\nconst firstValue = (values: readonly unknown[]): unknown => values[0];\n\n/** Compiles a recipe that composes no other recipe. */\nfunction compileLayer(\n  kind: LooseRecipeKind,\n  layer: Layer<unknown>,\n): CompiledRecipe {\n  const { initial, reduce, finish } = kind;\n  const { base } = layer;\n  const compiled = compileVariants<unknown>({ ...layer, noValue: undefined });\n  const reducer = { initial: (): unknown => initial(base), reduce };\n  const build =\n    finish === undefined\n      ? (indexes: Int32Array): unknown =>\n          reduceValues(compiled, indexes, reducer)\n      : (indexes: Int32Array): unknown =>\n          finish(reduceValues(compiled, indexes, reducer));\n  return { build, compiled };\n}\n\n/**\n * Compiles a recipe from the merged layers of the recipes it composes and\n * its own. With `kind.combine`, it combines the bases and the values of\n * each option and compiles them as one config. Without it, its accumulator\n * starts from the first base, and the other bases are reduced into it\n * first; when no option or compound variant has more than one value, it\n * compiles them as one config.\n */\nfunction compileMergedLayers(\n  kind: LooseRecipeKind,\n  merged: MergedLayers<unknown>,\n): CompiledRecipe {\n  const { combine } = kind;\n  if (combine !== undefined) {\n    const combined = (values: readonly unknown[]): unknown =>\n      combineValues(values, combine);\n    return compileLayer(\n      kind,\n      layerOfMerged(merged, combined(merged.bases), combined),\n    );\n  }\n  const [base, ...otherBases] = merged.bases;\n  const kindOfBases =\n    otherBases.length === 0\n      ? kind\n      : {\n          ...kind,\n          initial: (): unknown =>\n            reduceEach(kind.initial(base), otherBases, kind.reduce),\n        };\n  return isSingleValued(merged)\n    ? compileLayer(kindOfBases, layerOfMerged(merged, base, firstValue))\n    : compileValueLists(kindOfBases, merged, base);\n}\n\n/** Whether no option or compound variant has more than one value. */\nfunction isSingleValued(merged: MergedLayers<unknown>): boolean {\n  const optionValues = Object.values(merged.variants).flatMap((options) =>\n    Object.values(options),\n  );\n  return (\n    optionValues.every((values) => hasOneValueAtMost(values)) &&\n    merged.compoundVariants.every(({ value }) => hasOneValueAtMost(value))\n  );\n}\n\n/**\n * Returns the merged layers as one config with `base`, the value of each\n * option and compound variant made by `valueOf` from its values.\n */\nfunction layerOfMerged(\n  merged: MergedLayers<unknown>,\n  base: unknown,\n  valueOf: (values: readonly unknown[]) => unknown,\n): Layer<unknown> {\n  return {\n    base,\n    compoundVariants: merged.compoundVariants.map(({ variants, value }) => ({\n      value: valueOf(value),\n      variants,\n    })),\n    defaultVariants: merged.defaultVariants,\n    slots: [],\n    variants: Object.fromEntries(\n      Object.entries(merged.variants).map(\n        ([name, options]: readonly [\n          string,\n          Readonly<Record<string, readonly unknown[]>>,\n        ]) => [\n          name,\n          Object.fromEntries(\n            Object.entries(options).map(\n              ([option, values]: readonly [string, readonly unknown[]]) => [\n                option,\n                valueOf(values),\n              ],\n            ),\n          ),\n        ],\n      ),\n    ),\n  };\n}\n\nfunction hasOneValueAtMost(values: readonly unknown[]): boolean {\n  return values.length <= 1;\n}\n\n/** Compiles a recipe whose options or compound variants have value lists. */\nfunction compileValueLists(\n  kind: LooseRecipeKind,\n  merged: MergedLayers<unknown>,\n  base: unknown,\n): CompiledRecipe {\n  const { initial, reduce, finish = asResult } = kind;\n  const compiled = compileVariants<readonly unknown[]>({\n    ...merged,\n    noValue: noValues,\n  });\n  const reducer = { initial: (): unknown => initial(base), reduce };\n  const build = (indexes: Int32Array): unknown =>\n    finish(reduceValueLists(compiled, indexes, reducer));\n  return { build, compiled };\n}\n\nexport { compileLayer, compileMergedLayers };\nexport type { LooseKindRecipeConfig, LooseRecipeKind };\n","type UncheckedRecord = Readonly<Record<string, unknown>>;\n\n/** Checks a value of a slot recipe, such as an option's value. */\ntype CheckValue = (value: unknown, describe: () => string) => void;\n\nconst anyValue: CheckValue = () => {\n  // A recipe's values have the type of its kind, which the engine cannot check.\n};\n\nfunction isRecord(value: unknown): value is UncheckedRecord {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/** Checks a value of a slot recipe: undefined, or a value for each slot. */\nconst slotValues: CheckValue = (value, describe) => {\n  if (value !== undefined && !isRecord(value)) {\n    throw new TypeError(\n      `${describe()} needs an object of the value of each slot.`,\n    );\n  }\n};\n\nfunction checkVariants(variants: unknown, checkValue: CheckValue): void {\n  if (!isRecord(variants)) {\n    throw new TypeError(\n      \"A recipe's config needs `variants`, an object of the options of each variant. Use `variants: {}` for a recipe without variants.\",\n    );\n  }\n  for (const [name, options] of Object.entries(variants)) {\n    if (!isRecord(options)) {\n      throw new TypeError(\n        `The variant \"${name}\" needs an object of its options.`,\n      );\n    }\n    for (const [option, value] of Object.entries(options)) {\n      checkValue(\n        value,\n        () => `The option \"${option}\" of the variant \"${name}\"`,\n      );\n    }\n  }\n}\n\nfunction checkCompoundVariants(\n  compoundVariants: unknown,\n  checkValue: CheckValue,\n): void {\n  if (compoundVariants === undefined) {\n    return;\n  }\n  if (!Array.isArray(compoundVariants)) {\n    throw new TypeError(\n      \"`compoundVariants` needs an array of compound variants.\",\n    );\n  }\n  for (const [index, compound] of compoundVariants.entries()) {\n    const { variants, value }: UncheckedRecord = isRecord(compound)\n      ? compound\n      : {};\n    if (!isRecord(variants)) {\n      throw new TypeError(\n        `Compound variant ${String(index)} needs \\`variants\\`, an object of the options it matches.`,\n      );\n    }\n    checkValue(\n      value,\n      () => `The \\`value\\` of compound variant ${String(index)}`,\n    );\n  }\n}\n\nfunction checkLayer(config: unknown, checkValue: CheckValue): UncheckedRecord {\n  if (!isRecord(config)) {\n    throw new TypeError(\"A recipe needs a config object.\");\n  }\n  const { variants, compoundVariants } = config;\n  checkVariants(variants, checkValue);\n  checkCompoundVariants(compoundVariants, checkValue);\n  return config;\n}\n\n/**\n * Checks the shape of a recipe's config, which its types already check, so\n * that a config from untyped code fails when the recipe is created, with a\n * message that names what is wrong.\n *\n * @returns The config.\n * @throws {TypeError} When `variants` or a compound variant's `variants` is\n *   not an object.\n */\nfunction checkRecipeConfig<Config>(config: Config): Config {\n  checkLayer(config, anyValue);\n  return config;\n}\n\n/**\n * Checks the shape of a slot recipe's config, as {@link checkRecipeConfig}\n * does, and that `slots` is an array and each value is an object of the\n * value of each slot.\n *\n * @returns The config.\n * @throws {TypeError} When a part of the config has the wrong shape.\n */\nfunction checkSlotRecipeConfig<Config>(config: Config): Config {\n  const { slots, base } = checkLayer(config, slotValues);\n  if (!Array.isArray(slots)) {\n    throw new TypeError(\n      \"A slot recipe's config needs `slots`, an array of the names of its slots.\",\n    );\n  }\n  slotValues(base, () => \"The `base` of a slot recipe\");\n  return config;\n}\n\nexport { checkRecipeConfig, checkSlotRecipeConfig };\n","import type { CompiledVariants, SelectedVariants } from \"./variants.js\";\nimport { noProps, select, undeclared } from \"./variants.js\";\n\n/** How a selector computes its results. */\ninterface SelectorOptions {\n  /** Whether to cache the result of each declared selection. */\n  readonly cache: boolean;\n}\n\n/** Whether `results` holds `result`, read at `key`, even if it is undefined. */\nfunction isCached<Result>(\n  results: ReadonlyMap<number, Result>,\n  key: number,\n  result: Result | undefined,\n): result is Result {\n  return result !== undefined || results.has(key);\n}\n\n/**\n * Returns a function that builds the result of a selection from the option\n * index of each variant, and treats a missing selection as an empty one.\n * With `options.cache`, it builds the result of each declared selection\n * once and caches it by the selection's key.\n */\nfunction createSelector<Result>(\n  compiled: CompiledVariants<unknown>,\n  build: (indexes: Int32Array) => Result,\n  options: SelectorOptions,\n): (selected?: SelectedVariants | null) => Result {\n  const indexes = new Int32Array(compiled.names.length);\n  const results =\n    options.cache && compiled.isCacheable\n      ? new Map<number, Result>()\n      : undefined;\n\n  return (selected) => {\n    const key = select(compiled, selected ?? noProps, indexes);\n    if (key !== undeclared && results !== undefined) {\n      const cachedResult = results.get(key);\n      if (isCached(results, key, cachedResult)) {\n        return cachedResult;\n      }\n    }\n    const result = build(indexes);\n    if (key !== undeclared) {\n      results?.set(key, result);\n    }\n    return result;\n  };\n}\n\nexport { createSelector };\nexport type { SelectorOptions };\n","import { toOptionName, toOptionNames } from \"./variants.js\";\nimport type { Layer } from \"./compose.js\";\n\n/**\n * The console, which every runtime that runs the packages has, and which\n * the ES2022 library does not declare.\n */\ndeclare const console: { readonly warn: (message: string) => void };\n\n/** The options of each variant that the layers of a recipe declare. */\ntype DeclaredOptions = ReadonlyMap<string, readonly string[]>;\n\nfunction declaredOptionsOf<Value>(\n  layers: readonly Layer<Value>[],\n): DeclaredOptions {\n  const optionsByName = new Map<string, readonly string[]>();\n  for (const { variants } of layers) {\n    for (const [name, options] of Object.entries(variants)) {\n      const declared = [\n        ...(optionsByName.get(name) ?? []),\n        ...Object.keys(options),\n      ];\n      optionsByName.set(\n        name,\n        declared.some((option) => isBooleanName(option))\n          ? [...declared, \"true\", \"false\"]\n          : declared,\n      );\n    }\n  }\n  return optionsByName;\n}\n\nfunction isBooleanName(option: string): boolean {\n  return option === \"true\" || option === \"false\";\n}\n\nfunction unknownDefaults(\n  defaultVariants: Readonly<Record<string, unknown>>,\n  declared: ReadonlyMap<string, readonly string[]>,\n): string[] {\n  return Object.entries(defaultVariants).flatMap(\n    ([name, value]: readonly [string, unknown]) => {\n      if (value === undefined) {\n        return [];\n      }\n      const options = declared.get(name);\n      if (options === undefined) {\n        return [`\\`defaultVariants\\` names the variant \"${name}\".`];\n      }\n      const option = toOptionName(value);\n      return option !== undefined && options.includes(option)\n        ? []\n        : [\n            `\\`defaultVariants\\` gives \"${name}\" the option ${JSON.stringify(value)}.`,\n          ];\n    },\n  );\n}\n\nfunction unknownConditions<Value>(\n  own: Layer<Value>,\n  declared: ReadonlyMap<string, readonly string[]>,\n): string[] {\n  return own.compoundVariants.flatMap(({ variants }, index) =>\n    Object.entries(variants).flatMap(\n      ([name, value]: readonly [string, unknown]) => {\n        if (value === undefined) {\n          return [];\n        }\n        const options = declared.get(name);\n        if (options === undefined) {\n          return [\n            `Compound variant ${String(index)} names the variant \"${name}\".`,\n          ];\n        }\n        return toOptionNames(value)\n          .filter((option) => !options.includes(option))\n          .map(\n            (option) =>\n              `Compound variant ${String(index)} names the option \"${option}\" of \"${name}\".`,\n          );\n      },\n    ),\n  );\n}\n\nfunction unknownSlotsIn(\n  value: unknown,\n  slots: readonly string[],\n  where: string,\n): string[] {\n  if (typeof value !== \"object\" || value === null) {\n    return [];\n  }\n  return Object.keys(value)\n    .filter((slot) => !slots.includes(slot))\n    .map((slot) => `${where} gives a value to the slot \"${slot}\".`);\n}\n\nfunction unknownSlots<Value>(\n  own: Layer<Value>,\n  slots: readonly string[],\n): string[] {\n  return [\n    ...unknownSlotsIn(own.base, slots, \"`base`\"),\n    ...Object.entries(own.variants).flatMap(\n      ([name, options]: readonly [string, Readonly<Record<string, Value>>]) =>\n        Object.entries(options).flatMap(\n          ([option, value]: readonly [string, Value]) =>\n            unknownSlotsIn(value, slots, `The option \"${option}\" of \"${name}\"`),\n        ),\n    ),\n    ...own.compoundVariants.flatMap(({ value }, index) =>\n      unknownSlotsIn(value, slots, `Compound variant ${String(index)}`),\n    ),\n  ];\n}\n\n/**\n * Returns the names in a recipe's own config that none of its layers\n * declares: a variant or option in its defaults or compound variants, and,\n * for a slot recipe, a slot that a value is given to. Such a default or\n * value is left out, and such a compound variant never matches. Each layer\n * was checked when its own recipe was created, so only `own` is checked.\n */\nfunction unknownNames<Value>(\n  own: Layer<Value>,\n  layers: readonly Layer<Value>[],\n  isSlotRecipe: boolean,\n): string[] {\n  const declared = declaredOptionsOf(layers);\n  return [\n    ...unknownDefaults(own.defaultVariants, declared),\n    ...unknownConditions(own, declared),\n    ...(isSlotRecipe\n      ? unknownSlots(\n          own,\n          layers.flatMap(({ slots }) => slots),\n        )\n      : []),\n  ];\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warns once about the names that {@link unknownNames} returns, if any. A\n * warning already given is not repeated, so that a recipe created again\n * with the same config, such as a themed recipe for each theme, warns once.\n */\nfunction warnUnknownNames<Value>(\n  own: Layer<Value>,\n  layers: readonly Layer<Value>[],\n  isSlotRecipe: boolean,\n): void {\n  const problems = unknownNames(own, layers, isSlotRecipe);\n  if (problems.length === 0) {\n    return;\n  }\n  const warning = `A recipe's config names variants, options, or slots that it does not declare, so they add nothing:\\n- ${problems.join(\"\\n- \")}`;\n  if (!warned.has(warning)) {\n    warned.add(warning);\n    console.warn(warning);\n  }\n}\n\nexport { unknownNames, warnUnknownNames };\n","import type {\n  Composable,\n  ComposableKindRecipe,\n  ComposedKindRecipe,\n  ComposedVariants,\n  InheritedDefaultedName,\n} from \"./composition.js\";\nimport type {\n  KindCompoundCondition,\n  KindDefaultVariants,\n} from \"./kind-selection.js\";\nimport type { LooseKindRecipeConfig, LooseRecipeKind } from \"./build-recipe.js\";\nimport type {\n  LooseVariants,\n  SelectedVariants,\n  WithVariants,\n} from \"./variants.js\";\nimport type {\n  RecipeFunction,\n  RecipeKind,\n  SelectionDefaults,\n  VariantKey,\n  VariantOptions,\n} from \"./types.js\";\nimport { compileLayer, compileMergedLayers } from \"./build-recipe.js\";\nimport { createRegistry, layerOf, mergeLayers } from \"./compose.js\";\nimport { checkRecipeConfig } from \"./check-config.js\";\nimport { createSelector } from \"./selector.js\";\nimport { warnUnknownNames } from \"./check-names.js\";\nimport { withVariants } from \"./variants.js\";\n\nconst recipes = createRegistry<unknown>(\"recipe\");\n\n/**\n * The variants of a {@link KindRecipeConfig}: for each variant name, the\n * value of each of its options.\n *\n * @typeParam Value - The value of an option.\n */\ntype KindVariants<Value> = LooseVariants<Value>;\n\n/**\n * A value added when several variants have particular options at the same\n * time.\n *\n * @typeParam Variants - The variant definitions of the recipe.\n * @typeParam Value - The value of an option.\n */\ninterface KindCompoundVariant<Variants, Value> {\n  /**\n   * The options that must all be selected for\n   * {@link KindCompoundVariant.value} to apply.\n   */\n  readonly variants: KindCompoundCondition<Variants>;\n  /** The value added when the condition matches. */\n  readonly value: Value;\n}\n\n/**\n * The configuration of a recipe made from a {@link RecipeKind}.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Variants - The variant definitions, keyed by variant name.\n * @typeParam DefaultedName - The names of the variants that have a default.\n * @typeParam Composed - The types of the recipes that the recipe composes.\n */\ninterface KindRecipeConfig<\n  Value,\n  Variants extends KindVariants<Value>,\n  DefaultedName extends keyof ComposedVariants<Composed, Variants>,\n  Composed extends readonly ComposableKindRecipe<Value>[] = readonly [],\n> {\n  /**\n   * Recipes whose config the recipe adds to its own, in order, as if it\n   * were written in one config: their bases first, the values of each of\n   * their options before its own, and their compound variants first. A\n   * recipe composed several times counts once.\n   */\n  readonly composes?: Composed | undefined;\n  /** The value that the values of every selection are added to. */\n  readonly base?: Value | undefined;\n  /** For each variant name, the value of each of its options. */\n  readonly variants: Variants;\n  /**\n   * Values added when several variants have particular options at the same\n   * time, applied in order after the values of the variants' options.\n   */\n  readonly compoundVariants?:\n    | readonly KindCompoundVariant<\n        NoInfer<ComposedVariants<Composed, Variants>>,\n        Value\n      >[]\n    | undefined;\n  /** The option each variant uses when the recipe is called without it. */\n  readonly defaultVariants?:\n    | KindDefaultVariants<ComposedVariants<Composed, Variants>, DefaultedName>\n    | undefined;\n  /** Whether the recipe caches its results. Defaults to the kind's `cache`. */\n  readonly cache?: boolean | undefined;\n}\n\n/**\n * A recipe made from a {@link RecipeKind}: a function that returns the\n * result of a selection of variants, with the names of those variants in\n * `variantKeys`, the names of their options in `variantOptions`, and the\n * option each uses when a selection leaves it out in `defaultVariants`.\n *\n * @typeParam Selection - The variants the recipe accepts.\n * @typeParam Result - What the recipe returns.\n * @typeParam Composition - What the recipe passes on to the recipes that\n *   compose it, a `RecipeComposition`. Without it, the type does not\n *   allow composing the recipe.\n */\ntype KindRecipe<Selection, Result, Composition = unknown> = RecipeFunction<\n  Selection,\n  Result\n> & {\n  /**\n   * The names of the recipe's variants, in the order of\n   * `Object.keys(config.variants)`, after those of the recipes it\n   * composes.\n   */\n  readonly variantKeys: readonly VariantKey<Selection>[];\n  /**\n   * The names of the options of each variant, as strings, in the order in\n   * which the recipe numbers them: integer names first, then `\"false\"` and\n   * `\"true\"`, which a variant that declares either one has, then the\n   * others in the order of the config. A frozen object, keyed in the order\n   * of `variantKeys`.\n   */\n  readonly variantOptions: VariantOptions<Selection>;\n  /**\n   * The option, as a string, that each variant uses when a selection\n   * leaves it out: its default, or `\"false\"` for a variant whose only\n   * options are `\"true\"` and `\"false\"`. A frozen object, keyed in the\n   * order of `variantKeys`, without the variants that have no default.\n   */\n  readonly defaultVariants: SelectionDefaults<Selection>;\n} & Composable<Composition>;\n\n/**\n * Creates recipes of one kind, the function that {@link createRecipeKind}\n * returns.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Result - What a recipe of this kind returns.\n * @param config - The base value, variants, compound variants, and default\n *   variants of the recipe, and whether it caches its results.\n * @returns The recipe.\n */\ntype CreateKindRecipe<Value, Result> = <\n  const Variants extends KindVariants<Value>,\n  const DefaultedName extends keyof ComposedVariants<Composed, Variants> =\n    never,\n  const Composed extends readonly ComposableKindRecipe<Value>[] = readonly [],\n>(\n  config: KindRecipeConfig<Value, Variants, DefaultedName, Composed>,\n) => ComposedKindRecipe<\n  ComposedVariants<Composed, Variants>,\n  DefaultedName | InheritedDefaultedName<Composed, Variants>,\n  Value,\n  Result,\n  undefined\n>;\n\ntype LooseKindRecipe = WithVariants<\n  (selection?: SelectedVariants | null) => unknown\n>;\n\n/**\n * Creates a kind of recipe from how it turns the values of a selection into\n * its result, and returns the function that creates recipes of that kind.\n * A recipe maps a selection of variants to a result, as `cva` of\n * `@lynstack/class-recipe` does for class names, for values of any type,\n * such as style objects.\n *\n * @remarks\n * For each selection, a recipe reduces the value of each variant's selected\n * option and the value of each matching compound variant, with\n * `kind.reduce`, into the accumulator that `kind.initial` returns for the\n * recipe's base, then passes it to `kind.finish`. A variant whose only\n * options are `\"true\"` and `\"false\"` defaults to `false`, an option that the\n * config does not declare adds no value, and properties of the selection\n * that are not variants are ignored. A recipe's `variantKeys` property lists\n * the names of its variants, `variantOptions` the names of the options of\n * each, and `defaultVariants` the option each uses when a selection leaves\n * it out, so that a library can list every selection of a recipe.\n *\n * Creating a recipe warns once, with `console.warn`, about a default or a\n * compound variant's condition that names a variant or an option that no\n * config of the recipe declares. Such a default is ignored, and such a\n * condition never matches.\n *\n * With the cache, a recipe builds the result of each declared selection\n * once, and calling it again with the same variants returns the same\n * result. Freeze an object result in `kind.finish` so that callers cannot\n * change a result that later calls share. A selection with an undeclared\n * option is built on every call. A recipe keeps up to one result for each\n * combination of declared options; set `cache: false` in the config of a\n * recipe whose variants come from untrusted input, which overrides the kind.\n *\n * When the variant names are not known at compile time, as in a library\n * that passes on a config it received, a recipe accepts any selection.\n *\n * A recipe composes the recipes listed in its config's `composes`, of any\n * kind whose values have its type, as if their configs and its own were one:\n * the accumulator starts from the first base, and the other bases are\n * reduced first; every option of each is declared, with its values reduced\n * in the order of the recipes; their compound variants come before its own;\n * and a variant's default is the last one given. A recipe composed several\n * times counts once. With `kind.combine`, the bases, and the values that\n * the recipes give one option, are combined into one when the recipe is\n * created, so that it reduces one value for each.\n *\n * @typeParam Value - The value of an option, inferred from the `value`\n *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.\n * @typeParam Accumulator - What the values are reduced to, inferred from\n *   `kind.initial`.\n * @typeParam Result - What a recipe returns, inferred from `kind.finish`,\n *   or the accumulator without it.\n * @param kind - How a recipe turns the values of a selection into its\n *   result, and whether it caches the result.\n * @returns The function that creates recipes of this kind.\n *\n * @example\n * ```ts\n * type Style = Readonly<Record<string, string | number>>;\n *\n * const styleRecipe = createRecipeKind({\n *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),\n *   reduce: (style, value: Style) => Object.assign(style, value),\n *   combine: (first, second) => ({ ...first, ...second }),\n *   finish: (style): Style => Object.freeze(style),\n * });\n *\n * const text = styleRecipe({\n *   base: { color: \"black\" },\n *   variants: {\n *     size: { sm: { fontSize: 12 }, lg: { fontSize: 24 } },\n *     muted: { true: { opacity: 0.6 } },\n *   },\n *   compoundVariants: [\n *     { variants: { size: \"lg\", muted: true }, value: { fontWeight: 300 } },\n *   ],\n *   defaultVariants: { size: \"sm\" },\n * });\n *\n * text(); // => { color: \"black\", fontSize: 12 }\n *\n * text({ size: \"lg\", muted: true });\n * // => { color: \"black\", fontSize: 24, opacity: 0.6, fontWeight: 300 }\n *\n * text.variantKeys; // => [\"size\", \"muted\"]\n * text.variantOptions; // => { size: [\"sm\", \"lg\"], muted: [\"false\", \"true\"] }\n * text.defaultVariants; // => { size: \"sm\", muted: \"false\" }\n *\n * const heading = styleRecipe({\n *   composes: [text],\n *   base: { fontWeight: 700 },\n *   variants: { size: { xl: { fontSize: 32 } } },\n * });\n *\n * heading({ size: \"xl\" });\n * // => { color: \"black\", fontWeight: 700, fontSize: 32 }\n * ```\n */\nfunction createRecipeKind<Value, Accumulator, Result = Accumulator>(\n  kind: RecipeKind<Value, Accumulator, Result>,\n): CreateKindRecipe<Value, Result>;\n\nfunction createRecipeKind(kind: LooseRecipeKind): unknown {\n  const kindCache = kind.cache ?? true;\n\n  return (config: LooseKindRecipeConfig): LooseKindRecipe => {\n    const own = layerOf(checkRecipeConfig(config), []);\n    const layers = recipes.layersOf(config.composes ?? [], own);\n    warnUnknownNames(own, layers, false);\n    const { compiled, build } =\n      layers.length === 1\n        ? compileLayer(kind, own)\n        : compileMergedLayers(kind, mergeLayers(layers));\n    const options = { cache: config.cache ?? kindCache };\n    const recipe = createSelector(compiled, build, options);\n    return recipes.withLayers(withVariants(recipe, compiled), layers);\n  };\n}\n\nexport { createRecipeKind };\nexport type {\n  CreateKindRecipe,\n  KindCompoundVariant,\n  KindRecipe,\n  KindRecipeConfig,\n  KindVariants,\n};\n","import type { CompiledVariants, Compound } from \"./variants.js\";\nimport { combineValues } from \"./compose.js\";\nimport { matches } from \"./reduce-values.js\";\nimport { noOption } from \"./variants.js\";\n\n/** Values for some slots, keyed by slot name, as the runtime takes them. */\ntype LooseSlotValues = Readonly<Record<string, unknown>>;\n\n/** The values of the `false` option a boolean variant of a slot recipe adds. */\nconst noSlotValues: readonly LooseSlotValues[] = Object.freeze([]);\n\n/** How the values of each slot are reduced, as a recipe kind gives it. */\ninterface SlotsKind {\n  readonly initial: (base: unknown) => unknown;\n  readonly reduce: (accumulator: unknown, value: unknown) => unknown;\n  readonly combine?: ((first: unknown, second: unknown) => unknown) | undefined;\n  readonly finish?: ((accumulator: unknown) => unknown) | undefined;\n}\n\n/** The slots of a slot recipe and their bases, in the order of its layers. */\ninterface SlotsConfig {\n  readonly slots: readonly string[];\n  readonly bases: readonly LooseSlotValues[];\n}\n\n/**\n * The values that one option or compound variant adds to its slots: the\n * index of each slot it gives a value, and that value at the same position.\n * Slots without a value are left out, so reducing skips them.\n */\ninterface SlotEntries {\n  readonly slots: readonly number[];\n  readonly values: readonly unknown[];\n}\n\n/**\n * The accumulator of each slot while a selection is reduced, which\n * {@link addEntries} updates in place.\n */\ninterface SlotAccumulators {\n  readonly length: number;\n  [slot: number]: unknown;\n}\n\nfunction valueOfSlot(\n  values: LooseSlotValues | undefined,\n  slot: string,\n): unknown {\n  return values !== undefined && Object.hasOwn(values, slot)\n    ? values[slot]\n    : undefined;\n}\n\n/**\n * Returns the values of each slot in a list of values for some slots, in\n * the order of the list, combined into one with `combine` when the kind\n * has it.\n */\nfunction slotValuesOf(\n  slots: readonly string[],\n  valuesList: readonly LooseSlotValues[],\n  combine: SlotsKind[\"combine\"],\n): readonly (readonly unknown[])[] {\n  return slots.map((slot) => {\n    const values = valuesList.flatMap((each) =>\n      listOf(valueOfSlot(each, slot)),\n    );\n    return combine === undefined\n      ? values\n      : listOf(combineValues(values, combine));\n  });\n}\n\n/**\n * Returns the entries of the values of each slot, by slot index, or\n * undefined when no slot has one.\n */\nfunction entriesBySlot(\n  valuesBySlot: readonly (readonly unknown[])[],\n): SlotEntries | undefined {\n  const slotIndexes = valuesBySlot.flatMap((values, slot) =>\n    values.map(() => slot),\n  );\n  return slotIndexes.length === 0\n    ? undefined\n    : { slots: slotIndexes, values: valuesBySlot.flat() };\n}\n\nfunction listOf(value: unknown): readonly unknown[] {\n  return value === undefined ? [] : [value];\n}\n\n/** Turns the slot values of each option and compound variant into entries. */\nfunction compileEntries(\n  compiled: CompiledVariants<readonly LooseSlotValues[]>,\n  slots: readonly string[],\n  combine: SlotsKind[\"combine\"],\n): CompiledVariants<SlotEntries | undefined> {\n  const entriesOf = (\n    valuesList: readonly LooseSlotValues[],\n  ): SlotEntries | undefined =>\n    entriesBySlot(slotValuesOf(slots, valuesList, combine));\n  return {\n    ...compiled,\n    compounds: compiled.compounds\n      .map((compound): Compound<SlotEntries | undefined> => ({\n        conditions: compound.conditions,\n        value: entriesOf(compound.value),\n      }))\n      .filter((compound) => compound.value !== undefined),\n    valuesByIndex: compiled.valuesByIndex.map((valuesOfVariant) =>\n      valuesOfVariant.map((values) => entriesOf(values)),\n    ),\n  };\n}\n\n/** Reduces the values of `added` into the accumulators of their slots. */\nfunction addEntries(\n  accumulators: SlotAccumulators,\n  added: SlotEntries,\n  reduce: SlotsKind[\"reduce\"],\n): void {\n  const { slots, values } = added;\n  for (let entry = 0; entry < slots.length; entry += 1) {\n    const slot = slots[entry] ?? 0;\n    accumulators[slot] = reduce(accumulators[slot], values[entry]);\n  }\n}\n\n/**\n * The names of a slot recipe's slots, and an object with a property for\n * each, which results copy so that assigning a slot named `__proto__` sets\n * that property instead of the prototype.\n */\ninterface SlotNames {\n  readonly names: readonly string[];\n  readonly template: Readonly<Record<string, unknown>>;\n}\n\n/** Returns the frozen result of each slot, keyed by slot name. */\nfunction resultsBySlot(\n  slots: SlotNames,\n  accumulators: SlotAccumulators,\n  finish: (accumulator: unknown) => unknown,\n): Readonly<Record<string, unknown>> {\n  const { names } = slots;\n  const results: Record<string, unknown> = { ...slots.template };\n  for (let slot = 0; slot < names.length; slot += 1) {\n    results[names[slot] ?? \"\"] = finish(accumulators[slot]);\n  }\n  return Object.freeze(results);\n}\n\nconst asResult = (accumulator: unknown): unknown => accumulator;\n\n/**\n * Returns the function that builds the result of a selection for each slot\n * of a slot recipe: each slot reduces its own values with `kind`, and the\n * results are frozen in an object keyed by slot name.\n *\n * It reduces the values in a loop of its own instead of through\n * `reduceValues`, which recipes share, so that its calls to `kind.reduce`\n * see only the reducers of slot recipes and can be inlined.\n */\nfunction createSlotsBuilder(\n  kind: SlotsKind,\n  compiled: CompiledVariants<readonly LooseSlotValues[]>,\n  config: SlotsConfig,\n): (indexes: Int32Array) => Readonly<Record<string, unknown>> {\n  const { initial, reduce, combine, finish = asResult } = kind;\n  const names = [...config.slots];\n  const slotNames: SlotNames = {\n    names,\n    template: Object.fromEntries(names.map((slot) => [slot, undefined])),\n  };\n  const basesBySlot = slotValuesOf(names, config.bases, combine);\n  const bases = basesBySlot.map(([base]: readonly unknown[]) => base);\n  const otherBases = entriesBySlot(\n    basesBySlot.map(([, ...others]: readonly unknown[]) => others),\n  );\n  const { valuesByIndex, compounds } = compileEntries(compiled, names, combine);\n\n  /** Returns the accumulator of each slot, with every base reduced. */\n  const initialAccumulators = (): SlotAccumulators => {\n    const accumulators = bases.map((base) => initial(base));\n    if (otherBases !== undefined) {\n      addEntries(accumulators, otherBases, reduce);\n    }\n    return accumulators;\n  };\n\n  return (indexes) => {\n    const accumulators = initialAccumulators();\n    for (let variant = 0; variant < valuesByIndex.length; variant += 1) {\n      const added = valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n      if (added !== undefined) {\n        addEntries(accumulators, added, reduce);\n      }\n    }\n    for (const compound of compounds) {\n      if (compound.value !== undefined && matches(compound, indexes)) {\n        addEntries(accumulators, compound.value, reduce);\n      }\n    }\n    return resultsBySlot(slotNames, accumulators, finish);\n  };\n}\n\nexport { createSlotsBuilder, noSlotValues };\nexport type { LooseSlotValues, SlotsKind };\n","import type {\n  ComposableKindSlotRecipe,\n  ComposedKindRecipe,\n  ComposedVariants,\n  InheritedDefaultedName,\n  InheritedSlot,\n} from \"./composition.js\";\nimport type {\n  KindCompoundCondition,\n  KindDefaultVariants,\n} from \"./kind-selection.js\";\nimport type { LooseSlotValues, SlotsKind } from \"./slots.js\";\nimport type { NoUnknownComposedSlots, RecipeKind } from \"./types.js\";\nimport type { SelectedVariants, WithVariants } from \"./variants.js\";\nimport { compileVariants, withVariants } from \"./variants.js\";\nimport { createRegistry, layerOf, mergeLayers } from \"./compose.js\";\nimport { createSlotsBuilder, noSlotValues } from \"./slots.js\";\nimport type { KindVariants } from \"./recipe-kind.js\";\nimport { checkSlotRecipeConfig } from \"./check-config.js\";\nimport { createSelector } from \"./selector.js\";\nimport { warnUnknownNames } from \"./check-names.js\";\n\nconst slotRecipes = createRegistry<LooseSlotValues>(\"slot recipe\");\n\n/**\n * Values for some of a slot recipe's slots, keyed by slot name.\n *\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n */\ntype SlotValues<Slot extends string, Value> = {\n  readonly [Name in Slot]?: Value | undefined;\n};\n\n/**\n * The variants of a {@link KindSlotRecipeConfig}: for each variant name,\n * the values of each slot for each of its options.\n *\n * @typeParam Value - The value of a slot.\n */\ntype KindSlotVariants<Value> = KindVariants<SlotValues<string, Value>>;\n\n/**\n * Values added to some slots when several variants have particular options\n * at the same time.\n *\n * @typeParam Variants - The variant definitions of the slot recipe.\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n */\ninterface KindSlotCompoundVariant<Variants, Slot extends string, Value> {\n  /**\n   * The options that must all be selected for\n   * {@link KindSlotCompoundVariant.value} to apply.\n   */\n  readonly variants: KindCompoundCondition<Variants>;\n  /** The value added to each slot when the condition matches. */\n  readonly value: SlotValues<Slot, Value>;\n}\n\n/**\n * The configuration of a slot recipe made from a {@link RecipeKind}.\n *\n * @typeParam Slot - The names of the slots.\n * @typeParam Value - The value of a slot.\n * @typeParam Variants - The variant definitions, keyed by variant name.\n * @typeParam DefaultedName - The names of the variants that have a default.\n */\ninterface KindSlotRecipeConfig<\n  Slot extends string,\n  Value,\n  Variants extends KindSlotVariants<Value>,\n  DefaultedName extends keyof ComposedVariants<Composed, Variants>,\n  Composed extends readonly ComposableKindSlotRecipe<Value>[] = readonly [],\n> {\n  /**\n   * Slot recipes whose config the recipe adds to its own, in order, as if\n   * it were written in one config: their slots and bases first, the values\n   * of each of their options before its own, and their compound variants\n   * first. A slot recipe composed several times counts once.\n   */\n  readonly composes?: Composed | undefined;\n  /**\n   * The names of the slots, in the order of the recipe's result, after\n   * those of the slot recipes it composes.\n   */\n  readonly slots: readonly Slot[];\n  /** The value of each slot that the values of every selection are added to. */\n  readonly base?:\n    SlotValues<NoInfer<Slot> | InheritedSlot<Composed>, Value> | undefined;\n  /** For each variant name, the values of each slot for each of its options. */\n  readonly variants: Variants &\n    NoUnknownComposedSlots<Variants, NoInfer<Slot>, InheritedSlot<Composed>>;\n  /**\n   * Values added to some slots when several variants have particular\n   * options at the same time, applied in order after the values of the\n   * variants' options.\n   */\n  readonly compoundVariants?:\n    | readonly KindSlotCompoundVariant<\n        NoInfer<ComposedVariants<Composed, Variants>>,\n        NoInfer<Slot> | InheritedSlot<Composed>,\n        Value\n      >[]\n    | undefined;\n  /** The option each variant uses when the recipe is called without it. */\n  readonly defaultVariants?:\n    | KindDefaultVariants<ComposedVariants<Composed, Variants>, DefaultedName>\n    | undefined;\n  /** Whether the recipe caches its results. Defaults to the kind's `cache`. */\n  readonly cache?: boolean | undefined;\n}\n\n/**\n * Creates slot recipes of one kind, the function that\n * {@link createSlotRecipeKind} returns.\n *\n * @typeParam Value - The value of a slot.\n * @typeParam Result - What a recipe of this kind returns for each slot.\n * @param config - The slot recipes it composes, and the slots, base values,\n *   variants, compound variants, and default variants of the slot recipe,\n *   and whether it caches its results.\n * @returns The slot recipe.\n */\ntype CreateKindSlotRecipe<Value, Result> = <\n  const Slot extends string,\n  const Variants extends KindSlotVariants<Value>,\n  const DefaultedName extends keyof ComposedVariants<Composed, Variants> =\n    never,\n  const Composed extends readonly ComposableKindSlotRecipe<Value>[] =\n    readonly [],\n>(\n  config: KindSlotRecipeConfig<Slot, Value, Variants, DefaultedName, Composed>,\n) => ComposedKindRecipe<\n  ComposedVariants<Composed, Variants>,\n  DefaultedName | InheritedDefaultedName<Composed, Variants>,\n  Value,\n  // Not ComposedSlot, which declarations print with each composed type.\n  Readonly<\n    Record<\n      | Slot\n      | Exclude<Composed[number][\"~composition\"], undefined>[\"slots\"][number],\n      Result\n    >\n  >,\n  readonly (\n    Slot | Exclude<Composed[number][\"~composition\"], undefined>[\"slots\"][number]\n  )[]\n>;\n\ninterface LooseRecipeKind extends SlotsKind {\n  readonly cache?: boolean | undefined;\n}\n\ninterface LooseSlotRecipeConfig {\n  readonly composes?: readonly unknown[] | undefined;\n  readonly slots: readonly string[];\n  readonly base?: LooseSlotValues | undefined;\n  readonly variants: KindSlotVariants<unknown>;\n  readonly compoundVariants?:\n    | readonly {\n        readonly variants: SelectedVariants;\n        readonly value: LooseSlotValues;\n      }[]\n    | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n  readonly cache?: boolean | undefined;\n}\n\ntype LooseSlotRecipe = WithVariants<\n  (selection?: SelectedVariants | null) => Readonly<Record<string, unknown>>\n>;\n\n/**\n * Creates a kind of slot recipe from how it turns the values of each slot\n * into that slot's result, and returns the function that creates slot\n * recipes of that kind. A slot recipe maps a selection of variants to the\n * result of each of several slots, such as the class names or the styles of\n * the elements of a component, as `sva` of `@lynstack/class-recipe` does.\n *\n * @remarks\n * A slot recipe reduces the values of each slot as a recipe of the same\n * kind from {@link createRecipeKind} would: `kind.initial` returns the\n * accumulator for the slot's base value, `kind.reduce` adds the slot's\n * value of each variant's selected option, in the order of `variants`, and\n * of each matching compound variant, in the order of `compoundVariants`,\n * and `kind.finish` turns the accumulator into the slot's result. A slot\n * without values gets the result of its accumulator for an `undefined`\n * base, so every slot is in the result.\n *\n * The result is a frozen object of each slot's result, keyed by slot name\n * in the order of `slots`. With the cache, a slot recipe builds it once for\n * each declared selection and returns the same object for the same\n * variants. The `cache` of a slot recipe's config overrides the kind's.\n * Variants, boolean variants, undeclared options, the warning about\n * undeclared names, and the `variantKeys`, `variantOptions`, and\n * `defaultVariants` properties are as in {@link createRecipeKind}. It also\n * warns about a value for a slot that no config lists in `slots`, which is\n * ignored.\n *\n * A slot recipe composes the slot recipes listed in `composes` as a recipe\n * composes recipes, and has the slots of each, theirs first. With\n * `kind.combine`, the values of each slot are combined as a recipe's are.\n *\n * @typeParam Value - The value of a slot, inferred from the `value`\n *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.\n * @typeParam Accumulator - What the values of a slot are reduced to,\n *   inferred from `kind.initial`.\n * @typeParam Result - What a slot recipe returns for each slot, inferred\n *   from `kind.finish`, or the accumulator without it.\n * @param kind - How a slot recipe turns the values of each slot into its\n *   result, and whether it caches its results. The same kind can create\n *   recipes with {@link createRecipeKind}.\n * @returns The function that creates slot recipes of this kind.\n *\n * @example\n * ```ts\n * type Style = Readonly<Record<string, string | number>>;\n *\n * const styleKind = {\n *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),\n *   reduce: (style: Record<string, string | number>, value: Style) =>\n *     Object.assign(style, value),\n *   finish: (style: Record<string, string | number>): Style =>\n *     Object.freeze(style),\n * };\n *\n * const slotStyleRecipe = createSlotRecipeKind(styleKind);\n *\n * const card = slotStyleRecipe({\n *   slots: [\"root\", \"title\"],\n *   base: { root: { padding: 16 }, title: { fontSize: 18 } },\n *   variants: {\n *     tone: {\n *       light: { root: { backgroundColor: \"white\" } },\n *       dark: { root: { backgroundColor: \"black\" }, title: { color: \"white\" } },\n *     },\n *   },\n *   compoundVariants: [\n *     { variants: { tone: \"dark\" }, value: { title: { fontWeight: 600 } } },\n *   ],\n *   defaultVariants: { tone: \"light\" },\n * });\n *\n * card();\n * // => { root: { padding: 16, backgroundColor: \"white\" }, title: { fontSize: 18 } }\n *\n * card({ tone: \"dark\" });\n * // => {\n * //   root: { padding: 16, backgroundColor: \"black\" },\n * //   title: { fontSize: 18, color: \"white\", fontWeight: 600 },\n * // }\n *\n * card.variantOptions; // => { tone: [\"light\", \"dark\"] }\n * card.defaultVariants; // => { tone: \"light\" }\n *\n * const dialog = slotStyleRecipe({\n *   composes: [card],\n *   slots: [\"footer\"],\n *   variants: { tone: { dark: { footer: { borderColor: \"white\" } } } },\n * });\n *\n * dialog({ tone: \"dark\" }).footer; // => { borderColor: \"white\" }\n * ```\n */\nfunction createSlotRecipeKind<Value, Accumulator, Result = Accumulator>(\n  kind: RecipeKind<Value, Accumulator, Result>,\n): CreateKindSlotRecipe<Value, Result>;\n\nfunction createSlotRecipeKind(kind: LooseRecipeKind): unknown {\n  const kindCache = kind.cache ?? true;\n\n  return (config: LooseSlotRecipeConfig): LooseSlotRecipe => {\n    const own = layerOf(checkSlotRecipeConfig(config), config.slots);\n    const layers = slotRecipes.layersOf(config.composes ?? [], own);\n    warnUnknownNames(own, layers, true);\n    const merged = mergeLayers(layers);\n    const compiled = compileVariants<readonly LooseSlotValues[]>({\n      ...merged,\n      noValue: noSlotValues,\n    });\n    const build = createSlotsBuilder(kind, compiled, merged);\n    const options = { cache: config.cache ?? kindCache };\n    const recipe = createSelector(compiled, build, options);\n    return slotRecipes.withLayers(withVariants(recipe, compiled), layers);\n  };\n}\n\nexport { createSlotRecipeKind };\nexport type {\n  CreateKindSlotRecipe,\n  KindSlotCompoundVariant,\n  KindSlotRecipeConfig,\n  KindSlotVariants,\n  SlotValues,\n};\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynstack/recipe",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Fast, type-safe recipes for values of any type: define how a kind of recipe combines values, such as class names or styles, then create recipes of that kind.",
   "keywords": [
     "recipe",
@@ -44,8 +44,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "test:consumer": "tsc -p fixtures/consumer/tsconfig.json",
     "bench": "pnpm build && vitest bench --run",
-    "check": "pnpm build && pnpm typecheck && pnpm test:consumer && pnpm lint && pnpm format:check && pnpm test"
+    "check": "pnpm build && pnpm typecheck && pnpm lint && pnpm format:check && pnpm test"
   }
 }