praxis-kit 4.1.3 → 6.0.0

package/dist/svelte/index.d.ts

@@ -1,5 +1,5 @@
 import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
-import { Diagnostics, DiagnosticInput } from '../_shared/diagnostics.js';
+import { Diagnostics, DiagnosticInput, DiagnosticsMode } from '../_shared/diagnostics.js';
 
 type StringMap<T = unknown> = Record<string, T>;
 type AnyRecord = StringMap<unknown>;
@@ -36,6 +36,26 @@ type ChildrenEvaluator$1 = {
     evaluate: (children: unknown[]) => void;
 };
 
+/**
+ * Resolved per-instance state available to a dynamic (`dynamic(...)`) child
+ * rule field — the same tag/props every adapter already computes before
+ * evaluating children, exposed so a rule can vary by them (e.g. cardinality
+ * that depends on the resolved `as` tag).
+ */
+type ChildRuleContext = {
+    readonly tag: unknown;
+    readonly props: Readonly<AnyRecord>;
+};
+
+declare const RULE_BRAND: unique symbol;
+
+type DynamicRule<T, C = unknown> = {
+    readonly [RULE_BRAND]: true;
+    resolve(context: C): T;
+};
+
+type Rule<T, C = unknown> = T | DynamicRule<T, C>;
+
 type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
 
 type ChildRulePosition = 'first' | 'last' | 'any';
@@ -43,7 +63,13 @@ type ChildRulePosition = 'first' | 'last' | 'any';
 type ChildRuleInput<T = unknown, U extends T = T> = {
     name: string;
     match: ChildRuleMatch<T, U>;
-    cardinality?: CardinalityInput;
+    /**
+     * Either a static cardinality, or `dynamic((ctx) => ...)` to derive it from
+     * the resolved tag/props (e.g. a different max depending on `as`). `match`
+     * stays static-only — it's already a function, so a dynamic wrapper would
+     * be indistinguishable from the predicate itself without one.
+     */
+    cardinality?: Rule<CardinalityInput, ChildRuleContext>;
     position?: ChildRulePosition;
     /**
      * Optional component-type reference for O(1) dispatch index.
@@ -217,9 +243,25 @@ type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly Ar
 type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
 
 type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
-    readonly diagnostics?: Diagnostics;
+    /**
+     * Accepts a preset name (`'warn'`, `'throw'`, `'silent'`) or a full `Diagnostics`
+     * instance for custom reporting/policy. The string form needs no import from
+     * `@praxis-kit/diagnostics`.
+     */
+    readonly diagnostics?: Diagnostics | DiagnosticsMode;
     readonly aria?: readonly AriaRule[];
     readonly children?: readonly ChildRuleInput[];
+    /**
+     * When true, only children matching a `children` rule (or text, per `allowText`)
+     * are valid — anything else is rejected. Default: false (open — children not
+     * matching any rule are allowed).
+     */
+    readonly exclusiveChildren?: boolean;
+    /**
+     * When false, text/number child nodes are rejected regardless of exclusiveChildren
+     * or any listed rule. Default: true.
+     */
+    readonly allowText?: boolean;
     readonly props?: readonly PropNormalizer[];
     /** Restricts the `as` prop to this set of tags. Violations route through diagnostics. */
     readonly allowedAs?: readonly TAllowed[];
@@ -265,6 +307,8 @@ type ResolvedFactoryOptions<TDefault extends ElementType = ElementType, Props ex
     readonly htmlPropNormalizersFn?: (tag: unknown) => readonly PropNormalizer[] | undefined;
     readonly htmlChildrenEvaluatorFn?: (tag: unknown) => ChildrenEvaluator$1 | undefined;
     readonly childRules?: readonly ChildRuleInput[];
+    readonly exclusiveChildren?: boolean;
+    readonly allowText?: boolean;
     readonly ariaRules?: readonly AriaRule[];
     readonly allowedAs?: readonly ElementType[];
     readonly precomputedClasses?: Readonly<Record<string, string>>;
@@ -302,10 +346,27 @@ declare abstract class InvariantBase {
     protected invariant(condition: unknown, input: DiagnosticInput): void;
 }
 
+type ChildrenEvaluatorOptions = {
+    /**
+     * When true, only children matching a rule (or text, per `allowText`) are
+     * valid — anything else is rejected. Default: false (open — children not
+     * matching any rule are allowed).
+     */
+    readonly exclusiveChildren?: boolean | undefined;
+    /**
+     * When false, text/number child nodes are rejected regardless of
+     * exclusiveChildren or any listed rule. Default: true.
+     */
+    readonly allowText?: boolean | undefined;
+};
 declare class ChildrenEvaluator extends InvariantBase {
     #private;
-    constructor(rules: readonly ChildRuleInput[], diagnostics: Diagnostics, context?: string);
-    evaluate(children: unknown[]): void;
+    constructor(rules: readonly ChildRuleInput[], diagnostics: Diagnostics, context?: string, options?: ChildrenEvaluatorOptions);
+    /**
+     * @param context Required when any rule has a `dynamic(...)` cardinality —
+     *   supplies the resolved tag/props those rules are evaluated against.
+     */
+    evaluate(children: unknown[], context?: ChildRuleContext): void;
 }
 
 declare function createPolymorphic2<TDefault extends ElementType, Props extends AnyRecord, Variants extends Readonly<VariantMap>, TPreset extends RecipeMap<Variants> = Readonly<EmptyRecord>, TPlugin extends AnyClassPluginFactory = AnyClassPluginFactory>(options?: FactoryOptions<TDefault, Props, Variants, TPreset, TPlugin>): PolymorphicRuntime<TDefault, Props, Variants, Extract<keyof TPreset, string>, TPreset, PluginInstance<TPlugin>>;

package/dist/svelte/index.js

@@ -313,6 +313,19 @@ function makeResolveTag(defaultTag) {
   };
 }
 
