@cube-dev/ui-kit 0.0.0-canary-62e2450 → 0.0.0-canary-bacd3ad

package/dist/utils/react/usePopoverSync.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 import { EventBusContext, useEventBus } from "./useEventBus.js";
 import { useCallback, useContext, useEffect, useRef } from "react";
 

package/dist/utils/react/useQaProps.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/utils/react/useQaProps.ts
 /**
 * Processes QA props.

package/dist/utils/react/useScheme.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 import { useSyncExternalStore } from "react";
 
 //#region src/utils/react/useScheme.ts

package/dist/utils/react/useViewportSize.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 import { useEffect, useState } from "react";
 
 //#region src/utils/react/useViewportSize.ts

package/dist/utils/react/wrapNodeIfPlain.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 import { isValidElement } from "react";
 import { isFragment } from "react-is";
 

package/dist/utils/selection.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/utils/selection.ts
 /**
 * Deduplicate/toggle keys in a selection: if a key appears twice it is

package/dist/utils/styles.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/utils/styles.ts
 /**
 * Split properties into style and non-style properties.

package/dist/utils/tree.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/utils/tree.ts
 function toFlatTree(tree, includingFolders) {
 	return tree.reduce((result, node) => {

package/dist/utils/warnings.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/utils/warnings.ts
 const SUGGESTED_PROP_MAP = {
 	disabled: "isDisabled",

package/dist/version.js

@@ -1,7 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-62e2450 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-bacd3ad | Cube Dev Team */
 //#region src/version.ts
-const VERSION = "0.0.0-canary-62e2450";
-const TASTY_VERSION = "0.0.0-snapshot.04629d1";
+const VERSION = "0.0.0-canary-bacd3ad";
+const TASTY_VERSION = "3.5.0";
 if (typeof window !== "undefined") {
 	const version = VERSION;
 	const tastyVersion = TASTY_VERSION;

package/docs/components/layout/Board.md

@@ -146,11 +146,17 @@ An aligned board never shrinks its rows, so pair it with `isAutoHeight` on the c
 - **`isResizable`** `boolean` (default: `true`) — Enable resizing for all widgets. Same ceiling semantics as `isDraggable`.
 - **`isDroppable`** `boolean` (default: `true`) — Whether the board accepts widgets dropped from _other_ boards. `false` does not affect dragging within the board.
 - **`resizeHandles`** `ResizeHandleAxis[]` (default: `['se']`) — Which resize handles to show. Corner handles (`ne`/`nw`/`se`/`sw`) show an angle grip; edge handles (`n`/`s`/`e`/`w`) show a dotted grip. Both are revealed on hover/focus/resize. A single edge (e.g. `['e']` or `['s']`) gives a horizontally- or vertically-only resizable widget.
-- **`resizeGripPlacement`** `'inside' | 'corner'` (default: `'inside'`) — Where the corner grips sit. `'inside'` tucks each one into the widget box; `'corner'` centres it on the widget's corner, so it lines up with a control centred on the opposite corner. Only affects corner handles — a dotted edge grip always stays inside. A corner-placed grip is drawn _outside_ the widget (a widget clips its own content, which would otherwise cut the grip in half), so it needs the board to have at least half a grip's worth of `containerPadding` to show in full against the board's edge. Its hit-zone moves out with it and overhangs by the same half-grip, so the whole visible grip is grabbable and hovering it keeps it revealed — the trade is a ~5px band just outside each corner where a press starts a resize rather than a marquee. Can be overridden per widget.
+- **`resizeGripPlacement`** `'inside' | 'corner'` (default: `'inside'`) — Where the corner grips sit. `'inside'` tucks each one into the widget box; `'corner'` centres it on the widget's corner, so it lines up with a control centred on the opposite corner. Only affects corner handles — a dotted edge grip always stays inside. A corner-placed grip is drawn _outside_ the widget (a widget clips its own content, which would otherwise cut the grip in half), and nothing clips it in turn, so it shows in full even on a widget flush against the board's edge. Its hit-zone is kept to what you can see: half a grip inward, matching the half of the dot painted there, plus as much outward as half the grid gutter allows — so it never covers a neighbour's content, and never covers its own widget's content beyond the dot. The trade is a small band just outside each corner where a press starts a resize rather than a marquee. Can be overridden per widget.
+
+  **In a nested board, two widgets can want the same corner.** An inner board with no `containerPadding` — which `isAligned` sets — puts its last child's corner exactly on its host widget's corner, so both have a resize hit-zone on the same point. The innermost one takes the press: the child stays resizable, and the container cannot be resized from that corner. Give a container widget an edge axis to fall back on (`resizeHandles={['se', 'e', 's']}`), or give the inner board some `containerPadding` so the corners stop coinciding. A container left with only corner axes warns in development the first time it yields.
+
 - **`dragCancel`** `string` (default: `BOARD_SELECTION_CANCEL`) — CSS selector for elements that must not start a pointer drag. Defaults to the same set `selectionCancel` uses, because a control inside a widget has to keep its own press whether or not the board supports selection — a board hosting interactive content needs no configuration for buttons, inputs, links and the common ARIA widget roles to stay usable. Pass your own selector to narrow or widen it, or `''` to let a drag start from anywhere. Does not affect keyboard moves. Can be overridden per widget.
 - **`dragHandle`** `string` — CSS selector for the only elements from which a pointer drag may start. Combines with `dragCancel` rather than replacing it: a drag needs a target inside `dragHandle` _and_ outside `dragCancel`. Can be overridden per widget.
 - **`showGridLines`** `boolean | 'drag' | 'any-drag'` (default: `false`) — Show grid lines behind the widgets. `true` always; `false` never; `'drag'` only while _this_ board is part of the active gesture — it owns the drag (as its source, or as the board the widget is currently over) or one of its own widgets is being resized; `'any-drag'` while any drag is in flight anywhere under a shared `Board.Provider`, so every board advertises itself as somewhere the widget could land. Under one `Board.Provider`, `'drag'` keeps boards a widget cannot land in quiet, and `'any-drag'` is the opt-in for the noisier, more informative version. A nested board that does not set this inherits an enabled ancestor's setting in drag-scoped form: an ancestor's `true` arrives as `'drag'` (a nested board shows lines during a drag, not permanently), while `'any-drag'` is inherited verbatim. An explicit `false` opts out of the inheritance.
 - **`isAligned`** `boolean` (default: `false`) — Align a nested board with its ancestor `Board`'s layout. Only takes effect when the board is nested inside another `Board`'s widget. When set, every cell matches the parent's cell size exactly, which means it takes over three of the board's own metrics: `rowHeight` and `margin` are ignored in favour of the parent's, and `cols` is ignored once the board has been measured (the column count is derived from the measured width at the parent's column pitch, so cells stay parent-sized as the container is resized) — `cols` only serves as the pre-measurement fallback. It never shrinks rows to fit, so pair it with an `isAutoHeight` container so the widget grows to fit its rows at that height.
