@urbicon-ui/blocks 6.32.0 → 6.34.0

package/dist/components/Calendar/CalendarAgendaView.svelte

@@ -62,14 +62,18 @@
   const agendaKey = $derived(`${ctx.displayedYear}-${ctx.displayedMonth}`);
 
   function handleKeydown(e: KeyboardEvent) {
+    // Direction-gated like the swipes and header arrows (the DateGridScaffold
+    // pattern): an arrow key at the bound is inert — no navDirection flip, no
+    // clamped no-op onMonthChange emit. Disabled calendars ignore keys entirely.
+    if (ctx.disabled) return;
     switch (e.key) {
       case 'ArrowLeft':
         e.preventDefault();
-        ctx.navigate(-1);
+        if (ctx.canGoBack) ctx.navigate(-1);
         break;
       case 'ArrowRight':
         e.preventDefault();
-        ctx.navigate(1);
+        if (ctx.canGoForward) ctx.navigate(1);
         break;
     }
   }

package/dist/components/Calendar/CalendarDayView.svelte

@@ -33,14 +33,18 @@
   const totalEventCount = $derived(eventsWithInfo.length);
 
   function handleKeydown(e: KeyboardEvent) {
+    // Direction-gated like the swipes and header arrows (the DateGridScaffold
+    // pattern): an arrow key at the bound is inert — no navDirection flip, no
+    // clamped no-op onDayChange emit. Disabled calendars ignore keys entirely.
+    if (ctx.disabled) return;
     switch (e.key) {
       case 'ArrowLeft':
         e.preventDefault();
-        ctx.navigate(-1);
+        if (ctx.canGoBack) ctx.navigate(-1);
         break;
       case 'ArrowRight':
         e.preventDefault();
-        ctx.navigate(1);
+        if (ctx.canGoForward) ctx.navigate(1);
         break;
     }
   }

package/dist/internal/date-grid/date-grid.svelte.js

@@ -296,9 +296,11 @@ export class DateGridController {
                 break;
             }
             // Week/day steps carry no month bounds of their own, so clamp the shifted
-            // reference to [minDate, maxDate] too — otherwise a swipe or a day-view arrow
-            // key (neither gated by canGoBack/canGoForward the way the header arrows are)
-            // could step the anchor onto an all-disabled week/day past the boundary.
+            // reference to [minDate, maxDate] too. Swipes and the day/agenda arrow keys
+            // are canGoBack/canGoForward-gated like the header arrows these days, but the
+            // custom-header API (goTo/navigateWeek/navigateDay) is not — this clamp stays
+            // as the backstop so no caller can step the anchor onto an all-disabled
+            // week/day past the boundary.
             case 'week':
                 next = clampDate(addDays(referenceDate, delta * 7), minDate, maxDate);
                 break;

package/dist/mint/README.md

