@animus-ui/system 0.1.11 → 0.1.12

package/dist/appearance/index.js

@@ -1,41 +1,8 @@
 //#region src/appearance/index.ts
-/**
-* Appearance record write path — the CLIENT half of the contract the generated
-* bootstrap reads (openspec: color-mode-bootstrap, "Appearance record
-* contract").
-*
-* This module is runtime application code: it ships in client bundles and owns
-* only the record WRITE path. It deliberately imports nothing from
-* `@animus-ui/system/bootstrap` — that subpath is build tooling, reaches
-* `node:crypto`, and must never enter an application bundle — so the two
-* modules re-state the key and shape they agree on, and the round-trip tests
-* pin the agreement (a record written here is restored by the generated
-* snippet).
-*
-* Record: `animus:appearance` → `{"v":1,"mode":…,"theme":…}`.
-*
-* Two axes share one record. A writer that changes ONE axis reads, modifies
-* and writes back, so fields it does not own (`theme`, plus anything a future
-* version adds) survive untouched.
-*/
-/** The single versioned appearance record key. */
 const DEFAULT_STORAGE_KEY = "animus:appearance";
-/**
-* The CONTRACT's pre-record key. The generated bootstrap reads it once, only
-* when the record is absent, and never writes it — it may belong to another
-* app on this origin, so this module refuses to migrate (and therefore
-* delete) it. See {@link migrateLegacyModeKey}.
-*/
 const CONTRACT_LEGACY_KEY = "color-mode";
-/** The only appearance-record version this module writes or read-modify-writes. */
 const RECORD_VERSION = 1;
-/**
-* Mode value meaning "follow the OS". It is never a declared mode and never
-* reaches `data-color-mode` — the OS is followed by the attribute's ABSENCE,
-* which the generated bootstrap restores when it reads this value.
-*/
 const SYSTEM_MODE = "system";
-/** Applied when nothing is stored: OS-driven mode, default theme. */
 const DEFAULT_RECORD = {
 	v: RECORD_VERSION,
 	mode: SYSTEM_MODE,
@@ -49,25 +16,6 @@ function keyOf(options) {
 	if (typeof key !== "string" || key === "") throw new Error("appearance: storageKey must be a non-empty string.");
 	return key;
 }
-/**
-* Reads the stored record.
-*
-* READ FAILURE vs. ABSENT: a `getItem` that THROWS (blocked or partitioned
-* storage) — or no storage object at all — is reported as `absent`, not
-* `foreign`, deliberately. "Absent" here means "this code has no knowledge of
-* a stored record", and a store we cannot read at all is indistinguishable
-* from an empty one. The asymmetry is safe because the accompanying write is
-* wrapped in its own try/catch: a store that throws on read throws on write
-* too, so the `absent` classification can never actually clobber anything.
-* Only a store we CAN read and whose content we cannot interpret yields
-* `foreign`.
-*
-* A present-but-corrupt value (not JSON, not an object) is `absent`: it is
-* nobody's live state, so replacing it with a clean record is a repair. A
-* present record carrying an unrecognized `v` is `foreign`: that is a future
-* writer's data, and v1-shaped fields written over it would destroy fields
-* this version does not know exist.
-*/
 function readRecord(storageKey) {
 	let raw = null;
 	try {
@@ -90,24 +38,6 @@ function readRecord(storageKey) {
 		record
 	};
 }
-/**
-* Persists the mode axis, preserving every field this call does not own
-* (`v`, `theme`, and any additional keys already in the record).
-*
-* Pass {@link SYSTEM_MODE} to persist "follow the OS" — the generated
-* bootstrap restores it as attribute absence. Applying the mode to the
-* document (setting or removing `data-color-mode`) stays the caller's job:
-* this module is storage-only and never touches the DOM.
-*
-* REFUSAL RULE: when the stored record carries a version this code does not
-* understand, NOTHING is written. Downgrading it to a v1 shape would drop
-* whatever fields the newer writer keeps there, and this axis is not worth
-* that. A caller that has already updated the attribute keeps the user's
-* choice for the session — only its persistence is skipped.
-*
-* Storage failures are likewise swallowed: persistence is a convenience, and
-* the attribute write that accompanies it has already taken effect.
-*/
 function persistColorMode(mode, options) {
 	const storageKey = keyOf(options);
 	const outcome = readRecord(storageKey);
@@ -120,27 +50,6 @@ function persistColorMode(mode, options) {
 		}));
 	} catch {}
 }
