@urbicon-ui/blocks 6.33.0 → 6.35.0

package/dist/i18n/index.js

@@ -1,13 +1,62 @@
 import { createPackageI18n } from '@urbicon-ui/i18n';
-import deTranslations from '../translations/de.js';
 import enTranslations from '../translations/en.js';
-// Create package translations for blocks
-const blocksTranslations = {
-    en: enTranslations,
-    de: deTranslations
-};
-// Create the package i18n integration (registers lazily on first useTranslate()/t()).
-export const blocksI18n = createPackageI18n('blocks', blocksTranslations);
+/**
+ * blocks package i18n.
+ *
+ * **Only the English base bundle is eager.** German (`de`) is registered as a
+ * lazy dynamic-import loader, so an English-only app never statically bundles the
+ * `de` catalog (~4 KB min) — Vite/Rollup splits it into its own chunk that loads
+ * only when the `de` locale is activated. `en` is the base/fallback locale.
+ *
+ * The eager base is `{ en }` (not `blocksTranslations`, which is retained below as
+ * an `{ en }` back-compat export). Registration is lazy on first
+ * `useBlocksI18n()`/`t()` — see `createPackageI18n`.
+ *
+ * ## Before the `de` chunk loads: resolution falls back to `en`
+ *
+ * A package-scoped lookup for a `de` key that isn't loaded yet resolves through
+ * the package fallback locale, i.e. it returns the **English** string (verified:
+ * `@urbicon-ui/i18n` `registry.translate` package path + `lazy-load.test.ts`). It
+ * never renders the raw key. The provider (`<I18nProvider>`) triggers the `de`
+ * load in a **client-only** `$effect` on mount, so a `de` app renders English on
+ * the server and the first client paint, then re-resolves to German once the
+ * chunk lands — a brief text flash and a possible hydration text mismatch.
+ * Two consequences of that window worth knowing:
+ *
+ * - The "falls back to English" guarantee assumes the provider's `fallbackLocale`
+ *   stays at its default (`en`). Pointing `fallbackLocale` at a lazy locale that
+ *   has not loaded yet leaves both lookup paths empty — such a key then renders
+ *   raw and fires `onMissingKey`. Eager-register any locale you use as fallback.
+ * - `LocaleSwitcher` disables its trigger while a locale chunk load is in flight
+ *   (`registry.isLoading`), so without the eager register a `de` app briefly
+ *   shows the switcher disabled on first mount.
+ *
+ * The SSR recipe below removes both, along with the flash itself.
+ *
+ * ## SSR recipe for German (and other non-base) apps
+ *
+ * German SvelteKit SSR apps should register the `de` bundle eagerly **once at
+ * app start** so the very first server render is already German (no flash, no
+ * hydration mismatch). The registry is module-global and holds only static,
+ * request-identical translation data, so a single startup registration is
+ * SSR-safe — it carries no per-request state:
+ *
+ * ```ts
+ * // src/hooks.server.ts (or any module evaluated once at server start)
+ * import { registerBlocksLocale } from '@urbicon-ui/blocks';
+ * import de from '@urbicon-ui/blocks/i18n/de';
+ *
+ * registerBlocksLocale('de', de);
+ * ```
+ *
+ * This keeps the `de` catalog out of English-only client bundles (the whole point
+ * of the split) while making it eagerly present wherever it is actually rendered.
+ */
+export const blocksI18n = createPackageI18n('blocks', { en: enTranslations }, {
+    loaders: {
+        de: () => import('../translations/de.js').then((m) => m.default)
+    }
+});
 /**
  * Context-scoped translation hook for the blocks package. Call during component
  * initialisation, then use the returned `t` (conventionally aliased `bt`):
@@ -18,10 +67,35 @@ export const blocksI18n = createPackageI18n('blocks', blocksTranslations);
  * ```
  *
  * Resolves against the nearest `<I18nProvider>`'s locale (or the base locale
- * when none is mounted) and re-renders reactively on locale change.
+ * when none is mounted) and re-renders reactively on locale change. For a lazy
+ * locale (`de`) that isn't loaded yet, resolution falls back to the base locale
+ * (`en`); see the module docblock and `registerBlocksLocale` for the SSR path.
  */
 export const useBlocksI18n = blocksI18n.useTranslate;