@@ -162,6 +162,39 @@ mintRegistry.register('my-mint', (config) => ({
 - **Throttling**: Verhindert Spam bei schnellen Interaktionen
 - **Cleanup**: Automatische Bereinigung bei Component-Unmount
 
+## Auflösung & Tree-Shaking (resolveIcon-Muster)
+
+`mintRegistry.apply(el, mint, fallbacks?)` löst jeden Mint-Namen in dieser
+Reihenfolge auf:
+
+1. **Registry-Eintrag** — Consumer-`register()`-Override oder bereits geladene
+   Built-ins (gewinnt immer, wie der IconProvider bei `resolveIcon`).
+2. **`fallbacks`** — statisch importierte Factories des Aufrufers. Button
+   importiert `scaleMint` direkt (`{ scale: scaleMint }`), damit sein Default
+   tree-shaken mitkommt, ohne das gesamte Built-in-Set zu ziehen.
+3. **Demand-Load** — unbekannte Namen laden das Built-in-Set einmalig per
+   dynamischem `import('./presets')` nach (Chunk wird nur gefetcht, wenn
+   tatsächlich ein dynamischer Mint-Name verwendet wird) und wenden den Effekt
+   danach an. `<Button mint="ripple">` funktioniert also weiterhin ohne
+   manuelles `registerDefaultMints()`.
+
+**Kontrakt Demand-Load (dokumentiert):** Mint-Effekte sind dekorativ.
+Interaktionen im Fetch-Fenster werden NICHT nachgespielt — auf langsamen
+Netzen kann der erste Klick für einen noch nicht geladenen click-getriggerten
+Effekt (`ripple`, `shake`, …) verloren gehen; hover-getriggerte Effekte
+greifen ab dem nächsten `mouseenter`. Consumer-Overrides überleben den
+Demand-Load immer (die Built-ins registrieren sich nur auf freie Namen —
+`registerBuiltin`). Wer First-Interaction-Garantien braucht, registriert den
+Effekt statisch beim App-Start: `registerDefaultMints()` oder
+`mintRegistry.register(name, factory)` mit direkt importierter Factory.
+
+Modul-Layout (load-bearing für die Chunk-Zuordnung): `engine.ts` enthält die
+Micro-Interaction-Engine + `scaleMint` (schifft statisch mit Button);
+`micro-interactions.ts` enthält NUR die Registrierungen und ist ausschließlich
+über den demand-geladenen `presets.ts`-Chunk erreichbar. Neue statisch
+verschiffte Default-Effekte gehören in `engine.ts` (oder ein eigenes Modul),
+niemals in `micro-interactions.ts`.
+
 ## Accessibility
 
 Das Mint-System respektiert automatisch `prefers-reduced-motion`:

package/dist/mint/compose.d.ts

@@ -1,7 +1,13 @@
 import { mintRegistry } from './registry.js';
 import type { CompositeConfig, Mint } from './types.js';
 /**
- * Compose multiple mints into one
+ * Compose multiple mints into one.
+ *
+ * String members resolve like `mintRegistry.apply` does: a registry entry
+ * (consumer override or loaded built-in) applies synchronously; unresolved
+ * names demand-load the built-in set once and init after the load (skipped if
+ * the composite was destroyed in the meantime). A name that is still unknown
+ * after the load warns loudly instead of silently dropping the effect.
  */
 export declare function composeMints(...mints: Array<Mint | string>): Mint;
 /**

package/dist/mint/compose.js

@@ -1,26 +1,53 @@
-import { mintRegistry } from './registry.js';
+import { loadBuiltinMints, mintRegistry } from './registry.js';
 /**
- * Compose multiple mints into one
+ * Compose multiple mints into one.
+ *
+ * String members resolve like `mintRegistry.apply` does: a registry entry
+ * (consumer override or loaded built-in) applies synchronously; unresolved
+ * names demand-load the built-in set once and init after the load (skipped if
+ * the composite was destroyed in the meantime). A name that is still unknown
+ * after the load warns loudly instead of silently dropping the effect.
  */
 export function composeMints(...mints) {
     return {
         init(el, config) {
             const instances = [];
+            let disposed = false;
+            const applyInstance = (instance) => {
+                instance.init(el, config);
+                instances.push(instance);
+            };
+            const unresolved = [];
             mints.forEach((mint) => {
                 if (typeof mint === 'string') {
                     const factory = mintRegistry.get(mint);
                     if (factory) {
-                        const instance = factory(config);
-                        instance.init(el, config);
-                        instances.push(instance);
+                        applyInstance(factory(config));
+                    }
+                    else {
+                        unresolved.push(mint);
                     }
                 }
                 else {
-                    mint.init(el, config);
-                    instances.push(mint);
+                    applyInstance(mint);
                 }
             });
+            if (unresolved.length > 0) {
+                void loadBuiltinMints().then(() => {
+                    if (disposed)
+                        return;
+                    unresolved.forEach((name) => {
+                        const factory = mintRegistry.get(name);
+                        if (!factory) {
+                            console.warn(`[composeMints] Unknown mint: ${name}`);
+                            return;
+                        }
+                        applyInstance(factory(config));
+                    });
+                });
+            }
             this.destroy = () => {
+                disposed = true;
                 instances.forEach((instance) => {
                     instance.destroy?.(el);
                 });
@@ -46,5 +73,5 @@ export function createCompositeMint() {
  * Called by registerDefaultMints() - not at module level.
  */
 export function registerComposite(registry) {
-    registry.register('composite', createCompositeMint);
+    registry.registerBuiltin('composite', createCompositeMint);
 }

package/dist/mint/engine.d.ts

@@ -0,0 +1,34 @@
+import type { MicroInteractionConfig, Mint, MintFactory } from './types.js';
+/**
+ * Micro-interaction engine + the statically-shipped default effect (scale).
+ *
+ * This module split is load-bearing for tree-shaking: everything in this file
+ * ships statically with components that import `scaleMint` (Button's mint
+ * default), while the per-effect registrations stay in
+ * `./micro-interactions.ts`, which is only reachable through the
+ * demand-loaded `./presets.ts` chunk. Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it — if the registrations
+ * lived in this file, `registerMicroInteractions` (used by the lazy presets
+ * chunk) would be pulled into every Button consumer's initial bundle again.
+ * Add future statically-defaulted effects here (or in their own module),
+ * never in `micro-interactions.ts`.
+ */
+/**
+ * Check if user prefers reduced motion
+ * @internal Shared with ./micro-interactions.ts; not part of the public API.
+ */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Generic micro-interaction factory
+ */
+export declare function createMicroInteraction(className: string, defaultConfig?: MicroInteractionConfig): Mint<MicroInteractionConfig>;
+/**
+ * The `scale` micro-interaction factory, exported standalone so components
+ * whose mint *default* is `'scale'` (Button) can import it directly and pass
+ * it as a fallback: `mintRegistry.apply(el, mint, { scale: scaleMint })`.
+ * That is the `resolveIcon` tree-shaking pattern — the default effect ships
+ * with the component; the rest of the built-in set stays demand-loaded.
+ * `registerDefaultMints()` registers this same factory, so the registry path
+ * and the fallback path are behaviour-identical.
+ */
+export declare const scaleMint: MintFactory<MicroInteractionConfig>;

package/dist/mint/engine.js

@@ -0,0 +1,106 @@
+/**
+ * Micro-interaction engine + the statically-shipped default effect (scale).
+ *
+ * This module split is load-bearing for tree-shaking: everything in this file
+ * ships statically with components that import `scaleMint` (Button's mint
+ * default), while the per-effect registrations stay in
+ * `./micro-interactions.ts`, which is only reachable through the
+ * demand-loaded `./presets.ts` chunk. Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it — if the registrations
+ * lived in this file, `registerMicroInteractions` (used by the lazy presets
+ * chunk) would be pulled into every Button consumer's initial bundle again.
+ * Add future statically-defaulted effects here (or in their own module),
+ * never in `micro-interactions.ts`.
+ */
+/**
+ * Check if user prefers reduced motion
+ * @internal Shared with ./micro-interactions.ts; not part of the public API.
+ */
+export function prefersReducedMotion() {
+    return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+/**
+ * Generic micro-interaction factory
+ */
+export function createMicroInteraction(className, defaultConfig = {}) {
+    return {
+        init(el, config = {}) {
+            // Merge default config with provided config
+            const finalConfig = { ...defaultConfig, ...config };
+            // Skip if disabled or prefers reduced motion
+            if (finalConfig.disabled || prefersReducedMotion())
+                return;
+            const trigger = finalConfig.trigger || 'hover';
+            const duration = finalConfig.duration || 200;
+            const delay = finalConfig.delay || 0;
+            // Determine event based on trigger
+            const eventMap = {
+                hover: 'mouseenter',
+                click: 'click',
+                focus: 'focus',
+                load: 'load'
+            };
+            const event = eventMap[trigger] || 'mouseenter';
+            const handler = () => {
+                // Skip if this specific animation is already running
+                const animatingAttr = `data-animating-${className}`;
+                if (el.getAttribute(animatingAttr) === 'true')
+                    return;
+                // Apply delay if specified
+                const applyAnimation = () => {
+                    el.setAttribute(animatingAttr, 'true');
+                    // Add dynamic styles if intensity is specified
+                    if (finalConfig.intensity && className.includes('scale')) {
+                        el.style.setProperty('--scale-intensity', finalConfig.intensity.toString());
+                    }
+                    el.classList.add(className);
+                    const cleanup = () => {
+                        el.classList.remove(className);
+                        el.removeAttribute(animatingAttr);
+                        el.style.removeProperty('--scale-intensity');
+                        el.removeEventListener('animationend', cleanup);
+                        el.removeEventListener('transitionend', cleanup);
+                    };
+                    el.addEventListener('animationend', cleanup, { once: true });
+                    el.addEventListener('transitionend', cleanup, { once: true });
+                    // Fallback timeout
+                    setTimeout(cleanup, duration + 50);
+                };
+                if (delay > 0) {
+                    setTimeout(applyAnimation, delay);
+                }
+                else {
+                    applyAnimation();
+                }
+            };
+            // Special handling for load trigger
+            if (trigger === 'load') {
+                // Execute immediately if element is already loaded
+                requestAnimationFrame(() => handler());
+            }
+            else {
+                el.addEventListener(event, handler, { passive: true });
+            }
+            // Store cleanup function
+            this.destroy = () => {
+                if (event !== 'load') {
+                    el.removeEventListener(event, handler);
+                }
+            };
+        }
+    };
+}
+/**
+ * The `scale` micro-interaction factory, exported standalone so components
+ * whose mint *default* is `'scale'` (Button) can import it directly and pass
+ * it as a fallback: `mintRegistry.apply(el, mint, { scale: scaleMint })`.
+ * That is the `resolveIcon` tree-shaking pattern — the default effect ships
+ * with the component; the rest of the built-in set stays demand-loaded.
+ * `registerDefaultMints()` registers this same factory, so the registry path
+ * and the fallback path are behaviour-identical.
+ */
+export const scaleMint = (config) => createMicroInteraction('blocks-mint-scale', {
+    trigger: 'hover',
+    duration: 200,
+    ...config
+});

package/dist/mint/index.d.ts

@@ -1,7 +1,7 @@
 export { composeMints, createCompositeMint } from './compose.js';
-export { createMicroInteraction } from './micro-interactions.js';
+export { createMicroInteraction, scaleMint } from './engine.js';
 export { mintPresets, registerBusinessMints, registerDefaultMints, registerPlayfulMints } from './presets.js';
-export { mintRegistry } from './registry.js';
+export { type MintFallbacks, mintRegistry } from './registry.js';
 export { createRippleMint } from './ripple.js';
 export { mint, useMint } from './svelte.js';
 export * from './types.js';

package/dist/mint/index.js

@@ -1,7 +1,7 @@
 // Core exports
 export { composeMints, createCompositeMint } from './compose.js';
 // Mint factories
-export { createMicroInteraction } from './micro-interactions.js';
+export { createMicroInteraction, scaleMint } from './engine.js';
 // Presets
 export { mintPresets, registerBusinessMints, registerDefaultMints, registerPlayfulMints } from './presets.js';
 export { mintRegistry } from './registry.js';

package/dist/mint/micro-interactions.d.ts

@@ -1,9 +1,15 @@
 import type { mintRegistry } from './registry.js';
-import type { MicroInteractionConfig, Mint } from './types.js';
 /**
- * Generic micro-interaction factory
+ * Built-in micro-interaction registrations.
+ *
+ * The generic engine (`createMicroInteraction`) and the statically-shipped
+ * default (`scaleMint`) live in `./engine.ts` — this module must contain ONLY
+ * registration code, because it is reachable exclusively through the
+ * demand-loaded `./presets.ts` chunk. Anything defined here would otherwise
+ * be dragged back into every component's initial bundle once a statically
+ * imported module shared it (Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it).
  */
-export declare function createMicroInteraction(className: string, defaultConfig?: MicroInteractionConfig): Mint<MicroInteractionConfig>;
 /**
  * Register all default micro-interaction mints.
  * Called by registerDefaultMints() - not at module level.

package/dist/mint/micro-interactions.js

@@ -1,111 +1,42 @@
+import { createMicroInteraction, prefersReducedMotion, scaleMint } from './engine.js';
 /**
- * Check if user prefers reduced motion
+ * Built-in micro-interaction registrations.
+ *
+ * The generic engine (`createMicroInteraction`) and the statically-shipped
+ * default (`scaleMint`) live in `./engine.ts` — this module must contain ONLY
+ * registration code, because it is reachable exclusively through the
+ * demand-loaded `./presets.ts` chunk. Anything defined here would otherwise
+ * be dragged back into every component's initial bundle once a statically
+ * imported module shared it (Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it).
  */
-function prefersReducedMotion() {
-    return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
-}
-/**
- * Generic micro-interaction factory
- */
-export function createMicroInteraction(className, defaultConfig = {}) {
-    return {
-        init(el, config = {}) {
-            // Merge default config with provided config
-            const finalConfig = { ...defaultConfig, ...config };
-            // Skip if disabled or prefers reduced motion
-            if (finalConfig.disabled || prefersReducedMotion())
-                return;
-            const trigger = finalConfig.trigger || 'hover';
-            const duration = finalConfig.duration || 200;
-            const delay = finalConfig.delay || 0;
-            // Determine event based on trigger
-            const eventMap = {
-                hover: 'mouseenter',
-                click: 'click',
-                focus: 'focus',
-                load: 'load'
-            };
-            const event = eventMap[trigger] || 'mouseenter';
-            const handler = () => {
-                // Skip if this specific animation is already running
-                const animatingAttr = `data-animating-${className}`;
-                if (el.getAttribute(animatingAttr) === 'true')
-                    return;
-                // Apply delay if specified
-                const applyAnimation = () => {
-                    el.setAttribute(animatingAttr, 'true');
-                    // Add dynamic styles if intensity is specified
-                    if (finalConfig.intensity && className.includes('scale')) {
-                        el.style.setProperty('--scale-intensity', finalConfig.intensity.toString());
-                    }
-                    el.classList.add(className);
-                    const cleanup = () => {
-                        el.classList.remove(className);
-                        el.removeAttribute(animatingAttr);
-                        el.style.removeProperty('--scale-intensity');
-                        el.removeEventListener('animationend', cleanup);
-                        el.removeEventListener('transitionend', cleanup);
-                    };
-                    el.addEventListener('animationend', cleanup, { once: true });
-                    el.addEventListener('transitionend', cleanup, { once: true });
-                    // Fallback timeout
-                    setTimeout(cleanup, duration + 50);
-                };
-                if (delay > 0) {
-                    setTimeout(applyAnimation, delay);
-                }
-                else {
-                    applyAnimation();
-                }
-            };
-            // Special handling for load trigger
-            if (trigger === 'load') {
-                // Execute immediately if element is already loaded
-                requestAnimationFrame(() => handler());
-            }
-            else {
-                el.addEventListener(event, handler, { passive: true });
-            }
-            // Store cleanup function
-            this.destroy = () => {
-                if (event !== 'load') {
-                    el.removeEventListener(event, handler);
-                }
-            };
-        }
-    };
-}
 /**
  * Register all default micro-interaction mints.
  * Called by registerDefaultMints() - not at module level.
  */
 export function registerMicroInteractions(registry) {
-    registry.register('scale', (config) => createMicroInteraction('blocks-mint-scale', {
-        trigger: 'hover',
-        duration: 200,
-        ...config
-    }));
-    registry.register('translate', (config) => createMicroInteraction('blocks-mint-translate', {
+    registry.registerBuiltin('scale', scaleMint);
+    registry.registerBuiltin('translate', (config) => createMicroInteraction('blocks-mint-translate', {
         trigger: 'hover',
         duration: 200,
         ...config
     }));
-    registry.register('rotate', (config) => createMicroInteraction('blocks-mint-rotate', {
+    registry.registerBuiltin('rotate', (config) => createMicroInteraction('blocks-mint-rotate', {
         trigger: 'hover',
         duration: 200,
         ...config
     }));
-    registry.register('glow', (config) => createMicroInteraction('blocks-mint-glow', {
+    registry.registerBuiltin('glow', (config) => createMicroInteraction('blocks-mint-glow', {
         trigger: 'hover',
         duration: 300,
         ...config
     }));
-    registry.register('bounce', (config) => createMicroInteraction('blocks-mint-bounce', {
+    registry.registerBuiltin('bounce', (config) => createMicroInteraction('blocks-mint-bounce', {
         trigger: 'click',
         duration: 600,
         ...config
     }));
-    registry.register('pulse', (config) => ({
+    registry.registerBuiltin('pulse', (config) => ({
         init(el, inputConfig = {}) {
             const finalConfig = { trigger: 'hover', ...config, ...inputConfig };
             if (finalConfig.disabled || prefersReducedMotion())
@@ -143,12 +74,12 @@ export function registerMicroInteractions(registry) {
             }
         }
     }));
-    registry.register('shake', (config) => createMicroInteraction('blocks-mint-shake', {
+    registry.registerBuiltin('shake', (config) => createMicroInteraction('blocks-mint-shake', {
         trigger: 'click',
         duration: 500,
         ...config
     }));
-    registry.register('wiggle', (config) => createMicroInteraction('blocks-mint-wiggle', {
+    registry.registerBuiltin('wiggle', (config) => createMicroInteraction('blocks-mint-wiggle', {
         trigger: 'hover',
         duration: 500,
         ...config

package/dist/mint/presets.d.ts

@@ -1,6 +1,11 @@
 /**
  * Register all default mints (scale, translate, rotate, glow, bounce, pulse, shake, ripple, composite).
  * Safe to call multiple times – subsequent calls are no-ops.
+ *
+ * All registrations go through `registerBuiltin` (register-if-absent), so a
+ * consumer `register()` override for a built-in name ALWAYS survives — no
+ * matter whether the override ran before this call or while the demand-load
+ * that triggers it was still in flight.
  */
 export declare function registerDefaultMints(): void;
 /**
@@ -12,7 +17,8 @@ export declare function registerDefaultMints(): void;
  */
 export declare function registerPlayfulMints(): void;
 /**
- * Register business mints bundle
+ * Register business mints bundle.
+ * Registered via `registerBuiltin`: a consumer override for these names wins.
  */
 export declare function registerBusinessMints(): void;
 export declare const mintPresets: {

package/dist/mint/presets.js

@@ -6,6 +6,11 @@ let defaultMintsRegistered = false;
 /**
  * Register all default mints (scale, translate, rotate, glow, bounce, pulse, shake, ripple, composite).
  * Safe to call multiple times – subsequent calls are no-ops.
+ *
+ * All registrations go through `registerBuiltin` (register-if-absent), so a
+ * consumer `register()` override for a built-in name ALWAYS survives — no
+ * matter whether the override ran before this call or while the demand-load
+ * that triggers it was still in flight.
  */
 export function registerDefaultMints() {
     if (defaultMintsRegistered)
@@ -26,16 +31,17 @@ export function registerPlayfulMints() {
     // Reserved for future playful-only mints.
 }
 /**
- * Register business mints bundle
+ * Register business mints bundle.
+ * Registered via `registerBuiltin`: a consumer override for these names wins.
  */
 export function registerBusinessMints() {
     // Subtle mints for professional UIs
-    mintRegistry.register('fade', () => ({
+    mintRegistry.registerBuiltin('fade', () => ({
         init(el) {
             el.classList.add('blocks-mint-fade');
         }
     }));
-    mintRegistry.register('slide', () => ({
+    mintRegistry.registerBuiltin('slide', () => ({
         init(el) {
             el.classList.add('blocks-mint-slide');
         }

package/dist/mint/registry.d.ts

@@ -1,15 +1,54 @@
 import type { MintConfig, MintFactory, MintProp } from './types.js';
+/**
+ * Statically-imported fallback factories, keyed by mint name.
+ *
+ * Components pass their *default* mint's factory here — Button imports
+ * `scaleMint` directly and calls `mintRegistry.apply(el, mint, { scale:
+ * scaleMint })` — so the default effect ships tree-shaken with the component
+ * instead of dragging the whole built-in set (micro-interactions, the ripple
+ * engine, compose, presets — ~3.9 KB min) into every consumer bundle. Same
+ * precedence as `resolveIcon(name, fallback)`: a registry entry (consumer
+ * override / loaded built-in) wins, the direct import is only the fallback.
+ * See docs/ICON-DESIGN.md → "Icon resolution & tree-shaking".
+ */
+export type MintFallbacks = Readonly<Partial<Record<string, MintFactory>>>;
+/**
+ * @internal Shared with ./compose.ts so composite string members resolve
+ * through the same demand-load; not part of the public API.
+ */
+export declare function loadBuiltinMints(): Promise<void>;
 declare class MintRegistry {
     private mints;
     private instances;
     /** Register a mint globally */
     register<TConfig extends MintConfig = MintConfig>(name: string, factory: MintFactory<TConfig>): void;
+    /**
+     * Register a built-in mint — only if the name is still free. Used by the
+     * built-in set (`registerDefaultMints()` and the opt-in bundles) so the
+     * demand-load NEVER clobbers a consumer override: a `register()` entry
+     * survives regardless of whether it ran before or during the load. A later
+     * explicit `register()` call still overrides as before.
+     */
+    registerBuiltin<TConfig extends MintConfig = MintConfig>(name: string, factory: MintFactory<TConfig>): void;
     /** Get a mint factory by name */
     get(name: string): MintFactory | undefined;
     /** Check if a mint is registered */
     has(name: string): boolean;
-    /** Apply mints to an element using polymorphic input */
-    apply(el: HTMLElement, mint: MintProp): () => void;
+    /**
+     * Apply mints to an element using polymorphic input.
+     *
+     * Resolution order per name: registry entry (consumer `register()` override
+     * or an already-loaded built-in) → `fallbacks` (statically imported by the
+     * caller) → lazy-loaded built-in set. Names that resolve synchronously are
+     * applied synchronously; unresolved names wait for the built-ins chunk
+     * (one-time microtask + fetch). Events firing inside that fetch window are
+     * NOT replayed — on a slow network, a click landing before a demand-loaded
+     * click-triggered mint (ripple, shake) finished loading is lost for that
+     * effect. Acceptable for decorative effects (documented contract, see
+     * mint/README.md); consumers who need first-interaction guarantees register
+     * the effect statically up front (`registerDefaultMints()`).
+     */
+    apply(el: HTMLElement, mint: MintProp, fallbacks?: MintFallbacks): () => void;
     /** Normalize polymorphic mint prop to consistent format */
     private normalizeMintProp;
     /** Update mint config for an element */

package/dist/mint/registry.js

@@ -1,4 +1,24 @@
-import { registerDefaultMints } from './presets.js';
+// Lazily loads + registers the built-in mints (scale, glow, ripple, …) the
+// first time a name resolves neither from the registry nor from the caller's
+// fallbacks. The dynamic import() keeps the built-in set out of the static
+// module graph of every mint-consuming component — an app that only ever uses
+// component defaults never loads it at all; an app that passes a dynamic mint
+// name (mint="ripple", presets, composite) fetches it once on first use.
+//
+// The registry ↔ presets import is cyclic but inert: presets dereferences the
+// registry binding only at call time, and this side is a dynamic import, so
+// module initialisation completes cleanly regardless of load order.
+let builtinsLoading;
+/**
+ * @internal Shared with ./compose.ts so composite string members resolve
+ * through the same demand-load; not part of the public API.
+ */
+export function loadBuiltinMints() {
+    builtinsLoading ??= import('./presets.js').then((presets) => {
+        presets.registerDefaultMints();
+    });
+    return builtinsLoading;
+}
 class MintRegistry {
     mints = new Map();
     instances = new WeakMap();
@@ -6,6 +26,18 @@ class MintRegistry {
     register(name, factory) {
         this.mints.set(name, factory);
     }
+    /**
+     * Register a built-in mint — only if the name is still free. Used by the
+     * built-in set (`registerDefaultMints()` and the opt-in bundles) so the
+     * demand-load NEVER clobbers a consumer override: a `register()` entry
+     * survives regardless of whether it ran before or during the load. A later
+     * explicit `register()` call still overrides as before.
+     */
+    registerBuiltin(name, factory) {
+        if (!this.mints.has(name)) {
+            this.mints.set(name, factory);
+        }
+    }
     /** Get a mint factory by name */
     get(name) {
         return this.mints.get(name);
@@ -14,43 +46,64 @@ class MintRegistry {
     has(name) {
         return this.mints.has(name);
     }
-    /** Apply mints to an element using polymorphic input */
-    apply(el, mint) {
-        // Ensure the built-in mints (scale, glow, ripple, …) are registered before
-        // the first application. Components declare mint defaults — Button defaults
-        // to 'scale' — so a consumer that never called registerDefaultMints() would
-        // otherwise hit "Unknown mint: scale" on every button (and get no hover
-        // animation). registerDefaultMints() short-circuits on a module-level flag,
-        // so the recurring cost is a single boolean check.
-        //
-        // The registry ↔ presets import is cyclic but inert: both sides dereference
-        // the cyclic binding only at call time, never at module top level, so module
-        // initialisation completes cleanly regardless of load order.
-        registerDefaultMints();
+    /**
+     * Apply mints to an element using polymorphic input.
+     *
+     * Resolution order per name: registry entry (consumer `register()` override
+     * or an already-loaded built-in) → `fallbacks` (statically imported by the
+     * caller) → lazy-loaded built-in set. Names that resolve synchronously are
+     * applied synchronously; unresolved names wait for the built-ins chunk
+     * (one-time microtask + fetch). Events firing inside that fetch window are
+     * NOT replayed — on a slow network, a click landing before a demand-loaded
+     * click-triggered mint (ripple, shake) finished loading is lost for that
+     * effect. Acceptable for decorative effects (documented contract, see
+     * mint/README.md); consumers who need first-interaction guarantees register
+     * the effect statically up front (`registerDefaultMints()`).
+     */
+    apply(el, mint, fallbacks) {
         const mintDefinitions = this.normalizeMintProp(mint);
         const elementMints = new Map();
         const cleanupFunctions = [];
-        mintDefinitions.forEach((mintDef) => {
-            const name = typeof mintDef === 'string' ? mintDef : mintDef.name;
-            const config = typeof mintDef === 'object' ? mintDef.config : undefined;
-            const factory = this.get(name);
-            if (!factory) {
-                console.warn(`[MintRegistry] Unknown mint: ${name}`);
-                return;
-            }
+        let disposed = false;
+        const applyOne = (name, config, factory) => {
             const mintInstance = factory(config);
             mintInstance.init(el, config);
             elementMints.set(name, mintInstance);
-            // Create cleanup function
-            const cleanup = () => {
+            cleanupFunctions.push(() => {
                 mintInstance.destroy?.(el);
                 elementMints.delete(name);
-            };
-            cleanupFunctions.push(cleanup);
+            });
+        };
+        const unresolved = [];
+        mintDefinitions.forEach((mintDef) => {
+            const name = typeof mintDef === 'string' ? mintDef : mintDef.name;
+            const config = typeof mintDef === 'object' ? mintDef.config : undefined;
+            const factory = this.get(name) ?? fallbacks?.[name];
+            if (factory) {
+                applyOne(name, config, factory);
+            }
+            else {
+                unresolved.push({ name, config });
+            }
         });
+        if (unresolved.length > 0) {
+            void loadBuiltinMints().then(() => {
+                if (disposed)
+                    return;
+                unresolved.forEach(({ name, config }) => {
+                    const factory = this.get(name) ?? fallbacks?.[name];
+                    if (!factory) {
+                        console.warn(`[MintRegistry] Unknown mint: ${name}`);
+                        return;
+                    }
+                    applyOne(name, config, factory);
+                });
+            });
+        }
         this.instances.set(el, elementMints);
         // Return combined cleanup function
         return () => {
+            disposed = true;
             cleanupFunctions.forEach((fn) => {
                 fn();
             });

package/dist/mint/ripple.js

@@ -68,5 +68,5 @@ export function createRippleMint(defaultConfig = {}) {
  * Called by registerDefaultMints() - not at module level.
  */
 export function registerRipple(registry) {
-    registry.register('ripple', createRippleMint);
+    registry.registerBuiltin('ripple', createRippleMint);
 }

package/dist/primitives/Button/Button.svelte

@@ -1,5 +1,9 @@
 <script lang="ts">
   import { mintRegistry, Spinner } from '../..';
+  // Direct import (not the barrel): the resolveIcon tree-shaking pattern.
+  // Button's mint default is 'scale', so the scale factory ships statically
+  // as the apply() fallback; every other mint name stays demand-loaded.
+  import { scaleMint } from '../../mint/engine';
   import { getBlocksConfig, resolveSlotClasses } from '../../provider';
   import { getButtonGroupContext } from '../ButtonGroup/buttonGroup.context';
   import { buttonVariants, type ButtonVariants } from '..';
@@ -80,7 +84,7 @@
       !effectiveDisabled &&
       !loading
     ) {
-      return mintRegistry.apply(buttonElement, effectiveMint);
+      return mintRegistry.apply(buttonElement, effectiveMint, { scale: scaleMint });
     }
   });
 

package/dist/primitives/ButtonGroup/ButtonGroup.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
   import { buttonGroupVariants, type ButtonGroupVariants } from '..';
   import { getBlocksConfig, resolveSlotClasses } from '../../provider';
+  import { composeHandlers } from '../../utils/compose-handlers';
   import { edgeEnabledIndex, nextEnabledIndex } from '../../utils';
   import { getTierContext, setTierContext } from '../../utils/tier-context';
   import type { ButtonGroupContext, ButtonGroupProps } from './index';
@@ -25,6 +26,12 @@
     preset,
     ariaLabel,
     ariaLabelledBy,
+    // Pulled out of restProps so the `{...restProps}`-first spread (internal
+    // attributes win — see docs/COMPONENT-API-CONVENTIONS.md) can't clobber
+    // it: the roving keyboard navigation below is composed with a consumer's
+    // own handler (internal first, consumer second) instead of either side
+    // silently replacing the other.
+    onkeydown: onkeydownProp,
     ...restProps
   }: ButtonGroupProps = $props();
 
@@ -271,18 +278,35 @@
   const ariaOrientation = $derived(ariaRole === 'radiogroup' ? orientation : undefined);
 </script>
 
+<!--
+  restProps spreads FIRST so component-owned state wins (COMPONENT-API-CONVENTIONS
+  §restProps ordering) — a consumer role/tabindex through restProps must not
+  defeat the radiogroup semantics. The attributes after the spread are
+  conditional merges, not plain overrides, because an explicit `undefined`
+  after a spread REMOVES the attribute:
+  - role: always internally computed (radiogroup/group) — internal wins outright.
+  - aria-label / aria-labelledby: the dedicated props win, a consumer's own
+    `aria-label`/`aria-labelledby` through restProps is the fallback.
+  - aria-orientation: internal on the radiogroup arm; on the `group` arm it is
+    actively removed even against restProps — ARIA disallows aria-orientation
+    on role=group (aria-allowed-attr), mirroring Button's aria-pressed force-off.
+  - aria-disabled: internal `true` is unoverridable, idle falls back to the
+    consumer value; the default DOM output stays byte-identical (attr absent).
+  - onkeydown is destructured (never in restProps) and composed: the roving
+    keyboard nav always runs, a consumer handler runs after it.
+-->
 <div
   bind:this={containerElement}
+  {...restProps}
   role={ariaRole}
   class={unstyled
     ? [slotClasses?.base, className].filter(Boolean).join(' ')
     : styles.base({ class: [slotClasses?.base, className] })}
-  aria-label={ariaLabel}
-  aria-labelledby={ariaLabelledBy}
+  aria-label={ariaLabel ?? restProps['aria-label']}
+  aria-labelledby={ariaLabelledBy ?? restProps['aria-labelledby']}
   aria-orientation={ariaOrientation}
-  aria-disabled={disabled || undefined}
-  onkeydown={handleKeyDown}
-  {...restProps}
+  aria-disabled={disabled || restProps['aria-disabled'] || undefined}
+  onkeydown={composeHandlers(handleKeyDown, onkeydownProp)}
 >
   {@render children?.()}
 </div>

package/dist/primitives/Toolbar/Toolbar.svelte

@@ -39,14 +39,24 @@
   );
 </script>
 
+<!--
+  restProps spreads FIRST so component-owned state wins (COMPONENT-API-CONVENTIONS
+  §restProps ordering) — a consumer role through restProps must not defeat the
+  toolbar semantics. No conditional merges are needed here (unlike
+  Button/ButtonGroup), because every attribute after the spread is always
+  defined: role is static, `orientation` has a default, and `aria-label` is a
+  required prop destructured out of restProps. `aria-orientation` is valid on
+  role=toolbar on both arms, so there is no removal case; `aria-labelledby`
+  and other native/data-* attributes pass through the spread untouched.
+-->
 <div
+  {...restProps}
   class={unstyled
     ? [slotClasses?.base, className].filter(Boolean).join(' ')
     : styles.base({ class: [slotClasses?.base, className] })}
   role="toolbar"
   aria-orientation={orientation}
   aria-label={ariaLabel}
-  {...restProps}
 >
   {@render children()}
 </div>

package/docs/MIGRATION-v5.md

@@ -58,10 +58,12 @@ its disclosure sibling `Collapsible`.)
 
 ## 3. Table chrome
 
-The Table no longer renders a frame by default. The new `appearance` prop
-controls the container chrome:
+The Table no longer renders a frame by default. The new `variant` prop
+controls the container chrome. (The prop was named `appearance` from v5.0
+to v6.32; it now shares the single style-axis name `variant` with every
+other component.)
 
-| `appearance` | Effect                                                       |
+| `variant`    | Effect                                                       |
 | ------------ | ------------------------------------------------------------ |
 | `flush` (default) | No frame; the table sits inline in the reading flow.    |
 | `surface`    | Quiet tinted zone — `bg-surface-quiet`.                      |
@@ -73,7 +75,7 @@ The dead `tableVariants` export is removed (was unused in any consumer).
 <!-- v4 — implicit frame -->
 <Table data={rows} columns={cols} />
 <!-- v5 — explicit equivalent -->
-<Table data={rows} columns={cols} appearance="framed" />
+<Table data={rows} columns={cols} variant="framed" />
 <!-- v5 — new editorial default -->
 <Table data={rows} columns={cols} />
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urbicon-ui/blocks",
-  "version": "6.32.0",
+  "version": "6.34.0",
   "description": "Svelte 5 UI component library with Tailwind CSS 4, OKLCH design tokens and zero runtime dependencies",
   "license": "MIT",
   "repository": {
@@ -95,8 +95,8 @@
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@tailwindcss/vite": "^4.3.1",
-    "@urbicon-ui/i18n": "6.32.0",
-    "@urbicon-ui/shared-types": "6.32.0",
+    "@urbicon-ui/i18n": "6.34.0",
+    "@urbicon-ui/shared-types": "6.34.0",
     "prettier": "^3.8.4",
     "prettier-plugin-svelte": "^4.1.1",
     "prettier-plugin-tailwindcss": "^0.8.0",