+
+  Widgets already on the board keep their cells. Narrowing the container lowers the column count, but a widget whose columns now fall outside it is **not** re-flowed into the narrower grid — it holds its position and is clipped by the container's edge, and widening the container brings it back exactly as it was. This is deliberate: resizing a container is not a request to rearrange the widgets inside it, and a layout that reshuffled on the way down could not be restored on the way back up.
+
 - **`selectionMode`** `'none' | 'single' | 'multiple'` (default: `'none'`) — Whether widgets can be selected, and how many at a time. `'multiple'` also enables the marquee and rigid group movement.
 - **`selectedKeys`** `string[]` — Controlled selection. Keys are layout item ids (`LayoutItem.i`); keys with no matching layout item are silently ignored. Requires `selectionMode` other than `'none'`.
 - **`defaultSelectedKeys`** `string[]` — Initial selection for uncontrolled usage. Ignored when `selectedKeys` is set. An uncontrolled board also prunes keys of removed widgets and reports that through `onSelectionChange`; a controlled board leaves that to you.

package/docs/tasty/README.md

@@ -16,14 +16,13 @@ Use this hub to move from the core idea to a working component, then into design
 
 - **Application developer using an existing design system**: [Getting Started](getting-started.md), then [React API](react-api.md).
 - **Design-system author**: [Methodology](methodology.md), [Building a Design System](design-system.md), [Configuration](configuration.md), and [Adoption Guide](adoption.md).
-- **Platform or tooling engineer**: [Configuration](configuration.md), [Build-Time Extraction (`tastyStatic`)](tasty-static.md), [Precompiled Component Catalogs](precompile.md), [Server-Side Rendering](ssr.md), and [Debug Utilities](debug.md).
+- **Platform or tooling engineer**: [Configuration](configuration.md), [Build-Time Extraction (`tastyStatic`)](tasty-static.md), [Server-Side Rendering](ssr.md), and [Debug Utilities](debug.md).
 
 ## By Styling Approach
 
 - **React components**: [React API](react-api.md)
 - **Zero-client-runtime React with `tasty()`**: [Server-Side Rendering](ssr.md), especially the static Astro integration
 - **Build-time extraction with `tastyStatic()`**: [Build-Time Extraction](tasty-static.md)
