@bamboocss/generator 1.33.0 → 1.34.1

package/dist/index.cjs

@@ -111,6 +111,7 @@ function generateConditions(ctx) {
 function generateCssFn(ctx) {
 	const { utility, hash, prefix } = ctx;
 	const { separator } = utility;
+	const leafFallback = ctx.config.leafFallback ?? true;
 	return {
 		dts: outdent.outdent`
     ${ctx.file.importType("SystemStyleObject, ViewTransitionFn", "../types/index")}
@@ -204,12 +205,22 @@ function generateCssFn(ctx) {
 
     // Emitted for the source transform, which rewrites a single dynamic style leaf into a
     // call to this rather than leaving a \`css()\` behind. \`prefix\` is the class up to the
-    // value, resolved at build time; \`prop\` is only used for the shapes \`leafClass\`
-    // declines, which have to run the real thing.
-    export const cssLeaf = (prefix, prop, value) => {
+    // value, resolved at build time; \`prop\` names the property for the shapes \`leafClass\`
+    // declines.
+    ${leafFallback ? `export const cssLeaf = (prefix, prop, value) => {
       const className = leafClass(prefix, value)
       return className === undefined ? css({ [prop]: value }) : className
-    }
+    }` : `export const cssLeaf = (prefix, prop, value) => {
+      const className = leafClass(prefix, value)
+      if (className === undefined) {
+        throw new Error(
+          \`[bamboocss] \\\`\${prop}\\\` got a \${Array.isArray(value) ? 'responsive array' : 'condition object'} from a \` +
+            \`runtime value, and \\\`leafFallback\\\` is off. Write the conditions as a literal at the call site, so \` +
+            \`the build resolves each branch, or set \\\`leafFallback: true\\\` to keep the runtime.\`,
+        )
+      }
+      return className
+    }`}
 
     // Sugar for the string form, so the feature has an import to discover, a signature to
     // hover and a name the editor can complete. The extractor evaluates the call, so the
@@ -2353,13 +2364,36 @@ function generatePropTypes(ctx) {
 	return outdent.outdent`
   ${result.join("\n")}
 
-  type WithColorOpacityModifier<T> = [T] extends [string] ? \`$\{T}/\${string}\` & { __colorOpacityModifier?: true } : never
-
   type ImportantMark = "!" | "!important"
   type WhitespaceImportant = \` \${ImportantMark}\`
   type Important = ImportantMark | WhitespaceImportant
   type WithImportant<T> = [T] extends [string] ? \`\${T}\${Important}\` & { __important?: true } : never
 
+  /**
+   * The modifiers a token path may carry, as one open-ended tail rather than one closed
+   * template per form.
+   *
+   * ⚠️ The \`& { __modifier?: true }\` is load-bearing, and nothing reads it. Deleting it as
+   * dead weight costs **12.8x** on \`tsc\` — measured at 87.2s against 6.8s over 4,000 call
+   * sites — because it is what stops TypeScript attempting subtype reduction across the
+   * union these expand into. The same applies to \`__important\` above.
+   *
+   * A template literal distributes over a union in any placeholder, so \`\${T}\` against a
+   * 258-token colour palette is 258 members, and the old \`\${T}\${Important}\` was four times
+   * that. Between them the two modifier forms were 5N of a ~1,560-member union for \`color\`
+   * alone, and half the cost of type-checking a \`css()\` call under \`strictTokens\`. Folding
+   * them into one 3N tail is 14.5% off that — 7.09s against 8.29s over the same 4,000 call
+   * sites, with a control repeat agreeing to 3.5%.
+   *
+   * What it gives up is the tail: \`red.300!nonsense\` type-checks now, where five exact
+   * templates would have rejected it. \`unresolvedToken\` strips the mark and resolves the
+   * path underneath, so the build still reports it — warning by default, failing under
+   * \`'error'\`. The diagnostic moves rather than disappears, and only for a value nobody
+   * writes on purpose.
+   */
+  type Modifier = "/" | "!" | " !"
+  type WithModifier<T> = [T] extends [string] ? \`\${T}\${Modifier}\${string}\` & { __modifier?: true } : never
+
   /**
    * A list of candidate values, most-preferred first, emitted as repeated declarations so the
    * browser keeps the last one it understands.
@@ -2391,8 +2425,7 @@ function generatePropTypes(ctx) {
     | \`[\${string}]\`
     | FallbackValue
     | WithImportant<FallbackValue>
-    | WithColorOpacityModifier<T>
-    | WithImportant<T>
+    | WithModifier<T>
 
   /**
    * Will restrict the value of properties that have predefined values to those values only.
@@ -3934,8 +3967,21 @@ var Generator = class extends _bamboocss_core.Context {
 	* unused for want of a utility to reference it.
 	*
 	* `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+	*
+	* `reachableVars` is `pruneTokens`' answer about custom properties, which has to be handed
+	* over rather than re-derived here. A token kept by a reader outside the stylesheet — a
+	* `token()` call, a `prune.keepTokens` pattern, a theme, a `globalCss` export — is
+	* reachable to that pass and invisible to this one, so deriving it again from the css
+	* deletes the `@keyframes` out from under a declaration that ships. Every caller that
+	* prunes both hands it over.
+	*
+	* Omitting it falls back to what `prune.tokens` implies. Under `off` that is `'all'`: no
+	* token declaration is removable, so each one ships and keeps the keyframe it names —
+	* and `off` is precisely the setting chosen because something outside the stylesheet
+	* reads them. Otherwise it is the css alone, which is what a caller running this pass
+	* without the other one is asking for.
 	*/
-	pruneKeyframes = (sheet, keep) => {
+	pruneKeyframes = (sheet, keep, reachableVars) => {
 		if (!this.config.prune?.keyframes) return;
 		const layers = sheet.layers;
 		const keyframeNames = new Set(Object.keys(this.config.theme?.keyframes ?? {}));
@@ -3953,7 +3999,8 @@ var Generator = class extends _bamboocss_core.Context {
 			],
 			target: layers.tokens,
 			keyframeNames,
-			keep: new Set([...this.getThemeKeyframeNames(keyframeNames), ...keep ?? []])
+			keep: new Set([...this.getThemeKeyframeNames(keyframeNames), ...keep ?? []]),
+			reachableVars: reachableVars ?? ((this.config.prune?.tokens ?? "reachable") === "off" ? "all" : void 0)
 		});
 		_bamboocss_logger.logger.debug("prune:keyframes", `Removed ${result.removed} unused keyframe(s)`);
 		return result;
@@ -4041,9 +4088,79 @@ var Generator = class extends _bamboocss_core.Context {
 			artifact: "styles.css",
 			content: css
 		}) ?? css;
+		this.assertNoUnresolvedTokens();
 		return css;
 	};
 	/**
+	* Fail on a style value shaped like a token path that names no token.
+	*
+	* Only under `unresolvedToken: 'error'` — see that option for why this one is graded and a
+	* dead binding is not.
+	*
+	* Two sources, because neither sees the whole build.
+	*
+	* **Atomic styles are read off the decoded sheet** rather than accumulated as `transform`
+	* runs, and that is the load-bearing part for them. A `Context` outlives rebuilds while the
+	* decoder memoizes each atom by hash, so on the second build of the same source `transform`
+	* is never re-entered: an accumulating record either keeps a finding past the edit that
+	* fixed it — wedging a dev server — or is cleared and then never refilled, which passes a
+	* build whose source is still broken. That second one is the worse failure and is what an
+	* earlier version of this did.
+	*
+	* `decoder.atomic` has neither problem, because it is not a record of what happened — it is
+	* what the sheet is built from, and each result keeps the `prop` and `value` it was written
+	* with. So the question asked is the one that matters: does the stylesheet *being emitted*
+	* contain a declaration the browser will drop.
+	*
+	* Within a watch process that set is cumulative, and so is the css: extraction is additive,
+	* so the rule for a style deleted from source is still in the sheet until the process
+	* restarts. This reports the same way for the same reason — the declaration really is still
+	* in the file being written, and saying otherwise would be a check that disagreed with its
+	* own output. A production build is a fresh process and sees only what its source asked
+	* for.
+	*
+	* **Config-derived styles are not in that set at all**, which is the gap this used to have.
+	* `globalCss`, the reset, config recipes and compositions serialize through
+	* `transformStyles`, and that clones the decoder — so their atoms land in a throwaway and
+	* `decoder.atomic` never hears about them. Reading only the sheet made `'error'` *quieter*
+	* than the default on exactly those styles: the warning was suppressed in favour of a check
+	* that could not see them, so a bad token in `globalCss` warned with the option unset and
+	* then passed silently with it set to `'error'`. `utility.unresolvedTokens` is the record of
+	* what only `transform` can see; see it for why accumulating is right for that half.
+	*
+	* Both halves key on `property:path` with shorthands resolved, so a value that does reach
+	* both — every atomic style is transformed once before it is memoized — is one finding.
+	*
+	* Here rather than beside the asserts in `BambooContext` because this is where the sheet
+	* exists: those all run during extraction, before anything has been decoded. Every path
+	* that emits css comes through `getCss`.
+	*/
+	assertNoUnresolvedTokens = () => {
+		if (this.config.unresolvedToken !== "error") return;
+		const found = new Map(this.utility.unresolvedTokens);
+		for (const atom of this.decoder.atomic) {
+			const { prop, value } = atom.entry;
+			if (typeof value !== "string" || typeof prop !== "string") continue;
+			if (!this.utility.isUnresolvedTokenValue(prop, value)) continue;
+			const key = this.utility.resolveShorthand(prop);
+			const bare = this.utility.bareTokenPath(key, value);
+			found.set(`${key}:${bare}`, {
+				prop: key,
+				value: bare,
+				category: this.utility.getTokenCategory(key)
+			});
+		}
+		if (!found.size) return;
+		const detail = (0, _bamboocss_shared.truncateList)(Array.from(found.values(), ({ prop, value, category }) => {
+			return `- \`${prop}: ${value}\`.${category ? ` Check the path against your \`${category}\` tokens.` : ""}`;
+		}), {
+			limit: 25,
+			unit: "value",
+			separator: "\n"
+		});
+		throw new _bamboocss_shared.BambooError("UNRESOLVED_TOKEN", `${found.size} style value(s) name a token that does not exist:\n\n${detail}\n\nEach is emitted as written, which parses — so the stylesheet is valid and nothing downstream objects. The browser drops the declaration at compute time and the style is simply absent from the element, which surfaces as "this never applied" a long way from the typo that caused it. Write \`[value]\` to mark one as a literal, or set \`unresolvedToken: 'warn'\` to report these without failing.`);
+	};
+	/**
 	* Get CSS for a specific layer from the stylesheet
 	*/
 	getLayerCss = (sheet, layer) => {

package/dist/index.d.cts

@@ -37,10 +37,7 @@ declare class Generator extends Context {
    * `keep` carries references this cannot see for itself; see `collectTokenReferences`.
    */
   pruneTokens: (sheet: Stylesheet, keep?: Set<string>, tokensReachableFromJs?: boolean) => {
-    removed: number;
-    kept: number;
-    removedProperties?: undefined;
-  } | {
+    reachable: Set<string> | undefined;
     removed: number;
     removedProperties: number;
     kept: number;
@@ -63,8 +60,21 @@ declare class Generator extends Context {
    * unused for want of a utility to reference it.
    *
    * `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+   *
+   * `reachableVars` is `pruneTokens`' answer about custom properties, which has to be handed
+   * over rather than re-derived here. A token kept by a reader outside the stylesheet — a
+   * `token()` call, a `prune.keepTokens` pattern, a theme, a `globalCss` export — is
+   * reachable to that pass and invisible to this one, so deriving it again from the css
+   * deletes the `@keyframes` out from under a declaration that ships. Every caller that
+   * prunes both hands it over.
+   *
+   * Omitting it falls back to what `prune.tokens` implies. Under `off` that is `'all'`: no
+   * token declaration is removable, so each one ships and keeps the keyframe it names —
+   * and `off` is precisely the setting chosen because something outside the stylesheet
+   * reads them. Otherwise it is the css alone, which is what a caller running this pass
+   * without the other one is asking for.
    */
-  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>) => {
+  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>, reachableVars?: Set<string> | "all") => {
     removed: number;
     kept: number;
   } | undefined;
@@ -119,6 +129,51 @@ declare class Generator extends Context {
   private getAlwaysKeptTokenVars;
   getParserCss: (decoder: StyleDecoder) => string;
   getCss: (stylesheet?: Stylesheet) => string;
+  /**
+   * Fail on a style value shaped like a token path that names no token.
+   *
+   * Only under `unresolvedToken: 'error'` — see that option for why this one is graded and a
+   * dead binding is not.
+   *
+   * Two sources, because neither sees the whole build.
+   *
+   * **Atomic styles are read off the decoded sheet** rather than accumulated as `transform`
+   * runs, and that is the load-bearing part for them. A `Context` outlives rebuilds while the
+   * decoder memoizes each atom by hash, so on the second build of the same source `transform`
+   * is never re-entered: an accumulating record either keeps a finding past the edit that
+   * fixed it — wedging a dev server — or is cleared and then never refilled, which passes a
+   * build whose source is still broken. That second one is the worse failure and is what an
+   * earlier version of this did.
+   *
+   * `decoder.atomic` has neither problem, because it is not a record of what happened — it is
+   * what the sheet is built from, and each result keeps the `prop` and `value` it was written
+   * with. So the question asked is the one that matters: does the stylesheet *being emitted*
+   * contain a declaration the browser will drop.
+   *
+   * Within a watch process that set is cumulative, and so is the css: extraction is additive,
+   * so the rule for a style deleted from source is still in the sheet until the process
+   * restarts. This reports the same way for the same reason — the declaration really is still
+   * in the file being written, and saying otherwise would be a check that disagreed with its
+   * own output. A production build is a fresh process and sees only what its source asked
+   * for.
+   *
+   * **Config-derived styles are not in that set at all**, which is the gap this used to have.
+   * `globalCss`, the reset, config recipes and compositions serialize through
+   * `transformStyles`, and that clones the decoder — so their atoms land in a throwaway and
+   * `decoder.atomic` never hears about them. Reading only the sheet made `'error'` *quieter*
+   * than the default on exactly those styles: the warning was suppressed in favour of a check
+   * that could not see them, so a bad token in `globalCss` warned with the option unset and
+   * then passed silently with it set to `'error'`. `utility.unresolvedTokens` is the record of
+   * what only `transform` can see; see it for why accumulating is right for that half.
+   *
+   * Both halves key on `property:path` with shorthands resolved, so a value that does reach
+   * both — every atomic style is transformed once before it is memoized — is one finding.
+   *
+   * Here rather than beside the asserts in `BambooContext` because this is where the sheet
+   * exists: those all run during extraction, before anything has been decoded. Every path
+   * that emits css comes through `getCss`.
+   */
+  assertNoUnresolvedTokens: () => void;
   /**
    * Get CSS for a specific layer from the stylesheet
    */

package/dist/index.d.mts

@@ -37,10 +37,7 @@ declare class Generator extends Context {
    * `keep` carries references this cannot see for itself; see `collectTokenReferences`.
    */
   pruneTokens: (sheet: Stylesheet, keep?: Set<string>, tokensReachableFromJs?: boolean) => {
-    removed: number;
-    kept: number;
-    removedProperties?: undefined;
-  } | {
+    reachable: Set<string> | undefined;
     removed: number;
     removedProperties: number;
     kept: number;
@@ -63,8 +60,21 @@ declare class Generator extends Context {
    * unused for want of a utility to reference it.
    *
    * `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+   *
+   * `reachableVars` is `pruneTokens`' answer about custom properties, which has to be handed
+   * over rather than re-derived here. A token kept by a reader outside the stylesheet — a
+   * `token()` call, a `prune.keepTokens` pattern, a theme, a `globalCss` export — is
+   * reachable to that pass and invisible to this one, so deriving it again from the css
+   * deletes the `@keyframes` out from under a declaration that ships. Every caller that
+   * prunes both hands it over.
+   *
+   * Omitting it falls back to what `prune.tokens` implies. Under `off` that is `'all'`: no
+   * token declaration is removable, so each one ships and keeps the keyframe it names —
+   * and `off` is precisely the setting chosen because something outside the stylesheet
+   * reads them. Otherwise it is the css alone, which is what a caller running this pass
+   * without the other one is asking for.
    */
-  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>) => {
+  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>, reachableVars?: Set<string> | "all") => {
     removed: number;
     kept: number;
   } | undefined;
@@ -119,6 +129,51 @@ declare class Generator extends Context {
   private getAlwaysKeptTokenVars;
   getParserCss: (decoder: StyleDecoder) => string;
   getCss: (stylesheet?: Stylesheet) => string;
+  /**
+   * Fail on a style value shaped like a token path that names no token.
+   *
+   * Only under `unresolvedToken: 'error'` — see that option for why this one is graded and a
+   * dead binding is not.
+   *
+   * Two sources, because neither sees the whole build.
+   *
+   * **Atomic styles are read off the decoded sheet** rather than accumulated as `transform`
+   * runs, and that is the load-bearing part for them. A `Context` outlives rebuilds while the
+   * decoder memoizes each atom by hash, so on the second build of the same source `transform`
+   * is never re-entered: an accumulating record either keeps a finding past the edit that
+   * fixed it — wedging a dev server — or is cleared and then never refilled, which passes a
+   * build whose source is still broken. That second one is the worse failure and is what an
+   * earlier version of this did.
+   *
+   * `decoder.atomic` has neither problem, because it is not a record of what happened — it is
+   * what the sheet is built from, and each result keeps the `prop` and `value` it was written
+   * with. So the question asked is the one that matters: does the stylesheet *being emitted*
+   * contain a declaration the browser will drop.
+   *
+   * Within a watch process that set is cumulative, and so is the css: extraction is additive,
+   * so the rule for a style deleted from source is still in the sheet until the process
+   * restarts. This reports the same way for the same reason — the declaration really is still
+   * in the file being written, and saying otherwise would be a check that disagreed with its
+   * own output. A production build is a fresh process and sees only what its source asked
+   * for.
+   *
+   * **Config-derived styles are not in that set at all**, which is the gap this used to have.
+   * `globalCss`, the reset, config recipes and compositions serialize through
+   * `transformStyles`, and that clones the decoder — so their atoms land in a throwaway and
+   * `decoder.atomic` never hears about them. Reading only the sheet made `'error'` *quieter*
+   * than the default on exactly those styles: the warning was suppressed in favour of a check
+   * that could not see them, so a bad token in `globalCss` warned with the option unset and
+   * then passed silently with it set to `'error'`. `utility.unresolvedTokens` is the record of
+   * what only `transform` can see; see it for why accumulating is right for that half.
+   *
+   * Both halves key on `property:path` with shorthands resolved, so a value that does reach
+   * both — every atomic style is transformed once before it is memoized — is one finding.
+   *
+   * Here rather than beside the asserts in `BambooContext` because this is where the sheet
+   * exists: those all run during extraction, before anything has been decoded. Every path
+   * that emits css comes through `getCss`.
+   */
+  assertNoUnresolvedTokens: () => void;
   /**
    * Get CSS for a specific layer from the stylesheet
    */

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { Context, Recipes, expandNestedCss, extractParentSelectors, extractTrailingPseudos, pruneKeyframes, prunePreflight, pruneTokenVars, prunesPreflight, stringify } from "@bamboocss/core";
 import { logger } from "@bamboocss/logger";
-import { BambooError, capitalize, compact, cssVarRefs, dashCase, isBoolean, isObject, mapEntries, unionType, walkObject } from "@bamboocss/shared";
+import { BambooError, capitalize, compact, cssVarRefs, dashCase, isBoolean, isObject, mapEntries, truncateList, unionType, walkObject } from "@bamboocss/shared";
 import { match } from "ts-pattern";
 import outdent$1, { outdent } from "outdent";
 import { stringify as stringify$1 } from "javascript-stringify";
@@ -85,6 +85,7 @@ function generateConditions(ctx) {
 function generateCssFn(ctx) {
 	const { utility, hash, prefix } = ctx;
 	const { separator } = utility;
+	const leafFallback = ctx.config.leafFallback ?? true;
 	return {
 		dts: outdent`
     ${ctx.file.importType("SystemStyleObject, ViewTransitionFn", "../types/index")}
@@ -178,12 +179,22 @@ function generateCssFn(ctx) {
 
     // Emitted for the source transform, which rewrites a single dynamic style leaf into a
     // call to this rather than leaving a \`css()\` behind. \`prefix\` is the class up to the
-    // value, resolved at build time; \`prop\` is only used for the shapes \`leafClass\`
-    // declines, which have to run the real thing.
-    export const cssLeaf = (prefix, prop, value) => {
+    // value, resolved at build time; \`prop\` names the property for the shapes \`leafClass\`
+    // declines.
+    ${leafFallback ? `export const cssLeaf = (prefix, prop, value) => {
       const className = leafClass(prefix, value)
       return className === undefined ? css({ [prop]: value }) : className
-    }
+    }` : `export const cssLeaf = (prefix, prop, value) => {
+      const className = leafClass(prefix, value)
+      if (className === undefined) {
+        throw new Error(
+          \`[bamboocss] \\\`\${prop}\\\` got a \${Array.isArray(value) ? 'responsive array' : 'condition object'} from a \` +
+            \`runtime value, and \\\`leafFallback\\\` is off. Write the conditions as a literal at the call site, so \` +
+            \`the build resolves each branch, or set \\\`leafFallback: true\\\` to keep the runtime.\`,
+        )
+      }
+      return className
+    }`}
 
     // Sugar for the string form, so the feature has an import to discover, a signature to
     // hover and a name the editor can complete. The extractor evaluates the call, so the
@@ -2327,13 +2338,36 @@ function generatePropTypes(ctx) {
 	return outdent`
   ${result.join("\n")}
 
-  type WithColorOpacityModifier<T> = [T] extends [string] ? \`$\{T}/\${string}\` & { __colorOpacityModifier?: true } : never
-
   type ImportantMark = "!" | "!important"
   type WhitespaceImportant = \` \${ImportantMark}\`
   type Important = ImportantMark | WhitespaceImportant
   type WithImportant<T> = [T] extends [string] ? \`\${T}\${Important}\` & { __important?: true } : never
 
+  /**
+   * The modifiers a token path may carry, as one open-ended tail rather than one closed
+   * template per form.
+   *
+   * ⚠️ The \`& { __modifier?: true }\` is load-bearing, and nothing reads it. Deleting it as
+   * dead weight costs **12.8x** on \`tsc\` — measured at 87.2s against 6.8s over 4,000 call
+   * sites — because it is what stops TypeScript attempting subtype reduction across the
+   * union these expand into. The same applies to \`__important\` above.
+   *
+   * A template literal distributes over a union in any placeholder, so \`\${T}\` against a
+   * 258-token colour palette is 258 members, and the old \`\${T}\${Important}\` was four times
+   * that. Between them the two modifier forms were 5N of a ~1,560-member union for \`color\`
+   * alone, and half the cost of type-checking a \`css()\` call under \`strictTokens\`. Folding
+   * them into one 3N tail is 14.5% off that — 7.09s against 8.29s over the same 4,000 call
+   * sites, with a control repeat agreeing to 3.5%.
+   *
+   * What it gives up is the tail: \`red.300!nonsense\` type-checks now, where five exact
+   * templates would have rejected it. \`unresolvedToken\` strips the mark and resolves the
+   * path underneath, so the build still reports it — warning by default, failing under
+   * \`'error'\`. The diagnostic moves rather than disappears, and only for a value nobody
+   * writes on purpose.
+   */
+  type Modifier = "/" | "!" | " !"
+  type WithModifier<T> = [T] extends [string] ? \`\${T}\${Modifier}\${string}\` & { __modifier?: true } : never
+
   /**
    * A list of candidate values, most-preferred first, emitted as repeated declarations so the
    * browser keeps the last one it understands.
@@ -2365,8 +2399,7 @@ function generatePropTypes(ctx) {
     | \`[\${string}]\`
     | FallbackValue
     | WithImportant<FallbackValue>
-    | WithColorOpacityModifier<T>
-    | WithImportant<T>
+    | WithModifier<T>
 
   /**
    * Will restrict the value of properties that have predefined values to those values only.
@@ -3908,8 +3941,21 @@ var Generator = class extends Context {
 	* unused for want of a utility to reference it.
 	*
 	* `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+	*
+	* `reachableVars` is `pruneTokens`' answer about custom properties, which has to be handed
+	* over rather than re-derived here. A token kept by a reader outside the stylesheet — a
+	* `token()` call, a `prune.keepTokens` pattern, a theme, a `globalCss` export — is
+	* reachable to that pass and invisible to this one, so deriving it again from the css
+	* deletes the `@keyframes` out from under a declaration that ships. Every caller that
+	* prunes both hands it over.
+	*
+	* Omitting it falls back to what `prune.tokens` implies. Under `off` that is `'all'`: no
+	* token declaration is removable, so each one ships and keeps the keyframe it names —
+	* and `off` is precisely the setting chosen because something outside the stylesheet
+	* reads them. Otherwise it is the css alone, which is what a caller running this pass
+	* without the other one is asking for.
 	*/
-	pruneKeyframes = (sheet, keep) => {
+	pruneKeyframes = (sheet, keep, reachableVars) => {
 		if (!this.config.prune?.keyframes) return;
 		const layers = sheet.layers;
 		const keyframeNames = new Set(Object.keys(this.config.theme?.keyframes ?? {}));
@@ -3927,7 +3973,8 @@ var Generator = class extends Context {
 			],
 			target: layers.tokens,
 			keyframeNames,
-			keep: new Set([...this.getThemeKeyframeNames(keyframeNames), ...keep ?? []])
+			keep: new Set([...this.getThemeKeyframeNames(keyframeNames), ...keep ?? []]),
+			reachableVars: reachableVars ?? ((this.config.prune?.tokens ?? "reachable") === "off" ? "all" : void 0)
 		});
 		logger.debug("prune:keyframes", `Removed ${result.removed} unused keyframe(s)`);
 		return result;
@@ -4015,9 +4062,79 @@ var Generator = class extends Context {
 			artifact: "styles.css",
 			content: css
 		}) ?? css;
+		this.assertNoUnresolvedTokens();
 		return css;
 	};
 	/**
+	* Fail on a style value shaped like a token path that names no token.
+	*
+	* Only under `unresolvedToken: 'error'` — see that option for why this one is graded and a
+	* dead binding is not.
+	*
+	* Two sources, because neither sees the whole build.
+	*
+	* **Atomic styles are read off the decoded sheet** rather than accumulated as `transform`
+	* runs, and that is the load-bearing part for them. A `Context` outlives rebuilds while the
+	* decoder memoizes each atom by hash, so on the second build of the same source `transform`
+	* is never re-entered: an accumulating record either keeps a finding past the edit that
+	* fixed it — wedging a dev server — or is cleared and then never refilled, which passes a
+	* build whose source is still broken. That second one is the worse failure and is what an
+	* earlier version of this did.
+	*
+	* `decoder.atomic` has neither problem, because it is not a record of what happened — it is
+	* what the sheet is built from, and each result keeps the `prop` and `value` it was written
+	* with. So the question asked is the one that matters: does the stylesheet *being emitted*
+	* contain a declaration the browser will drop.
+	*
+	* Within a watch process that set is cumulative, and so is the css: extraction is additive,
+	* so the rule for a style deleted from source is still in the sheet until the process
+	* restarts. This reports the same way for the same reason — the declaration really is still
+	* in the file being written, and saying otherwise would be a check that disagreed with its
+	* own output. A production build is a fresh process and sees only what its source asked
+	* for.
+	*
+	* **Config-derived styles are not in that set at all**, which is the gap this used to have.
+	* `globalCss`, the reset, config recipes and compositions serialize through
+	* `transformStyles`, and that clones the decoder — so their atoms land in a throwaway and
+	* `decoder.atomic` never hears about them. Reading only the sheet made `'error'` *quieter*
+	* than the default on exactly those styles: the warning was suppressed in favour of a check
+	* that could not see them, so a bad token in `globalCss` warned with the option unset and
+	* then passed silently with it set to `'error'`. `utility.unresolvedTokens` is the record of
+	* what only `transform` can see; see it for why accumulating is right for that half.
+	*
+	* Both halves key on `property:path` with shorthands resolved, so a value that does reach
+	* both — every atomic style is transformed once before it is memoized — is one finding.
+	*
+	* Here rather than beside the asserts in `BambooContext` because this is where the sheet
+	* exists: those all run during extraction, before anything has been decoded. Every path
+	* that emits css comes through `getCss`.
+	*/
+	assertNoUnresolvedTokens = () => {
+		if (this.config.unresolvedToken !== "error") return;
+		const found = new Map(this.utility.unresolvedTokens);
+		for (const atom of this.decoder.atomic) {
+			const { prop, value } = atom.entry;
+			if (typeof value !== "string" || typeof prop !== "string") continue;
+			if (!this.utility.isUnresolvedTokenValue(prop, value)) continue;
+			const key = this.utility.resolveShorthand(prop);
+			const bare = this.utility.bareTokenPath(key, value);
+			found.set(`${key}:${bare}`, {
+				prop: key,
+				value: bare,
+				category: this.utility.getTokenCategory(key)
+			});
+		}
+		if (!found.size) return;
+		const detail = truncateList(Array.from(found.values(), ({ prop, value, category }) => {
+			return `- \`${prop}: ${value}\`.${category ? ` Check the path against your \`${category}\` tokens.` : ""}`;
+		}), {
+			limit: 25,
+			unit: "value",
+			separator: "\n"
+		});
+		throw new BambooError("UNRESOLVED_TOKEN", `${found.size} style value(s) name a token that does not exist:\n\n${detail}\n\nEach is emitted as written, which parses — so the stylesheet is valid and nothing downstream objects. The browser drops the declaration at compute time and the style is simply absent from the element, which surfaces as "this never applied" a long way from the typo that caused it. Write \`[value]\` to mark one as a literal, or set \`unresolvedToken: 'warn'\` to report these without failing.`);
+	};
+	/**
 	* Get CSS for a specific layer from the stylesheet
 	*/
 	getLayerCss = (sheet, layer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/generator",
-  "version": "1.33.0",
+  "version": "1.34.1",
   "description": "The css generator for css bamboo",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -38,12 +38,12 @@
     "pluralize": "8.0.0",
     "postcss": "8.5.26",
     "ts-pattern": "5.9.0",
-    "@bamboocss/core": "1.33.0",
-    "@bamboocss/is-valid-prop": "^1.33.0",
-    "@bamboocss/logger": "1.33.0",
-    "@bamboocss/shared": "1.33.0",
-    "@bamboocss/token-dictionary": "1.33.0",
-    "@bamboocss/types": "1.33.0"
+    "@bamboocss/core": "1.34.1",
+    "@bamboocss/is-valid-prop": "^1.34.1",
+    "@bamboocss/logger": "1.34.1",
+    "@bamboocss/shared": "1.34.1",
+    "@bamboocss/token-dictionary": "1.34.1",
+    "@bamboocss/types": "1.34.1"
   },
   "devDependencies": {
     "@types/pluralize": "0.0.33"