+/**
+ * Eagerly register the blocks bundle for a lazy locale (currently `de`) so it is
+ * present for SSR / the first render, instead of loading client-side on mount.
+ * Call once at app/server start, paired with the public locale subpath import:
+ *
+ * ```ts
+ * import { registerBlocksLocale } from '@urbicon-ui/blocks';
+ * import de from '@urbicon-ui/blocks/i18n/de';
+ * registerBlocksLocale('de', de);
+ * ```
+ *
+ * Additive (does not drop the eager `en` base) and strict (throws on an
+ * unsupported locale or a non-object bundle).
+ */
+export const registerBlocksLocale = (locale, bundle) => blocksI18n.registerLocale(locale, bundle);
 // Introspection helpers (locale list / key existence).
 export const { exists: hasBlocksTranslation, getLocales: getBlocksLocales } = blocksI18n;
+/**
+ * The eager base bundle only (`{ en }`). `de` is lazy and no longer part of this
+ * object; import it explicitly via `@urbicon-ui/blocks/i18n/de` (e.g. for a parity
+ * test or the SSR eager-register recipe above).
+ */
+const blocksTranslations = {
+    en: enTranslations
+};
 // Re-export for external use
 export { blocksTranslations };

package/dist/internal/core/CoreIconButton.svelte

@@ -0,0 +1,66 @@
+<!--
+  CoreIconButton — behaviour-only internal core for the small icon-only controls
+  embedded inside other public components (Badge's remove ×, Dialog/Drawer close
+  ×). It renders a native `<button type="button">` with just the interaction
+  baseline (flex-centred content, pointer/select affordance, focus-visible reset,
+  disabled inertness). Visual identity — size, radius, colour, ring, shadow — comes
+  entirely from the call-site's `class` (a `*.variants.ts` slot), NOT from a variant
+  engine pass here: this core deliberately does not touch tv()/mint/tokens, which is
+  what lets a public component embed a control without importing another public
+  component (keeps the public-to-public import graph clean, see internal/core/).
+
+  The base classes are structural plumbing, deliberately NOT tw-merged against the
+  incoming `class` (no engine here): a consumer slot class targeting one of these
+  buckets (display/cursor/select/disabled-opacity) is resolved by stylesheet order,
+  not by the override ladder. That is accepted: overrides belong on the call-site's
+  variants slot (which merges correctly bucket-by-bucket); the plumbing is not an
+  override surface. Under `unstyled` the plumbing also stays — stripping
+  `disabled:pointer-events-none` & co. would break behaviour, not styling.
+
+  INTERNAL — never exported from the package barrel, no docs/MCP entry. For a full
+  themed button use the public `Button`.
+
+  restProps-first spread (COMPONENT-API-CONVENTIONS §restProps ordering): the
+  explicit attributes come AFTER `{...restProps}` so component-owned wiring wins —
+  `aria-label` is required (an icon-only button has no text accessible name) and
+  can never be clobbered, and `type="button"` stays a submit-safe default.
+-->
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import type { HTMLButtonAttributes } from 'svelte/elements';
+
+  let {
+    'aria-label': ariaLabel,
+    class: className = '',
+    disabled = false,
+    onclick,
+    children,
+    ...restProps
+  }: {
+    /** Required — an icon-only control has no text to name it. */
+    'aria-label': string;
+    class?: string;
+    disabled?: boolean;
+    onclick?: (event: MouseEvent) => void;
+    children: Snippet;
+  } & Omit<
+    HTMLButtonAttributes,
+    'aria-label' | 'class' | 'disabled' | 'onclick' | 'children'
+  > = $props();
+</script>
+
+<button
+  {...restProps}
+  type="button"
+  {disabled}
+  {onclick}
+  aria-label={ariaLabel}
+  class={[
+    'inline-flex items-center justify-center cursor-pointer select-none',
+    'focus-visible:outline-none',
+    'disabled:opacity-50 disabled:cursor-not-allowed disabled:pointer-events-none',
+    className
+  ]}
+>
+  {@render children()}
+</button>