-- **Shared UI-kit CSS with runtime fallback**: [Precompiled Component Catalogs](precompile.md)
 - **Hydrated `tasty()` with server collection**: [Server-Side Rendering](ssr.md)
 - **Upgrading from v2**: [Migration Guide (v2 → v3)](migration-v3.md)
 
@@ -38,4 +37,3 @@ Use this hub to move from the core idea to a working component, then into design
 - **Understand how selector generation works internally**: [Style rendering pipeline](pipeline.md)
 - **Understand runtime injection internals**: [Style Injector](injector.md)
 - **Reproduce and interpret performance measurements**: [Runtime Benchmarks](runtime-benchmarks.md)
-- **Precompile a UI-kit component catalog**: [Precompiled Component Catalogs](precompile.md)

package/docs/tasty/debug.md

@@ -144,14 +144,8 @@ One-shot overview of the entire Tasty CSS state. Logs a compact report.
 ```typescript
 interface Summary {
   activeClasses: string[];
-  runtimeActiveClasses: string[];
-  precompiledActiveClasses: string[];
-  precompiledInactiveClasses: string[];
-  precompiledUsedClasses: string[];
   unusedClasses: string[];
   totalStyledClasses: string[];
-  precompiledClasses: string[];
-  precompiledManifestCount: number;
 
   activeCSSSize: number;
   unusedCSSSize: number;
@@ -159,7 +153,6 @@ interface Summary {
   rawCSSSize: number;
   keyframesCSSSize: number;
   propertyCSSSize: number;
-  precompiledCSSSize: number;
   totalCSSSize: number;
 
   activeRuleCount: number;
@@ -168,7 +161,6 @@ interface Summary {
   rawRuleCount: number;
   keyframesRuleCount: number;
   propertyRuleCount: number;
-  precompiledRuleCount: number;
   totalRuleCount: number;
 
   metrics: CacheMetrics | null;
@@ -182,20 +174,17 @@ interface Summary {
 // Logged automatically
 tastyDebug.summary();
 // Output:
-//   Active:   42 classes (18 runtime, 24 precompiled), 81 runtime rules, 5.4KB runtime CSS
-//   Unused:   3 runtime classes, 8 rules, 0.5KB
+//   Active:   42 classes, 186 rules, 12.4KB
+//   Unused:   3 classes, 8 rules, 0.5KB
 //   Global:   12 rules, 1.1KB
-//   Precompiled: 24 active, 516 inactive, 31/540 used since reset; 1,024 rules, 697.6KB (1 manifest)
-//   Total:    585 classes, 1,230 rules, 711.6KB
-//   Lookups:  312 (280 precompiled across 31 classes, 14 runtime cache hits, 18 generated; 94.2% reused)
+//   Total:    45 classes, 206 rules, 14.0KB
+//   Cache:    94.2% hit rate (312 lookups)
 
 // Silent
 const s = tastyDebug.summary({ raw: true });
-console.log(s.totalRuleCount); // 1230
+console.log(s.totalRuleCount); // 206
 ```
 
-Registered precompiled stylesheets are immutable external assets, so `summary()` uses their manifest metadata for class, rule, and size totals without reading or parsing CSSOM. `precompiledActiveClasses` is the subset currently present in the DOM, `precompiledInactiveClasses` is the rest of the registered asset, and `precompiledUsedClasses` records distinct classes served since metrics were reset. The last measure distinguishes broad catalog coverage from repeated renders of a small class set. Precompiled hits are included in `metrics.hits`; `metrics.precompiledHits` reports render-frequency hits and `metrics.precompiledUniqueHits` reports distinct served classes. CSS text methods continue to return injector-owned CSS; a linked external stylesheet may not be readable from JavaScript at all.
-
 ---
 
 ### `chunks(opts?): ChunkBreakdown`
