@tenphi/tasty 0.0.0-snapshot.de81152 → 0.0.0-snapshot.dfef2a5

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.
@@ -43,7 +46,7 @@ On top of that foundation, Tasty gives teams a governed styling model: a CSS-lik
 
 - **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).
 - **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.
+- **Broad modern CSS coverage** — Media queries, container queries, `@supports`, `:has()`, `@starting-style`, `@property`, `@keyframes`, `@font-face`, `@counter-style`, `@function`, 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.
 
@@ -422,15 +425,34 @@ 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).
 
+### CSS Functions (`@function`)
+
+Define reusable, parameterized CSS functions and call them anywhere a value is accepted. Declare with `$$name`, invoke with `$$name(...)`; parameters and local variables use `$name`.
+
+```jsx
+const Card = tasty({
+  styles: {
+    '@function': {
+      $$negative: { args: ['$value'], result: '(-1 * $value)' },
+    },
+    marginTop: '$$negative(2x)',
+  },
+});
+```
+
+Definitions can also come from `configure({ functions })` or the `useFunction` style function, and work across client, SSR/RSC, and zero-runtime modes. `@function` is an experimental CSS feature, so for browsers that do not ship it yet enable `configure({ polyfills: { functions: true } })` to inline every call into plain CSS at parse time.
+
+See [Style DSL - Functions](docs/dsl.md#functions-function) and [Configuration - Polyfills](docs/configuration.md#polyfills).
+
 ### Style Functions
 
-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.
+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`, `useCounterStyle`, and `useFunction` for animation, custom-property, font, counter-style, and CSS-function primitives. All style functions are hook-free and work in React Server Components.
 
 See [React API - Style Functions](docs/react-api.md#style-functions).
 
@@ -464,10 +486,11 @@ See the [full SSR guide](docs/ssr.md).
 |--------|-------------|----------|
 | `@tenphi/tasty` | Runtime style engine (`tasty`, style functions, `configure`) | Browser |
 | `@tenphi/tasty/static` | Zero-runtime static styles (`tastyStatic`) | Browser |
+| `@tenphi/tasty/static/inject` | Runtime helper the Babel plugin rewrites `tastyStatic` imports to in inject mode | 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 integration + middleware | Node |
@@ -489,39 +512,41 @@ 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
 
-If you choose the runtime approach, performance is usually a non-issue in practice. The numbers below show single-call throughput for the core pipeline stages, measured with `vitest bench` on an Apple M1 Max (Node 22).
+If you choose the runtime approach, performance is usually a non-issue in practice. The numbers below show single-call throughput for the core pipeline stages, measured with `pnpm bench` on an Apple M1 Max (Node 22).
 
 | Operation | ops/sec | Latency (mean) |
 |-----------|--------:|---------------:|
-| `renderStyles` — 5 flat properties (cold) | ~72,000 | ~14 us |
-| `renderStyles` — state map with media/hover/modifier (cold) | ~22,000 | ~46 us |
-| `renderStyles` — same styles (cached) | ~7,200,000 | ~0.14 us |
-| `parseStateKey` — simple key like `:hover` (cold) | ~1,200,000 | ~0.9 us |
-| `parseStateKey` — complex OR/AND/NOT key (cold) | ~190,000 | ~5 us |
-| `parseStateKey` — any key (cached) | ~3,300,000–8,900,000 | ~0.1–0.3 us |
-| `parseStyle` — value tokens like `2x 4x` (cold) | ~345,000 | ~3 us |
-| `parseStyle` — color tokens (cold) | ~525,000 | ~1.9 us |
-| `parseStyle` — any value (cached) | ~15,500,000 | ~0.06 us |
+| `renderStyles` — 5 flat properties (cold) | ~60,000 | ~17 us |
+| `renderStyles` — state map with media/hover/modifier (cold) | ~18,500 | ~54 us |
+| `renderStyles` — same styles (cached) | ~5,800,000 | ~0.17 us |
+| `parseStateKey` — simple key like `:hover` (cold) | ~790,000 | ~1.3 us |
+| `parseStateKey` — complex OR/AND/NOT key (cold) | ~140,000 | ~7 us |
+| `parseStateKey` — any key (cached) | ~3,400,000–8,300,000 | ~0.1–0.3 us |
+| `parseStyle` — value tokens like `2x 4x` (cold) | ~344,000 | ~2.9 us |
+| `parseStyle` — color tokens (cold) | ~567,000 | ~1.8 us |
+| `parseStyle` — any value (cached) | ~15,250,000 | ~0.07 us |
 
-"Cold" benchmarks use unique inputs to bypass all caches. Cached benchmarks reuse a single input and measure the LRU hot path.
+"Cold" benchmarks use unique inputs to bypass all caches. Cached benchmarks reuse a single input and measure the LRU hot path. Expect roughly ±10% between runs on an otherwise idle machine.
 
-Run `pnpm bench` to reproduce.
+Run `pnpm bench` to reproduce. `pnpm bench:browser` runs the component-render benchmarks separately, in headless Chromium — those are useful for comparing variants against each other (a plain element vs. one with sub-elements), but the browser's 0.1 ms timer resolution makes their absolute values too coarse to quote. The two suites are deliberately separate commands: running them together lets the browser compete with Node for CPU and depresses both.
 
 #### What This Means in Practice
 
 - **Cached path dominates production.** After a component's first render, subsequent renders with stable styles skip the pipeline entirely (React `useMemo` + LRU cache hits at every level). All cached operations are sub-microsecond — effectively free.
-- **Cold path is fast enough.** The heaviest cold operation — a complex state map with media queries, hover, and modifiers — takes ~46 us. Even a page with 100 unique styled components adds only ~5 ms of total style computation on first render, negligible next to React reconciliation and DOM work.
-- **Cache multipliers are 30x–100x.** This confirms the multi-level LRU architecture (parser, state-key, simplify, condition, pipeline) is delivering real value.
-- **Comparable to lighter systems.** Emotion's `css()` is typically 5–20 us for simple styles; Tasty's cold `renderStyles` at ~14 us for 5 properties is in the same range despite doing significantly more work (state maps, design tokens, sub-elements, chunking).
-- **On slower devices.** The benchmarks above are from an M1 Max (Geekbench 6 SC ~2,400). A mid-range consumer laptop (~1,800 SC) is roughly 1.3x slower; a mid-range phone (~1,200 SC) is roughly 2x slower; a budget phone (~700 SC) is roughly 3–4x slower. Even at 4x, the heaviest cold operation stays under 200 us and 100 unique components under 20 ms — still well within a single frame budget. The cached path remains sub-microsecond on all devices.
+- **Cold path is fast enough.** The heaviest cold operation — a complex state map with media queries, hover, and modifiers — takes ~54 us. Even a page with 100 unique styled components adds only ~5 ms of total style computation on first render, negligible next to React reconciliation and DOM work.
+- **Cache multipliers are 10x–300x.** The parser sees ~30x, state-key parsing ~10x–25x, and the full pipeline ~100x on flat styles and ~300x on complex state maps — the deeper the work, the more the cache saves. This confirms the multi-level LRU architecture (parser, state-key, simplify, condition, pipeline) is delivering real value.
+- **Comparable to lighter systems.** Emotion's `css()` is typically 5–20 us for simple styles; Tasty's cold `renderStyles` at ~17 us for 5 properties is in the same range despite doing significantly more work (state maps, design tokens, sub-elements, chunking).
+- **On slower devices.** The benchmarks above are from an M1 Max (Geekbench 6 SC ~2,400). A mid-range consumer laptop (~1,800 SC) is roughly 1.3x slower; a mid-range phone (~1,200 SC) is roughly 2x slower; a budget phone (~700 SC) is roughly 3–4x slower. Even at 4x, the heaviest cold operation stays under 250 us and 100 unique components under 25 ms — still well within a single frame budget. The cached path remains sub-microsecond on all devices.
 
 ### How It Stays Fast
 
@@ -531,6 +556,7 @@ Run `pnpm bench` to reproduce.
 - Style normalization guarantees equivalent style input resolves to the same chunks, improving deduplication hit rates.
 - A style garbage collector removes unused styles/chunks over time.
 - A dedicated style injector minimizes DOM/style-tag overhead.
+- Optional [batched injection](docs/configuration.md#batched-injection) collapses many `insertRule()` calls into one style invalidation per commit, which matters when components measure layout during render.
 - This approach is validated in enterprise-scale apps where runtime styling overhead is not noticeable in normal UI flows.
 
 ## Ecosystem
@@ -610,10 +636,16 @@ 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
+- **[Style DSL](docs/dsl.md)** — The Tasty style language: state maps, tokens, units, color syntax, extending semantics, recipes, keyframes, `@property`, `@font-face`, `@counter-style`, and `@function`
 - **[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
+- **[Configuration](docs/configuration.md)** — Global configuration: tokens, recipes, custom units, functions, polyfills, style handlers, props middleware, and TypeScript extensions
+- **[Plugins & Extension Points](docs/plugins.md)** — Extending Tasty: choosing an extension point, authoring style handlers and props middleware, and packaging it as a plugin
 - **[Style Properties](docs/styles.md)** — Complete reference for all enhanced style properties: syntax, values, modifiers, and recommendations
+- **[Style Rules for AI Agents](docs/ai-agents.md)** — Condensed, rule-based brief for AI coding agents: correct value syntax, state maps, and property choices in one short page
+
+### Upgrading
+
+- **[Migration Guide (v2 → v3)](docs/migration-v3.md)** — Every breaking change in 3.0 with a search-and-replace cheat sheet: at-rule key renames, the directional-shorthand rule, config keys, renamed and removed exports, and what deliberately did not change
 
 ### Rendering modes
 

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

@@ -41,4 +41,4 @@ function getSSRCollector() {
 //#endregion
 export { runWithCollector as n, getSSRCollector as t };
 
-//# sourceMappingURL=async-storage-B7_o6FKt.js.map
+//# sourceMappingURL=async-storage-DKK-wTD4.js.map

package/dist/{async-storage-B7_o6FKt.js.map → async-storage-DKK-wTD4.js.map}

@@ -1 +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"}
+{"version":3,"file":"async-storage-DKK-wTD4.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,kBAAwC;CAE3D,OAAO,EAAE;AACX;;;;;;AAOA,SAAgB,iBACd,WACA,IACG;CACH,OAAO,iBAAiB,CAAC,CAAC,IAAI,WAAW,EAAE;AAC7C;;;;;AAMA,SAAgB,kBAA+C;CAC7D,MAAM,UAAU,iBAAiB;CACjC,IAAI,OAAO,SAAS,aAAa,YAAY,OAAO;CACpD,OAAO,QAAQ,SAAS,KAAK;AAC/B"}

package/dist/babel-BUQGeOXA.d.ts

@@ -0,0 +1,83 @@
+import { t as TastyConfig } from "./config-YsxGv4tq.js";
+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) => import("@babel/core").PluginObj<PluginPass>;
+//#endregion
+export { _default as n, TastyZeroConfig as r, TastyZeroBabelOptions as t };
+//# sourceMappingURL=babel-BUQGeOXA.d.ts.map

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

@@ -1,21 +1,19 @@
-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";
+import { L as renderStyles, Mt as formatFunctionRule, Pt as parseFunctionName, X as fontFaceContentHash, Z as formatFontFaceRule, _t as hashString, a as getGlobalCounterStyles, d as getGlobalStyles, f as getNamePrefix, ft as makeClassName, gt as validateNamePrefix, i as getGlobalConfigTokens, mt as makeKeyframeName, o as getGlobalFontFaces, pt as makeCounterStyleName, q as formatCounterStyleRule, r as getEffectiveProperties, s as getGlobalFunctions } from "./config-B5kHzuNz.js";
+import { n as formatPropertyCSS, t as formatRules } from "./format-rules-DKOA-6qu.js";
+import { t as formatGlobalRules } from "./format-global-rules-DklyaXv-.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
-* hash-based class names (`t${hash}`), formats CSS rules into text,
-* and tracks rendered class names for lightweight client transfer.
+* hash-based class names using the configured `namePrefix` (defaults
+* to `'t'`), 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(cacheKey) {
-	return `t${hashString(cacheKey)}`;
-}
 var ServerStyleCollector = class {
 	chunks = /* @__PURE__ */ new Map();
 	cacheKeyToClassName = /* @__PURE__ */ new Map();
@@ -32,9 +30,26 @@ var ServerStyleCollector = class {
 	flushedFontFaceKeys = /* @__PURE__ */ new Set();
 	counterStyleRules = /* @__PURE__ */ new Map();
 	flushedCounterStyleKeys = /* @__PURE__ */ new Set();
+	functionRules = /* @__PURE__ */ new Map();
+	flushedFunctionKeys = /* @__PURE__ */ new Set();
 	keyframesCounter = 0;
 	counterStyleCounter = 0;
 	internalsCollected = false;
+	namePrefix;
+	/**
+	* @param namePrefix - Optional override for the configured prefix.
+	*   Defaults to the value from `configure({ namePrefix })` (or `'t'`).
+	*   Pass an explicit prefix when constructing a collector outside the
+	*   normal configure() lifecycle (e.g. in tests). Validated eagerly
+	*   so misconfiguration fails before any CSS is collected.
+	*/
+	constructor(namePrefix) {
+		if (namePrefix !== void 0) validateNamePrefix(namePrefix);
+		this.namePrefix = namePrefix ?? getNamePrefix();
+	}
+	generateClassName(cacheKey) {
+		return makeClassName(this.namePrefix, hashString(cacheKey));
+	}
 	/**
 	* Collect internal @property rules and :root token defaults.
 	* Mirrors markStylesGenerated() from the client-side injector.
@@ -59,7 +74,7 @@ var ServerStyleCollector = class {
 				if (css) this.collectGlobalStyles("__global:tokens", css);
 			}
 		}
-		const globalFF = getGlobalFontFace();
+		const globalFF = getGlobalFontFaces();
 		if (globalFF) for (const [family, input] of Object.entries(globalFF)) {
 			const descriptors = Array.isArray(input) ? input : [input];
 			for (const desc of descriptors) {
@@ -68,10 +83,15 @@ var ServerStyleCollector = class {
 				this.collectFontFace(hash, css);
 			}
 		}
-		const globalCS = getGlobalCounterStyle();
+		const globalCS = getGlobalCounterStyles();
 		if (globalCS) for (const [name, descriptors] of Object.entries(globalCS)) {
 			const css = formatCounterStyleRule(name, descriptors);
-			this.collectCounterStyle(name, css);
+			this.collectCounterStyle(name, css, { weak: true });
+		}
+		const globalFn = getGlobalFunctions();
+		if (globalFn) for (const [name, definition] of Object.entries(globalFn)) {
+			const css = formatFunctionRule(name, definition);
+			this.collectFunction(parseFunctionName(name), css, { weak: true });
 		}
 		const globalStyles = getGlobalStyles();
 		if (globalStyles) {
@@ -94,7 +114,7 @@ var ServerStyleCollector = class {
 			className: existing,
 			isNewAllocation: false
 		};
-		const className = generateClassName(cacheKey);
+		const className = this.generateClassName(cacheKey);
 		this.cacheKeyToClassName.set(cacheKey, className);
 		return {
 			className,
@@ -126,7 +146,7 @@ var ServerStyleCollector = class {
 	* Allocate a keyframe name for SSR. Uses provided name or generates one.
 	*/
 	allocateKeyframeName(providedName) {
-		return providedName ?? `k${this.keyframesCounter++}`;
+		return providedName ?? makeKeyframeName(this.namePrefix, String(this.keyframesCounter++));
 	}
 	/**
 	* Record a @font-face rule. Deduplicated by key (content hash).
@@ -135,28 +155,58 @@ var ServerStyleCollector = class {
 		if (!this.fontFaceRules.has(key)) this.fontFaceRules.set(key, css);
 	}
 	/**
-	* Record a @counter-style rule. Deduplicated by name.
+	* Record a @counter-style rule. Deduplicated by name and overrides an
+	* existing rule by default. Pass `weak: true` for global `configure()`
+	* definitions, which never clobber an existing rule.
 	*/
-	collectCounterStyle(name, css) {
-		if (!this.counterStyleRules.has(name)) this.counterStyleRules.set(name, css);
+	collectCounterStyle(name, css, options) {
+		const existing = this.counterStyleRules.get(name);
+		if (existing === void 0) {
+			this.counterStyleRules.set(name, css);
+			return;
+		}
+		if (options?.weak || existing === css) return;
+		this.counterStyleRules.set(name, css);
+		this.flushedCounterStyleKeys.delete(name);
+	}
+	/**
+	* Record a @function rule. Deduplicated by CSS function name and overrides an
+	* existing rule by default. Pass `weak: true` for global `configure()`
+	* definitions, which never clobber an existing rule.
+	*/
+	collectFunction(name, css, options) {
+		const existing = this.functionRules.get(name);
+		if (existing === void 0) {
+			this.functionRules.set(name, css);
+			return;
+		}
+		if (options?.weak || existing === css) return;
+		this.functionRules.set(name, css);
+		this.flushedFunctionKeys.delete(name);
 	}
 	/**
 	* Allocate a counter-style name for SSR. Uses provided name or generates one.
 	*/
 	allocateCounterStyleName(providedName) {
-		return providedName ?? `cs${this.counterStyleCounter++}`;
+		return providedName ?? makeCounterStyleName(this.namePrefix, String(this.counterStyleCounter++));
 	}
 	/**
 	* Record global styles (from useGlobalStyles). Deduplicated by key.
+	*
+	* Pass `replace` for slot-keyed entries (an explicit `id`), where the last
+	* write must win to match the client's update-tracking behavior.
 	*/
-	collectGlobalStyles(key, css) {
-		if (!this.globalStyles.has(key)) this.globalStyles.set(key, css);
+	collectGlobalStyles(key, css, replace) {
+		if (replace || !this.globalStyles.has(key)) this.globalStyles.set(key, css);
 	}
 	/**
 	* Record raw CSS text (from useRawCSS). Deduplicated by key.
+	*
+	* Pass `replace` for slot-keyed entries (an explicit `id`), where the last
+	* write must win to match the client's update-tracking behavior.
 	*/
-	collectRawCSS(key, css) {
-		if (!this.rawCSS.has(key)) this.rawCSS.set(key, css);
+	collectRawCSS(key, css, replace) {
+		if (replace || !this.rawCSS.has(key)) this.rawCSS.set(key, css);
 	}
 	/**
 	* Extract all CSS collected so far as a single string.
@@ -168,6 +218,7 @@ var ServerStyleCollector = class {
 		for (const css of this.propertyRules.values()) parts.push(css);
 		for (const css of this.fontFaceRules.values()) parts.push(css);
 		for (const css of this.counterStyleRules.values()) parts.push(css);
+		for (const css of this.functionRules.values()) parts.push(css);
 		for (const css of this.rawCSS.values()) parts.push(css);
 		for (const css of this.globalStyles.values()) parts.push(css);
 		for (const css of this.chunks.values()) parts.push(css);
@@ -192,6 +243,10 @@ var ServerStyleCollector = class {
 			parts.push(css);
 			this.flushedCounterStyleKeys.add(key);
 		}
+		for (const [key, css] of this.functionRules) if (!this.flushedFunctionKeys.has(key)) {
+			parts.push(css);
+			this.flushedFunctionKeys.add(key);
+		}
 		for (const [key, css] of this.rawCSS) if (!this.flushedRawKeys.has(key)) {
 			parts.push(css);
 			this.flushedRawKeys.add(key);
@@ -224,7 +279,26 @@ var ServerStyleCollector = class {
 		return names;
 	}
 };
+/**
+* Factory for creating a {@link ServerStyleCollector} instance.
+*
+* Canonical functional entry point; the `ServerStyleCollector` class remains
+* exported for advanced/internal use.
+*
+* @param namePrefix - Optional override for the configured class-name prefix.
+*   Defaults to the value from `configure({ namePrefix })` (or `'t'`).
+*
+* @example
+* ```ts
+* import { createServerStyleCollector } from '@tenphi/tasty/ssr';
+*
+* const collector = createServerStyleCollector();
+* ```
+*/
+function createServerStyleCollector(namePrefix) {
+	return new ServerStyleCollector(namePrefix);
+}
 //#endregion
-export { ServerStyleCollector as t };
+export { createServerStyleCollector as n, ServerStyleCollector as t };
 
-//# sourceMappingURL=collector-DrgDE7QB.js.map
+//# sourceMappingURL=collector-DTahQUiV.js.map

package/dist/collector-DTahQUiV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector-DTahQUiV.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 using the configured `namePrefix` (defaults\n * to `'t'`), formats CSS rules into text, and tracks rendered class\n * 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  getGlobalCounterStyles,\n  getGlobalFontFaces,\n  getGlobalFunctions,\n  getGlobalConfigTokens,\n  getNamePrefix,\n} from '../config';\nimport { formatCounterStyleRule } from '../counter-style';\nimport { fontFaceContentHash, formatFontFaceRule } from '../font-face';\nimport { formatFunctionRule, parseFunctionName } from '../functions';\nimport { renderStyles } from '../pipeline';\nimport type { StyleResult } from '../pipeline';\nimport { hashString } from '../utils/hash';\nimport {\n  makeClassName,\n  makeCounterStyleName,\n  makeKeyframeName,\n  validateNamePrefix,\n} from '../utils/name-prefix';\nimport { formatPropertyCSS } from './format-property';\nimport { formatGlobalRules } from './format-global-rules';\nimport { formatRules } from './format-rules';\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 functionRules = new Map<string, string>();\n  private flushedFunctionKeys = new Set<string>();\n  private keyframesCounter = 0;\n  private counterStyleCounter = 0;\n  private internalsCollected = false;\n  private namePrefix: string;\n\n  /**\n   * @param namePrefix - Optional override for the configured prefix.\n   *   Defaults to the value from `configure({ namePrefix })` (or `'t'`).\n   *   Pass an explicit prefix when constructing a collector outside the\n   *   normal configure() lifecycle (e.g. in tests). Validated eagerly\n   *   so misconfiguration fails before any CSS is collected.\n   */\n  constructor(namePrefix?: string) {\n    if (namePrefix !== undefined) {\n      validateNamePrefix(namePrefix);\n    }\n    this.namePrefix = namePrefix ?? getNamePrefix();\n  }\n\n  private generateClassName(cacheKey: string): string {\n    return makeClassName(this.namePrefix, hashString(cacheKey));\n  }\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 = getGlobalFontFaces();\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 = getGlobalCounterStyles();\n    if (globalCS) {\n      for (const [name, descriptors] of Object.entries(globalCS)) {\n        const css = formatCounterStyleRule(name, descriptors);\n        this.collectCounterStyle(name, css, { weak: true });\n      }\n    }\n\n    const globalFn = getGlobalFunctions();\n    if (globalFn) {\n      for (const [name, definition] of Object.entries(globalFn)) {\n        const css = formatFunctionRule(name, definition);\n        this.collectFunction(parseFunctionName(name), css, { weak: true });\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 = this.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 (\n      providedName ??\n      makeKeyframeName(this.namePrefix, String(this.keyframesCounter++))\n    );\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 and overrides an\n   * existing rule by default. Pass `weak: true` for global `configure()`\n   * definitions, which never clobber an existing rule.\n   */\n  collectCounterStyle(\n    name: string,\n    css: string,\n    options?: { weak?: boolean },\n  ): void {\n    const existing = this.counterStyleRules.get(name);\n    if (existing === undefined) {\n      this.counterStyleRules.set(name, css);\n      return;\n    }\n    if (options?.weak || existing === css) return;\n    this.counterStyleRules.set(name, css);\n    // If a rule with this name was already flushed (streaming), allow the\n    // overriding rule to be flushed again so it wins by source order.\n    this.flushedCounterStyleKeys.delete(name);\n  }\n\n  /**\n   * Record a @function rule. Deduplicated by CSS function name and overrides an\n   * existing rule by default. Pass `weak: true` for global `configure()`\n   * definitions, which never clobber an existing rule.\n   */\n  collectFunction(\n    name: string,\n    css: string,\n    options?: { weak?: boolean },\n  ): void {\n    const existing = this.functionRules.get(name);\n    if (existing === undefined) {\n      this.functionRules.set(name, css);\n      return;\n    }\n    if (options?.weak || existing === css) return;\n    this.functionRules.set(name, css);\n    // If a rule with this name was already flushed (streaming), allow the\n    // overriding rule to be flushed again so it wins by source order.\n    this.flushedFunctionKeys.delete(name);\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 (\n      providedName ??\n      makeCounterStyleName(this.namePrefix, String(this.counterStyleCounter++))\n    );\n  }\n\n  /**\n   * Record global styles (from useGlobalStyles). Deduplicated by key.\n   *\n   * Pass `replace` for slot-keyed entries (an explicit `id`), where the last\n   * write must win to match the client's update-tracking behavior.\n   */\n  collectGlobalStyles(key: string, css: string, replace?: boolean): void {\n    if (replace || !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   * Pass `replace` for slot-keyed entries (an explicit `id`), where the last\n   * write must win to match the client's update-tracking behavior.\n   */\n  collectRawCSS(key: string, css: string, replace?: boolean): void {\n    if (replace || !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.functionRules.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.functionRules) {\n      if (!this.flushedFunctionKeys.has(key)) {\n        parts.push(css);\n        this.flushedFunctionKeys.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\n/**\n * Factory for creating a {@link ServerStyleCollector} instance.\n *\n * Canonical functional entry point; the `ServerStyleCollector` class remains\n * exported for advanced/internal use.\n *\n * @param namePrefix - Optional override for the configured class-name prefix.\n *   Defaults to the value from `configure({ namePrefix })` (or `'t'`).\n *\n * @example\n * ```ts\n * import { createServerStyleCollector } from '@tenphi/tasty/ssr';\n *\n * const collector = createServerStyleCollector();\n * ```\n */\nexport function createServerStyleCollector(\n  namePrefix?: string,\n): ServerStyleCollector {\n  return new ServerStyleCollector(namePrefix);\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-import { n as StyleResult } from "./index-dUtwpOux.js";
+import { n as StyleResult } from "./index-Cd45t5NM.js";
 
 //#region src/ssr/collector.d.ts
 declare class ServerStyleCollector {
@@ -17,9 +17,21 @@ declare class ServerStyleCollector {
   private flushedFontFaceKeys;
   private counterStyleRules;
   private flushedCounterStyleKeys;
+  private functionRules;
+  private flushedFunctionKeys;
   private keyframesCounter;
   private counterStyleCounter;
   private internalsCollected;
+  private namePrefix;
+  /**
+   * @param namePrefix - Optional override for the configured prefix.
+   *   Defaults to the value from `configure({ namePrefix })` (or `'t'`).
+   *   Pass an explicit prefix when constructing a collector outside the
+   *   normal configure() lifecycle (e.g. in tests). Validated eagerly
+   *   so misconfiguration fails before any CSS is collected.
+   */
+  constructor(namePrefix?: string);
+  private generateClassName;
   /**
    * Collect internal @property rules and :root token defaults.
    * Mirrors markStylesGenerated() from the client-side injector.
@@ -60,21 +72,39 @@ declare class ServerStyleCollector {
    */
   collectFontFace(key: string, css: string): void;
   /**
-   * Record a @counter-style rule. Deduplicated by name.
+   * Record a @counter-style rule. Deduplicated by name and overrides an
+   * existing rule by default. Pass `weak: true` for global `configure()`
+   * definitions, which never clobber an existing rule.
+   */
+  collectCounterStyle(name: string, css: string, options?: {
+    weak?: boolean;
+  }): void;
+  /**
+   * Record a @function rule. Deduplicated by CSS function name and overrides an
+   * existing rule by default. Pass `weak: true` for global `configure()`
+   * definitions, which never clobber an existing rule.
    */
-  collectCounterStyle(name: string, css: string): void;
+  collectFunction(name: string, css: string, options?: {
+    weak?: boolean;
+  }): void;
   /**
    * Allocate a counter-style name for SSR. Uses provided name or generates one.
    */
   allocateCounterStyleName(providedName?: string): string;
   /**
    * Record global styles (from useGlobalStyles). Deduplicated by key.
+   *
+   * Pass `replace` for slot-keyed entries (an explicit `id`), where the last
+   * write must win to match the client's update-tracking behavior.
    */
-  collectGlobalStyles(key: string, css: string): void;
+  collectGlobalStyles(key: string, css: string, replace?: boolean): void;
   /**
    * Record raw CSS text (from useRawCSS). Deduplicated by key.
+   *
+   * Pass `replace` for slot-keyed entries (an explicit `id`), where the last
+   * write must win to match the client's update-tracking behavior.
    */
-  collectRawCSS(key: string, css: string): void;
+  collectRawCSS(key: string, css: string, replace?: boolean): void;
   /**
    * Extract all CSS collected so far as a single string.
    * Includes @property and @keyframes rules.
@@ -93,6 +123,23 @@ declare class ServerStyleCollector {
    */
   getRenderedClassNames(): string[];
 }
+/**
+ * Factory for creating a {@link ServerStyleCollector} instance.
+ *
+ * Canonical functional entry point; the `ServerStyleCollector` class remains
+ * exported for advanced/internal use.
+ *
+ * @param namePrefix - Optional override for the configured class-name prefix.
+ *   Defaults to the value from `configure({ namePrefix })` (or `'t'`).
+ *
+ * @example
+ * ```ts
+ * import { createServerStyleCollector } from '@tenphi/tasty/ssr';
+ *
+ * const collector = createServerStyleCollector();
+ * ```
+ */
+declare function createServerStyleCollector(namePrefix?: string): ServerStyleCollector;
 //#endregion
-export { ServerStyleCollector as t };
-//# sourceMappingURL=collector-LuU1vZ68.d.ts.map
+export { createServerStyleCollector as n, ServerStyleCollector as t };
+//# sourceMappingURL=collector-DUaHCcTS.d.ts.map