@tenphi/tasty 0.0.0-snapshot.01d8a9e

package/dist/properties/property-type-resolver.d.ts

@@ -0,0 +1,24 @@
+//#region src/properties/property-type-resolver.d.ts
+/**
+ * PropertyTypeResolver
+ *
+ * Automatically infers CSS @property types from custom property values.
+ * Supports deferred resolution for var() reference chains of arbitrary depth.
+ */
+declare class PropertyTypeResolver {
+  /** propName → the prop it depends on */
+  private pendingDeps;
+  /** propName → list of props waiting on it */
+  private reverseDeps;
+  /**
+   * Scan CSS declarations and auto-register @property for custom properties
+   * whose types can be inferred from their values.
+   */
+  scanDeclarations(declarations: string, isPropertyDefined: (name: string) => boolean, registerProperty: (name: string, syntax: string, initialValue: string) => void): void;
+  private addDependency;
+  private resolve;
+  private isComplexValue;
+}
+//#endregion
+export { PropertyTypeResolver };
+//# sourceMappingURL=property-type-resolver.d.ts.map

package/dist/properties/property-type-resolver.js

@@ -0,0 +1,90 @@
+import { inferSyntaxFromValue } from "./index.js";
+//#region src/properties/property-type-resolver.ts
+/**
+* PropertyTypeResolver
+*
+* Automatically infers CSS @property types from custom property values.
+* Supports deferred resolution for var() reference chains of arbitrary depth.
+*/
+const CUSTOM_PROP_DECL = /^\s*(--[a-z0-9_-]+)\s*:\s*(.+?)\s*$/i;
+const SINGLE_VAR_REF = /^var\((--[a-z0-9_-]+)\)$/i;
+var PropertyTypeResolver = class {
+	/** propName → the prop it depends on */
+	pendingDeps = /* @__PURE__ */ new Map();
+	/** propName → list of props waiting on it */
+	reverseDeps = /* @__PURE__ */ new Map();
+	/**
+	* Scan CSS declarations and auto-register @property for custom properties
+	* whose types can be inferred from their values.
+	*/
+	scanDeclarations(declarations, isPropertyDefined, registerProperty) {
+		if (!declarations.includes("--")) return;
+		const parts = declarations.split(/;+/);
+		for (const part of parts) {
+			if (!part.trim()) continue;
+			const match = CUSTOM_PROP_DECL.exec(part);
+			if (!match) continue;
+			const propName = match[1];
+			const value = match[2].trim();
+			if (isPropertyDefined(propName)) continue;
+			if (propName.endsWith("-color")) {
+				registerProperty(propName, "<color>", "transparent");
+				continue;
+			}
+			if (propName.endsWith("-line-height")) {
+				registerProperty(propName, "<number> | <length-percentage>", "0");
+				continue;
+			}
+			if (propName.endsWith("-opacity")) {
+				registerProperty(propName, "<number> | <percentage>", "0");
+				continue;
+			}
+			const varMatch = SINGLE_VAR_REF.exec(value);
+			if (varMatch) {
+				const depName = varMatch[1];
+				this.addDependency(propName, depName);
+				continue;
+			}
+			if (this.isComplexValue(value)) continue;
+			const inferred = inferSyntaxFromValue(value);
+			if (!inferred) continue;
+			this.resolve(propName, inferred.syntax, inferred.initialValue, isPropertyDefined, registerProperty);
+		}
+	}
+	addDependency(propName, depName) {
+		if (propName === depName) return;
+		this.pendingDeps.set(propName, depName);
+		let dependents = this.reverseDeps.get(depName);
+		if (!dependents) {
+			dependents = [];
+			this.reverseDeps.set(depName, dependents);
+		}
+		if (!dependents.includes(propName)) dependents.push(propName);
+	}
+	resolve(propName, syntax, initialValue, isPropertyDefined, registerProperty, resolving) {
+		if (!resolving) resolving = /* @__PURE__ */ new Set();
+		if (resolving.has(propName)) return;
+		resolving.add(propName);
+		if (!isPropertyDefined(propName)) registerProperty(propName, syntax, initialValue);
+		const dependents = this.reverseDeps.get(propName);
+		if (dependents) {
+			this.reverseDeps.delete(propName);
+			for (const dependent of dependents) {
+				this.pendingDeps.delete(dependent);
+				if (isPropertyDefined(dependent)) continue;
+				this.resolve(dependent, syntax, initialValue, isPropertyDefined, registerProperty, resolving);
+			}
+		}
+	}
+	isComplexValue(value) {
+		if (value.includes("calc(")) return true;
+		const firstVar = value.indexOf("var(");
+		if (firstVar === -1) return false;
+		if (value.indexOf("var(", firstVar + 4) !== -1) return true;
+		return !SINGLE_VAR_REF.test(value);
+	}
+};
+//#endregion
+export { PropertyTypeResolver };
+
+//# sourceMappingURL=property-type-resolver.js.map