@@ -245,7 +234,7 @@ interface CacheStatus {
 tastyDebug.cache();
 // Output:
 //   Active: 42, Unused: 3
-//   Hits: 294 (280 precompiled), Misses: 18, Rate: 94.2%
+//   Hits: 294, Misses: 18, Rate: 94.2%
 ```
 
 ---

package/docs/tasty/runtime-benchmarks.md

@@ -7,7 +7,7 @@ different costs:
 1. Style parsing and generation in Node.
 2. The React overhead of an empty `tasty({})` wrapper.
 3. Cold browser generation and injection compared with equivalent CSS that is
-   already on the page or registered as a precompiled catalog.
+   already on the page.
 
 These are focused microbenchmarks, not page-load or interaction scores. Run
 them several times on an otherwise idle machine and use a production profile
@@ -122,13 +122,6 @@ rules. Both paths perform the same class assignment, DOM commit, and
 computed-style reads. Only the runtime path calls `computeStyles()` and inserts
 the new rules.
 
-The 1,000-rule workload also includes a precompiled Tasty case. Its catalog is
-generated and registered, and its CSS is parsed in an isolated document,
-before the timer starts. The timed work is the chunk-key lookup, class
-assignment, DOM commit, and the same computed-style reads. This keeps CSS
-delivery and registration out of render latency while preserving the real
-runtime lookup path.
-
 Preparation and cleanup happen outside the sample timer. Every runtime style
 value is unique within a cycle, the relevant caches are cleared between cycles,
 and a guard verifies that both paths resolve to the same color. React and the
@@ -177,8 +170,6 @@ They describe different paths:
   rule.
 - A genuinely new style pays generation and injection once, then becomes
   reusable.
-- A registered precompiled chunk skips declaration rendering and rule
-  insertion, while uncovered chunks in the same component remain dynamic.
 - Browser style resolution, layout, and paint depend on the actual document and
   need application-level profiling.
 

package/docs/tasty/ssr.md

@@ -86,92 +86,6 @@ export default function RootLayout({
 
 That's it. All `tasty()` components inside the tree automatically get SSR support. No per-component changes needed.
 
-### Optional shared globals stylesheet
-
-By default, configured global CSS is included in the streamed Tasty style tag
-for every route. `withTastyNext()` can move that stable CSS into one
-content-hashed stylesheet shared by all routes while leaving component and hook
-styles in the normal streaming path.
-
-Keep the Tasty config in a side-effect-free module:
-
-```ts
-// app/tasty.config.ts
-import type { TastyConfig } from '@tenphi/tasty';
-
-const config: TastyConfig = {
-  tokens: { $gap: '8px', '#brand': 'rebeccapurple' },
-  globalStyles: { body: { margin: '0', color: '#brand' } },
-  fontFaces: {
-    Brand: { src: 'url("/fonts/brand.woff2") format("woff2")' },
-  },
-};
-
-export default config;
-```
-
-Use it from the Next config:
-
-```ts
-// next.config.ts
-import { withTastyNext } from '@tenphi/tasty/ssr/next-config';
-import config from './app/tasty.config';
-
-export default withTastyNext({
-  config,
-})({
-  // your Next.js config
-});
-```
-
-The runtime must receive the same config. Import and configure it before the
-registry renders:
-
-```tsx
-// app/tasty-registry.tsx
-'use client';
-
-import { configure } from '@tenphi/tasty';
-import { TastyRegistry } from '@tenphi/tasty/ssr/next';
-import config from './tasty.config';
-
-configure(config);
-
-export default function TastyStyleRegistry({ children }) {
-  return <TastyRegistry>{children}</TastyRegistry>;
-}
-```
-
-The generated file contains eager configuration artifacts: built-in and custom
-`@property` rules, tokens and presets, `@font-face`, `@counter-style`, native
-CSS `@function` definitions, and `globalStyles`. Route-dependent component
-rules and calls to `useGlobalStyles`, `useRawCSS`, `useKeyframes`,
-`useProperty`, `useFontFace`, `useCounterStyle`, and `useFunction` remain
-route-specific. Configured keyframes also remain lazy and are streamed only
-when a route references them.
-
-The default output directory is `public/_tasty`. The wrapper adds the generated
-URL to `TastyRegistry`, respects `basePath`, preserves existing `env` and
-`headers` config, and serves the content-hashed file with an immutable one-year
-cache header on Next server deployments. Static exports keep the content-hashed
-URL and leave cache headers to the hosting provider. Older hashes are not
-deleted automatically, so rolling deployments cannot break pages from the
-previous build; clean the generated directory as part of a clean deployment if
-needed. Page-relative CSS resources such as
-`url(../fonts/brand.woff2)` are rejected because moving them would change their
-meaning; use root-relative, absolute, or data URLs.
-
-`withTastyNext()` options:
-
-| Option       | Type          | Default                   | Description                                                            |
-| ------------ | ------------- | ------------------------- | ---------------------------------------------------------------------- |
-| `config`     | `TastyConfig` | —                         | Config object; takes precedence over `configFile`                      |
-| `configFile` | `string`      | —                         | Project-relative config module path; requires the optional `jiti` peer |
-| `rootDir`    | `string`      | current directory         | Next app root when the build runs from a monorepo root                 |
-| `outputDir`  | `string`      | `public/_tasty`           | Filesystem output directory                                            |
-| `publicPath` | `string`      | inferred from `outputDir` | Root-relative URL; required when output is outside `public`            |
-| `enabled`    | `boolean`     | `true`                    | Disable generation without changing wrapper composition                |
-
 ### How it works
 
 - `TastyRegistry` is a `'use client'` component, but Next.js still server-renders it on initial page load. The `'use client'` boundary is required solely to access `useServerInsertedHTML` — **not** because `tasty()` components need the client.
@@ -216,13 +130,13 @@ The nonce is automatically applied to all `<style>` and `<script>` tags injected
 
 Tasty offers several levels of Astro integration. Choose the one that matches your needs:
 
-| Setup                                                            | Config needed | Deduplication             | Hooks work             | Client JS      |
-| ---------------------------------------------------------------- | ------------- | ------------------------- | ---------------------- | -------------- |
-| Zero setup                                                       | None          | Per render tree           | Yes (within each tree) | None           |
-| `tastyIntegration({ islands: false })`                           | One line      | Cross-tree                | Yes                    | None           |
-| `tastyIntegration()`                                             | One line      | Cross-tree                | Yes                    | Auto-hydration |
-| `tastyIntegration({ css: { mode: 'extract' } })`                 | One line      | Cross-tree and cross-page | Yes                    | Auto-hydration |
-| `tastyIntegration({ islands: false, css: { mode: 'extract' } })` | One line      | Cross-tree and cross-page | Yes                    | None           |
+| Setup                                                     | Config needed | Deduplication                 | Hooks work             | Client JS      |
+| --------------------------------------------------------- | ------------- | ----------------------------- | ---------------------- | -------------- |
+| Zero setup                                                | None          | Per render tree               | Yes (within each tree) | None           |
+| `tastyIntegration({ islands: false })`                    | One line      | Cross-tree                    | Yes                    | None           |
+| `tastyIntegration()`                                      | One line      | Cross-tree                    | Yes                    | Auto-hydration |
+| `tastyIntegration({ css: { mode: 'extract' } })`          | One line      | Cross-tree and cross-page     | Yes                    | Auto-hydration |
+| `tastyIntegration({ islands: false, css: { mode: 'extract' } })` | One line | Cross-tree and cross-page | Yes                    | None           |
 
 ### Zero setup (static pages)
 
@@ -321,8 +235,8 @@ This gives the same middleware deduplication and hook support, but ships zero cl
 
 #### Build-wide CSS extraction
 
-Static Astro builds can move Tasty CSS into content-hashed, browser-cacheable
-shared and page assets:
+Static Astro builds can move repeated Tasty CSS into a content-hashed,
+browser-cacheable asset:
 
 ```ts
 export default defineConfig({
@@ -343,38 +257,14 @@ output. Extraction requires Astro 5 or newer and only applies to prerendered
 production pages. Development, preview-time SSR, and on-demand routes continue
 to receive the normal inline `<style data-tasty-ssr>` output.
 
-Extraction writes every artifact emitted by all styled pages to a shared
-stylesheet. Each page's strict set difference is written to a separate page
-stylesheet. The shared link comes first and the page link follows, so shared
-styles form the base cascade and page-only styles can override them. A fully
-shared page omits the empty page stylesheet. If generated pages have no common
-artifacts, each page receives only its page stylesheet.
-
-The shared-base/page-override order is the extraction-mode cascade contract.
-It does not preserve an inline artifact order where a page-only rule originally
-appeared before a shared rule. Use shared styles for defaults and page-only
-styles for overrides.
-
-Extracted CSS preserves resource URLs verbatim. Relative URLs in an inline
-style resolve from the page, but in an extracted stylesheet they resolve from
-the asset directory. Use absolute URLs or data URLs when extraction is enabled.
-Root-relative URLs such as `url(/fonts/brand.woff2)` are also safe while the
-stylesheet stays on the page's origin. The build fails with a clear error if an
-artifact contains a page-relative or fragment-only URL, including URL strings
-in `image-set()`, `image()`, `src()`, and `@import`.
-
-Assets are written under Astro's configured `build.assets` directory (for
-example, `/_astro/tasty.shared.a1b2c3.css` and
-`/_astro/tasty.page.d4e5f6.css`). Links include the configured Astro `base`, so
-nested routes do not need relative-path handling. Content hashes and output are
-deterministic for identical builds. If `build.assetsPrefix` is configured,
-Tasty uses its CSS-specific prefix (or `fallback`) just like Astro-generated
-stylesheets. When that prefix points to a different origin, root-relative
-resources would resolve against the asset origin rather than the page's origin,
-so the build rejects them as well. Tasty compares the prefix with Astro's `site`
-when it is configured; without `site`, an absolute or protocol-relative prefix
-is treated conservatively as cross-origin. Use a fully absolute resource URL in
-that configuration.
+Extraction moves the largest common block whose position can be preserved on
+every generated page into one stylesheet. Page-only component, global, and raw
+CSS stays inline, so unvisited routes do not receive unrelated styles.
+
+The asset is written under Astro's configured `build.assets` directory (for
+example, `/_astro/tasty.a1b2c3.css`). Links include the configured Astro
+`base`, so nested routes do not need relative-path handling. The content hash
+and output are deterministic for identical builds.
 
 ### Manual middleware (advanced)
 
@@ -410,13 +300,12 @@ Astro's `@astrojs/react` renderer calls `renderToString()` for each React compon
 - The middleware reads the full response body, then injects the collected CSS into `</head>` before sending the final HTML.
 - In extraction mode, prerendered responses also carry temporary structured
   artifact metadata. `astro:build:done` uses those collector-provided
-  boundaries to write shared and page assets and rewrite generated HTML, then
-  removes the metadata. Artifact boundaries are never inferred by splitting or
-  reparsing the generated CSS.
+  boundaries to write the shared asset and rewrite generated HTML, then removes
+  the metadata. CSS is never split on newlines or parsed heuristically.
 
 ### CSP nonce
 
-Call `configure({ nonce: '...' })` before any rendering happens. The middleware reads the nonce and applies it to injected `<style>` and `<script>` tags. In extraction mode, the external stylesheet links retain the nonce.
+Call `configure({ nonce: '...' })` before any rendering happens. The middleware reads the nonce and applies it to injected `<style>` and `<script>` tags. In extraction mode, page-local inline style tags and the external stylesheet link retain the nonce.
 
 ---
 
@@ -499,13 +388,12 @@ const stream = await runWithCollector(collector, () =>
 
 ### Entry points
 
-| Import path                                                                                                                                                                                | Description                                                                                                                                                                                                     |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@tenphi/tasty/ssr`                                                                                                                                                                        | Core SSR API: `ServerStyleCollector`, `createServerStyleCollector`, `runWithCollector`, `hydrateTastyClasses`                                                                                                   |
-| `@tenphi/tasty/ssr/next`                                                                                                                                                                   | Next.js App Router: `TastyRegistry` component                                                                                                                                                                   |
-| `@tenphi/tasty/ssr/next-config`                                                                                                                                                            | Next.js config wrapper: shared, content-hashed global stylesheet                                                                                                                                                |
-| `@tenphi/tasty/ssr/astro`                                                                                                                                                                  | Astro: `tastyIntegration`, `tastyMiddleware`                                                                                                                                                                    |
-| `@tenphi/tasty/ssr/astro-client`                                                                                                                                                           | Astro: client-side cache hydration (auto-injected by integration, or import manually)                                                                                                                           |
+| Import path                                                                         | Description                                                                                                                                                                                                     |
+| ----------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@tenphi/tasty/ssr`                                                                 | Core SSR API: `ServerStyleCollector`, `createServerStyleCollector`, `runWithCollector`, `hydrateTastyClasses`                                                                                                   |
+| `@tenphi/tasty/ssr/next`                                                            | Next.js App Router: `TastyRegistry` component                                                                                                                                                                   |
+| `@tenphi/tasty/ssr/astro`                                                           | Astro: `tastyIntegration`, `tastyMiddleware`                                                                                                                                                                    |
+| `@tenphi/tasty/ssr/astro-client`                                                    | Astro: client-side cache hydration (auto-injected by integration, or import manually)                                                                                                                           |
 | `@tenphi/tasty/ssr/astro-middleware`<br>`@tenphi/tasty/ssr/astro-middleware-static`<br>`@tenphi/tasty/ssr/astro-middleware-extract`<br>`@tenphi/tasty/ssr/astro-middleware-extract-static` | Astro: the middleware entrypoints `tastyIntegration()` registers via `addMiddleware()`. Exported so Astro can resolve them by specifier; you should not import them. For manual setups use `tastyMiddleware()`. |
 
 ### `ServerStyleCollector`
@@ -526,7 +414,7 @@ Constructor: `new ServerStyleCollector(namePrefix?)`, or use the `createServerSt
 | `allocateCounterStyleName(providedName?)`  | Allocate a counter-style name. Returns `providedName` if given, otherwise generates one using `${namePrefix}c${counter}` (e.g. `tc0`, `tc1`, ...).                                                                                                                         |
 | `collectGlobalStyles(key, css)`            | Record global styles (from `useGlobalStyles`). Deduplicated by key.                                                                                                                                                                                                        |
 | `collectRawCSS(key, css)`                  | Record raw CSS text (from `useRawCSS`). Deduplicated by key.                                                                                                                                                                                                               |
-| `collectInternals()`                       | Collect eager configured globals: `@property`, `:root` tokens and presets, `@font-face`, `@counter-style`, `@function`, and `globalStyles`. Called automatically on first chunk collection; idempotent.                                                                    |
+| `collectInternals()`                       | Collect internal `@property` rules, `:root` token defaults, `@font-face`, and `@counter-style` rules from the global config. Called automatically on first chunk collection; idempotent.                                                                                   |
 | `getCSS()`                                 | Get all collected CSS as a single string. For non-streaming SSR.                                                                                                                                                                                                           |
 | `flushCSS()`                               | Get only CSS collected since the last flush. For streaming SSR.                                                                                                                                                                                                            |
 | `getRenderedClassNames()`                  | Get the list of class names rendered so far. Serialized to `window.__TASTY__` for client hydration via `hydrateTastyClasses()`.                                                                                                                                            |
@@ -535,18 +423,10 @@ Constructor: `new ServerStyleCollector(namePrefix?)`, or use the `createServerSt
 
 Next.js App Router component. Props:
 
-| Prop               | Type              | Default   | Description                                                               |
-| ------------------ | ----------------- | --------- | ------------------------------------------------------------------------- |
-| `children`         | `ReactNode`       | required  | Application tree                                                          |
-| `transferCache`    | `boolean`         | `true`    | Embed cache state script for zero-cost hydration                          |
-| `sharedStylesheet` | `string \| false` | generated | Override the shared URL, or disable generated shared CSS for the registry |
-
-### `withTastyNext(options)`
-
-Next.js configuration wrapper exported from
-`@tenphi/tasty/ssr/next-config`. It generates a shared stylesheet from eager
-Tasty configuration artifacts and wires its URL and immutable cache header
-into the Next config. Route-specific CSS continues through `TastyRegistry`.
+| Prop            | Type        | Default  | Description                                      |
+| --------------- | ----------- | -------- | ------------------------------------------------ |
+| `children`      | `ReactNode` | required | Application tree                                 |
+| `transferCache` | `boolean`   | `true`   | Embed cache state script for zero-cost hydration |
 
 ### `tastyIntegration(options?)`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cube-dev/ui-kit",
-  "version": "0.0.0-canary-62e2450",
+  "version": "0.0.0-canary-bacd3ad",
   "type": "module",
   "description": "UIKit for Cube Projects",
   "repository": {
@@ -9,11 +9,7 @@
   },
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "sideEffects": [
-    "./dist/precompiled/index.js",
-    "./dist/precompiled/register.js",
-    "./dist/precompiled/styles.css"
-  ],
+  "sideEffects": false,
   "packageManager": "pnpm@10.34.5",
   "exports": {
     ".": {
@@ -27,32 +23,10 @@
     "./probe": {
       "import": "./dist/probe/index.js",
       "types": "./dist/probe/index.d.ts"
-    },
-    "./precompile": {
-      "import": "./dist/precompile/index.js",
-      "types": "./dist/precompile/index.d.ts"
-    },
-    "./precompiled-styles": {
-      "import": "./dist/precompiled/index.js",
-      "types": "./dist/precompiled/index.d.ts"
-    },
-    "./precompiled-styles/register": {
-      "import": "./dist/precompiled/register.js",
-      "types": "./dist/precompiled/register.d.ts"
-    },
-    "./precompiled-styles.css": {
-      "types": "./dist/precompiled/styles.d.ts",
-      "default": "./dist/precompiled/styles.css"
-    },
-    "./precompiled-styles/manifest": {
-      "import": "./dist/precompiled/manifest.js",
-      "types": "./dist/precompiled/manifest.d.ts"
     }
   },
   "files": [
     "dist/**/*.js",
-    "dist/**/*.css",
-    "dist/**/*.json",
     "dist/**/*.d.ts",
     "dist/**/*.map",
     "dist/README.md",
@@ -61,20 +35,16 @@
     "docs/tasty",
     "docs/glaze",
     "docs/*.md",
-    "tasty.config.ts",
-    "scripts/precompile-tasty-catalog.mjs"
+    "tasty.config.ts"
   ],
   "scripts": {
     "start": "pnpm storybook",
-    "build": "tsdown && pnpm precompile:tasty",
+    "build": "tsdown",
     "watch": "tsdown --watch",
     "test": "vitest run",
     "test:browser": "vitest run --config vitest.browser.config.ts",
-    "test:precompiled": "pnpm build && vitest run --config vitest.precompiled.config.ts",
     "probe": "node scripts/probe.mjs",
     "probe:browser": "PROBE_TIER=browser node scripts/probe.mjs",
-    "precompile:tasty": "node scripts/precompile-tasty.mjs",
-    "bench:precompiled": "pnpm build && vitest bench --config vitest.browser.config.ts scripts/precompile-startup.bench.js",
     "test-cover": "vitest run --coverage",
     "test-watch": "vitest",
     "prettier": "prettier --check \"src/**/*.{js,jsx,ts,tsx}\" \"**/*.{md,mdx}\"",
@@ -126,7 +96,7 @@
     "@tabler/icons-react": "^3.31.0",
     "@tanstack/react-virtual": "^3.13.12",
     "@tenphi/glaze": "2.0.0",
-    "@tenphi/tasty": "0.0.0-snapshot.04629d1",
+    "@tenphi/tasty": "^3.5.0",
     "clipboard-copy": "^4.0.1",
     "clsx": "^1.1.1",
     "diff": "^8.0.3",

package/dist/components/fields/ListBoxPopover/useCompositeFocus.d.ts

@@ -1,2 +0,0 @@
-
-import React, { RefObject } from "react";

package/dist/components/portal/PortalProvider.d.ts

@@ -1,2 +0,0 @@
-
-import { RefObject } from "react";

package/dist/precompile/index.d.ts

@@ -1,45 +0,0 @@
-
-import { CubeRootProps } from "../components/Root.js";
-import { TastyPrecompileCase, TastyPrecompileResult } from "@tenphi/tasty/precompile";
-
-//#region src/precompile/index.d.ts
-type PrecompileCase = TastyPrecompileCase;
-interface PrecompileStylesOptions {
-  id: string;
-  cases: readonly PrecompileCase[];
-  /**
-   * Props for the UI Kit Root wrapped around every case. Pass false when each
-   * case already returns the application's complete Root tree.
-   */
-  root?: false | Omit<CubeRootProps, 'children'>;
-  /**
-   * Re-render UI Kit's own component catalog under this application's Tasty
-   * configuration and fold it into the artifact. Defaults to `true`.
-   *
-   * A chunk's lookup key hashes the style source, not the CSS it produced, so a
-   * kit chunk compiled under UI Kit's configuration keeps the same key under an
-   * application that redefines a unit, recipe or handler the chunk relies on —
-   * while the CSS behind that key no longer matches. Recompiling here removes
-   * the divergence instead of leaving Tasty to detect it and fall back.
-   *
-   * Set to `false` only when this application makes no compilation-affecting
-   * configuration change, and pair it with the shipped artifact:
-   *
-   * ```ts
-   * import '@cube-dev/ui-kit/precompiled-styles';
-   * ```
-   *
-   * The two register side by side — catalogs stack, and identical chunks
-   * compile to identical class names, so the overlap is free. Skipping the
-   * recompilation is a build-time saving, not a way to drop kit coverage.
-   */
-  recompileKitCatalog?: boolean;
-}
-/**
- * Compile application-owned catalog cases under UI Kit's exact Tasty
- * configuration and normal Root providers.
- */
-declare function precompileStyles(options: PrecompileStylesOptions): Promise<TastyPrecompileResult>;
-//#endregion
-export { PrecompileCase, PrecompileStylesOptions, precompileStyles };
-//# sourceMappingURL=index.d.ts.map