@tenphi/tasty 0.0.0-snapshot.cfcf770 → 0.0.0-snapshot.d1f4019

package/README.md

@@ -6,7 +6,7 @@
 
 <p align="center">
   <strong>Deterministic styling for stateful component systems.</strong><br>
-  A design-system styling engine that compiles component states into mutually exclusive selectors.
+  A design-system styling engine that compiles component states into mutually exclusive selectors, so complex components stay predictable as they evolve.
 </p>
 
 <p align="center">
@@ -23,6 +23,8 @@ It compiles state maps into **mutually exclusive selectors**, so for a given pro
 
 That is the core guarantee: component styling resolves from declared state logic, not from source-order accidents or specificity fights.
 
+The practical payoff shows up later: adding states, variants, and overrides stays inside the state map instead of reopening selector logic by hand.
+
 Tasty fits best when you are building a design system or component library with intersecting states, variants, tokens, sub-elements, responsive rules, and extension semantics that need to stay predictable over time.
 
 On top of that foundation, Tasty gives teams a governed styling model: a CSS-like DSL, tokens, recipes, typed style props, sub-elements, and multiple rendering modes.
@@ -35,6 +37,7 @@ On top of that foundation, Tasty gives teams a governed styling model: a CSS-lik
 ## Why Tasty
 
 - **Deterministic composition, not cascade fights** — Stateful styles resolve from the state map you declared, not from selector competition. See [How It Actually Works](#how-it-actually-works).
+- **Easier to extend over time** — When components gain new states, variants, or overrides, you update declared branches instead of re-deriving selector interactions by hand.
 - **Built for design-system teams** — Best fit for reusable component systems with complex state interactions.
 - **A governed styling model, not just syntax sugar** — Design-system authors define the styling language product teams consume.
 - **DSL that still feels like CSS** — Familiar property names, less selector boilerplate. Start with the [Style DSL](docs/dsl.md), then use [Style Properties](docs/styles.md) as the handler reference.
@@ -42,7 +45,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 +82,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 +191,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 +199,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 +367,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 +382,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 +401,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
 
@@ -421,17 +425,17 @@ If you prefer explicit control, disable inference with `configure({ autoProperty
 
 See [Style DSL - Properties (`@property`)](docs/dsl.md#properties-property).
 
-### Explicit `@properties`
+### Explicit `@property`
 
-Use explicit `@properties` only when you need to override defaults such as `inherits: false` or a custom `initialValue`.
+Use explicit `@property` only when you need to override defaults such as `inherits: false` or a custom `initialValue`.
 
 See [Style DSL - Properties (`@property`)](docs/dsl.md#properties-property).
 
-### React Hooks
+### Style Functions
 
-When you do not need a full component wrapper, use the hooks directly: `useStyles` for local class names, `useGlobalStyles` for selector-scoped global CSS, `useRawCSS` for raw rules, plus `useKeyframes` and `useProperty` for animation and custom-property primitives.
+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 - Hooks](docs/runtime.md#hooks).
+See [React API - Style Functions](docs/react-api.md#style-functions).
 
 ### Zero-Runtime Mode
 
@@ -441,15 +445,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.
+
+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:
 
-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.
+- `@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).
 
@@ -457,15 +465,16 @@ See the [full SSR guide](docs/ssr.md).
 
 | Import | Description | Platform |
 |--------|-------------|----------|
-| `@tenphi/tasty` | Runtime style engine (`tasty`, hooks, `configure`) | Browser |
+| `@tenphi/tasty` | Runtime style engine (`tasty`, style functions, `configure`) | Browser |
 | `@tenphi/tasty/static` | Zero-runtime static styles (`tastyStatic`) | Browser |
 | `@tenphi/tasty/core` | Lower-level internals (config, parser, pipeline, injector, style handlers) for tooling and advanced use | Browser / Node |
 | `@tenphi/tasty/babel-plugin` | Babel plugin for zero-runtime CSS extraction | Node |
 | `@tenphi/tasty/zero` | Programmatic extraction API | Node |