package/dist/properties/property-type-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-type-resolver.js","names":[],"sources":["../../src/properties/property-type-resolver.ts"],"sourcesContent":["/**\n * PropertyTypeResolver\n *\n * Automatically infers CSS @property types from custom property values.\n * Supports deferred resolution for var() reference chains of arbitrary depth.\n */\n\nimport { inferSyntaxFromValue } from './index';\n\nconst CUSTOM_PROP_DECL = /^\\s*(--[a-z0-9_-]+)\\s*:\\s*(.+?)\\s*$/i;\nconst SINGLE_VAR_REF = /^var\\((--[a-z0-9_-]+)\\)$/i;\n\nexport class PropertyTypeResolver {\n  /** propName → the prop it depends on */\n  private pendingDeps = new Map<string, string>();\n  /** propName → list of props waiting on it */\n  private reverseDeps = new Map<string, string[]>();\n\n  /**\n   * Scan CSS declarations and auto-register @property for custom properties\n   * whose types can be inferred from their values.\n   */\n  scanDeclarations(\n    declarations: string,\n    isPropertyDefined: (name: string) => boolean,\n    registerProperty: (\n      name: string,\n      syntax: string,\n      initialValue: string,\n    ) => void,\n  ): void {\n    if (!declarations.includes('--')) return;\n\n    const parts = declarations.split(/;+/);\n\n    for (const part of parts) {\n      if (!part.trim()) continue;\n\n      const match = CUSTOM_PROP_DECL.exec(part);\n      if (!match) continue;\n\n      const propName = match[1];\n      const value = match[2].trim();\n\n      if (isPropertyDefined(propName)) continue;\n\n      // Name-based: --*-color properties are always <color> (from #name tokens)\n      if (propName.endsWith('-color')) {\n        registerProperty(propName, '<color>', 'transparent');\n        continue;\n      }\n\n      // Name-based: --*-line-height accepts numbers, lengths, and percentages\n      if (propName.endsWith('-line-height')) {\n        registerProperty(propName, '<number> | <length-percentage>', '0');\n        continue;\n      }\n\n      // Name-based: --*-opacity accepts numbers and percentages\n      if (propName.endsWith('-opacity')) {\n        registerProperty(propName, '<number> | <percentage>', '0');\n        continue;\n      }\n\n      // Single var() reference → record dependency for deferred resolution\n      const varMatch = SINGLE_VAR_REF.exec(value);\n      if (varMatch) {\n        const depName = varMatch[1];\n        this.addDependency(propName, depName);\n        continue;\n      }\n\n      // Skip complex expressions (calc, multiple var, etc.)\n      if (this.isComplexValue(value)) continue;\n\n      const inferred = inferSyntaxFromValue(value);\n      if (!inferred) continue;\n\n      this.resolve(\n        propName,\n        inferred.syntax,\n        inferred.initialValue,\n        isPropertyDefined,\n        registerProperty,\n      );\n    }\n  }\n\n  private addDependency(propName: string, depName: string): void {\n    if (propName === depName) return;\n\n    this.pendingDeps.set(propName, depName);\n\n    let dependents = this.reverseDeps.get(depName);\n    if (!dependents) {\n      dependents = [];\n      this.reverseDeps.set(depName, dependents);\n    }\n    if (!dependents.includes(propName)) {\n      dependents.push(propName);\n    }\n  }\n\n  private resolve(\n    propName: string,\n    syntax: string,\n    initialValue: string,\n    isPropertyDefined: (name: string) => boolean,\n    registerProperty: (\n      name: string,\n      syntax: string,\n      initialValue: string,\n    ) => void,\n    resolving?: Set<string>,\n  ): void {\n    if (!resolving) resolving = new Set();\n    if (resolving.has(propName)) return;\n    resolving.add(propName);\n\n    if (!isPropertyDefined(propName)) {\n      registerProperty(propName, syntax, initialValue);\n    }\n\n    const dependents = this.reverseDeps.get(propName);\n    if (dependents) {\n      this.reverseDeps.delete(propName);\n\n      for (const dependent of dependents) {\n        this.pendingDeps.delete(dependent);\n\n        if (isPropertyDefined(dependent)) continue;\n\n        this.resolve(\n          dependent,\n          syntax,\n          initialValue,\n          isPropertyDefined,\n          registerProperty,\n          resolving,\n        );\n      }\n    }\n  }\n\n  private isComplexValue(value: string): boolean {\n    if (value.includes('calc(')) return true;\n    const firstVar = value.indexOf('var(');\n    if (firstVar === -1) return false;\n    if (value.indexOf('var(', firstVar + 4) !== -1) return true;\n    return !SINGLE_VAR_REF.test(value);\n  }\n}\n"],"mappings":";;;;;;;;AASA,MAAM,mBAAmB;AACzB,MAAM,iBAAiB;AAEvB,IAAa,uBAAb,MAAkC;;CAEhC,8BAAsB,IAAI,KAAqB;;CAE/C,8BAAsB,IAAI,KAAuB;;;;;CAMjD,iBACE,cACA,mBACA,kBAKM;AACN,MAAI,CAAC,aAAa,SAAS,KAAK,CAAE;EAElC,MAAM,QAAQ,aAAa,MAAM,KAAK;AAEtC,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,CAAC,KAAK,MAAM,CAAE;GAElB,MAAM,QAAQ,iBAAiB,KAAK,KAAK;AACzC,OAAI,CAAC,MAAO;GAEZ,MAAM,WAAW,MAAM;GACvB,MAAM,QAAQ,MAAM,GAAG,MAAM;AAE7B,OAAI,kBAAkB,SAAS,CAAE;AAGjC,OAAI,SAAS,SAAS,SAAS,EAAE;AAC/B,qBAAiB,UAAU,WAAW,cAAc;AACpD;;AAIF,OAAI,SAAS,SAAS,eAAe,EAAE;AACrC,qBAAiB,UAAU,kCAAkC,IAAI;AACjE;;AAIF,OAAI,SAAS,SAAS,WAAW,EAAE;AACjC,qBAAiB,UAAU,2BAA2B,IAAI;AAC1D;;GAIF,MAAM,WAAW,eAAe,KAAK,MAAM;AAC3C,OAAI,UAAU;IACZ,MAAM,UAAU,SAAS;AACzB,SAAK,cAAc,UAAU,QAAQ;AACrC;;AAIF,OAAI,KAAK,eAAe,MAAM,CAAE;GAEhC,MAAM,WAAW,qBAAqB,MAAM;AAC5C,OAAI,CAAC,SAAU;AAEf,QAAK,QACH,UACA,SAAS,QACT,SAAS,cACT,mBACA,iBACD;;;CAIL,cAAsB,UAAkB,SAAuB;AAC7D,MAAI,aAAa,QAAS;AAE1B,OAAK,YAAY,IAAI,UAAU,QAAQ;EAEvC,IAAI,aAAa,KAAK,YAAY,IAAI,QAAQ;AAC9C,MAAI,CAAC,YAAY;AACf,gBAAa,EAAE;AACf,QAAK,YAAY,IAAI,SAAS,WAAW;;AAE3C,MAAI,CAAC,WAAW,SAAS,SAAS,CAChC,YAAW,KAAK,SAAS;;CAI7B,QACE,UACA,QACA,cACA,mBACA,kBAKA,WACM;AACN,MAAI,CAAC,UAAW,6BAAY,IAAI,KAAK;AACrC,MAAI,UAAU,IAAI,SAAS,CAAE;AAC7B,YAAU,IAAI,SAAS;AAEvB,MAAI,CAAC,kBAAkB,SAAS,CAC9B,kBAAiB,UAAU,QAAQ,aAAa;EAGlD,MAAM,aAAa,KAAK,YAAY,IAAI,SAAS;AACjD,MAAI,YAAY;AACd,QAAK,YAAY,OAAO,SAAS;AAEjC,QAAK,MAAM,aAAa,YAAY;AAClC,SAAK,YAAY,OAAO,UAAU;AAElC,QAAI,kBAAkB,UAAU,CAAE;AAElC,SAAK,QACH,WACA,QACA,cACA,mBACA,kBACA,UACD;;;;CAKP,eAAuB,OAAwB;AAC7C,MAAI,MAAM,SAAS,QAAQ,CAAE,QAAO;EACpC,MAAM,WAAW,MAAM,QAAQ,OAAO;AACtC,MAAI,aAAa,GAAI,QAAO;AAC5B,MAAI,MAAM,QAAQ,QAAQ,WAAW,EAAE,KAAK,GAAI,QAAO;AACvD,SAAO,CAAC,eAAe,KAAK,MAAM"}

package/dist/rsc-cache.js

@@ -0,0 +1,79 @@
+import { hashString } from "./utils/hash.js";
+import { getRegisteredSSRCollector } from "./ssr/ssr-collector-ref.js";
+import { cache } from "react";
+//#region src/rsc-cache.ts
+/**
+* Shared RSC (React Server Components) inline style cache.
+*
+* Uses React.cache for per-request memoization in Server Components.
+* Both computeStyles() and standalone style functions (useGlobalStyles,
+* useRawCSS, useKeyframes, useProperty, useFontFace, useCounterStyle)
+* share this cache so that CSS accumulated by standalone functions is
+* flushed into inline <style> tags by the next tasty() component.
+*/
+/**
+* Per-request RSC style cache using React.cache.
+* React.cache provides per-request memoization in Server Components,
+* so each request gets its own isolated cache.
+*/
+const getRSCCache = cache(() => ({
+	cacheKeyToClassName: /* @__PURE__ */ new Map(),
+	emittedKeys: /* @__PURE__ */ new Set(),
+	internalsEmitted: false,
+	pendingCSS: [],
+	generatedNames: /* @__PURE__ */ new Map()
+}));
+function rscAllocateClassName(rscCache, cacheKey) {
+	const existing = rscCache.cacheKeyToClassName.get(cacheKey);
+	if (existing) return {
+		className: existing,
+		isNew: false
+	};
+	const className = `t${hashString(cacheKey)}`;
+	rscCache.cacheKeyToClassName.set(cacheKey, className);
+	return {
+		className,
+		isNew: true
+	};
+}
+/**
+* Flush any pending CSS accumulated by standalone functions.
+* Returns the CSS string and clears the buffer.
+*/
+function flushPendingCSS(rscCache) {
+	if (rscCache.pendingCSS.length === 0) return "";
+	const css = rscCache.pendingCSS.join("\n");
+	rscCache.pendingCSS.length = 0;
+	return css;
+}
+/**
+* Push CSS into the RSC pending buffer with dedup via emittedKeys.
+* Returns true if the CSS was added, false if it was already emitted.
+*/
+function pushRSCCSS(rscCache, key, css) {
+	if (rscCache.emittedKeys.has(key)) return false;
+	rscCache.emittedKeys.add(key);
+	rscCache.pendingCSS.push(css);
+	return true;
+}
+/**
+* Determine the current style injection target.
+* Centralizes the three-way detection (SSR collector / RSC cache / client DOM)
+* used by all style functions.
+*/
+function getStyleTarget() {
+	const collector = getRegisteredSSRCollector();
+	if (collector) return {
+		mode: "ssr",
+		collector
+	};
+	if (typeof document === "undefined") return {
+		mode: "rsc",
+		cache: getRSCCache()
+	};
+	return { mode: "client" };
+}
+//#endregion
+export { flushPendingCSS, getRSCCache, getStyleTarget, pushRSCCSS, rscAllocateClassName };
+
+//# sourceMappingURL=rsc-cache.js.map

package/dist/rsc-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc-cache.js","names":[],"sources":["../src/rsc-cache.ts"],"sourcesContent":["/**\n * Shared RSC (React Server Components) inline style cache.\n *\n * Uses React.cache for per-request memoization in Server Components.\n * Both computeStyles() and standalone style functions (useGlobalStyles,\n * useRawCSS, useKeyframes, useProperty, useFontFace, useCounterStyle)\n * share this cache so that CSS accumulated by standalone functions is\n * flushed into inline <style> tags by the next tasty() component.\n */\n\nimport { cache } from 'react';\n\nimport type { ServerStyleCollector } from './ssr/collector';\nimport { getRegisteredSSRCollector } from './ssr/ssr-collector-ref';\nimport { hashString } from './utils/hash';\n\nexport interface RSCStyleCache {\n  cacheKeyToClassName: Map<string, string>;\n  emittedKeys: Set<string>;\n  internalsEmitted: boolean;\n  pendingCSS: string[];\n  /** Maps dedup key -> generated name for keyframes and counter-styles in RSC mode. */\n  generatedNames: Map<string, string>;\n}\n\n/**\n * Per-request RSC style cache using React.cache.\n * React.cache provides per-request memoization in Server Components,\n * so each request gets its own isolated cache.\n */\nexport const getRSCCache = cache(\n  (): RSCStyleCache => ({\n    cacheKeyToClassName: new Map(),\n    emittedKeys: new Set(),\n    internalsEmitted: false,\n    pendingCSS: [],\n    generatedNames: new Map(),\n  }),\n);\n\nexport function rscAllocateClassName(\n  rscCache: RSCStyleCache,\n  cacheKey: string,\n): { className: string; isNew: boolean } {\n  const existing = rscCache.cacheKeyToClassName.get(cacheKey);\n  if (existing) return { className: existing, isNew: false };\n\n  // Content-hash ensures stable names across all environments (RSC, SSR, client),\n  // enabling cross-environment dedup and preventing class collisions.\n  const className = `t${hashString(cacheKey)}`;\n  rscCache.cacheKeyToClassName.set(cacheKey, className);\n  return { className, isNew: true };\n}\n\n/**\n * Flush any pending CSS accumulated by standalone functions.\n * Returns the CSS string and clears the buffer.\n */\nexport function flushPendingCSS(rscCache: RSCStyleCache): string {\n  if (rscCache.pendingCSS.length === 0) return '';\n  const css = rscCache.pendingCSS.join('\\n');\n  rscCache.pendingCSS.length = 0;\n  return css;\n}\n\n/**\n * Push CSS into the RSC pending buffer with dedup via emittedKeys.\n * Returns true if the CSS was added, false if it was already emitted.\n */\nexport function pushRSCCSS(\n  rscCache: RSCStyleCache,\n  key: string,\n  css: string,\n): boolean {\n  if (rscCache.emittedKeys.has(key)) return false;\n  rscCache.emittedKeys.add(key);\n  rscCache.pendingCSS.push(css);\n  return true;\n}\n\nexport type StyleTarget =\n  | { mode: 'ssr'; collector: ServerStyleCollector }\n  | { mode: 'rsc'; cache: RSCStyleCache }\n  | { mode: 'client' };\n\n/**\n * Determine the current style injection target.\n * Centralizes the three-way detection (SSR collector / RSC cache / client DOM)\n * used by all style functions.\n */\nexport function getStyleTarget(): StyleTarget {\n  const collector = getRegisteredSSRCollector();\n  if (collector) return { mode: 'ssr', collector };\n  if (typeof document === 'undefined')\n    return { mode: 'rsc', cache: getRSCCache() };\n  return { mode: 'client' };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8BA,MAAa,cAAc,aACH;CACpB,qCAAqB,IAAI,KAAK;CAC9B,6BAAa,IAAI,KAAK;CACtB,kBAAkB;CAClB,YAAY,EAAE;CACd,gCAAgB,IAAI,KAAK;CAC1B,EACF;AAED,SAAgB,qBACd,UACA,UACuC;CACvC,MAAM,WAAW,SAAS,oBAAoB,IAAI,SAAS;AAC3D,KAAI,SAAU,QAAO;EAAE,WAAW;EAAU,OAAO;EAAO;CAI1D,MAAM,YAAY,IAAI,WAAW,SAAS;AAC1C,UAAS,oBAAoB,IAAI,UAAU,UAAU;AACrD,QAAO;EAAE;EAAW,OAAO;EAAM;;;;;;AAOnC,SAAgB,gBAAgB,UAAiC;AAC/D,KAAI,SAAS,WAAW,WAAW,EAAG,QAAO;CAC7C,MAAM,MAAM,SAAS,WAAW,KAAK,KAAK;AAC1C,UAAS,WAAW,SAAS;AAC7B,QAAO;;;;;;AAOT,SAAgB,WACd,UACA,KACA,KACS;AACT,KAAI,SAAS,YAAY,IAAI,IAAI,CAAE,QAAO;AAC1C,UAAS,YAAY,IAAI,IAAI;AAC7B,UAAS,WAAW,KAAK,IAAI;AAC7B,QAAO;;;;;;;AAaT,SAAgB,iBAA8B;CAC5C,MAAM,YAAY,2BAA2B;AAC7C,KAAI,UAAW,QAAO;EAAE,MAAM;EAAO;EAAW;AAChD,KAAI,OAAO,aAAa,YACtB,QAAO;EAAE,MAAM;EAAO,OAAO,aAAa;EAAE;AAC9C,QAAO,EAAE,MAAM,UAAU"}

package/dist/ssr/astro-client.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/ssr/astro-client.js

@@ -0,0 +1,19 @@
+import { hydrateTastyClasses } from "./hydrate.js";
+//#region src/ssr/astro-client.ts
+/**
+* Client-side cache hydration for Astro islands.
+*
+* Reads the class name list from `window.__TASTY__` (populated by
+* inline scripts emitted during SSR) and pre-populates the injector
+* so island hydration skips the style pipeline entirely.
+*
+* This module is browser-safe — it does NOT import node:async_hooks.
+*
+* Usage:
+* - Automatically injected by tastyIntegration() via injectScript('before-hydration')
+* - Can be imported manually: `import '@tenphi/tasty/ssr/astro-client'`
+*/
+if (typeof window !== "undefined") hydrateTastyClasses();
+//#endregion
+
+//# sourceMappingURL=astro-client.js.map

package/dist/ssr/astro-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro-client.js","names":[],"sources":["../../src/ssr/astro-client.ts"],"sourcesContent":["/**\n * Client-side cache hydration for Astro islands.\n *\n * Reads the class name list from `window.__TASTY__` (populated by\n * inline scripts emitted during SSR) and pre-populates the injector\n * so island hydration skips the style pipeline entirely.\n *\n * This module is browser-safe — it does NOT import node:async_hooks.\n *\n * Usage:\n * - Automatically injected by tastyIntegration() via injectScript('before-hydration')\n * - Can be imported manually: `import '@tenphi/tasty/ssr/astro-client'`\n */\n\nimport { hydrateTastyClasses } from './hydrate';\n\nif (typeof window !== 'undefined') {\n  hydrateTastyClasses();\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,IAAI,OAAO,WAAW,YACpB,sBAAqB"}

package/dist/ssr/astro-middleware.d.ts

@@ -0,0 +1,15 @@
+//#region src/ssr/astro-middleware.d.ts
+/**
+ * Astro middleware entrypoint for tastyIntegration().
+ *
+ * Referenced by the integration via addMiddleware(). Not intended
+ * as a public package export — use tastyMiddleware() directly if
+ * you need manual middleware composition.
+ *
+ * The transferCache setting is controlled by setMiddlewareTransferCache(),
+ * called by tastyIntegration() before middleware is loaded.
+ */
+declare const onRequest: (_context: unknown, next: () => Promise<Response>) => Promise<Response>;
+//#endregion
+export { onRequest };
+//# sourceMappingURL=astro-middleware.d.ts.map

package/dist/ssr/astro-middleware.js

@@ -0,0 +1,19 @@
+import { getMiddlewareTransferCache, tastyMiddleware } from "./astro.js";
+//#region src/ssr/astro-middleware.ts
+/**
+* Astro middleware entrypoint for tastyIntegration().
+*
+* Referenced by the integration via addMiddleware(). Not intended
+* as a public package export — use tastyMiddleware() directly if
+* you need manual middleware composition.
+*
+* The transferCache setting is controlled by setMiddlewareTransferCache(),
+* called by tastyIntegration() before middleware is loaded.
+*/
+const onRequest = tastyMiddleware({ get transferCache() {
+	return getMiddlewareTransferCache();
+} });
+//#endregion
+export { onRequest };
+
+//# sourceMappingURL=astro-middleware.js.map

package/dist/ssr/astro-middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro-middleware.js","names":[],"sources":["../../src/ssr/astro-middleware.ts"],"sourcesContent":["/**\n * Astro middleware entrypoint for tastyIntegration().\n *\n * Referenced by the integration via addMiddleware(). Not intended\n * as a public package export — use tastyMiddleware() directly if\n * you need manual middleware composition.\n *\n * The transferCache setting is controlled by setMiddlewareTransferCache(),\n * called by tastyIntegration() before middleware is loaded.\n */\n\nimport { getMiddlewareTransferCache, tastyMiddleware } from './astro';\n\nexport const onRequest = tastyMiddleware({\n  get transferCache() {\n    return getMiddlewareTransferCache();\n  },\n});\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,YAAY,gBAAgB,EACvC,IAAI,gBAAgB;AAClB,QAAO,4BAA4B;GAEtC,CAAC"}

package/dist/ssr/astro.d.ts

@@ -0,0 +1,108 @@
+//#region src/ssr/astro.d.ts
+/**
+ * Astro integration for Tasty SSR.
+ *
+ * Provides:
+ * - tastyIntegration() — Astro Integration API (recommended)
+ * - tastyMiddleware()  — manual middleware for advanced composition
+ *
+ * Import from '@tenphi/tasty/ssr/astro'.
+ */
+interface TastyMiddlewareOptions {
+  /**
+   * Whether to embed the class-list script for client hydration.
+   * Set to false to skip class transfer (e.g. for CSP restrictions).
+   * Without it, client components may re-inject CSS that already exists
+   * in server-rendered `<style>` tags. Default: true.
+   */
+  transferCache?: boolean;
+}
+/**
+ * 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,
+ * );
+ * ```
+ */
+declare function tastyMiddleware(options?: TastyMiddlewareOptions): (_context: unknown, next: () => Promise<Response>) => Promise<Response>;
+/** @internal */
+declare function setMiddlewareTransferCache(value: boolean): void;
+/** @internal */
+declare function getMiddlewareTransferCache(): boolean;
+interface TastyIntegrationOptions {
+  /**
+   * Enable island hydration support.
+   *
+   * When `true` (default): injects a client hydration script via
+   * `injectScript('before-hydration')` and sets `transferCache: true`
+   * on the middleware. Islands skip the style pipeline during hydration.
+   *
+   * When `false`: no client JS is shipped and `transferCache` is set
+   * to `false`. Use this for fully static sites without `client:*`
+   * directives.
+   */
+  islands?: boolean;
+}
+/**
+ * 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 })],
+ * });
+ * ```
+ */
+declare function tastyIntegration(options?: TastyIntegrationOptions): {
+  name: string;
+  hooks: {
+    'astro:config:setup': ({
+      addMiddleware,
+      injectScript
+    }: {
+      addMiddleware: (middleware: {
+        entrypoint: string | URL;
+        order: "pre" | "post";
+      }) => void;
+      injectScript: (stage: string, content: string) => void;
+    }) => void;
+  };
+};
+//#endregion
+export { TastyIntegrationOptions, TastyMiddlewareOptions, getMiddlewareTransferCache, setMiddlewareTransferCache, tastyIntegration, tastyMiddleware };
+//# sourceMappingURL=astro.d.ts.map

package/dist/ssr/astro.js

@@ -0,0 +1,149 @@
+import { getConfig } from "../config.js";
+import { registerSSRCollectorGetterGlobal } from "./ssr-collector-ref.js";
+import { ServerStyleCollector } from "./collector.js";
+import { getSSRCollector, runWithCollector } from "./async-storage.js";
+//#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
+		});
+	};
+}
+let _middlewareTransferCache = true;
+/** @internal */
+function setMiddlewareTransferCache(value) {
+	_middlewareTransferCache = value;
+}
+/** @internal */
+function getMiddlewareTransferCache() {
+	return _middlewareTransferCache;
+}
+/**
+* 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 { getMiddlewareTransferCache, setMiddlewareTransferCache, tastyIntegration, tastyMiddleware };
+
+//# sourceMappingURL=astro.js.map

package/dist/ssr/astro.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro.js","names":[],"sources":["../../src/ssr/astro.ts"],"sourcesContent":["/**\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';\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// Module-level middleware config (set by tastyIntegration, read by\n// astro-middleware.ts via getter property)\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// ============================================================================\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  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: (stage: string, content: string) => 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":";;;;;;;;;;;;;;AAmBA,iCAAiC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCjD,SAAgB,gBAAgB,SAAkC;AAChE,QAAO,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;AACtB,OAAI,CAAC,KACH,QAAO;IACL,MAAM;IACN,QAAQ,SAAS;IACjB,SAAS,SAAS;IACnB;GAGH,MAAM,SAAS,KAAK,YAAY,IAAI,mBAAmB,CAAC,CAAC,WAAW;GACpE,MAAM,QAAkB,EAAE;AAC1B,YAAS;IACP,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,QAAI,KAAM;AACV,UAAM,KAAK,MAAM;;AAEnB,UAAO;IACL,MAAM,MAAM,KAAK,GAAG;IACpB,QAAQ,SAAS;IACjB,SAAS,SAAS;IACnB;IACD;AAEF,MAAI,CAAC,SAAS,KACZ,QAAO,IAAI,SAAS,MAAM;GACxB,QAAQ,SAAS;GACjB,SAAS,SAAS;GACnB,CAAC;EAGJ,IAAI,EAAE,SAAS;EAEf,MAAM,MAAM,UAAU,QAAQ;AAC9B,MAAI,CAAC,IACH,QAAO,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;AACf,MAAI,eAAe;GACjB,MAAM,aAAa,UAAU,uBAAuB;AACpD,OAAI,WAAW,SAAS,EAEtB,YAAW,UAAU,UAAU,gDADT,WAAW,KAAK,MAAM,IAAI,EAAE,GAAG,CAAC,KAAK,IAAI,CAC8B;;EAIjG,MAAM,YAAY,WAAW;EAC7B,MAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,MAAI,QAAQ,GACV,QAAO,KAAK,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK,MAAM,IAAI;MAEvD,QAAO,YAAY;EAGrB,MAAM,UAAU,IAAI,QAAQ,SAAS,QAAQ;AAC7C,UAAQ,OAAO,iBAAiB;AAEhC,SAAO,IAAI,SAAS,MAAM;GACxB,QAAQ,SAAS;GACjB;GACD,CAAC;;;AASN,IAAI,2BAA2B;;AAG/B,SAAgB,2BAA2B,OAAsB;AAC/D,4BAA2B;;;AAI7B,SAAgB,6BAAsC;AACpD,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDT,SAAgB,iBAAiB,SAAmC;CAClE,MAAM,EAAE,UAAU,SAAS,WAAW,EAAE;AAExC,4BAA2B,QAAQ;AAEnC,QAAO;EACL,MAAM;EACN,OAAO,EACL,uBAAuB,EACrB,eACA,mBAOI;AACJ,iBAAc;IACZ,YAAY,IAAI,IAAI,yBAAyB,OAAO,KAAK,IAAI;IAC7D,OAAO;IACR,CAAC;AAEF,OAAI,QACF,cACE,oBACA,2CACD;KAGN;EACF"}

package/dist/ssr/async-storage.d.ts

@@ -0,0 +1,17 @@
+import { ServerStyleCollector } from "./collector.js";
+
+//#region src/ssr/async-storage.d.ts
+/**
+ * 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().
+ */
+declare function runWithCollector<T>(collector: ServerStyleCollector, fn: () => T): T;
+/**
+ * Retrieve the ServerStyleCollector bound to the current async context.
+ * Returns null when called outside of runWithCollector() or on the client.
+ */
+declare function getSSRCollector(): ServerStyleCollector | null;
+//#endregion
+export { getSSRCollector, runWithCollector };
+//# sourceMappingURL=async-storage.d.ts.map

package/dist/ssr/async-storage.js

@@ -0,0 +1,44 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/ssr/async-storage.ts
+/**
+* AsyncLocalStorage integration for SSR collector discovery.
+*
+* Used by Astro middleware and generic framework integrations where
+* the library cannot wrap the React tree with a context provider.
+* 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 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 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() {
+	const storage = getSharedStorage();
+	if (typeof storage?.getStore !== "function") return null;
+	return storage.getStore() ?? null;
+}
+//#endregion
+export { getSSRCollector, runWithCollector };
+
+//# sourceMappingURL=async-storage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-storage.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"}