+// ../../lib/primitive/src/rule/rule-brand.ts
+var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
+
+// ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+  return isObject(rule, true) && rule[RULE_BRAND] === true;
+}
+
+// ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+  return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+
 // ../../lib/primitive/src/utils/assert-never.ts
 function assertNever(value) {
   throw new Error(`Unexpected value: ${String(value)}`);
@@ -1760,32 +1773,68 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 };
 
 // ../../lib/contract/src/children/children-evaluator.ts
+var isTextLike = (child) => isString(child) || isNumber(child);
+function checkPositionCardinalityInvariant(rules, context) {
+  iterate.forEach(rules, (rule) => {
+    const { name, position, cardinality } = rule;
+    if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+      throw new RangeError(
+        `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+      );
+    }
+  });
+}
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
-  #rules;
-  #ruleNames;
+  /** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+  #staticRules;
+  /** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+  #dynamicRuleInputs;
   #matcher;
   #ruleValidator;
-  constructor(rules, diagnostics, context = "Component") {
+  #exclusiveChildren;
+  #allowText;
+  constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
-    iterate.forEach(this.#rules, (rule) => {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
+    this.#exclusiveChildren = options.exclusiveChildren ?? false;
+    this.#allowText = options.allowText ?? true;
+    const staticRuleInputs = [];
+    const dynamicRuleInputs = [];
+    iterate.forEach(rules, (rule) => {
+      if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+      else staticRuleInputs.push(rule);
     });
-    this.#matcher = new RuleMatcher(this.#rules);
+    this.#dynamicRuleInputs = dynamicRuleInputs;
+    this.#staticRules = staticRuleInputs.map(
+      (r) => normalizeChildRule(r)
+    );
     this.#ruleValidator = new RuleValidator(context, diagnostics);
+    if (this.#dynamicRuleInputs.length === 0) {
+      checkPositionCardinalityInvariant(this.#staticRules, context);
+      this.#matcher = new RuleMatcher(this.#staticRules);
+    } else {
+      this.#matcher = void 0;
+    }
   }
-  evaluate(children) {
+  /**
+   * @param context Required when any rule has a `dynamic(...)` cardinality —
+   *   supplies the resolved tag/props those rules are evaluated against.
+   */
+  evaluate(children, context) {
     if (!this.active) return;
-    const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    const { rules, matcher } = this.#resolveRules(context);
+    const {
+      matrix,
+      unexpectedIndices: rawUnexpectedIndices,
+      ambiguousIndices
+    } = matcher.match(children);
+    this.#ruleValidator.validate(rules, matrix, children.length);
+    const unexpectedIndices = new Set(
+      [...rawUnexpectedIndices].filter(
+        (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
+      )
+    );
     if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
     const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
     iterate.forEach(violating, (ci) => {
@@ -1794,11 +1843,28 @@ var ChildrenEvaluator = class extends InvariantBase {
         this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        const names = [...matches].map((ri) => rules[ri]?.name ?? `#${ri}`);
         this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
     });
   }
+  #resolveRules(context) {
+    if (this.#dynamicRuleInputs.length === 0) {
+      return { rules: this.#staticRules, matcher: this.#matcher };
+    }
+    if (context === void 0) {
+      throw new RangeError(
+        `ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality \u2014 evaluate() requires a context argument to resolve them.`
+      );
+    }
+    const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+      const cardinality = resolveRule(r.cardinality, context);
+      return normalizeChildRule({ ...r, cardinality });
+    });
+    checkPositionCardinalityInvariant(resolvedDynamicRules, this.#context);
+    const rules = [...this.#staticRules, ...resolvedDynamicRules];
+    return { rules, matcher: new RuleMatcher(rules) };
+  }
 };
 
 // ../../lib/contract/src/props/get-disabled-props.ts