-/**
-* One-shot migration of an application's OWN historical mode key into the
-* record.
-*
-* The generated bootstrap only knows the record and the contract's `color-mode`
-* key — an app that persisted under its own key before adopting the record
-* would silently drop every returning visitor's mode without this. Run it
-* post-paint from the app entry: the visit on which it migrates still paints
-* in the OS-resolved mode before correcting itself — one accepted flash, once
-* — and every later load restores pre-paint through the bootstrap.
-*
-* It writes only when there is nothing to lose (no record) and something worth
-* keeping (a value in `declaredModes`), then DELETES the old key so the
-* migration cannot run twice or resurrect a stale value. Deleting is
-* legitimate precisely because the key is the application's own; the
-* contract's `color-mode` key may belong to another app on this origin and is
-* refused, as is the record key itself.
-*
-* @returns the migrated mode name, so the caller can apply it to the document
-*   for this one visit, or `null` when nothing was migrated.
-*/
 function migrateLegacyModeKey(legacyKey, declaredModes, options) {
 	const storageKey = keyOf(options);
 	if (legacyKey === CONTRACT_LEGACY_KEY) throw new Error(`appearance: '${CONTRACT_LEGACY_KEY}' is the contract's shared legacy key — the generated bootstrap reads it read-only and it may belong to another app on this origin. Migrate only keys your application owns.`);

package/dist/assert-root-slot-C3Lp9MNJ.js

@@ -0,0 +1,10 @@
+//#region src/runtime/assert-root-slot.ts
+/**
+* Without a Root slot a family has no cascade source: composed child rules
+* inherit nothing and the context transport renders the empty default.
+*/
+function assertRootSlot(slots, fnName) {
+	if (!Object.prototype.propertyIsEnumerable.call(slots, "Root")) throw new Error(`${fnName}(): No "Root" slot found. The root slot key must be exactly "Root" (PascalCase).`);
+}
+//#endregion
+export { assertRootSlot as t };

package/dist/asset.d.ts

@@ -1,24 +1,15 @@
 declare const ASSET_REF_BRAND: unique symbol;
 /**
- * A branded package-asset reference for `fontFaces[].src[].url`
- * (global-styles-system). The VALUE is the deterministic placeholder
- * `animus-asset:<specifier>` — a plain string, so it survives the QuickJS
- * sandbox's JSON serialization and the extraction emitter's byte-exact url
- * pass-through untouched. The HOST plugin substitutes the placeholder with
- * the bundler-resolved asset URL after extraction; the sandbox never
- * resolves anything.
+ * A plain string so it crosses the sandbox's JSON boundary untouched; the host
+ * plugin substitutes the placeholder with the bundler-resolved URL.
  */
 export type AssetRef = string & {
     readonly [ASSET_REF_BRAND]: true;
 };
-/** The reserved scheme marking an unsubstituted asset reference. */
 export declare const ASSET_PLACEHOLDER_PREFIX = "animus-asset:";
 /**
- * Reference a package-owned asset (e.g. a font file) by module specifier:
- * `asset('@acme/tokens/fonts/inter.woff2')`. Resolution — aliases, exports
- * maps, `base`, content hashing — belongs to the host bundler; this function
- * only brands the specifier into its placeholder form. A literal URL string
- * (`'/fonts/inter.woff2'`) remains the pass-through alternative.
+ * Brands the specifier only — aliases, exports maps and hashing belong to the
+ * host bundler. A literal URL string stays a valid alternative.
  */
 export declare function asset(specifier: string): AssetRef;
 export {};

package/dist/asset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../src/asset.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,eAAe,EAAE,OAAO,MAAM,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAErE,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAEjD"}
+{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../src/asset.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,eAAe,EAAE,OAAO,MAAM,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAErE,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD;;;GAGG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAEjD"}

package/dist/bootstrap/createAppearanceBootstrap.d.ts

@@ -1,71 +1,14 @@
-/**
- * The slice of a built theme the generator reads: the declared mode names.
- * Structural on purpose — the generator reads mode KEYS only and never touches
- * the theme's pipeline wire (guardrail G5).
- */
 export interface AppearanceBootstrapTheme {
     manifest: {
-        /** Mode name → resolved tokens. Only the KEYS are read. */
         modes?: Record<string, unknown>;
     };
 }
 export interface AppearanceBootstrapOptions {
-    /** Overrides the record key. Defaults to `animus:appearance`. */
     storageKey?: string;
 }
 export interface AppearanceBootstrapArtifact {
-    /** Dependency-free inline IIFE, safe to embed in a document head. */
     code: string;
-    /**
-     * `sha256-<base64>` — the CSP hash of `code`, ready for a `script-src`
-     * source list.
-     *
-     * The source expression MUST be SINGLE-QUOTED in the header, exactly as
-     * returned:
-     *
-     * ```
-     * Content-Security-Policy: script-src 'sha256-<the artifact hash>'
-     * ```
-     *
-     * Unquoted, it is parsed as a host source and silently fails to authorize
-     * the script.
-     *
-     * Always derive the header from this field at build time — never hand-copy
-     * it. Any theme edit that changes the declared mode names (or a changed
-     * `storageKey`) changes `code` and therefore this hash; a stale literal in a
-     * config file turns into a blocked script and a flash of the wrong mode.
-     */
     cspHash: string;
 }
-/**
- * Builds the inline appearance-restoration script for a built theme.
- *
- * The generated snippet, before first paint:
- * 1. reads the appearance record from `storageKey`, falling back to the legacy
- *    `color-mode` key ONLY when the record is absent (missing key, or an empty
- *    string, which is not a record);
- * 2. accepts the record only at version `1` — a future or absent version is
- *    treated as NO record, because an older snippet cannot interpret a newer
- *    record and absence is the neutral fail-safe;
- * 3. sets `data-color-mode` when the resulting name is a declared mode;
- * 4. removes the attribute for `system`, no record, an unreadable store, or an
- *    unknown mode — absence is how "follow the OS" is represented, so later OS
- *    changes apply with no script running.
- *
- * The failure semantics are deliberately asymmetric:
- * - storage that THROWS on read (private browsing, blocked storage) means "no
- *   knowledge", so the attribute is REMOVED and the media-query fallback takes
- *   over; freezing a server-rendered mode would defeat that fallback;
- * - a record that is PRESENT but unparseable means "storage is telling us
- *   something we cannot read", so the snippet exits leaving the server-rendered
- *   markup exactly as it was.
- *
- * It never writes storage, never calls `matchMedia`, and ignores the record's
- * `theme` axis. Identical inputs always yield byte-identical output.
- *
- * @throws if the theme declares no color modes (a bootstrap without a mode
- *   allowlist could not validate anything), declares the reserved name
- *   `system`, or declares a blank mode name.
- */
 export declare function createAppearanceBootstrap(theme: AppearanceBootstrapTheme, options?: AppearanceBootstrapOptions): AppearanceBootstrapArtifact;
 //# sourceMappingURL=createAppearanceBootstrap.d.ts.map

package/dist/bootstrap/createAppearanceBootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createAppearanceBootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap/createAppearanceBootstrap.ts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE;QACR,2DAA2D;QAC3D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACjC,CAAC;CACH;AAED,MAAM,WAAW,0BAA0B;IACzC,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,GAAE,0BAA+B,GACvC,2BAA2B,CAsE7B"}
+{"version":3,"file":"createAppearanceBootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap/createAppearanceBootstrap.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACjC,CAAC;CACH;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAyBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,GAAE,0BAA+B,GACvC,2BAA2B,CAuD7B"}

package/dist/bootstrap/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bootstrap/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,yBAAyB,GAC1B,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bootstrap/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,yBAAyB,GAC1B,MAAM,gCAAgC,CAAC"}

package/dist/bootstrap/index.js

@@ -1,39 +1,15 @@
 import { createHash } from "node:crypto";
 //#region src/bootstrap/createAppearanceBootstrap.ts
-/**
-* Appearance bootstrap generator — build-tooling surface ONLY.
-*
-* This module is reachable exclusively from the `@animus-ui/system/bootstrap`
-* subpath. It is never imported by the component/runtime entries, so no part of
-* it (including the storage keys below) can reach an extracted application
-* bundle.
-*/
-/** The single versioned appearance record key. */
 const DEFAULT_STORAGE_KEY = "animus:appearance";
-/**
-* Pre-record key read once, only when the record is absent. Never written —
-* migration is read-only by contract.
-*/
 const LEGACY_STORAGE_KEY = "color-mode";
-/** The mode axis attribute. Its ABSENCE means "follow the OS" (D4). */
 const MODE_ATTRIBUTE = "data-color-mode";
-/**
-* Reserved mode name. `system` is modeled as attribute absence and can never be
-* a declared mode, so it must never enter the generated allowlist.
-*/
 const RESERVED_MODE_NAME = "system";
-/** The only appearance-record version this generation of the snippet reads. */
 const RECORD_VERSION = 1;
 /**
-* Renders a string as a JS literal that is also safe inside an inline
-* `<script>` and inside a consumer's own string context:
-* - `<` is escaped, so an embedded value can never open a closing tag or an
-*   HTML comment;
-* - U+2028/U+2029 are escaped, so `code` survives being nested in string
-*   contexts that still treat them as line terminators.
-*
-* Character-wise on purpose: this file stays pure ASCII, so no invisible
-* separator can hide in it.
+* Renders a JS string literal safe inside an inline `<script>`: `<` cannot open
+* a closing tag, and U+2028/U+2029 survive nesting in string contexts. The loop
+* compares code points rather than matching literal separators, so no invisible
+* character has to appear in this source — keep it that way.
 */
 function inlineLiteral(value) {
 	let out = "";
@@ -51,36 +27,6 @@ function inlineLiteral(value) {
 	}
 	return out;
 }
-/**
-* Builds the inline appearance-restoration script for a built theme.
-*
-* The generated snippet, before first paint:
-* 1. reads the appearance record from `storageKey`, falling back to the legacy
-*    `color-mode` key ONLY when the record is absent (missing key, or an empty
-*    string, which is not a record);
-* 2. accepts the record only at version `1` — a future or absent version is
-*    treated as NO record, because an older snippet cannot interpret a newer
-*    record and absence is the neutral fail-safe;
-* 3. sets `data-color-mode` when the resulting name is a declared mode;
-* 4. removes the attribute for `system`, no record, an unreadable store, or an
-*    unknown mode — absence is how "follow the OS" is represented, so later OS
-*    changes apply with no script running.
-*
-* The failure semantics are deliberately asymmetric:
-* - storage that THROWS on read (private browsing, blocked storage) means "no
-*   knowledge", so the attribute is REMOVED and the media-query fallback takes
-*   over; freezing a server-rendered mode would defeat that fallback;
-* - a record that is PRESENT but unparseable means "storage is telling us
-*   something we cannot read", so the snippet exits leaving the server-rendered
-*   markup exactly as it was.
-*
-* It never writes storage, never calls `matchMedia`, and ignores the record's
-* `theme` axis. Identical inputs always yield byte-identical output.
-*
-* @throws if the theme declares no color modes (a bootstrap without a mode
-*   allowlist could not validate anything), declares the reserved name
-*   `system`, or declares a blank mode name.
-*/
 function createAppearanceBootstrap(theme, options = {}) {
 	const { storageKey = DEFAULT_STORAGE_KEY } = options;
 	if (typeof storageKey !== "string" || storageKey === "") throw new Error("createAppearanceBootstrap: storageKey must be a non-empty string.");

package/dist/class-resolver.d.ts

@@ -1,8 +1,6 @@
 /**
- * Framework-neutral runtime for `.asClass()` output.
- *
- * This entry intentionally excludes the React component runtime so non-React
- * consumers can install and bundle class resolvers without React.
+ * Excludes the React component runtime so non-React consumers can bundle
+ * class resolvers without installing React.
  */
 export { type ClassResolver, type ClassResolverAttributes, createClassResolver, } from './runtime/createClassResolver.js';
 //# sourceMappingURL=class-resolver.d.ts.map

package/dist/class-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"class-resolver.d.ts","sourceRoot":"","sources":["../src/class-resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,mBAAmB,GACpB,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"class-resolver.d.ts","sourceRoot":"","sources":["../src/class-resolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,mBAAmB,GACpB,MAAM,kCAAkC,CAAC"}

package/dist/class-resolver.js

@@ -1,2 +1,2 @@
-import { t as createClassResolver } from "./createClassResolver-BWyEQ5KZ.js";
+import { t as createClassResolver } from "./createClassResolver-EpwTL9Sa.js";
 export { createClassResolver };

package/dist/compose.d.ts

@@ -1,21 +1,7 @@
 import type { AnyBrandedComponent, ComposedFamily, SharedConfig } from './types/component';
 /**
- * Compose independently-authored Animus components into a sealed,
- * namespaced component family with shared variant propagation via
- * CSS cascade.
- *
- * - **Enforce**: TypeScript ensures shared keys exist on Root (the
- *   cascade source). Non-Root slots that have the key consume it from
- *   CSS inheritance; slots without the key are unaffected.
- * - **Wire**: The extraction pipeline emits composed variant CSS
- *   rules — two per shared variant option per child (inheritance +
- *   override) within @layer variants.
- * - **Seal**: Output components are plain ForwardRefExoticComponent —
- *   no `.extend()`, no builder methods. One-way door from builder-land
- *   to component-land.
- *
- * For React context propagation (portal-crossing), use
- * `composeWithContext` from `@animus-ui/system/compose-with-context`.
+ * Shared variants propagate through the CSS cascade, so a slot only inherits
+ * as a DOM descendant of Root; `composeWithContext` covers portaled children.
  */
 export declare function compose<Slots extends {
     Root: AnyBrandedComponent;

package/dist/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACb,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CACrB,KAAK,SAAS;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,GAAG,MAAM,CAClD,MAAM,EACN,mBAAmB,CACpB,EACD,KAAK,CAAC,MAAM,SAAS,YAAY,CAAC,KAAK,CAAC,EAExC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzC,cAAc,CAAC,KAAK,CAAC,CAoBvB"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACb,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,wBAAgB,OAAO,CACrB,KAAK,SAAS;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,GAAG,MAAM,CAClD,MAAM,EACN,mBAAmB,CACpB,EACD,KAAK,CAAC,MAAM,SAAS,YAAY,CAAC,KAAK,CAAC,EAExC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzC,cAAc,CAAC,KAAK,CAAC,CAoBvB"}

package/dist/compose.js

@@ -1,23 +1,9 @@
-import { t as assertRootSlot } from "./assert-root-slot-B73sDJ1Q.js";
+import { t as assertRootSlot } from "./assert-root-slot-C3Lp9MNJ.js";
 import { createElement, forwardRef } from "react";
 //#region src/compose.ts
 /**
-* Compose independently-authored Animus components into a sealed,
-* namespaced component family with shared variant propagation via
-* CSS cascade.
-*
-* - **Enforce**: TypeScript ensures shared keys exist on Root (the
-*   cascade source). Non-Root slots that have the key consume it from
-*   CSS inheritance; slots without the key are unaffected.
-* - **Wire**: The extraction pipeline emits composed variant CSS
-*   rules — two per shared variant option per child (inheritance +
-*   override) within @layer variants.
-* - **Seal**: Output components are plain ForwardRefExoticComponent —
-*   no `.extend()`, no builder methods. One-way door from builder-land
-*   to component-land.
-*
-* For React context propagation (portal-crossing), use
-* `composeWithContext` from `@animus-ui/system/compose-with-context`.
+* Shared variants propagate through the CSS cascade, so a slot only inherits
+* as a DOM descendant of Root; `composeWithContext` covers portaled children.
 */
 function compose(slots, options) {
 	assertRootSlot(slots, "compose");

package/dist/composeWithContext.d.ts

@@ -1,14 +1,8 @@
 import { type ForwardRefExoticComponent } from 'react';
 import type { AnyBrandedComponent, ComposedFamily, SharedConfig } from './types/component';
 /**
- * Compose components into a sealed family with shared variant propagation
- * via React context. Use this when children may be rendered in portals
- * or other React subtrees that escape the DOM hierarchy (where CSS
- * descendant selectors cannot reach).
- *
- * This function uses `createContext` and `useContext` — it is client-only.
- * For CSS-only propagation (RSC-safe), use `compose` from the barrel or
- * `@animus-ui/system/compose`.
+ * Context transport for shared variants, for children rendered in portals,
+ * where the CSS descendant selectors `compose` relies on cannot reach.
  */
 export declare function composeWithContext<Slots extends {
     Root: AnyBrandedComponent;
@@ -17,13 +11,8 @@ export declare function composeWithContext<Slots extends {
     name?: string;
 }): ComposedFamily<Slots>;
 /**
- * createComposedFamilyWithContext — extraction-time replacement for composeWithContext().
- *
- * The transform emitter replaces `composeWithContext({ Root, Body }, { shared, name })`
- * with `createComposedFamilyWithContext({ Root, Body }, { name, sharedKeys })`.
- *
- * Client-only: uses createContext and useContext. Files containing this function
- * receive a 'use client' directive from the transform emitter.
+ * The extraction emitter rewrites `composeWithContext()` calls to this form
+ * and adds the `'use client'` directive its context hooks require.
  */
 export declare function createComposedFamilyWithContext(slots: Record<string, ForwardRefExoticComponent<any>>, config: {
     name: string;

package/dist/composeWithContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composeWithContext.d.ts","sourceRoot":"","sources":["../src/composeWithContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,yBAAyB,EAI/B,MAAM,OAAO,CAAC;AAIf,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACb,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,SAAS;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,GAAG,MAAM,CAClD,MAAM,EACN,mBAAmB,CACpB,EACD,KAAK,CAAC,MAAM,SAAS,YAAY,CAAC,KAAK,CAAC,EAExC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzC,cAAc,CAAC,KAAK,CAAC,CA8DvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,GAAG,CAAC,CAAC,EACrD,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAC7C,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,GAAG,CAAC,CAAC,CAuDhD"}
+{"version":3,"file":"composeWithContext.d.ts","sourceRoot":"","sources":["../src/composeWithContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,yBAAyB,EAI/B,MAAM,OAAO,CAAC;AAIf,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACb,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,SAAS;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,GAAG,MAAM,CAClD,MAAM,EACN,mBAAmB,CACpB,EACD,KAAK,CAAC,MAAM,SAAS,YAAY,CAAC,KAAK,CAAC,EAExC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzC,cAAc,CAAC,KAAK,CAAC,CAuDvB;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,GAAG,CAAC,CAAC,EACrD,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAC7C,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,GAAG,CAAC,CAAC,CAkDhD"}

package/dist/composeWithContext.js

@@ -1,16 +1,10 @@
 "use client";
-import { t as assertRootSlot } from "./assert-root-slot-B73sDJ1Q.js";
+import { t as assertRootSlot } from "./assert-root-slot-C3Lp9MNJ.js";
 import { createContext, createElement, forwardRef, useContext } from "react";
 //#region src/composeWithContext.ts
 /**
-* Compose components into a sealed family with shared variant propagation
-* via React context. Use this when children may be rendered in portals
-* or other React subtrees that escape the DOM hierarchy (where CSS
-* descendant selectors cannot reach).
-*
-* This function uses `createContext` and `useContext` — it is client-only.
-* For CSS-only propagation (RSC-safe), use `compose` from the barrel or
-* `@animus-ui/system/compose`.
+* Context transport for shared variants, for children rendered in portals,
+* where the CSS descendant selectors `compose` relies on cannot reach.
 */
 function composeWithContext(slots, options) {
 	assertRootSlot(slots, "composeWithContext");
@@ -51,13 +45,8 @@ function composeWithContext(slots, options) {
 	return result;
 }
 /**
-* createComposedFamilyWithContext — extraction-time replacement for composeWithContext().
-*
-* The transform emitter replaces `composeWithContext({ Root, Body }, { shared, name })`
-* with `createComposedFamilyWithContext({ Root, Body }, { name, sharedKeys })`.
-*
-* Client-only: uses createContext and useContext. Files containing this function
-* receive a 'use client' directive from the transform emitter.
+* The extraction emitter rewrites `composeWithContext()` calls to this form
+* and adds the `'use client'` directive its context hooks require.
 */
 function createComposedFamilyWithContext(slots, config) {
 	assertRootSlot(slots, "createComposedFamilyWithContext");