-| `@tenphi/tasty/next` | Next.js integration wrapper | Node |
+| `@tenphi/tasty/zero/next` | Next.js integration wrapper | Node |
 | `@tenphi/tasty/ssr` | Core SSR API (collector, context, hydration) | Node |
 | `@tenphi/tasty/ssr/next` | Next.js App Router SSR integration | Node |
-| `@tenphi/tasty/ssr/astro` | Astro middleware + auto-hydration | Node / Browser |
+| `@tenphi/tasty/ssr/astro` | Astro integration + middleware | Node |
+| `@tenphi/tasty/ssr/astro-client` | Astro client-side cache hydration | Browser |
 
 ## Browser Requirements
 
@@ -483,11 +492,13 @@ All sizes measured with [size-limit](https://github.com/ai/size-limit) — minif
 
 | Entry point | Size |
 |-------------|------|
-| `@tenphi/tasty` (runtime + SSR) | ~44 kB |
-| `@tenphi/tasty/core` (runtime, no SSR) | ~41 kB |
-| `@tenphi/tasty/static` (zero-runtime) | ~1.5 kB |
+| `@tenphi/tasty` (runtime + SSR) | 50.19 kB |
+| `@tenphi/tasty/core` (runtime, no SSR) | 47.76 kB |
+| `@tenphi/tasty/static` (zero-runtime) | 16.43 kB |
+| `@tenphi/tasty/zero` (programmatic extraction) | 29.6 kB |
+| `@tenphi/tasty/babel-plugin` (Babel plugin entry) | 43.7 kB |
 
-Run `pnpm size` for exact up-to-date numbers.
+Run `pnpm size` to reproduce (outputs may shift slightly with releases).
 
 ### Runtime Benchmarks
 
@@ -605,7 +616,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 hooks
+- **[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
 
@@ -616,7 +627,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/astro-C_Q2ZvRk.js

@@ -0,0 +1,158 @@
+import { n as getConfig } from "./config-DmbFli5B.js";
+import { a as registerSSRCollectorGetterGlobal } from "./format-rules-fUE2cZ21.js";
+import { t as ServerStyleCollector } from "./collector-BPdGUKLA.js";
+import { n as runWithCollector, t as getSSRCollector } from "./async-storage-B7_o6FKt.js";
+//#region src/ssr/astro-transfer-cache.ts
+/**
+* Internal module-level state for the Astro middleware transfer-cache flag.
+*
+* Set by `tastyIntegration` and read by `astro-middleware.ts`. Kept in a
+* separate non-exported module so it does not appear on the public API
+* surface of `@tenphi/tasty/ssr/astro`.
+*/
+let _middlewareTransferCache = true;
+/** @internal */
+function setMiddlewareTransferCache(value) {
+	_middlewareTransferCache = value;
+}
+/** @internal */
+function getMiddlewareTransferCache() {
+	return _middlewareTransferCache;
+}
+//#endregion
+//#region src/ssr/astro.ts
+/**
+* Astro integration for Tasty SSR.
+*
+* Provides:
+* - tastyIntegration() — Astro Integration API (recommended)
+* - tastyMiddleware()  — manual middleware for advanced composition
+*
+* Import from '@tenphi/tasty/ssr/astro'.
+*/
+registerSSRCollectorGetterGlobal(getSSRCollector);
+/**
+* Create an Astro middleware that collects Tasty styles during SSR.
+*
+* All React components rendered during the request will have their
+* computeStyles() calls captured by the collector via AsyncLocalStorage.
+* After rendering, the middleware injects the collected CSS into </head>.
+*
+* @example Manual middleware setup
+* ```ts
+* // src/middleware.ts
+* import { tastyMiddleware } from '@tenphi/tasty/ssr/astro';
+* export const onRequest = tastyMiddleware();
+* ```
+*
+* @example Composing with other middleware
+* ```ts
+* // src/middleware.ts
+* import { sequence } from 'astro:middleware';
+* import { tastyMiddleware } from '@tenphi/tasty/ssr/astro';
+*
+* export const onRequest = sequence(
+*   tastyMiddleware(),
+*   myOtherMiddleware,
+* );
+* ```
+*/
+function tastyMiddleware(options) {
+	return async (_context, next) => {
+		const transferCache = options?.transferCache ?? true;
+		const collector = new ServerStyleCollector();
+		const rendered = await runWithCollector(collector, async () => {
+			const response = await next();
+			const body = response.body;
+			if (!body) return {
+				html: null,
+				status: response.status,
+				headers: response.headers
+			};
+			const reader = body.pipeThrough(new TextDecoderStream()).getReader();
+			const parts = [];
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				parts.push(value);
+			}
+			return {
+				html: parts.join(""),
+				status: response.status,
+				headers: response.headers
+			};
+		});
+		if (!rendered.html) return new Response(null, {
+			status: rendered.status,
+			headers: rendered.headers
+		});
+		let { html } = rendered;
+		const css = collector.getCSS();
+		if (!css) return new Response(html, {
+			status: rendered.status,
+			headers: rendered.headers
+		});
+		const nonce = getConfig().nonce;
+		const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
+		const styleTag = `<style data-tasty-ssr${nonceAttr}>${css}</style>`;
+		let cacheTag = "";
+		if (transferCache) {
+			const classNames = collector.getRenderedClassNames();
+			if (classNames.length > 0) cacheTag = `<script${nonceAttr}>(window.__TASTY__=window.__TASTY__||[]).push(${classNames.map((n) => `"${n}"`).join(",")})<\/script>`;
+		}
+		const injection = styleTag + cacheTag;
+		const idx = html.indexOf("</head>");
+		if (idx !== -1) html = html.slice(0, idx) + injection + html.slice(idx);
+		else html = injection + html;
+		const headers = new Headers(rendered.headers);
+		headers.delete("content-length");
+		return new Response(html, {
+			status: rendered.status,
+			headers
+		});
+	};
+}
+/**
+* Astro integration that automatically sets up Tasty SSR.
+*
+* Registers middleware for cross-component CSS deduplication and
+* optionally injects a client hydration script for island support.
+*
+* @example Basic setup (with islands)
+* ```ts
+* // astro.config.mjs
+* import { tastyIntegration } from '@tenphi/tasty/ssr/astro';
+*
+* export default defineConfig({
+*   integrations: [tastyIntegration()],
+* });
+* ```
+*
+* @example Static-only (no client JS)
+* ```ts
+* // astro.config.mjs
+* import { tastyIntegration } from '@tenphi/tasty/ssr/astro';
+*
+* export default defineConfig({
+*   integrations: [tastyIntegration({ islands: false })],
+* });
+* ```
+*/
+function tastyIntegration(options) {
+	const { islands = true } = options ?? {};
+	setMiddlewareTransferCache(islands);
+	return {
+		name: "@tenphi/tasty",
+		hooks: { "astro:config:setup": ({ addMiddleware, injectScript }) => {
+			addMiddleware({
+				entrypoint: new URL("./astro-middleware.js", import.meta.url),
+				order: "pre"
+			});
+			if (islands) injectScript("before-hydration", `import "@tenphi/tasty/ssr/astro-client";`);
+		} }
+	};
+}
+//#endregion
+export { tastyMiddleware as n, getMiddlewareTransferCache as r, tastyIntegration as t };
+
+//# sourceMappingURL=astro-C_Q2ZvRk.js.map

package/dist/astro-C_Q2ZvRk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro-C_Q2ZvRk.js","names":[],"sources":["../src/ssr/astro-transfer-cache.ts","../src/ssr/astro.ts"],"sourcesContent":["/**\n * Internal module-level state for the Astro middleware transfer-cache flag.\n *\n * Set by `tastyIntegration` and read by `astro-middleware.ts`. Kept in a\n * separate non-exported module so it does not appear on the public API\n * surface of `@tenphi/tasty/ssr/astro`.\n */\n\nlet _middlewareTransferCache = true;\n\n/** @internal */\nexport function setMiddlewareTransferCache(value: boolean): void {\n  _middlewareTransferCache = value;\n}\n\n/** @internal */\nexport function getMiddlewareTransferCache(): boolean {\n  return _middlewareTransferCache;\n}\n","/**\n * Astro integration for Tasty SSR.\n *\n * Provides:\n * - tastyIntegration() — Astro Integration API (recommended)\n * - tastyMiddleware()  — manual middleware for advanced composition\n *\n * Import from '@tenphi/tasty/ssr/astro'.\n */\n\nimport { getConfig } from '../config';\nimport { getSSRCollector, runWithCollector } from './async-storage';\nimport { ServerStyleCollector } from './collector';\nimport { registerSSRCollectorGetterGlobal } from './ssr-collector-ref';\nimport { setMiddlewareTransferCache } from './astro-transfer-cache';\n\n// Wire up ALS-based collector discovery so computeStyles() can find\n// the collector set by tastyMiddleware's runWithCollector().\n// Uses globalThis so the getter is visible across Astro's separate\n// module graphs (middleware vs page components).\nregisterSSRCollectorGetterGlobal(getSSRCollector);\n\nexport interface TastyMiddlewareOptions {\n  /**\n   * Whether to embed the class-list script for client hydration.\n   * Set to false to skip class transfer (e.g. for CSP restrictions).\n   * Without it, client components may re-inject CSS that already exists\n   * in server-rendered `<style>` tags. Default: true.\n   */\n  transferCache?: boolean;\n}\n\n/**\n * Create an Astro middleware that collects Tasty styles during SSR.\n *\n * All React components rendered during the request will have their\n * computeStyles() calls captured by the collector via AsyncLocalStorage.\n * After rendering, the middleware injects the collected CSS into </head>.\n *\n * @example Manual middleware setup\n * ```ts\n * // src/middleware.ts\n * import { tastyMiddleware } from '@tenphi/tasty/ssr/astro';\n * export const onRequest = tastyMiddleware();\n * ```\n *\n * @example Composing with other middleware\n * ```ts\n * // src/middleware.ts\n * import { sequence } from 'astro:middleware';\n * import { tastyMiddleware } from '@tenphi/tasty/ssr/astro';\n *\n * export const onRequest = sequence(\n *   tastyMiddleware(),\n *   myOtherMiddleware,\n * );\n * ```\n */\nexport function tastyMiddleware(options?: TastyMiddlewareOptions) {\n  return async (\n    _context: unknown,\n    next: () => Promise<Response>,\n  ): Promise<Response> => {\n    const transferCache = options?.transferCache ?? true;\n    const collector = new ServerStyleCollector();\n\n    // Run the entire request — including body stream consumption — inside\n    // the ALS context so that components rendering lazily during stream\n    // reads can still find the collector via getSSRCollector().\n    const rendered = await runWithCollector(collector, async () => {\n      const response = await next();\n      const body = response.body;\n      if (!body) {\n        return {\n          html: null as string | null,\n          status: response.status,\n          headers: response.headers,\n        };\n      }\n\n      const reader = body.pipeThrough(new TextDecoderStream()).getReader();\n      const parts: string[] = [];\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        parts.push(value);\n      }\n      return {\n        html: parts.join(''),\n        status: response.status,\n        headers: response.headers,\n      };\n    });\n\n    if (!rendered.html) {\n      return new Response(null, {\n        status: rendered.status,\n        headers: rendered.headers,\n      });\n    }\n\n    let { html } = rendered;\n\n    const css = collector.getCSS();\n    if (!css) {\n      return new Response(html, {\n        status: rendered.status,\n        headers: rendered.headers,\n      });\n    }\n\n    const nonce = getConfig().nonce;\n    const nonceAttr = nonce ? ` nonce=\"${nonce}\"` : '';\n    const styleTag = `<style data-tasty-ssr${nonceAttr}>${css}</style>`;\n\n    let cacheTag = '';\n    if (transferCache) {\n      const classNames = collector.getRenderedClassNames();\n      if (classNames.length > 0) {\n        const classListJSON = classNames.map((n) => `\"${n}\"`).join(',');\n        cacheTag = `<script${nonceAttr}>(window.__TASTY__=window.__TASTY__||[]).push(${classListJSON})</script>`;\n      }\n    }\n\n    const injection = styleTag + cacheTag;\n    const idx = html.indexOf('</head>');\n    if (idx !== -1) {\n      html = html.slice(0, idx) + injection + html.slice(idx);\n    } else {\n      html = injection + html;\n    }\n\n    const headers = new Headers(rendered.headers);\n    headers.delete('content-length');\n\n    return new Response(html, {\n      status: rendered.status,\n      headers,\n    });\n  };\n}\n\n// ============================================================================\n// Astro Integration API\n// ============================================================================\n\nexport interface TastyIntegrationOptions {\n  /**\n   * Enable island hydration support.\n   *\n   * When `true` (default): injects a client hydration script via\n   * `injectScript('before-hydration')` and sets `transferCache: true`\n   * on the middleware. Islands skip the style pipeline during hydration.\n   *\n   * When `false`: no client JS is shipped and `transferCache` is set\n   * to `false`. Use this for fully static sites without `client:*`\n   * directives.\n   */\n  islands?: boolean;\n}\n\n/**\n * Astro integration that automatically sets up Tasty SSR.\n *\n * Registers middleware for cross-component CSS deduplication and\n * optionally injects a client hydration script for island support.\n *\n * @example Basic setup (with islands)\n * ```ts\n * // astro.config.mjs\n * import { tastyIntegration } from '@tenphi/tasty/ssr/astro';\n *\n * export default defineConfig({\n *   integrations: [tastyIntegration()],\n * });\n * ```\n *\n * @example Static-only (no client JS)\n * ```ts\n * // astro.config.mjs\n * import { tastyIntegration } from '@tenphi/tasty/ssr/astro';\n *\n * export default defineConfig({\n *   integrations: [tastyIntegration({ islands: false })],\n * });\n * ```\n */\nexport function tastyIntegration(options?: TastyIntegrationOptions): {\n  name: string;\n  hooks: Record<string, (...args: never[]) => void>;\n} {\n  const { islands = true } = options ?? {};\n\n  setMiddlewareTransferCache(islands);\n\n  return {\n    name: '@tenphi/tasty',\n    hooks: {\n      'astro:config:setup': ({\n        addMiddleware,\n        injectScript,\n      }: {\n        addMiddleware: (middleware: {\n          entrypoint: string | URL;\n          order: 'pre' | 'post';\n        }) => void;\n        injectScript: (\n          stage: 'head-inline' | 'before-hydration' | 'page' | 'page-ssr',\n          content: string,\n        ) => void;\n      }) => {\n        addMiddleware({\n          entrypoint: new URL('./astro-middleware.js', import.meta.url),\n          order: 'pre',\n        });\n\n        if (islands) {\n          injectScript(\n            'before-hydration',\n            `import \"@tenphi/tasty/ssr/astro-client\";`,\n          );\n        }\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAQA,IAAI,2BAA2B;;AAG/B,SAAgB,2BAA2B,OAAsB;CAC/D,2BAA2B;;;AAI7B,SAAgB,6BAAsC;CACpD,OAAO;;;;;;;;;;;;;ACGT,iCAAiC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCjD,SAAgB,gBAAgB,SAAkC;CAChE,OAAO,OACL,UACA,SACsB;EACtB,MAAM,gBAAgB,SAAS,iBAAiB;EAChD,MAAM,YAAY,IAAI,sBAAsB;EAK5C,MAAM,WAAW,MAAM,iBAAiB,WAAW,YAAY;GAC7D,MAAM,WAAW,MAAM,MAAM;GAC7B,MAAM,OAAO,SAAS;GACtB,IAAI,CAAC,MACH,OAAO;IACL,MAAM;IACN,QAAQ,SAAS;IACjB,SAAS,SAAS;IACnB;GAGH,MAAM,SAAS,KAAK,YAAY,IAAI,mBAAmB,CAAC,CAAC,WAAW;GACpE,MAAM,QAAkB,EAAE;GAC1B,SAAS;IACP,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;IAC3C,IAAI,MAAM;IACV,MAAM,KAAK,MAAM;;GAEnB,OAAO;IACL,MAAM,MAAM,KAAK,GAAG;IACpB,QAAQ,SAAS;IACjB,SAAS,SAAS;IACnB;IACD;EAEF,IAAI,CAAC,SAAS,MACZ,OAAO,IAAI,SAAS,MAAM;GACxB,QAAQ,SAAS;GACjB,SAAS,SAAS;GACnB,CAAC;EAGJ,IAAI,EAAE,SAAS;EAEf,MAAM,MAAM,UAAU,QAAQ;EAC9B,IAAI,CAAC,KACH,OAAO,IAAI,SAAS,MAAM;GACxB,QAAQ,SAAS;GACjB,SAAS,SAAS;GACnB,CAAC;EAGJ,MAAM,QAAQ,WAAW,CAAC;EAC1B,MAAM,YAAY,QAAQ,WAAW,MAAM,KAAK;EAChD,MAAM,WAAW,wBAAwB,UAAU,GAAG,IAAI;EAE1D,IAAI,WAAW;EACf,IAAI,eAAe;GACjB,MAAM,aAAa,UAAU,uBAAuB;GACpD,IAAI,WAAW,SAAS,GAEtB,WAAW,UAAU,UAAU,gDADT,WAAW,KAAK,MAAM,IAAI,EAAE,GAAG,CAAC,KAAK,IACiC,CAAC;;EAIjG,MAAM,YAAY,WAAW;EAC7B,MAAM,MAAM,KAAK,QAAQ,UAAU;EACnC,IAAI,QAAQ,IACV,OAAO,KAAK,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK,MAAM,IAAI;OAEvD,OAAO,YAAY;EAGrB,MAAM,UAAU,IAAI,QAAQ,SAAS,QAAQ;EAC7C,QAAQ,OAAO,iBAAiB;EAEhC,OAAO,IAAI,SAAS,MAAM;GACxB,QAAQ,SAAS;GACjB;GACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDN,SAAgB,iBAAiB,SAG/B;CACA,MAAM,EAAE,UAAU,SAAS,WAAW,EAAE;CAExC,2BAA2B,QAAQ;CAEnC,OAAO;EACL,MAAM;EACN,OAAO,EACL,uBAAuB,EACrB,eACA,mBAUI;GACJ,cAAc;IACZ,YAAY,IAAI,IAAI,yBAAyB,OAAO,KAAK,IAAI;IAC7D,OAAO;IACR,CAAC;GAEF,IAAI,SACF,aACE,oBACA,2CACD;KAGN;EACF"}

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

@@ -8,27 +8,37 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * The middleware calls runWithCollector() around the render, and
 * useStyles() calls getSSRCollector() to find it.
 *
+* Uses globalThis to ensure the AsyncLocalStorage instance is shared
+* across module instances — frameworks like Astro may load middleware
+* and page components from separate module graphs.
+*
 * This module imports from 'node:async_hooks' — it must be excluded
 * from client bundles via the build configuration.
 */
-const tastySSRStorage = new AsyncLocalStorage();
+const ALS_KEY = "__tasty_ssr_als__";
+function getSharedStorage() {
+	const g = globalThis;
+	if (!g[ALS_KEY]) g[ALS_KEY] = new AsyncLocalStorage();
+	return g[ALS_KEY];
+}
 /**
 * Run a function with a ServerStyleCollector bound to the current
 * async context. All useStyles() calls within `fn` (and any async
 * continuations) will find this collector via getSSRCollector().
 */
 function runWithCollector(collector, fn) {
-	return tastySSRStorage.run(collector, fn);
+	return getSharedStorage().run(collector, fn);
 }
 /**
 * Retrieve the ServerStyleCollector bound to the current async context.
 * Returns null when called outside of runWithCollector() or on the client.
 */
 function getSSRCollector() {
-	if (typeof tastySSRStorage?.getStore !== "function") return null;
-	return tastySSRStorage.getStore() ?? null;
+	const storage = getSharedStorage();
+	if (typeof storage?.getStore !== "function") return null;
+	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;CACV,IAAI,CAAC,EAAE,UACL,EAAE,WAAW,IAAI,mBAAyC;CAE5D,OAAO,EAAE;;;;;;;AAQX,SAAgB,iBACd,WACA,IACG;CACH,OAAO,kBAAkB,CAAC,IAAI,WAAW,GAAG;;;;;;AAO9C,SAAgB,kBAA+C;CAC7D,MAAM,UAAU,kBAAkB;CAClC,IAAI,OAAO,SAAS,aAAa,YAAY,OAAO;CACpD,OAAO,QAAQ,UAAU,IAAI"}

package/dist/babel-D3rC5vJS.d.ts

@@ -0,0 +1,84 @@
+import { t as TastyConfig } from "./config-DlTe4GvV.js";
+import * as _$_babel_core0 from "@babel/core";
+import { PluginPass } from "@babel/core";
+
+//#region src/zero/babel-types.d.ts
+/**
+ * Build-time configuration for zero-runtime mode.
+ * Subset of TastyConfig excluding runtime-only DOM options
+ * (`nonce`, `maxRulesPerSheet`, `forceTextInjection`, `gc`)
+ * and overriding `devMode` default to `false`.
+ */
+type TastyZeroConfig = Omit<TastyConfig, 'nonce' | 'maxRulesPerSheet' | 'forceTextInjection' | 'gc' | 'devMode'> & {
+  /**
+   * Enable development mode features: source comments in generated CSS.
+   * @default false
+   */
+  devMode?: boolean;
+};
+//#endregion
+//#region src/zero/babel.d.ts
+/**
+ * Options for the `@tenphi/tasty/babel-plugin` Babel plugin.
+ */
+interface TastyZeroBabelOptions {
+  /** Output path for generated CSS (default: 'tasty.css') */
+  output?: string;
+  /**
+   * Tasty configuration for build-time processing.
+   * Can be a static object or a factory function that returns fresh config.
+   * A factory is called on each plugin invocation, enabling hot reload
+   * of config values that depend on external files (e.g. theme tokens).
+   */
+  config?: TastyZeroConfig | (() => TastyZeroConfig);
+  /**
+   * Absolute path to a TypeScript/JavaScript module that default-exports
+   * a `TastyZeroConfig` object. The module is loaded via jiti on each
+   * plugin invocation, enabling hot reload when the file changes.
+   *
+   * This option is JSON-serializable and is the primary way Turbopack
+   * passes config to the Babel plugin (since Turbopack loader options
+   * must be plain primitives/objects/arrays).
+   *
+   * When both `config` and `configFile` are set, `config` takes precedence.
+   *
+   * @example '/absolute/path/to/tasty-zero.config.ts'
+   */
+  configFile?: string;
+  /**
+   * Absolute file paths whose content affects the generated CSS.
+   * When any of these files change, babel-loader invalidates its cache
+   * and re-runs the plugin with fresh config values.
+   *
+   * Typically includes theme files that define Glaze palettes or token values.
+   * Paths must be absolute (resolved by the Next.js wrapper).
+   */
+  configDeps?: string[];
+  /**
+   * Automatically replace `@tenphi/tasty/static` imports with an import
+   * of the generated CSS file. This eliminates the need for users to
+   * manually import the CSS in their app entry point.
+   *
+   * @default true
+   */
+  injectImport?: boolean;
+  /**
+   * Output mode for extracted CSS.
+   *
+   * - `'file'` (default): CSS is written to a single output file and
+   *   the `@tenphi/tasty/static` import is rewritten to import that file.
+   * - `'inject'`: CSS is embedded inline in the JS output and injected
+   *   at runtime via a tiny injector from `@tenphi/tasty/static/inject`.
+   *   No CSS file is written. Each `tastyStatic` call becomes
+   *   self-contained. Best for reusable components and extensions.
+   *
+   * When `mode` is `'inject'`, `output` and `injectImport` are ignored.
+   *
+   * @default 'file'
+   */
+  mode?: 'file' | 'inject';
+}
+declare const _default: (api: object, options: TastyZeroBabelOptions | null | undefined, dirname: string) => _$_babel_core0.PluginObj<PluginPass>;
+//#endregion
+export { _default as n, TastyZeroConfig as r, TastyZeroBabelOptions as t };
+//# sourceMappingURL=babel-D3rC5vJS.d.ts.map