zyzz 0.0.34 → 0.0.36

package/src/compiler/Graph.ts

@@ -106,7 +106,7 @@ export declare namespace compile {
     readonly [Stylesheets.packed]?: readonly Stylesheets.Resource[]
     /** Independently loaded reset for module-based hosts. */
     readonly [Stylesheets.reset]?: Stylesheets.Resource | undefined
-    /** Versioned compiler-only JSON per module; publish beside the compiled entrypoint as <entry>.zyzz.json. */
+    /** Versioned compiler-only JSON, including static literal exports. Publish beside the compiled entrypoint as <entry>.zyzz.json. */
     readonly contracts: Readonly<Record<string, string>>
     /** Direct static runtime source and library-contract dependencies, keyed by module identity. */
     readonly dependencies: Readonly<Record<string, readonly string[]>>

package/src/internal/Condition.ts

@@ -91,16 +91,35 @@ export type Relationship = symbol & { readonly [relationship]: true }
 export type Keys<
   tokens extends Theme.Tokens = {},
   key extends PropertyKey = never,
-> =
-  | ([key] extends [never]
-      ? never
-      : symbol extends key
-        ? symbol
-        : Relationship | Query)
-  | Raw
-  | `@media ${Alias<Names<tokens, 'breakpoint'>>}`
-  | `@container ${Alias<Names<tokens, 'container'>>}`
-  | `@container ${Containers<tokens>} ${Alias<Names<tokens, 'container'>>}`
+> = [key] extends [never]
+  ? Static<tokens>
+  : symbol extends key
+    ? Static<tokens, symbol>
+    : Static<tokens, Relationship | Query>
+
+/** The part of `Keys` that depends on the authored keys. */
+export type Dynamic<key extends PropertyKey> = [key] extends [never]
+  ? never
+  : symbol extends key
+    ? symbol
+    : Relationship | Query
+
+/**
+ * The part of `Keys` that depends only on the bound tokens, plus `extra`.
+ * The wrapping conditional caches the union by its arguments. A bare union alias is reduced
+ * again on every instantiation, which compares each literal against each pattern.
+ */
+export type Static<tokens extends Theme.Tokens, extra = never> = [
+  tokens,
+  extra,
+] extends [unknown, unknown]
+  ?
+      | extra
+      | Raw
+      | `@media ${Alias<Names<tokens, 'breakpoint'>>}`
+      | `@container ${Alias<Names<tokens, 'container'>>}`
+      | `@container ${Containers<tokens>} ${Alias<Names<tokens, 'container'>>}`
+  : never
 
 /** Recognizes structured rule keys before declaration parsing. */
 export function is(key: string): boolean {

package/src/internal/Configuration.ts

@@ -19,6 +19,7 @@ import * as VariableSets from './VariableSets.js'
 import * as Vars from '../Vars.js'
 import * as Selection from '../runtime/Selection.js'
 import * as Token from './Token.js'
+import type * as Value from './Value.js'
 import type * as Completion from './Completion.js'
 
 /** Creates token-free authoring without a configuration file or global state. */
@@ -673,6 +674,45 @@ type Entry<
 
 type Keys<styles> = styles extends unknown ? keyof styles : never
 
+/**
+ * Returns `key` when it names a condition or an allowed `@layer` block, otherwise `never`.
+ * Testing the key against the cached `Condition.Static` union avoids building a union per key.
+ */
+export type Nested<
+  tokens extends Theme.Tokens,
+  key extends PropertyKey,
+  layers extends string,
+> = key extends `@layer${string}`
+  ? key extends '@layer' | `@layer ${layers}`
+    ? key
+    : key extends Exclude<Condition.Static<tokens>, `@layer${string}`>
+      ? key
+      : never
+  : key extends Condition.Static<tokens>
+    ? key
+    : key extends Condition.Dynamic<key>
+      ? key
+      : never
+
+// The conditional caches this union per configuration. `Body` runs for every style, and the
+// union holds every property name.
+type Reserved<
+  tokens extends Theme.Tokens,
+  layers extends string,
+  mappings extends Shorthands.Map,
+> = [tokens, layers, mappings] extends [unknown, unknown, unknown]
+  ?
+      | keyof mappings
+      | 'selectors'
+      | 'targets'
+      | 'typography'
+      | 'vars'
+      | keyof Style.DeclarationProperties
+      | Exclude<Condition.Static<tokens>, `@layer${string}`>
+      | '@layer'
+      | `@layer ${layers}`
+  : never
+
 /** Checked declaration body shared by configured styles and recipe choices. */
 export type Body<
   styles,
@@ -682,16 +722,8 @@ export type Body<
   targets extends boolean = true,
 > = Record<
   Exclude<
-    Keys<styles>,
-    | keyof mappings
-    | 'selectors'
-    | 'targets'
-    | 'typography'
-    | 'vars'
-    | keyof Style.DeclarationProperties
-    | Exclude<Condition.Keys<tokens, Keys<styles>>, `@layer${string}`>
-    | '@layer'
-    | `@layer ${layers}`
+    Exclude<Keys<styles>, Reserved<tokens, layers, mappings>>,
+    Exclude<Condition.Dynamic<Keys<styles>>, `@layer${string}`>
   >,
   never
 > &
@@ -735,10 +767,7 @@ export type Body<
                     : never
                 }
               : never
-            : key extends
-                  | Exclude<Condition.Keys<tokens, key>, `@layer${string}`>
-                  | '@layer'
-                  | `@layer ${layers}`
+            : key extends Nested<tokens, key, layers>
               ? styles[key] extends Record<string, unknown>
                 ? Body<styles[key], tokens, layers, mappings, targets>
                 : never
@@ -753,7 +782,9 @@ export type Body<
                       : target
                   }[mappings[key][number]] extends never
                   ? styles[key]
-                  : never
+                  : [Token.Names<tokens, mappings[key][number]>] extends [never]
+                    ? never
+                    : Value.Mismatch<tokens, mappings[key][number]>
                 : Style.Accepted<Pick<styles, key>, tokens>[key]
       }
     : never)

package/src/internal/Value.ts

@@ -201,6 +201,11 @@ export type Mismatch<tokens, property extends keyof Literal.Properties> =
       >
     : never
 
+/** Lists the named sets a property accepts, so mismatch diagnostics name them. */
+export type Unmatched<names> =
+  // Without configured names the property is unknown, and `never` reports it as such.
+  [names] extends [never] ? never : Expected<names>
+
 // An object brand never reduces with a string literal, so the diagnostic keeps the expected values.
 type Expected<values> = { readonly [expected]: values }
 

package/src/internal/VariableSets.ts

@@ -82,6 +82,28 @@ export function build(
   const conditions: string[][] = []
   const active = new Set<object>()
   function visit(input: unknown, path: string[]) {
+    if (input === null && base && path.length) {
+      if (options.derived)
+        throw new Vars.InvalidError(
+          path,
+          'Derived variables cannot remove paths.',
+        )
+      const key = JSON.stringify(path)
+      if (!leaves.has(key) && !categories.has(key))
+        throw new Vars.InvalidError(
+          path,
+          'Extensions can only remove existing paths.',
+        )
+      // A removed category takes every leaf below it, including typography conditions.
+      for (const name of Object.keys(values)) {
+        const parts = paths[name] ?? name.split('.')
+        if (path.every((part, index) => parts[index] === part)) {
+          delete values[name]
+          delete paths[name]
+        }
+      }
+      return
+    }
     if (
       typeof input === 'string' ||
       typeof input === 'number' ||