@@ -1907,8 +1973,11 @@ function metadata(name = "metadata") {
 function firstOptional(name, tag) {
   return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
 }
-function contract(children) {
-  return { diagnostics: warnDiagnostics, children };
+function contract(children, options) {
+  return { diagnostics: warnDiagnostics, children, ...options };
+}
+function closedContract(children) {
+  return contract(children, { exclusiveChildren: true });
 }
 function ariaContract(aria) {
   return { diagnostics: warnDiagnostics, aria };
@@ -1934,8 +2003,10 @@ var VOID_TAGS = [
 ];
 var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
 var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
-var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
-var tableContract = contract([
+var listContract = closedContract([
+  { name: "list-item", match: isTag("li", ...METADATA_TAGS) }
+]);
+var tableContract = closedContract([
   firstOptional("caption", "caption"),
   { name: "colgroup", match: isTag("colgroup") },
   { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
@@ -1943,29 +2014,31 @@ var tableContract = contract([
   { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableBodyContract = contract([
+var tableBodyContract = closedContract([
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableRowContract = contract([
+var tableRowContract = closedContract([
   { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
 ]);
-var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
-var dlContract = contract([
+var colgroupContract = closedContract([
+  { name: "column", match: isTag("col", "template") }
+]);
+var dlContract = closedContract([
   { name: "term", match: isTag("dt") },
   { name: "description", match: isTag("dd") },
   { name: "group", match: isTag("div") },
   metadata()
 ]);
-var selectContract = contract([
+var selectContract = closedContract([
   { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
 ]);
-var optgroupContract = contract([
+var optgroupContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var datalistContract = contract([
+var datalistContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var pictureContract = contract([
+var pictureContract = closedContract([
   { name: "source", match: isTag("source", ...METADATA_TAGS) },
   { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
 ]);
@@ -1981,23 +2054,18 @@ var mediaContract = contract([
   metadata(),
   { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
 ]);
-var headContract = contract([
+var headContract = closedContract([
   {
     name: "metadata",
     match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
   }
 ]);
-var htmlContract = contract([
+var htmlContract = closedContract([
   { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
   { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
 ]);
-var voidContract = contract([]);
-var textOnlyContract = contract([
-  {
-    name: "text",
-    match: (child) => isString(child) || isNumber(child)
-  }
-]);
+var voidContract = contract([], { exclusiveChildren: true, allowText: false });
+var textOnlyContract = contract([], { exclusiveChildren: true });
 var landmarkContract = ariaContract([landmarkRoleRule, landmarkNameAdvisory]);
 var dialogContract = ariaContract([requireAccessibleName]);
 var menuContract = ariaContract([requireAccessibleName]);
@@ -2042,9 +2110,15 @@ var htmlContracts = {
 var htmlDiagnostics = warnDiagnostics2;
 function buildEvaluatorMap() {
   const map2 = /* @__PURE__ */ new Map();
-  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
-    if (children?.length) {
-      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
+  iterate.forEachEntry(htmlContracts, (tag, { children, exclusiveChildren, allowText }) => {
+    if (children?.length || exclusiveChildren || allowText === false) {
+      map2.set(
+        tag,
+        new ChildrenEvaluator(children ?? [], htmlDiagnostics, `<${tag}>`, {
+          exclusiveChildren,
+          allowText
+        })
+      );
     }
   });
   return map2;
@@ -2255,7 +2329,7 @@ function definePipeline(factory) {
 }
 
 // ../core/src/options/resolve-factory-options.ts
-import { silentDiagnostics } from "../_shared/diagnostics.js";
+import { resolveDiagnostics, silentDiagnostics } from "../_shared/diagnostics.js";
 var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
 function composeNormalizers(normalizers, fn) {
   if (!normalizers?.length) return fn;
@@ -2276,7 +2350,7 @@ function resolveFactoryOptions(options = {}) {
   const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
   return Object.freeze({
     defaultTag: options.tag ?? "div",
-    diagnostics: enforcement?.diagnostics ?? silentDiagnostics,
+    diagnostics: resolveDiagnostics(enforcement?.diagnostics, silentDiagnostics),
     variantKeys,
     ...whenDefined("displayName", options.name),
     ...whenDefined("defaultProps", options.defaults),
@@ -2289,6 +2363,8 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("normalizeFn", composedNormalizeFn),
     ...whenDefined("ariaRules", enforcement?.aria),
     ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
+    ...whenDefined("allowText", enforcement?.allowText),
     ...whenDefined("allowedAs", enforcement?.allowedAs),
     ...whenDefined("precomputedClasses", styling?.precomputedClasses)
   });
@@ -2464,16 +2540,22 @@ function buildCoreRuntime(normalized) {
 }
 
 // ../../lib/adapter-utils/src/runtime/build-engines.ts
-function buildEngines(diagnostics, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
+function buildEngines(diagnostics, childRules, context, childrenOptions) {
+  const { exclusiveChildren, allowText } = childrenOptions ?? {};
+  return childRules?.length || exclusiveChildren || allowText === false ? {
+    childrenEvaluator: new ChildrenEvaluator(childRules ?? [], diagnostics, context, {
+      exclusiveChildren,
+      allowText
+    })
+  } : {};
 }
 
 // ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
-import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
+import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics2, resolveDiagnostics as resolveDiagnostics2 } from "../_shared/diagnostics.js";
 function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics2) {
   return {
     name: options.name ?? defaultName,
-    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
+    diagnostics: resolveDiagnostics2(options.enforcement?.diagnostics, defaultDiagnostics)
   };
 }
 
@@ -2518,7 +2600,11 @@ function buildRuntime(options) {
   const { childrenEvaluator } = buildEngines(
     normalized.diagnostics,
     normalized.enforcement?.children,
-    normalized.name
+    normalized.name,
+    {
+      exclusiveChildren: normalized.enforcement?.exclusiveChildren,
+      allowText: normalized.enforcement?.allowText
+    }
   );
   const filterProps = composeFilter(ownedKeys, normalized.filterProps);
   const slotValidator = new SlotValidator(normalized.name, normalized.diagnostics, "Snippet");

package/dist/tailwind/index.d.ts

@@ -1,5 +1,21 @@
 import { Diagnostics } from '../_shared/diagnostics.js';
-import { RequireAtLeastOne, Simplify } from 'type-fest';
+import { RequireAtLeastOne, Simplify, ValueOf } from 'type-fest';
+
+/**
+ * Canonical list of reserved layout prop names.
+ *
+ * This array is the single source of truth for every supported CSS `display`
+ * value exposed as a boolean prop. The `LayoutKey` type is derived directly
+ * from this list.
+ *
+ * To add a new display mode:
+ *   1. Add the display value here.
+ *   2. Register its layout family in `LAYOUT_FAMILY_MAP`.
+ *
+ * Prop names intentionally match the corresponding Tailwind/CSS display
+ * utilities, so no additional prop-to-class mapping is required.
+ */
+declare const layoutKeys: readonly ["flex", "inline-flex", "grid", "inline-grid", "block", "inline-block", "inline", "hidden", "contents", "flow-root", "list-item", "table", "inline-table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row-group", "table-row"];
 
 type StringMap<T = unknown> = Record<string, T>;
 type AnyRecord = StringMap<unknown>;
@@ -94,35 +110,19 @@ type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
     readonly _pluginProps?: TProps;
 }>;
 
-/**
- * Canonical list of reserved layout prop names.
- *
- * This array is the single source of truth for every supported CSS `display`
- * value exposed as a boolean prop. The `LayoutKey` type is derived directly
- * from this list.
- *
- * To add a new display mode:
- *   1. Add the display value here.
- *   2. Register its layout family in `LAYOUT_FAMILY_MAP`.
- *
- * Prop names intentionally match the corresponding Tailwind/CSS display
- * utilities, so no additional prop-to-class mapping is required.
- */
-declare const layoutKeys: readonly ["flex", "inline-flex", "grid", "inline-grid", "block", "inline-block", "inline", "hidden", "contents", "flow-root", "list-item", "table", "inline-table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row-group", "table-row"];
-
 type TupleValues<T extends readonly unknown[]> = T[number];
-type ValueOf<T> = T[keyof T];
 type LayoutKey<T extends readonly string[]> = TupleValues<T>;
 type LayoutFamily<M extends StringMap<string>> = ValueOf<M>;
-type LayoutMode<T extends readonly string[]> = LayoutKey<T> | 'none';
+type ResolvedLayout<T extends readonly string[]> = LayoutKey<T> | 'none';
 type ExclusiveTrueProp<K extends PropertyKey> = {
     [P in K]: Simplify<Record<P, true> & Partial<Record<Exclude<K, P>, never>>>;
 }[K];
 /**
- * Mutually exclusive display shorthand props.
+ * Mutually exclusive layout shorthand props.
  *
- * At most one key may be `true`. Passing multiple is a compile-time error; the
- * runtime also warns and lets the first key in declaration order take precedence.
+ * Exactly one layout prop may be `true`, or none at all. Multiple `true`
+ * props produce a compile-time error. If invalid props reach runtime, the
+ * resolver warns and uses the first declared layout.
  */
 type LayoutProps<T extends readonly string[]> = ExclusiveTrueProp<LayoutKey<T>> | Partial<Record<LayoutKey<T>, never>>;
 
@@ -155,23 +155,76 @@ type Token<TKind extends string, TData extends object = EmptyRecord> = {
     kind: TKind;
     raw: string;
 } & TData;
-type LayoutToken = Token<'layout', {
-    value: LayoutKey<typeof layoutKeys>;
-}>;
-type ConditionalToken = Token<'conditional', {
-    requires: Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>;
-}>;
-type GapToken = Token<'gap'>;
-type UtilityToken = Token<'utility', {
-    base: string;
-}>;
-type ClassifiedToken = Simplify<LayoutToken | ConditionalToken | GapToken | UtilityToken>;
-
-type VariantSelection = Record<string, string>;
+type TokenData = {
+    layout: {
+        value: LayoutKey<typeof layoutKeys>;
+    };
+    conditional: {
+        requires: Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>;
+    };
+    gap: EmptyRecord;
+    shared: EmptyRecord;
+    utility: {
+        base: string;
+    };
+};
+type TokenMap = {
+    [K in keyof TokenData]: Token<K, TokenData[K]>;
+};
+type LayoutToken = TokenMap['layout'];
+type ConditionalToken = TokenMap['conditional'];
+type GapToken = TokenMap['gap'];
+type SharedToken = TokenMap['shared'];
+type UtilityToken = TokenMap['utility'];
+type ClassifiedToken = Simplify<ValueOf<TokenMap>>;
+
+type VariantSelection = StringMap<string>;
 type CompoundVariant = {
     class?: unknown;
 } & AnyRecord;
 
+/**
+ * The resolved display mode for a single render.
+ *
+ * Mode is owned by the display props; a display class literal in the resolved
+ * class string is a reserved-literal authoring mistake. Defaults to `'none'`
+ * when no prop is set.
+ *
+ * `family` is derived from mode: `'flex'` for flex/inline-flex, `'grid'` for
+ * grid/inline-grid, `'none'` for all other values (and when no prop is set).
+ * The evaluator uses family — not mode — for utility and gap filtering.
+ */
+declare class LayoutState {
+    #private;
+    constructor(mode: ResolvedLayout<typeof layoutKeys>);
+    get mode(): ResolvedLayout<typeof layoutKeys>;
+    get family(): LayoutFamily<typeof LAYOUT_FAMILY_MAP>;
+}
+
+type PipelineLayoutProps = LayoutProps<typeof layoutKeys>;
+type PipelineLayout = ResolvedLayout<typeof layoutKeys>;
+type PipelineProps = PipelineLayoutProps & AnyRecord;
+interface PipelineInputs {
+    readonly props: PipelineProps;
+    readonly recipe: string | undefined;
+}
+interface PipelineResolution {
+    readonly mode: PipelineLayout;
+    readonly state: LayoutState;
+}
+interface PipelineTokens {
+    readonly filtered: ClassifiedToken[];
+    readonly tokens: ClassifiedToken[];
+}
+type TailwindPipelineArgs = [
+    tag: unknown,
+    props: PipelineInputs['props'],
+    className: ClassName | undefined,
+    recipe: PipelineInputs['recipe']
+];
+interface TailwindPipelineContext extends PipelineInputs, PipelineResolution, PipelineTokens {
+}
+
 /**
  * Layout-aware class pipeline for Tailwind CSS utility class strings.
  *
@@ -220,28 +273,10 @@ declare class ClassClassifier {
 type DependencyRules = Record<Exclude<LayoutFamily<typeof LAYOUT_FAMILY_MAP>, 'none'>, readonly RegExp[]>;
 declare const defaultDependencyRules: DependencyRules;
 
-/**
- * The resolved display mode for a single render.
- *
- * Mode is owned by the display props; a display class literal in the resolved
- * class string is a reserved-literal authoring mistake. Defaults to `'none'`
- * when no prop is set.
- *
- * `family` is derived from mode: `'flex'` for flex/inline-flex, `'grid'` for
- * grid/inline-grid, `'none'` for all other values (and when no prop is set).
- * The evaluator uses family — not mode — for utility and gap filtering.
- */
-declare class LayoutState {
-    #private;
-    constructor(mode: LayoutMode<typeof layoutKeys>);
-    get mode(): LayoutMode<typeof layoutKeys>;
-    get family(): LayoutFamily<typeof LAYOUT_FAMILY_MAP>;
-}
-
 declare class DependencyEvaluator {
     private readonly rules;
     constructor(rules: DependencyRules);
     evaluate(token: ClassifiedToken, state: LayoutState): boolean;
 }
 
-export { ClassBuilder, ClassClassifier, type ClassToken, type ClassifiedToken, type CompoundVariant, type ConditionalToken, DependencyEvaluator, type DependencyRules, type GapToken, type LayoutFamily, type LayoutKey, type LayoutMode, type LayoutProps, LayoutState, type LayoutToken, type UtilityToken, type VariantSelection, createTailwindPipeline, defaultDependencyRules, layoutKeys };
+export { ClassBuilder, ClassClassifier, type ClassToken, type ClassifiedToken, type CompoundVariant, type ConditionalToken, DependencyEvaluator, type DependencyRules, type GapToken, type LayoutFamily, type LayoutKey, type LayoutProps, LayoutState, type LayoutToken, type ResolvedLayout, type SharedToken, type TailwindPipelineArgs, type TailwindPipelineContext, type UtilityToken, type VariantSelection, createTailwindPipeline, defaultDependencyRules, layoutKeys };