@santi020k/lumen-core 3.0.0 → 4.0.0

package/dist/theme.js

@@ -1,3 +1,6 @@
+import { lumenCssColorTokens, lumenRadii, lumenSpacing } from './foundations.generated.js';
+import { lumenThemePresetDefinitions } from './theme-presets.generated.js';
+export { lumenThemePresetDefinitions } from './theme-presets.generated.js';
 export const lumenSemanticColorTokenNames = [
     'canvas',
     'surface',
@@ -73,7 +76,16 @@ export const lumenStructureTokenNames = [
     ...lumenRadiusTokenNames,
     ...lumenShadowTokenNames,
     ...lumenTypographyTokenNames,
-    ...lumenMotionTokenNames
+    ...lumenMotionTokenNames,
+    'ui-border-width',
+    'ui-space-zero',
+    'ui-space-xs',
+    'ui-space-sm',
+    'ui-space-md',
+    'ui-space-lg',
+    'ui-space-xl',
+    'ui-space-2xl',
+    'ui-space-3xl'
 ];
 export const lumenColorTokenNames = [
     ...lumenSemanticColorTokenNames,
@@ -192,8 +204,50 @@ const createStructureTokens = (hue, scheme = 'light') => ({
     ...lumenRadiusTokens,
     ...createShadowTokens(hue, scheme),
     ...lumenTypographyTokens,
-    ...lumenMotionTokens
+    ...lumenMotionTokens,
+    'ui-border-width': '1px',
+    'ui-space-zero': '0rem',
+    'ui-space-xs': `${lumenSpacing.xs / 16}rem`,
+    'ui-space-sm': `${lumenSpacing.sm / 16}rem`,
+    'ui-space-md': `${lumenSpacing.md / 16}rem`,
+    'ui-space-lg': `${lumenSpacing.lg / 16}rem`,
+    'ui-space-xl': `${lumenSpacing.xl / 16}rem`,
+    'ui-space-2xl': `${lumenSpacing['2xl'] / 16}rem`,
+    'ui-space-3xl': `${lumenSpacing['3xl'] / 16}rem`
 });
+export const mergeThemeTokens = (tokens, overrides) => ({
+    ...tokens,
+    ...Object.fromEntries(Object.entries(overrides).filter((entry) => Boolean(entry[1])))
+});
+/** A preset configures tokens; components retain explicit control of glass surfaces. */
+export const createThemePreset = (preset = 'default', options = {}) => {
+    const scheme = options.scheme ?? 'light';
+    const definition = lumenThemePresetDefinitions[preset];
+    const colors = Object.fromEntries(lumenSemanticColorTokenNames.map(name => [
+        name,
+        Object.entries(lumenCssColorTokens[scheme]).find(([key]) => key === name.replaceAll(/-([a-z])/g, (_match, character) => character.toUpperCase()))?.[1] ?? ''
+    ]));
+    const tokens = {
+        ...colors,
+        ...definition.cssColors[scheme],
+        ...createGlassThemeTokens(preset === 'studio' ? 0 : 220, scheme),
+        ...createStructureTokens(222, scheme),
+        ...definition.effects[scheme],
+        'ui-border-width': `${definition.borderWidth}px`,
+        'ui-font': definition.fontFamily.map(family => ['system-ui', 'sans-serif'].includes(family) ? family : `"${family}"`).join(', '),
+        'ui-radius-sm': `${lumenRadii.sm / 16 * definition.radiusScale}rem`,
+        'ui-radius': `${lumenRadii.md / 16 * definition.radiusScale}rem`,
+        'ui-radius-lg': `${lumenRadii.lg / 16 * definition.radiusScale}rem`,
+        ...Object.fromEntries(Object.entries(lumenSpacing).map(([name, value]) => [
+            `ui-space-${name}`, `${value * definition.spacingScale / 16}rem`
+        ]))
+    };
+    if (definition.elevationScale === 0) {
+        for (const name of lumenShadowTokenNames)
+            tokens[name] = 'none';
+    }
+    return mergeThemeTokens(tokens, options.overrides ?? {});
+};
 export const createThemePalette = (brand, accent = brand) => ({
     accent,
     brand,
@@ -326,10 +380,6 @@ export const scoreThemeContrast = (tokens, foreground = 'ink', background = 'can
         wcagAAA: ratio >= 7
     };
 };
-export const mergeThemeTokens = (tokens, overrides) => ({
-    ...tokens,
-    ...Object.fromEntries(Object.entries(overrides).filter((entry) => Boolean(entry[1])))
-});
 export const suggestReadableInk = (background) => {
     const darkForeground = '0 0% 0%';
     const lightForeground = '0 0% 100%';

package/dist/virtual-collection.d.ts

@@ -0,0 +1,14 @@
+export interface LumenVirtualCollectionOptions<T> {
+    getKey: (item: T, index: number) => string | number;
+    items: readonly T[];
+    itemSize?: number;
+    overscan?: number;
+    renderItem: (item: T, index: number, previous?: HTMLElement) => HTMLElement;
+}
+export interface LumenVirtualCollectionController<T> {
+    destroy: () => void;
+    update: (items: readonly T[]) => void;
+}
+/** Data mode owns an empty VirtualList root; only its visible window and focused neighbors mount. */
+export declare const createLumenVirtualCollectionController: <T>(root: HTMLElement, options: LumenVirtualCollectionOptions<T>) => LumenVirtualCollectionController<T>;
+//# sourceMappingURL=virtual-collection.d.ts.map

package/dist/virtual-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-collection.d.ts","sourceRoot":"","sources":["../src/virtual-collection.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,6BAA6B,CAAC,CAAC;IAC9C,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAAA;IACnD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,KAAK,WAAW,CAAA;CAC5E;AACD,MAAM,WAAW,gCAAgC,CAAC,CAAC;IACjD,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,CAAA;CACtC;AA0CD,qGAAqG;AACrG,eAAO,MAAM,sCAAsC,GAAI,CAAC,EACtD,MAAM,WAAW,EACjB,SAAS,6BAA6B,CAAC,CAAC,CAAC,KACxC,gCAAgC,CAAC,CAAC,CA2IpC,CAAA"}

package/dist/virtual-collection.js

@@ -0,0 +1,132 @@
+import { observeLumenVirtualWindow } from './virtual-window.js';
+const isHtmlElement = (element) => element?.namespaceURI === 'http://www.w3.org/1999/xhtml';
+const positionRow = (root, row, index, count, itemSize) => {
+    if (root.getAttribute('role') === 'list') {
+        row.setAttribute('role', 'listitem');
+        row.setAttribute('aria-posinset', String(index + 1));
+        row.setAttribute('aria-setsize', String(count));
+    }
+    row.dataset.uiVirtualListIndex = String(index);
+    row.style.position = 'absolute';
+    row.style.insetInline = '0';
+    row.style.top = `${index * itemSize}px`;
+    row.style.height = `${itemSize}px`;
+    row.style.boxSizing = 'border-box';
+};
+const insertRow = (content, row, previousRow) => {
+    if (row.previousElementSibling !== (previousRow ?? null) || row.parentElement !== content) {
+        content.insertBefore(row, previousRow ? previousRow.nextSibling : content.firstChild);
+    }
+};
+const restoreFocus = (root, focused, ownedFocus) => {
+    // Adopted controls retain their original realm's prototype; their HTML namespace stays stable.
+    if (!ownedFocus || !isHtmlElement(focused) || focused === root.ownerDocument.activeElement)
+        return;
+    if (root.contains(focused))
+        focused.focus({ preventScroll: true });
+    else
+        root.focus({ preventScroll: true });
+};
+/** Data mode owns an empty VirtualList root; only its visible window and focused neighbors mount. */
+export const createLumenVirtualCollectionController = (root, options) => {
+    if (root.childElementCount)
+        throw new Error('VirtualList data mode requires an empty root.');
+    const content = root.ownerDocument.createElement('div');
+    const previousMode = root.getAttribute('data-ui-virtual-list-mode');
+    const rows = new Map();
+    let destroyed = false;
+    let observer;
+    const entriesFor = (items) => {
+        const keys = new Set();
+        return Array.from(items, (item, index) => {
+            const key = String(options.getKey(item, index));
+            if (keys.has(key))
+                throw new Error(`VirtualList item keys must be unique: ${key}`);
+            keys.add(key);
+            return { item, key, index };
+        });
+    };
+    let entries = entriesFor(options.items);
+    content.dataset.uiVirtualListContent = '';
+    content.style.position = 'relative';
+    root.dataset.uiVirtualListMode = 'data';
+    root.append(content);
+    const updateFocus = () => {
+        const active = root.ownerDocument.activeElement;
+        const focused = [...rows].find(([, rendered]) => rendered.row.contains(active));
+        const entry = focused ? entries.find(item => item.key === focused[0]) : undefined;
+        if (entry && focused)
+            focused[1].row.dataset.uiVirtualListIndex = String(entry.index);
+    };
+    const getRow = (entry) => {
+        const index = entry.index;
+        let rendered = rows.get(entry.key);
+        if (!rendered) {
+            const row = root.ownerDocument.createElement('div');
+            row.append(options.renderItem(entry.item, index));
+            rendered = { index, item: entry.item, row };
+            rows.set(entry.key, rendered);
+        }
+        else if (rendered.item !== entry.item || rendered.index !== index) {
+            const previous = rendered.row.firstElementChild;
+            const element = options.renderItem(entry.item, index, isHtmlElement(previous) ? previous : undefined);
+            if (element !== previous)
+                rendered.row.replaceChildren(element);
+            rendered.item = entry.item;
+            rendered.index = index;
+        }
+        return rendered.row;
+    };
+    const render = (window) => {
+        const focused = root.ownerDocument.activeElement;
+        const ownedFocus = root.contains(focused);
+        content.style.height = `${window.totalSize}px`;
+        const visibleKeys = new Set();
+        let previousRow;
+        for (const index of window.indexes) {
+            const entry = entries[index];
+            if (!entry)
+                continue;
+            visibleKeys.add(entry.key);
+            const row = getRow(entry);
+            positionRow(root, row, index, entries.length, window.itemSize);
+            insertRow(content, row, previousRow);
+            previousRow = row;
+        }
+        for (const [key, rendered] of rows) {
+            if (!visibleKeys.has(key)) {
+                rendered.row.remove();
+                rows.delete(key);
+            }
+        }
+        restoreFocus(root, focused, ownedFocus);
+    };
+    const observe = () => {
+        observer?.destroy();
+        observer = observeLumenVirtualWindow(root, {
+            itemCount: entries.length, itemSize: options.itemSize ?? 44, overscan: options.overscan ?? 4, onChange: render
+        });
+    };
+    observe();
+    return {
+        update: items => {
+            if (destroyed)
+                return;
+            // Validate the complete new key set before replacing the live collection.
+            const next = entriesFor(items);
+            entries = next;
+            updateFocus();
+            observe();
+        },
+        destroy: () => {
+            destroyed = true;
+            observer?.destroy();
+            content.remove();
+            rows.clear();
+            if (previousMode === null)
+                delete root.dataset.uiVirtualListMode;
+            else
+                root.setAttribute('data-ui-virtual-list-mode', previousMode);
+        }
+    };
+};

package/dist/virtual-list.d.ts

@@ -0,0 +1,7 @@
+export interface LumenVirtualListController {
+    destroy: () => void;
+    update: () => void;
+}
+/** Fixed-height DOM windowing; rows remain mounted so application state is retained. */
+export declare const createLumenVirtualListController: (root: HTMLElement) => LumenVirtualListController;
+//# sourceMappingURL=virtual-list.d.ts.map

package/dist/virtual-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-list.d.ts","sourceRoot":"","sources":["../src/virtual-list.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB;AAWD,wFAAwF;AACxF,eAAO,MAAM,gCAAgC,GAAI,MAAM,WAAW,KAAG,0BAiLpE,CAAA"}

package/dist/virtual-list.js

@@ -0,0 +1,135 @@
+import { getVirtualRange } from './data.js';
+const getDocumentConstructors = (document) => {
+    const view = document.defaultView;
+    return {
+        RangeEvent: view?.CustomEvent ?? CustomEvent,
+        RowObserver: view?.MutationObserver ?? MutationObserver
+    };
+};
+/** Fixed-height DOM windowing; rows remain mounted so application state is retained. */
+export const createLumenVirtualListController = (root) => {
+    if (root.getAttribute('data-ui-virtual-list-mode') === 'data' || root.getAttribute('mode') === 'data')
+        return { destroy: () => undefined, update: () => undefined };
+    const document = root.ownerDocument;
+    const view = document.defaultView;
+    const { RangeEvent, RowObserver } = getDocumentConstructors(document);
+    const originalRows = new Map();
+    const spacers = ['start', 'end'].map(position => {
+        const spacer = document.createElement('div');
+        spacer.dataset.uiVirtualListSpacer = position;
+        spacer.setAttribute('aria-hidden', 'true');
+        return spacer;
+    });
+    const [before, after] = spacers;
+    if (!before || !after)
+        throw new Error('Virtual list spacers are required');
+    let destroyed = false;
+    let previousRange = '';
+    const readNumber = (dataName, name, fallback, minimum) => {
+        const value = Number(root.getAttribute(dataName) ?? root.getAttribute(name) ?? fallback);
+        return Number.isFinite(value) && value >= minimum && value <= Number.MAX_SAFE_INTEGER ? value : fallback;
+    };
+    const restoreRow = (row) => {
+        const original = originalRows.get(row);
+        if (!original)
+            return;
+        row.hidden = original.hidden;
+        row.style.blockSize = original.blockSize;
+        row.style.boxSizing = original.boxSizing;
+        originalRows.delete(row);
+    };
+    const syncRows = () => {
+        const children = [...root.children].filter((child) => child.namespaceURI === 'http://www.w3.org/1999/xhtml' && child !== before && child !== after);
+        const childSet = new Set(children);
+        for (const row of originalRows.keys()) {
+            if (!childSet.has(row))
+                restoreRow(row);
+        }
+        for (const row of children) {
+            if (!originalRows.has(row))
+                originalRows.set(row, {
+                    hidden: row.hidden,
+                    blockSize: row.style.blockSize,
+                    boxSizing: row.style.boxSizing
+                });
+        }
+        return children.filter(row => !originalRows.get(row)?.hidden);
+    };
+    const getViewport = () => {
+        const padding = view?.getComputedStyle(root);
+        const start = Number.parseFloat(padding?.paddingTop ?? '0') || 0;
+        const end = Number.parseFloat(padding?.paddingBottom ?? '0') || 0;
+        return Math.max(0, root.clientHeight - start - end);
+    };
+    const update = () => {
+        if (destroyed)
+            return;
+        const rows = syncRows();
+        const size = readNumber('data-ui-item-size', 'item-size', 44, 1);
+        const overscan = readNumber('data-ui-overscan', 'overscan', 4, 0);
+        const viewport = getViewport();
+        const maximumOffset = Math.max(0, rows.length * size - viewport);
+        if (root.scrollTop > maximumOffset)
+            root.scrollTop = maximumOffset;
+        const range = getVirtualRange(root.scrollTop, viewport, size, rows.length, overscan);
+        const focusedIndex = rows.findIndex(row => row.contains(document.activeElement));
+        // Keep the focused row and its neighbors available for native sequential Tab navigation.
+        if (focusedIndex >= 0) {
+            range.startIndex = Math.min(range.startIndex, Math.max(0, focusedIndex - 1));
+            range.endIndex = Math.max(range.endIndex, Math.min(rows.length - 1, focusedIndex + 1));
+        }
+        for (const [index, row] of rows.entries()) {
+            row.style.blockSize = `${size}px`;
+            row.style.boxSizing = 'border-box';
+            row.hidden = index < range.startIndex || index > range.endIndex;
+        }
+        before.style.blockSize = `${range.startIndex * size}px`;
+        after.style.blockSize = `${Math.max(0, rows.length - range.endIndex - 1) * size}px`;
+        // React or an application may append new rows after the trailing spacer.
+        if (root.firstElementChild !== before)
+            root.prepend(before);
+        if (root.lastElementChild !== after)
+            root.append(after);
+        root.dataset.uiRangeStart = String(range.startIndex);
+        root.dataset.uiRangeEnd = String(range.endIndex);
+        const rangeKey = `${range.startIndex}:${range.endIndex}:${rows.length}`;
+        if (rangeKey !== previousRange) {
+            previousRange = rangeKey;
+            root.dispatchEvent(new RangeEvent('ui:virtual-list-range', { bubbles: true, detail: range }));
+        }
+    };
+    const observer = new RowObserver(update);
+    const resizeObserver = typeof ResizeObserver === 'undefined' ? undefined : new ResizeObserver(update);
+    const onFocusOut = () => {
+        queueMicrotask(update);
+    };
+    root.addEventListener('scroll', update, { passive: true });
+    root.addEventListener('focusin', update);
+    root.addEventListener('focusout', onFocusOut);
+    view?.addEventListener('resize', update);
+    update();
+    observer.observe(root, {
+        childList: true,
+        attributes: true,
+        attributeFilter: ['data-ui-item-size', 'data-ui-overscan', 'item-size', 'overscan']
+    });
+    resizeObserver?.observe(root);
+    return {
+        update,
+        destroy: () => {
+            destroyed = true;
+            observer.disconnect();
+            resizeObserver?.disconnect();
+            root.removeEventListener('scroll', update);
+            root.removeEventListener('focusin', update);
+            root.removeEventListener('focusout', onFocusOut);
+            view?.removeEventListener('resize', update);
+            for (const row of originalRows.keys())
+                restoreRow(row);
+            for (const spacer of spacers)
+                spacer.remove();
+            delete root.dataset.uiRangeStart;
+            delete root.dataset.uiRangeEnd;
+        }
+    };
+};

package/dist/virtual-window.d.ts

@@ -0,0 +1,19 @@
+export interface LumenVirtualWindow {
+    endIndex: number;
+    indexes: number[];
+    itemSize: number;
+    startIndex: number;
+    totalSize: number;
+}
+export interface LumenVirtualWindowOptions {
+    itemCount: number;
+    itemSize?: number;
+    onChange: (window: LumenVirtualWindow) => void;
+    overscan?: number;
+}
+export declare const getLumenVirtualWindow: (offset: number, viewport: number, itemCount: number, itemSize?: number, overscan?: number, focusedIndex?: number) => LumenVirtualWindow;
+export declare const observeLumenVirtualWindow: (root: HTMLElement, options: LumenVirtualWindowOptions) => {
+    destroy: () => void;
+    update: () => void;
+};
+//# sourceMappingURL=virtual-window.d.ts.map

package/dist/virtual-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-window.d.ts","sourceRoot":"","sources":["../src/virtual-window.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB;AACD,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAA;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAkBD,eAAO,MAAM,qBAAqB,GAChC,QAAQ,MAAM,EACd,UAAU,MAAM,EAChB,WAAW,MAAM,EACjB,iBAAa,EACb,iBAAY,EACZ,qBAAiB,KAChB,kBAcF,CAAA;AAkBD,eAAO,MAAM,yBAAyB,GACpC,MAAM,WAAW,EAAE,SAAS,yBAAyB,KACpD;IAAE,OAAO,EAAE,MAAM,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAwE3C,CAAA"}

package/dist/virtual-window.js

@@ -0,0 +1,84 @@
+import { getVirtualRange } from './data.js';
+const normalizeCount = (count) => Number.isSafeInteger(count) && count > 0 ? count : 0;
+const normalizeSize = (size, count) => {
+    if (!Number.isFinite(size) || size <= 0 || size > Number.MAX_SAFE_INTEGER / Math.max(1, count))
+        return 44;
+    return size;
+};
+const pinFocus = (indexes, focusedIndex, count) => {
+    if (!Number.isSafeInteger(focusedIndex) || focusedIndex < 0 || focusedIndex >= count)
+        return;
+    const end = Math.min(count - 1, focusedIndex + 1);
+    for (let index = Math.max(0, focusedIndex - 1); index <= end; index += 1)
+        indexes.add(index);
+};
+export const getLumenVirtualWindow = (offset, viewport, itemCount, itemSize = 44, overscan = 4, focusedIndex = -1) => {
+    const count = normalizeCount(itemCount);
+    const size = normalizeSize(itemSize, count);
+    const range = getVirtualRange(offset, viewport, size, count, overscan);
+    const indexes = new Set();
+    for (let index = range.startIndex; index <= range.endIndex; index += 1)
+        indexes.add(index);
+    // Retain focused content and its Tab neighbors without mounting the intervening rows.
+    pinFocus(indexes, focusedIndex, count);
+    return {
+        ...range, indexes: [...indexes].sort((first, second) => first - second), itemSize: size, totalSize: count * size
+    };
+};
+const getViewport = (root) => {
+    const styles = root.ownerDocument.defaultView?.getComputedStyle(root);
+    const start = Number.parseFloat(styles?.paddingTop ?? '0') || 0;
+    const end = Number.parseFloat(styles?.paddingBottom ?? '0') || 0;
+    return Math.max(0, root.clientHeight - start - end);
+};
+const getFocusedIndex = (root) => {
+    const active = root.ownerDocument.activeElement;
+    // Element APIs remain available when the focused control was adopted from another document.
+    const row = active?.closest('[data-ui-virtual-list-index]');
+    return row?.closest('[data-ui-virtual-list]') === root ? Number(row.getAttribute('data-ui-virtual-list-index')) : -1;
+};
+export const observeLumenVirtualWindow = (root, options) => {
+    const view = root.ownerDocument.defaultView;
+    let destroyed = false;
+    let previous = '';
+    const update = () => {
+        if (destroyed)
+            return;
+        const viewport = getViewport(root);
+        const window = getLumenVirtualWindow(root.scrollTop, viewport, options.itemCount, options.itemSize, options.overscan, getFocusedIndex(root));
+        root.scrollTop = Math.min(root.scrollTop, Math.max(0, window.totalSize - viewport));
+        const signature = `${window.itemSize}:${window.totalSize}:${window.startIndex}:${window.endIndex}:${window.indexes.join(',')}`;
+        if (signature === previous)
+            return;
+        previous = signature;
+        root.dataset.uiRangeStart = String(window.startIndex);
+        root.dataset.uiRangeEnd = String(window.endIndex);
+        options.onChange(window);
+        const RangeEvent = view?.CustomEvent ?? CustomEvent;
+        root.dispatchEvent(new RangeEvent('ui:virtual-list-range', { bubbles: true, detail: { startIndex: window.startIndex, endIndex: window.endIndex } }));
+    };
+    const onFocusOut = () => {
+        queueMicrotask(update);
+    };
+    const ViewResizeObserver = view?.ResizeObserver ?? (typeof ResizeObserver === 'undefined' ? undefined : ResizeObserver);
+    const resize = ViewResizeObserver ? new ViewResizeObserver(update) : undefined;
+    root.addEventListener('scroll', update, { passive: true });
+    root.addEventListener('focusin', update);
+    root.addEventListener('focusout', onFocusOut);
+    view?.addEventListener('resize', update);
+    resize?.observe(root);
+    update();
+    return {
+        update,
+        destroy: () => {
+            destroyed = true;
+            resize?.disconnect();
+            root.removeEventListener('scroll', update);
+            root.removeEventListener('focusin', update);
+            root.removeEventListener('focusout', onFocusOut);
+            view?.removeEventListener('resize', update);
+            delete root.dataset.uiRangeStart;
+            delete root.dataset.uiRangeEnd;
+        }
+    };
+};

package/dist/visual-effects.d.ts

@@ -0,0 +1,6 @@
+export declare const lumenVisualEffectVariants: readonly ["mesh", "aurora", "spotlight", "grain", "border", "draw", "depth"];
+export type LumenVisualEffectVariant = typeof lumenVisualEffectVariants[number];
+export declare const normalizeLumenEffectIntensity: (value: unknown) => number;
+/** Pointer tracking is optional decoration; content remains operable without this controller. */
+export declare const createLumenSpotlightController: (root: HTMLElement) => (() => void);
+//# sourceMappingURL=visual-effects.d.ts.map

package/dist/visual-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-effects.d.ts","sourceRoot":"","sources":["../src/visual-effects.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,8EAA+E,CAAA;AACrH,MAAM,MAAM,wBAAwB,GAAG,OAAO,yBAAyB,CAAC,MAAM,CAAC,CAAA;AAE/E,eAAO,MAAM,6BAA6B,GAAI,OAAO,OAAO,KAAG,MAAqG,CAAA;AAEpK,iGAAiG;AACjG,eAAO,MAAM,8BAA8B,GAAI,MAAM,WAAW,KAAG,CAAC,MAAM,IAAI,CA2D7E,CAAA"}

package/dist/visual-effects.js

@@ -0,0 +1,44 @@
+import { isLumenWorkflowMotionReduced } from './motion-workflows.js';
+export const lumenVisualEffectVariants = ['mesh', 'aurora', 'spotlight', 'grain', 'border', 'draw', 'depth'];
+export const normalizeLumenEffectIntensity = (value) => typeof value === 'number' && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0.5;
+/** Pointer tracking is optional decoration; content remains operable without this controller. */
+export const createLumenSpotlightController = (root) => {
+    const view = root.ownerDocument.defaultView;
+    let frame;
+    let x = '50%';
+    let y = '50%';
+    const write = () => {
+        frame = undefined;
+        root.style.setProperty('--ui-spotlight-x', x);
+        root.style.setProperty('--ui-spotlight-y', y);
+    };
+    const move = (event) => {
+        if (event.pointerType === 'touch' || isLumenWorkflowMotionReduced(root))
+            return;
+        const rect = root.getBoundingClientRect();
+        x = `${Math.min(rect.width, Math.max(0, event.clientX - rect.left))}px`;
+        y = `${Math.min(rect.height, Math.max(0, event.clientY - rect.top))}px`;
+        if (frame === undefined && view)
+            frame = view.requestAnimationFrame(write);
+    };
+    const reset = () => {
+        if (frame !== undefined)
+            view?.cancelAnimationFrame(frame);
+        frame = undefined;
+        x = '50%';
+        y = '50%';
+        write();
+    };
+    const media = view?.matchMedia('(prefers-reduced-motion: reduce)');
+    media?.addEventListener('change', reset);
+    root.addEventListener('pointermove', move);
+    root.addEventListener('pointerleave', reset);
+    root.addEventListener('focusout', reset);
+    return () => {
+        media?.removeEventListener('change', reset);
+        root.removeEventListener('pointermove', move);
+        root.removeEventListener('pointerleave', reset);
+        root.removeEventListener('focusout', reset);
+        reset();
+    };
+};

package/dist/world-map-data.generated.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generated by `pnpm run generate:world-map-data`. Do not edit by hand.
+ *
+ * Source: maps/world-map.source.json (Natural Earth 1:50m Admin 0 Countries, public domain).
+ * See maps/README.md and THIRD_PARTY_NOTICES.md for provenance, projection, and precision notes.
+ */
+import type { LumenWorldMapCountryGeometry } from './world-map.js';
+export declare const lumenWorldMapCountries: readonly LumenWorldMapCountryGeometry[];
+//# sourceMappingURL=world-map-data.generated.d.ts.map

package/dist/world-map-data.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-map-data.generated.d.ts","sourceRoot":"","sources":["../src/world-map-data.generated.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAA;AAElE,eAAO,MAAM,sBAAsB,EAAE,SAAS,4BAA4B,EA+OzE,CAAA"}