@tenphi/tasty 0.0.0-snapshot.f6c0abf → 0.0.0-snapshot.fa23a44

package/README.md

@@ -42,7 +42,7 @@ On top of that foundation, Tasty gives teams a governed styling model: a CSS-lik
 ### Supporting capabilities
 
 - **Typed style props and mod props** — `styleProps` exposes selected CSS properties as typed React props (`<Space flow="row" gap="2x">`); `modProps` does the same for modifier keys (`<Button isLoading size="large">`). Both support state maps and full TypeScript autocomplete. See [Style Props](#style-props) and [Mod Props](#mod-props).
-- **Runtime, SSR, and zero-runtime options** — Use `tasty()` for runtime React components, add SSR integrations when your framework renders that runtime on the server, or use `tastyStatic()` when you specifically want build-time extraction instead of runtime styling.
+- **Server-compatible by default, zero client JS in server-only contexts** — All `tasty()` components and style functions are hook-free. In server-only rendering (Next.js RSC, Astro without islands, SSG), they produce zero client JavaScript with the full feature set. Add SSR integration only when your app also has client-side hydration. Use `tastyStatic()` only when you need build-time extraction without React.
 - **Broad modern CSS coverage** — Media queries, container queries, `@supports`, `:has()`, `@starting-style`, `@property`, `@keyframes`, and more. Features that do not fit the component model (such as `@layer` and `!important`) are intentionally left out.
 - **Performance and caching** — Runtime mode injects CSS on demand, reuses chunks aggressively, and relies on multi-level caching so large component systems stay practical.
 - **TypeScript-first and AI-friendly** — Style definitions are declarative, structurally consistent, and fully typed, which helps both humans and tooling understand advanced stateful styles without hidden cascade logic.
@@ -79,7 +79,7 @@ For the fuller docs map beyond the quick routes above, start here:
 - **[Comparison](docs/comparison.md)** — read this first if you are evaluating whether Tasty fits your team's styling model
 - **[Adoption Guide](docs/adoption.md)** — understand who Tasty is for, where it fits, and how to introduce it incrementally
 - **[Getting Started](docs/getting-started.md)** — the canonical onboarding path: install, first component, optional shared `configure()`, ESLint, editor tooling, and rendering mode selection
-- **[Style rendering pipeline](docs/PIPELINE.md)** — see the selector model behind deterministic style resolution
+- **[Style rendering pipeline](docs/pipeline.md)** — see the selector model behind deterministic style resolution
 - **[Docs Hub](docs/README.md)** — choose docs by role and task: runtime, zero-runtime, runtime SSR integration, design-system authoring, internals, and debugging
 - **[Methodology](docs/methodology.md)** — the recommended component model and public API conventions for design-system code
 
@@ -188,7 +188,7 @@ Use `configure()` once when your app or design system needs shared aliases, toke
 </Space>
 ```
 
-See [Style Props](#style-props) and [Mod Props](#mod-props) below, or the full reference in [Runtime API](docs/runtime.md#style-props).
+See [Style Props](#style-props) and [Mod Props](#mod-props) below, or the full reference in [React API](docs/react-api.md#style-props).
 
 ## Choose a Styling Approach
 
@@ -196,16 +196,17 @@ Once you understand the component model, pick the rendering mode that matches yo
 
 | Approach | Entry point | Best for | Trade-off |
 |----------|-------------|----------|-----------|
-| **Runtime** | `@tenphi/tasty` | Interactive apps with reusable stateful components and design systems | Full feature set; CSS is generated on demand at runtime |
-| **Zero-runtime** | `@tenphi/tasty/static` | Static sites, SSG, landing pages | Requires the Babel plugin; no component-level `styleProps` or runtime-only APIs |
+| **Runtime (default)** | `tasty()` from `@tenphi/tasty` | All React apps — server-rendered by default, zero client JS until you need interactivity | Full feature set; CSS computed during React rendering (server or client) |
+| **Runtime + SSR integration** | Add `@tenphi/tasty/ssr/*` | Apps with client-side hydration (Next.js client components, Astro islands) | Adds CSS deduplication, FOUC prevention, and client cache hydration |
+| **Zero-runtime** | `tastyStatic()` from `@tenphi/tasty/static` | Non-React frameworks or when you need build-time extraction without React | Requires the Babel plugin; no component-level `styleProps` or runtime-only APIs |
 
-If your framework can execute runtime React code on the server, you can also add **SSR on top of runtime** with `@tenphi/tasty/ssr/*`. This uses the same `tasty()` pipeline, but collects CSS during server rendering and hydrates the cache on the client. That is the model for Next.js, generic React SSR, and Astro islands. See [Getting Started](docs/getting-started.md#choosing-a-rendering-mode), [Zero Runtime](docs/tasty-static.md), and [Server-Side Rendering](docs/ssr.md).
+All `tasty()` components are hook-free and work as React Server Components. In server-only contexts — Next.js RSC without `'use client'`, Astro without `client:*` directives, and other SSG setups — they produce the same end result as `tastyStatic()` (static HTML + CSS, zero client JavaScript) but with the full feature set including `styleProps`, sub-elements, and variants. SSR integration is only needed when your app also has client-side rendering. See [Getting Started](docs/getting-started.md#choosing-a-rendering-mode), [Zero Runtime](docs/tasty-static.md), and [Server-Side Rendering](docs/ssr.md).
 
 ## How It Actually Works
 
 This is the core idea that makes everything else possible.
 
-For the end-to-end architecture — parsing state keys, building exclusive conditions, merging by output, and materializing selectors and at-rules — see **[Style rendering pipeline](docs/PIPELINE.md)**.
+For the end-to-end architecture — parsing state keys, building exclusive conditions, merging by output, and materializing selectors and at-rules — see **[Style rendering pipeline](docs/pipeline.md)**.
 
 ### The structural problem with normal CSS
 
@@ -363,7 +364,7 @@ Compound components can style inner parts from the parent definition with capita
 
 Sub-elements share the root state context by default, so keys like `:hover`, modifiers, root states, and media queries resolve as one coordinated styling block. Use `@own(...)` when a sub-element should react to its own state, and use the `$` selector affix when you need precise descendant targeting.
 
-See [Runtime API - Sub-element Styling](docs/runtime.md#sub-element-styling), [Style DSL - Advanced States](docs/dsl.md#advanced-states--prefix), and [Methodology](docs/methodology.md#component-architecture-root--sub-elements).
+See [React API - Sub-element Styling](docs/react-api.md#sub-element-styling), [Style DSL - Advanced States](docs/dsl.md#advanced-states--prefix), and [Methodology](docs/methodology.md#component-architecture-root--sub-elements).
 
 ### Style Props
 
@@ -378,7 +379,7 @@ const Space = tasty({
 <Space flow="row" gap={{ '': '2x', '@tablet': '4x' }}>
 ```
 
-See [Runtime API - Style Props](docs/runtime.md#style-props) and [Methodology - styleProps](docs/methodology.md#styleprops-as-the-public-api).
+See [React API - Style Props](docs/react-api.md#style-props) and [Methodology - styleProps](docs/methodology.md#styleprops-as-the-public-api).
 
 ### Mod Props
 
@@ -397,13 +398,13 @@ const Button = tasty({
 <Button isLoading size="lg">Submit</Button>
 ```
 
-See [Runtime API - Mod Props](docs/runtime.md#mod-props) and [Methodology - modProps](docs/methodology.md#modprops-and-mods).
+See [React API - Mod Props](docs/react-api.md#mod-props) and [Methodology - modProps](docs/methodology.md#modprops-and-mods).
 
 ### Variants
 
 Variants let one component expose named visual versions without pre-generating a separate class for every possible combination. In runtime mode, Tasty emits only the variant CSS that is actually used.
 
-See [Runtime API - Variants](docs/runtime.md#variants).
+See [React API - Variants](docs/react-api.md#variants).
 
 ### Recipes
 
@@ -431,7 +432,7 @@ See [Style DSL - Properties (`@property`)](docs/dsl.md#properties-property).
 
 When you do not need a full component wrapper, use the style functions directly: `useStyles` for local class names, `useGlobalStyles` for selector-scoped global CSS, `useRawCSS` for raw rules, plus `useKeyframes`, `useProperty`, `useFontFace`, and `useCounterStyle` for animation, custom-property, font, and counter-style primitives. All style functions are hook-free and work in React Server Components.
 
-See [Runtime API - Style Functions](docs/runtime.md#style-functions).
+See [React API - Style Functions](docs/react-api.md#style-functions).
 
 ### Zero-Runtime Mode
 
@@ -441,15 +442,19 @@ See [Zero Runtime (tastyStatic)](docs/tasty-static.md) and [Getting Started - Ch
 
 ### `tasty` vs `tastyStatic`
 
-`tasty()` returns React components and injects CSS on demand at runtime. `tastyStatic()` returns class names and extracts CSS during the build. Both share the same DSL, tokens, units, state mappings, and recipes, so the main choice is runtime flexibility versus build-time extraction.
+`tasty()` returns React components that compute CSS during rendering. In server-only contexts, this produces static HTML + CSS with zero client JavaScript — the same end result as `tastyStatic()` but with the full feature set. `tastyStatic()` returns class names and extracts CSS during the build via a Babel plugin, with no React dependency at runtime. Both share the same DSL, tokens, units, state mappings, and recipes. Use `tasty()` as the default for any React-based setup; use `tastyStatic()` when you need build-time extraction without React.
 
-See [Zero Runtime (tastyStatic)](docs/tasty-static.md), [Runtime API](docs/runtime.md), and [Comparison - Build-time vs runtime](docs/comparison.md#build-time-vs-runtime).
+See [Zero Runtime (tastyStatic)](docs/tasty-static.md), [React API](docs/react-api.md), and [Comparison - Build-time vs runtime](docs/comparison.md#build-time-vs-runtime).
 
 ### Server-Side Rendering
 
-SSR layers on top of runtime `tasty()` rather than introducing a separate styling model. Existing components stay unchanged while Tasty collects CSS during server rendering and hydrates the cache on the client.
+`tasty()` components already work on the server without any SSR integration — they are hook-free and render as React Server Components by default. In server-only contexts (Next.js RSC, Astro without islands), they produce zero client JavaScript with the full feature set.
 
-Use `@tenphi/tasty/ssr/next` for Next.js App Router, `@tenphi/tasty/ssr/astro` for Astro, or the core SSR API for other React SSR setups.
+SSR integration (`TastyRegistry`, `tastyIntegration`) adds CSS batching, deduplication across component trees, FOUC prevention, and client cache hydration. Use it when your app also has client-side rendering:
+
+- `@tenphi/tasty/ssr/next` for Next.js App Router (mixed server + client components)
+- `@tenphi/tasty/ssr/astro` for Astro (with or without islands)
+- The core SSR API for other React SSR setups
 
 See the [full SSR guide](docs/ssr.md).
 
@@ -606,7 +611,7 @@ Start from the docs hub if you want the shortest path to the right guide for you
 ### Reference
 
 - **[Style DSL](docs/dsl.md)** — The Tasty style language: state maps, tokens, units, color syntax, extending semantics, recipes, keyframes, and @property
-- **[Runtime API](docs/runtime.md)** — React-specific API: `tasty()` factory, component props, variants, sub-elements, and style functions
+- **[React API](docs/react-api.md)** — React-specific API: `tasty()` factory, component props, variants, sub-elements, and style functions
 - **[Configuration](docs/configuration.md)** — Global configuration: tokens, recipes, custom units, style handlers, and TypeScript extensions
 - **[Style Properties](docs/styles.md)** — Complete reference for all enhanced style properties: syntax, values, modifiers, and recommendations
 
@@ -617,7 +622,7 @@ Start from the docs hub if you want the shortest path to the right guide for you
 
 ### Internals
 
-- **[Style rendering pipeline](docs/PIPELINE.md)** — How `Styles` become mutually exclusive CSS rules: parse → exclusives → combinations → handlers → merge → materialize (`src/pipeline/`)
+- **[Style rendering pipeline](docs/pipeline.md)** — How `Styles` become mutually exclusive CSS rules: parse → exclusives → combinations → handlers → merge → materialize (`src/pipeline/`)
 - **[Style Injector](docs/injector.md)** — Internal CSS injection engine: `inject()`, `injectGlobal()`, `injectRawCSS()`, `keyframes()`, deduplication, reference counting, cleanup, SSR support, and Shadow DOM
 - **[Debug Utilities](docs/debug.md)** — Runtime CSS inspection via `tastyDebug`: CSS extraction, element inspection, cache metrics, chunk breakdown, and performance monitoring
 

package/dist/{ssr/async-storage.js → async-storage-B7_o6FKt.js}

@@ -39,6 +39,6 @@ function getSSRCollector() {
 	return storage.getStore() ?? null;
 }
 //#endregion
-export { getSSRCollector, runWithCollector };
+export { runWithCollector as n, getSSRCollector as t };
 
-//# sourceMappingURL=async-storage.js.map
+//# sourceMappingURL=async-storage-B7_o6FKt.js.map

package/dist/async-storage-B7_o6FKt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-storage-B7_o6FKt.js","names":[],"sources":["../src/ssr/async-storage.ts"],"sourcesContent":["/**\n * AsyncLocalStorage integration for SSR collector discovery.\n *\n * Used by Astro middleware and generic framework integrations where\n * the library cannot wrap the React tree with a context provider.\n * The middleware calls runWithCollector() around the render, and\n * useStyles() calls getSSRCollector() to find it.\n *\n * Uses globalThis to ensure the AsyncLocalStorage instance is shared\n * across module instances — frameworks like Astro may load middleware\n * and page components from separate module graphs.\n *\n * This module imports from 'node:async_hooks' — it must be excluded\n * from client bundles via the build configuration.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\n\nimport type { ServerStyleCollector } from './collector';\n\nconst ALS_KEY = '__tasty_ssr_als__';\n\nfunction getSharedStorage(): AsyncLocalStorage<ServerStyleCollector> {\n  const g = globalThis as Record<string, unknown>;\n  if (!g[ALS_KEY]) {\n    g[ALS_KEY] = new AsyncLocalStorage<ServerStyleCollector>();\n  }\n  return g[ALS_KEY] as AsyncLocalStorage<ServerStyleCollector>;\n}\n\n/**\n * Run a function with a ServerStyleCollector bound to the current\n * async context. All useStyles() calls within `fn` (and any async\n * continuations) will find this collector via getSSRCollector().\n */\nexport function runWithCollector<T>(\n  collector: ServerStyleCollector,\n  fn: () => T,\n): T {\n  return getSharedStorage().run(collector, fn);\n}\n\n/**\n * Retrieve the ServerStyleCollector bound to the current async context.\n * Returns null when called outside of runWithCollector() or on the client.\n */\nexport function getSSRCollector(): ServerStyleCollector | null {\n  const storage = getSharedStorage();\n  if (typeof storage?.getStore !== 'function') return null;\n  return storage.getStore() ?? null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,MAAM,UAAU;AAEhB,SAAS,mBAA4D;CACnE,MAAM,IAAI;AACV,KAAI,CAAC,EAAE,SACL,GAAE,WAAW,IAAI,mBAAyC;AAE5D,QAAO,EAAE;;;;;;;AAQX,SAAgB,iBACd,WACA,IACG;AACH,QAAO,kBAAkB,CAAC,IAAI,WAAW,GAAG;;;;;;AAO9C,SAAgB,kBAA+C;CAC7D,MAAM,UAAU,kBAAkB;AAClC,KAAI,OAAO,SAAS,aAAa,WAAY,QAAO;AACpD,QAAO,QAAQ,UAAU,IAAI"}

package/dist/{ssr/collector.js → collector-DrgDE7QB.js}

@@ -1,29 +1,24 @@
-import { fontFaceContentHash, formatFontFaceRule } from "../font-face/index.js";
-import { formatCounterStyleRule } from "../counter-style/index.js";
-import { renderStyles } from "../pipeline/index.js";
-import { getEffectiveProperties, getGlobalConfigTokens, getGlobalCounterStyle, getGlobalFontFace } from "../config.js";
-import { formatPropertyCSS } from "./format-property.js";
-import { formatGlobalRules } from "./format-global-rules.js";
-import { formatRules } from "./format-rules.js";
+import { F as formatFontFaceRule, P as fontFaceContentHash, a as getGlobalCounterStyle, ct as hashString, i as getGlobalConfigTokens, j as formatCounterStyleRule, o as getGlobalFontFace, r as getEffectiveProperties, u as getGlobalStyles, x as renderStyles } from "./config-_aQ_PZ-P.js";
+import { n as formatPropertyCSS, t as formatRules } from "./format-rules-xwteB7a1.js";
+import { t as formatGlobalRules } from "./format-global-rules-Dbc_1tc3.js";
 //#region src/ssr/collector.ts
 /**
 * ServerStyleCollector — server-safe style collector for SSR.
 *
 * Accumulates CSS rules and cache metadata during server rendering.
 * This is the server-side counterpart to StyleInjector: it allocates
-* sequential class names (t0, t1, …), formats CSS rules into text,
-* and serializes the cache state for client hydration.
+* hash-based class names (`t${hash}`), formats CSS rules into text,
+* and tracks rendered class names for lightweight client transfer.
 *
 * One instance is created per HTTP request. Concurrent requests
 * each get their own collector (via AsyncLocalStorage or React context).
 */
-function generateClassName(counter) {
-	return `t${counter}`;
+function generateClassName(cacheKey) {
+	return `t${hashString(cacheKey)}`;
 }
 var ServerStyleCollector = class {
 	chunks = /* @__PURE__ */ new Map();
 	cacheKeyToClassName = /* @__PURE__ */ new Map();
-	classCounter = 0;
 	flushedKeys = /* @__PURE__ */ new Set();
 	propertyRules = /* @__PURE__ */ new Map();
 	flushedPropertyKeys = /* @__PURE__ */ new Set();
@@ -44,6 +39,10 @@ var ServerStyleCollector = class {
 	* Collect internal @property rules and :root token defaults.
 	* Mirrors markStylesGenerated() from the client-side injector.
 	* Called automatically on first chunk collection; idempotent.
+	*
+	* Internals are always emitted here — the RSC path deliberately
+	* defers to SSR so that tokens appear exactly once per page in
+	* <style data-tasty-ssr> (avoiding duplication of large token sets).
 	*/
 	collectInternals() {
 		if (this.internalsCollected) return;
@@ -74,6 +73,16 @@ var ServerStyleCollector = class {
 			const css = formatCounterStyleRule(name, descriptors);
 			this.collectCounterStyle(name, css);
 		}
+		const globalStyles = getGlobalStyles();
+		if (globalStyles) {
+			for (const [selector, styles] of Object.entries(globalStyles)) if (Object.keys(styles).length > 0) {
+				const rules = renderStyles(styles, selector);
+				if (rules.length > 0) {
+					const css = formatGlobalRules(rules);
+					if (css) this.collectGlobalStyles(`__global:styles:${selector}`, css);
+				}
+			}
+		}
 	}
 	/**
 	* Allocate a className for a cache key, server-side.
@@ -85,7 +94,7 @@ var ServerStyleCollector = class {
 			className: existing,
 			isNewAllocation: false
 		};
-		const className = generateClassName(this.classCounter++);
+		const className = generateClassName(cacheKey);
 		this.cacheKeyToClassName.set(cacheKey, className);
 		return {
 			className,
@@ -201,19 +210,21 @@ var ServerStyleCollector = class {
 		}
 		return parts.join("\n");
 	}
+	flushedClassNames = /* @__PURE__ */ new Set();
 	/**
-	* Serialize the cache state for client hydration.
+	* Return class names rendered since the last call (for streaming).
+	* Used to emit lightweight class-list scripts for client hydration.
 	*/
-	getCacheState() {
-		const entries = {};
-		for (const [cacheKey, className] of this.cacheKeyToClassName) entries[cacheKey] = className;
-		return {
-			entries,
-			classCounter: this.classCounter
-		};
+	getRenderedClassNames() {
+		const names = [];
+		for (const className of this.cacheKeyToClassName.values()) if (!this.flushedClassNames.has(className)) {
+			this.flushedClassNames.add(className);
+			names.push(className);
+		}
+		return names;
 	}
 };
 //#endregion
-export { ServerStyleCollector };
+export { ServerStyleCollector as t };
 
-//# sourceMappingURL=collector.js.map
+//# sourceMappingURL=collector-DrgDE7QB.js.map

package/dist/collector-DrgDE7QB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector-DrgDE7QB.js","names":[],"sources":["../src/ssr/collector.ts"],"sourcesContent":["/**\n * ServerStyleCollector — server-safe style collector for SSR.\n *\n * Accumulates CSS rules and cache metadata during server rendering.\n * This is the server-side counterpart to StyleInjector: it allocates\n * hash-based class names (`t${hash}`), formats CSS rules into text,\n * and tracks rendered class names for lightweight client transfer.\n *\n * One instance is created per HTTP request. Concurrent requests\n * each get their own collector (via AsyncLocalStorage or React context).\n */\n\nimport {\n  getEffectiveProperties,\n  getGlobalStyles,\n  getGlobalCounterStyle,\n  getGlobalFontFace,\n  getGlobalConfigTokens,\n} from '../config';\nimport { formatCounterStyleRule } from '../counter-style';\nimport { fontFaceContentHash, formatFontFaceRule } from '../font-face';\nimport { renderStyles } from '../pipeline';\nimport type { StyleResult } from '../pipeline';\nimport { hashString } from '../utils/hash';\nimport { formatPropertyCSS } from './format-property';\nimport { formatGlobalRules } from './format-global-rules';\nimport { formatRules } from './format-rules';\n\nfunction generateClassName(cacheKey: string): string {\n  return `t${hashString(cacheKey)}`;\n}\n\nexport class ServerStyleCollector {\n  private chunks = new Map<string, string>();\n  private cacheKeyToClassName = new Map<string, string>();\n  private flushedKeys = new Set<string>();\n  private propertyRules = new Map<string, string>();\n  private flushedPropertyKeys = new Set<string>();\n  private keyframeRules = new Map<string, string>();\n  private flushedKeyframeKeys = new Set<string>();\n  private globalStyles = new Map<string, string>();\n  private flushedGlobalKeys = new Set<string>();\n  private rawCSS = new Map<string, string>();\n  private flushedRawKeys = new Set<string>();\n  private fontFaceRules = new Map<string, string>();\n  private flushedFontFaceKeys = new Set<string>();\n  private counterStyleRules = new Map<string, string>();\n  private flushedCounterStyleKeys = new Set<string>();\n  private keyframesCounter = 0;\n  private counterStyleCounter = 0;\n  private internalsCollected = false;\n\n  /**\n   * Collect internal @property rules and :root token defaults.\n   * Mirrors markStylesGenerated() from the client-side injector.\n   * Called automatically on first chunk collection; idempotent.\n   *\n   * Internals are always emitted here — the RSC path deliberately\n   * defers to SSR so that tokens appear exactly once per page in\n   * <style data-tasty-ssr> (avoiding duplication of large token sets).\n   */\n  collectInternals(): void {\n    if (this.internalsCollected) return;\n    this.internalsCollected = true;\n\n    for (const [token, definition] of Object.entries(\n      getEffectiveProperties(),\n    )) {\n      const css = formatPropertyCSS(token, definition);\n      if (css) {\n        this.collectProperty(`__prop:${token}`, css);\n      }\n    }\n\n    const tokenStyles = getGlobalConfigTokens();\n    if (tokenStyles && Object.keys(tokenStyles).length > 0) {\n      const tokenRules = renderStyles(tokenStyles, ':root') as StyleResult[];\n      if (tokenRules.length > 0) {\n        const css = formatGlobalRules(tokenRules);\n        if (css) {\n          this.collectGlobalStyles('__global:tokens', css);\n        }\n      }\n    }\n\n    const globalFF = getGlobalFontFace();\n    if (globalFF) {\n      for (const [family, input] of Object.entries(globalFF)) {\n        const descriptors = Array.isArray(input) ? input : [input];\n        for (const desc of descriptors) {\n          const hash = fontFaceContentHash(family, desc);\n          const css = formatFontFaceRule(family, desc);\n          this.collectFontFace(hash, css);\n        }\n      }\n    }\n\n    const globalCS = getGlobalCounterStyle();\n    if (globalCS) {\n      for (const [name, descriptors] of Object.entries(globalCS)) {\n        const css = formatCounterStyleRule(name, descriptors);\n        this.collectCounterStyle(name, css);\n      }\n    }\n\n    const globalStyles = getGlobalStyles();\n    if (globalStyles) {\n      for (const [selector, styles] of Object.entries(globalStyles)) {\n        if (Object.keys(styles).length > 0) {\n          const rules = renderStyles(styles, selector) as StyleResult[];\n          if (rules.length > 0) {\n            const css = formatGlobalRules(rules);\n            if (css) {\n              this.collectGlobalStyles(`__global:styles:${selector}`, css);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Allocate a className for a cache key, server-side.\n   * Mirrors StyleInjector.allocateClassName but without DOM access.\n   */\n  allocateClassName(cacheKey: string): {\n    className: string;\n    isNewAllocation: boolean;\n  } {\n    const existing = this.cacheKeyToClassName.get(cacheKey);\n    if (existing) {\n      return { className: existing, isNewAllocation: false };\n    }\n\n    const className = generateClassName(cacheKey);\n    this.cacheKeyToClassName.set(cacheKey, className);\n\n    return { className, isNewAllocation: true };\n  }\n\n  /**\n   * Record CSS rules for a chunk.\n   * Called by useStyles during server render.\n   */\n  collectChunk(\n    cacheKey: string,\n    className: string,\n    rules: StyleResult[],\n  ): void {\n    if (this.chunks.has(cacheKey)) return;\n    const css = formatRules(rules, className);\n    if (css) {\n      this.chunks.set(cacheKey, css);\n    }\n  }\n\n  /**\n   * Record a @property rule. Deduplicated by name.\n   */\n  collectProperty(name: string, css: string): void {\n    if (!this.propertyRules.has(name)) {\n      this.propertyRules.set(name, css);\n    }\n  }\n\n  /**\n   * Record a @keyframes rule. Deduplicated by name.\n   */\n  collectKeyframes(name: string, css: string): void {\n    if (!this.keyframeRules.has(name)) {\n      this.keyframeRules.set(name, css);\n    }\n  }\n\n  /**\n   * Allocate a keyframe name for SSR. Uses provided name or generates one.\n   */\n  allocateKeyframeName(providedName?: string): string {\n    return providedName ?? `k${this.keyframesCounter++}`;\n  }\n\n  /**\n   * Record a @font-face rule. Deduplicated by key (content hash).\n   */\n  collectFontFace(key: string, css: string): void {\n    if (!this.fontFaceRules.has(key)) {\n      this.fontFaceRules.set(key, css);\n    }\n  }\n\n  /**\n   * Record a @counter-style rule. Deduplicated by name.\n   */\n  collectCounterStyle(name: string, css: string): void {\n    if (!this.counterStyleRules.has(name)) {\n      this.counterStyleRules.set(name, css);\n    }\n  }\n\n  /**\n   * Allocate a counter-style name for SSR. Uses provided name or generates one.\n   */\n  allocateCounterStyleName(providedName?: string): string {\n    return providedName ?? `cs${this.counterStyleCounter++}`;\n  }\n\n  /**\n   * Record global styles (from useGlobalStyles). Deduplicated by key.\n   */\n  collectGlobalStyles(key: string, css: string): void {\n    if (!this.globalStyles.has(key)) {\n      this.globalStyles.set(key, css);\n    }\n  }\n\n  /**\n   * Record raw CSS text (from useRawCSS). Deduplicated by key.\n   */\n  collectRawCSS(key: string, css: string): void {\n    if (!this.rawCSS.has(key)) {\n      this.rawCSS.set(key, css);\n    }\n  }\n\n  /**\n   * Extract all CSS collected so far as a single string.\n   * Includes @property and @keyframes rules.\n   * Used for non-streaming SSR (renderToString).\n   */\n  getCSS(): string {\n    const parts: string[] = [];\n\n    for (const css of this.propertyRules.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.fontFaceRules.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.counterStyleRules.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.rawCSS.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.globalStyles.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.chunks.values()) {\n      parts.push(css);\n    }\n\n    for (const css of this.keyframeRules.values()) {\n      parts.push(css);\n    }\n\n    return parts.join('\\n');\n  }\n\n  /**\n   * Flush only newly collected CSS since the last flush.\n   * Used for streaming SSR (renderToPipeableStream + useServerInsertedHTML).\n   */\n  flushCSS(): string {\n    const parts: string[] = [];\n\n    for (const [name, css] of this.propertyRules) {\n      if (!this.flushedPropertyKeys.has(name)) {\n        parts.push(css);\n        this.flushedPropertyKeys.add(name);\n      }\n    }\n\n    for (const [key, css] of this.fontFaceRules) {\n      if (!this.flushedFontFaceKeys.has(key)) {\n        parts.push(css);\n        this.flushedFontFaceKeys.add(key);\n      }\n    }\n\n    for (const [key, css] of this.counterStyleRules) {\n      if (!this.flushedCounterStyleKeys.has(key)) {\n        parts.push(css);\n        this.flushedCounterStyleKeys.add(key);\n      }\n    }\n\n    for (const [key, css] of this.rawCSS) {\n      if (!this.flushedRawKeys.has(key)) {\n        parts.push(css);\n        this.flushedRawKeys.add(key);\n      }\n    }\n\n    for (const [key, css] of this.globalStyles) {\n      if (!this.flushedGlobalKeys.has(key)) {\n        parts.push(css);\n        this.flushedGlobalKeys.add(key);\n      }\n    }\n\n    for (const [key, css] of this.chunks) {\n      if (!this.flushedKeys.has(key)) {\n        parts.push(css);\n        this.flushedKeys.add(key);\n      }\n    }\n\n    for (const [name, css] of this.keyframeRules) {\n      if (!this.flushedKeyframeKeys.has(name)) {\n        parts.push(css);\n        this.flushedKeyframeKeys.add(name);\n      }\n    }\n\n    return parts.join('\\n');\n  }\n\n  private flushedClassNames = new Set<string>();\n\n  /**\n   * Return class names rendered since the last call (for streaming).\n   * Used to emit lightweight class-list scripts for client hydration.\n   */\n  getRenderedClassNames(): string[] {\n    const names: string[] = [];\n    for (const className of this.cacheKeyToClassName.values()) {\n      if (!this.flushedClassNames.has(className)) {\n        this.flushedClassNames.add(className);\n        names.push(className);\n      }\n    }\n    return names;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,SAAS,kBAAkB,UAA0B;AACnD,QAAO,IAAI,WAAW,SAAS;;AAGjC,IAAa,uBAAb,MAAkC;CAChC,yBAAiB,IAAI,KAAqB;CAC1C,sCAA8B,IAAI,KAAqB;CACvD,8BAAsB,IAAI,KAAa;CACvC,gCAAwB,IAAI,KAAqB;CACjD,sCAA8B,IAAI,KAAa;CAC/C,gCAAwB,IAAI,KAAqB;CACjD,sCAA8B,IAAI,KAAa;CAC/C,+BAAuB,IAAI,KAAqB;CAChD,oCAA4B,IAAI,KAAa;CAC7C,yBAAiB,IAAI,KAAqB;CAC1C,iCAAyB,IAAI,KAAa;CAC1C,gCAAwB,IAAI,KAAqB;CACjD,sCAA8B,IAAI,KAAa;CAC/C,oCAA4B,IAAI,KAAqB;CACrD,0CAAkC,IAAI,KAAa;CACnD,mBAA2B;CAC3B,sBAA8B;CAC9B,qBAA6B;;;;;;;;;;CAW7B,mBAAyB;AACvB,MAAI,KAAK,mBAAoB;AAC7B,OAAK,qBAAqB;AAE1B,OAAK,MAAM,CAAC,OAAO,eAAe,OAAO,QACvC,wBAAwB,CACzB,EAAE;GACD,MAAM,MAAM,kBAAkB,OAAO,WAAW;AAChD,OAAI,IACF,MAAK,gBAAgB,UAAU,SAAS,IAAI;;EAIhD,MAAM,cAAc,uBAAuB;AAC3C,MAAI,eAAe,OAAO,KAAK,YAAY,CAAC,SAAS,GAAG;GACtD,MAAM,aAAa,aAAa,aAAa,QAAQ;AACrD,OAAI,WAAW,SAAS,GAAG;IACzB,MAAM,MAAM,kBAAkB,WAAW;AACzC,QAAI,IACF,MAAK,oBAAoB,mBAAmB,IAAI;;;EAKtD,MAAM,WAAW,mBAAmB;AACpC,MAAI,SACF,MAAK,MAAM,CAAC,QAAQ,UAAU,OAAO,QAAQ,SAAS,EAAE;GACtD,MAAM,cAAc,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;AAC1D,QAAK,MAAM,QAAQ,aAAa;IAC9B,MAAM,OAAO,oBAAoB,QAAQ,KAAK;IAC9C,MAAM,MAAM,mBAAmB,QAAQ,KAAK;AAC5C,SAAK,gBAAgB,MAAM,IAAI;;;EAKrC,MAAM,WAAW,uBAAuB;AACxC,MAAI,SACF,MAAK,MAAM,CAAC,MAAM,gBAAgB,OAAO,QAAQ,SAAS,EAAE;GAC1D,MAAM,MAAM,uBAAuB,MAAM,YAAY;AACrD,QAAK,oBAAoB,MAAM,IAAI;;EAIvC,MAAM,eAAe,iBAAiB;AACtC,MAAI;QACG,MAAM,CAAC,UAAU,WAAW,OAAO,QAAQ,aAAa,CAC3D,KAAI,OAAO,KAAK,OAAO,CAAC,SAAS,GAAG;IAClC,MAAM,QAAQ,aAAa,QAAQ,SAAS;AAC5C,QAAI,MAAM,SAAS,GAAG;KACpB,MAAM,MAAM,kBAAkB,MAAM;AACpC,SAAI,IACF,MAAK,oBAAoB,mBAAmB,YAAY,IAAI;;;;;;;;;CAYxE,kBAAkB,UAGhB;EACA,MAAM,WAAW,KAAK,oBAAoB,IAAI,SAAS;AACvD,MAAI,SACF,QAAO;GAAE,WAAW;GAAU,iBAAiB;GAAO;EAGxD,MAAM,YAAY,kBAAkB,SAAS;AAC7C,OAAK,oBAAoB,IAAI,UAAU,UAAU;AAEjD,SAAO;GAAE;GAAW,iBAAiB;GAAM;;;;;;CAO7C,aACE,UACA,WACA,OACM;AACN,MAAI,KAAK,OAAO,IAAI,SAAS,CAAE;EAC/B,MAAM,MAAM,YAAY,OAAO,UAAU;AACzC,MAAI,IACF,MAAK,OAAO,IAAI,UAAU,IAAI;;;;;CAOlC,gBAAgB,MAAc,KAAmB;AAC/C,MAAI,CAAC,KAAK,cAAc,IAAI,KAAK,CAC/B,MAAK,cAAc,IAAI,MAAM,IAAI;;;;;CAOrC,iBAAiB,MAAc,KAAmB;AAChD,MAAI,CAAC,KAAK,cAAc,IAAI,KAAK,CAC/B,MAAK,cAAc,IAAI,MAAM,IAAI;;;;;CAOrC,qBAAqB,cAA+B;AAClD,SAAO,gBAAgB,IAAI,KAAK;;;;;CAMlC,gBAAgB,KAAa,KAAmB;AAC9C,MAAI,CAAC,KAAK,cAAc,IAAI,IAAI,CAC9B,MAAK,cAAc,IAAI,KAAK,IAAI;;;;;CAOpC,oBAAoB,MAAc,KAAmB;AACnD,MAAI,CAAC,KAAK,kBAAkB,IAAI,KAAK,CACnC,MAAK,kBAAkB,IAAI,MAAM,IAAI;;;;;CAOzC,yBAAyB,cAA+B;AACtD,SAAO,gBAAgB,KAAK,KAAK;;;;;CAMnC,oBAAoB,KAAa,KAAmB;AAClD,MAAI,CAAC,KAAK,aAAa,IAAI,IAAI,CAC7B,MAAK,aAAa,IAAI,KAAK,IAAI;;;;;CAOnC,cAAc,KAAa,KAAmB;AAC5C,MAAI,CAAC,KAAK,OAAO,IAAI,IAAI,CACvB,MAAK,OAAO,IAAI,KAAK,IAAI;;;;;;;CAS7B,SAAiB;EACf,MAAM,QAAkB,EAAE;AAE1B,OAAK,MAAM,OAAO,KAAK,cAAc,QAAQ,CAC3C,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,cAAc,QAAQ,CAC3C,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,kBAAkB,QAAQ,CAC/C,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,OAAO,QAAQ,CACpC,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,aAAa,QAAQ,CAC1C,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,OAAO,QAAQ,CACpC,OAAM,KAAK,IAAI;AAGjB,OAAK,MAAM,OAAO,KAAK,cAAc,QAAQ,CAC3C,OAAM,KAAK,IAAI;AAGjB,SAAO,MAAM,KAAK,KAAK;;;;;;CAOzB,WAAmB;EACjB,MAAM,QAAkB,EAAE;AAE1B,OAAK,MAAM,CAAC,MAAM,QAAQ,KAAK,cAC7B,KAAI,CAAC,KAAK,oBAAoB,IAAI,KAAK,EAAE;AACvC,SAAM,KAAK,IAAI;AACf,QAAK,oBAAoB,IAAI,KAAK;;AAItC,OAAK,MAAM,CAAC,KAAK,QAAQ,KAAK,cAC5B,KAAI,CAAC,KAAK,oBAAoB,IAAI,IAAI,EAAE;AACtC,SAAM,KAAK,IAAI;AACf,QAAK,oBAAoB,IAAI,IAAI;;AAIrC,OAAK,MAAM,CAAC,KAAK,QAAQ,KAAK,kBAC5B,KAAI,CAAC,KAAK,wBAAwB,IAAI,IAAI,EAAE;AAC1C,SAAM,KAAK,IAAI;AACf,QAAK,wBAAwB,IAAI,IAAI;;AAIzC,OAAK,MAAM,CAAC,KAAK,QAAQ,KAAK,OAC5B,KAAI,CAAC,KAAK,eAAe,IAAI,IAAI,EAAE;AACjC,SAAM,KAAK,IAAI;AACf,QAAK,eAAe,IAAI,IAAI;;AAIhC,OAAK,MAAM,CAAC,KAAK,QAAQ,KAAK,aAC5B,KAAI,CAAC,KAAK,kBAAkB,IAAI,IAAI,EAAE;AACpC,SAAM,KAAK,IAAI;AACf,QAAK,kBAAkB,IAAI,IAAI;;AAInC,OAAK,MAAM,CAAC,KAAK,QAAQ,KAAK,OAC5B,KAAI,CAAC,KAAK,YAAY,IAAI,IAAI,EAAE;AAC9B,SAAM,KAAK,IAAI;AACf,QAAK,YAAY,IAAI,IAAI;;AAI7B,OAAK,MAAM,CAAC,MAAM,QAAQ,KAAK,cAC7B,KAAI,CAAC,KAAK,oBAAoB,IAAI,KAAK,EAAE;AACvC,SAAM,KAAK,IAAI;AACf,QAAK,oBAAoB,IAAI,KAAK;;AAItC,SAAO,MAAM,KAAK,KAAK;;CAGzB,oCAA4B,IAAI,KAAa;;;;;CAM7C,wBAAkC;EAChC,MAAM,QAAkB,EAAE;AAC1B,OAAK,MAAM,aAAa,KAAK,oBAAoB,QAAQ,CACvD,KAAI,CAAC,KAAK,kBAAkB,IAAI,UAAU,EAAE;AAC1C,QAAK,kBAAkB,IAAI,UAAU;AACrC,SAAM,KAAK,UAAU;;AAGzB,SAAO"}

package/dist/{ssr/collector.d.ts → collector-LuU1vZ68.d.ts}

@@ -1,19 +1,9 @@
-import { StyleResult } from "../pipeline/index.js";
+import { n as StyleResult } from "./index-dUtwpOux.js";
 
 //#region src/ssr/collector.d.ts
-/**
- * Cache state serialized to the client for hydration.
- */
-interface SSRCacheState {
-  /** cacheKey → className map, to pre-populate the client registry */
-  entries: Record<string, string>;
-  /** Counter value so client allocations don't collide with server ones */
-  classCounter: number;
-}
 declare class ServerStyleCollector {
   private chunks;
   private cacheKeyToClassName;
-  private classCounter;
   private flushedKeys;
   private propertyRules;
   private flushedPropertyKeys;
@@ -34,6 +24,10 @@ declare class ServerStyleCollector {
    * Collect internal @property rules and :root token defaults.
    * Mirrors markStylesGenerated() from the client-side injector.
    * Called automatically on first chunk collection; idempotent.
+   *
+   * Internals are always emitted here — the RSC path deliberately
+   * defers to SSR so that tokens appear exactly once per page in
+   * <style data-tasty-ssr> (avoiding duplication of large token sets).
    */
   collectInternals(): void;
   /**
@@ -92,11 +86,13 @@ declare class ServerStyleCollector {
    * Used for streaming SSR (renderToPipeableStream + useServerInsertedHTML).
    */
   flushCSS(): string;
+  private flushedClassNames;
   /**
-   * Serialize the cache state for client hydration.
+   * Return class names rendered since the last call (for streaming).
+   * Used to emit lightweight class-list scripts for client hydration.
    */
-  getCacheState(): SSRCacheState;
+  getRenderedClassNames(): string[];
 }
 //#endregion
-export { SSRCacheState, ServerStyleCollector };
-//# sourceMappingURL=collector.d.ts.map
+export { ServerStyleCollector as t };
+//# sourceMappingURL=collector-LuU1vZ68.d.ts.map