package/dist/internal/core/CoreIconButton.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { HTMLButtonAttributes } from 'svelte/elements';
+type $$ComponentProps = {
+    /** Required — an icon-only control has no text to name it. */
+    'aria-label': string;
+    class?: string;
+    disabled?: boolean;
+    onclick?: (event: MouseEvent) => void;
+    children: Snippet;
+} & Omit<HTMLButtonAttributes, 'aria-label' | 'class' | 'disabled' | 'onclick' | 'children'>;
+declare const CoreIconButton: import("svelte").Component<$$ComponentProps, {}, "">;
+type CoreIconButton = ReturnType<typeof CoreIconButton>;
+export default CoreIconButton;

package/dist/internal/core/CoreSpinner.svelte

@@ -0,0 +1,49 @@
+<!--
+  CoreSpinner — the bare rotating-arc SVG shared by embedding contexts (loading
+  Button, and any internal surface that needs an inline busy indicator) WITHOUT
+  pulling in the public Spinner.
+
+  INTERNAL — never exported from the package barrel, no docs/MCP entry. For a
+  configurable spinner (variants, speed, intent palette, sr-only label, unstyled
+  / slotClasses) use the public `Spinner`; this core is deliberately fixed to the
+  default variant at 1s.
+
+  No `role` / `aria-*` / sr-only label here on purpose: the embedding context
+  owns the semantics. Button wraps this in an `aria-hidden` span and announces
+  loading via its own `aria-busy`; a `role="status"` here would nest a live
+  region inside contexts that already declare one (e.g. Toast). The geometry is
+  imported from `spinner-geometry.ts` so it can never drift from the public
+  Spinner.
+-->
+<script lang="ts">
+  import { SPINNER_ARC_PATH } from './spinner-geometry';
+
+  let {
+    size = 'md',
+    class: className = ''
+  }: {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Extra classes on the wrapper span (the call site supplies visual identity). */
+    class?: string;
+  } = $props();
+
+  // Matches the public Spinner's per-size box (spinner.variants → base sizes).
+  const sizeClass = {
+    xs: 'w-4 h-4',
+    sm: 'w-5 h-5',
+    md: 'w-6 h-6',
+    lg: 'w-8 h-8'
+  };
+</script>
+
+<span class={['inline-flex items-center justify-center text-current', sizeClass[size], className]}>
+  <svg
+    class="w-full h-full animate-spin [animation-duration:1s] motion-reduce:animate-none"
+    viewBox="0 0 24 24"
+    fill="none"
+    xmlns="http://www.w3.org/2000/svg"
+  >
+    <circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" class="opacity-25" />
+    <path class="fill-current" d={SPINNER_ARC_PATH} />
+  </svg>
+</span>

package/dist/internal/core/CoreSpinner.svelte.d.ts

@@ -0,0 +1,8 @@
+type $$ComponentProps = {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Extra classes on the wrapper span (the call site supplies visual identity). */
+    class?: string;
+};
+declare const CoreSpinner: import("svelte").Component<$$ComponentProps, {}, "">;
+type CoreSpinner = ReturnType<typeof CoreSpinner>;
+export default CoreSpinner;

package/dist/internal/core/spinner-geometry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * single source of the spinner geometry — imported by CoreSpinner and the
+ * public Spinner. The `d` attribute of the rotating arc `<path>` in the
+ * default (spinner) variant. Kept in one place so the two SVGs never drift.
+ */
+export declare const SPINNER_ARC_PATH = "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z";

package/dist/internal/core/spinner-geometry.js

@@ -0,0 +1,6 @@
+/**
+ * single source of the spinner geometry — imported by CoreSpinner and the
+ * public Spinner. The `d` attribute of the rotating arc `<path>` in the
+ * default (spinner) variant. Kept in one place so the two SVGs never drift.
+ */
+export const SPINNER_ARC_PATH = 'M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z';

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.