@autumnsgrove/gossamer 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AutumnsGrove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/animation.js

@@ -0,0 +1,165 @@
+/**
+ * Gossamer Animation Utilities
+ *
+ * FPS limiting, animation loop management, and timing utilities.
+ */
+/**
+ * Create a managed animation loop with FPS limiting
+ */
+export function createAnimationLoop(options) {
+    const { fps = 30, onStart, onStop, onFrame } = options;
+    const state = {
+        isRunning: false,
+        frameId: null,
+        lastFrameTime: 0,
+        frameInterval: 1000 / fps,
+        elapsedTime: 0,
+        frameCount: 0,
+    };
+    let pausedTime = 0;
+    let isPaused = false;
+    function animate(currentTime) {
+        if (!state.isRunning || isPaused)
+            return;
+        const deltaTime = currentTime - state.lastFrameTime;
+        if (deltaTime >= state.frameInterval) {
+            state.elapsedTime += deltaTime;
+            state.frameCount++;
+            const continueAnimation = onFrame(currentTime, deltaTime, state.frameCount);
+            if (continueAnimation === false) {
+                stop();
+                return;
+            }
+            // Adjust for frame timing drift
+            state.lastFrameTime = currentTime - (deltaTime % state.frameInterval);
+        }
+        state.frameId = requestAnimationFrame(animate);
+    }
+    function start() {
+        if (state.isRunning)
+            return;
+        state.isRunning = true;
+        state.lastFrameTime = performance.now();
+        state.elapsedTime = 0;
+        state.frameCount = 0;
+        isPaused = false;
+        onStart?.();
+        state.frameId = requestAnimationFrame(animate);
+    }
+    function stop() {
+        state.isRunning = false;
+        isPaused = false;
+        if (state.frameId !== null) {
+            cancelAnimationFrame(state.frameId);
+            state.frameId = null;
+        }
+        onStop?.();
+    }
+    function pause() {
+        if (!state.isRunning || isPaused)
+            return;
+        isPaused = true;
+        pausedTime = performance.now();
+        if (state.frameId !== null) {
+            cancelAnimationFrame(state.frameId);
+            state.frameId = null;
+        }
+    }
+    function resume() {
+        if (!state.isRunning || !isPaused)
+            return;
+        isPaused = false;
+        // Adjust lastFrameTime to account for paused duration
+        state.lastFrameTime += performance.now() - pausedTime;
+        state.frameId = requestAnimationFrame(animate);
+    }
+    function getState() {
+        return { ...state };
+    }
+    return { start, stop, pause, resume, getState };
+}
+/**
+ * Simple throttle function for limiting function execution
+ */
+export function throttle(fn, limit) {
+    let lastCall = 0;
+    let timeout = null;
+    return (...args) => {
+        const now = Date.now();
+        if (now - lastCall >= limit) {
+            lastCall = now;
+            fn(...args);
+        }
+        else if (!timeout) {
+            timeout = setTimeout(() => {
+                lastCall = Date.now();
+                timeout = null;
+                fn(...args);
+            }, limit - (now - lastCall));
+        }
+    };
+}
+/**
+ * Debounce function for delaying execution until activity stops
+ */
+export function debounce(fn, delay) {
+    let timeout = null;
+    return (...args) => {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+            timeout = null;
+            fn(...args);
+        }, delay);
+    };
+}
+/**
+ * Calculate actual FPS from frame times
+ */
+export function calculateFPS(frameTimes, sampleSize = 60) {
+    if (frameTimes.length < 2)
+        return 0;
+    const samples = frameTimes.slice(-sampleSize);
+    const totalTime = samples[samples.length - 1] - samples[0];
+    const frameCount = samples.length - 1;
+    if (totalTime <= 0)
+        return 0;
+    return (frameCount / totalTime) * 1000;
+}
+/**
+ * Easing functions for smooth animations
+ */
+export const easings = {
+    /** Linear - no easing */
+    linear: (t) => t,
+    /** Ease in - slow start */
+    easeIn: (t) => t * t,
+    /** Ease out - slow end */
+    easeOut: (t) => t * (2 - t),
+    /** Ease in/out - slow start and end */
+    easeInOut: (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+    /** Sine ease in */
+    sineIn: (t) => 1 - Math.cos((t * Math.PI) / 2),
+    /** Sine ease out */
+    sineOut: (t) => Math.sin((t * Math.PI) / 2),
+    /** Sine ease in/out */
+    sineInOut: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+    /** Bounce at end */
+    bounceOut: (t) => {
+        const n1 = 7.5625;
+        const d1 = 2.75;
+        if (t < 1 / d1) {
+            return n1 * t * t;
+        }
+        else if (t < 2 / d1) {
+            return n1 * (t -= 1.5 / d1) * t + 0.75;
+        }
+        else if (t < 2.5 / d1) {
+            return n1 * (t -= 2.25 / d1) * t + 0.9375;
+        }
+        else {
+            return n1 * (t -= 2.625 / d1) * t + 0.984375;
+        }
+    },
+};

package/dist/animation.test.js

@@ -0,0 +1,204 @@
+/**
+ * Tests for animation utilities
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { throttle, debounce, calculateFPS, easings, createAnimationLoop } from './animation';
+describe('throttle', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('should call function immediately on first call', () => {
+        const fn = vi.fn();
+        const throttled = throttle(fn, 100);
+        throttled();
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('should throttle subsequent calls within limit', () => {
+        const fn = vi.fn();
+        const throttled = throttle(fn, 100);
+        throttled();
+        throttled();
+        throttled();
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('should call function again after limit expires', () => {
+        const fn = vi.fn();
+        const throttled = throttle(fn, 100);
+        throttled();
+        expect(fn).toHaveBeenCalledTimes(1);
+        vi.advanceTimersByTime(150);
+        throttled();
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    it('should pass arguments to throttled function', () => {
+        const fn = vi.fn();
+        const throttled = throttle(fn, 100);
+        throttled('arg1', 'arg2');
+        expect(fn).toHaveBeenCalledWith('arg1', 'arg2');
+    });
+});
+describe('debounce', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('should not call function immediately', () => {
+        const fn = vi.fn();
+        const debounced = debounce(fn, 100);
+        debounced();
+        expect(fn).not.toHaveBeenCalled();
+    });
+    it('should call function after delay', () => {
+        const fn = vi.fn();
+        const debounced = debounce(fn, 100);
+        debounced();
+        vi.advanceTimersByTime(100);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('should reset timer on subsequent calls', () => {
+        const fn = vi.fn();
+        const debounced = debounce(fn, 100);
+        debounced();
+        vi.advanceTimersByTime(50);
+        debounced();
+        vi.advanceTimersByTime(50);
+        expect(fn).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(50);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('should pass arguments to debounced function', () => {
+        const fn = vi.fn();
+        const debounced = debounce(fn, 100);
+        debounced('test', 123);
+        vi.advanceTimersByTime(100);
+        expect(fn).toHaveBeenCalledWith('test', 123);
+    });
+});
+describe('calculateFPS', () => {
+    it('should return 0 for empty array', () => {
+        expect(calculateFPS([])).toBe(0);
+    });
+    it('should return 0 for single frame time', () => {
+        expect(calculateFPS([1000])).toBe(0);
+    });
+    it('should calculate FPS correctly', () => {
+        // 60 frames over 1 second = 60 FPS
+        const frameTimes = Array.from({ length: 61 }, (_, i) => i * (1000 / 60));
+        const fps = calculateFPS(frameTimes);
+        expect(fps).toBeCloseTo(60, 0);
+    });
+    it('should handle 30 FPS', () => {
+        // 30 frames over 1 second = 30 FPS
+        const frameTimes = Array.from({ length: 31 }, (_, i) => i * (1000 / 30));
+        const fps = calculateFPS(frameTimes);
+        expect(fps).toBeCloseTo(30, 0);
+    });
+    it('should use sample size parameter', () => {
+        // Create 100 frame times
+        const frameTimes = Array.from({ length: 100 }, (_, i) => i * 16.67);
+        // Should only use last 10 samples
+        const fps = calculateFPS(frameTimes, 10);
+        expect(fps).toBeCloseTo(60, 0);
+    });
+});
+describe('easings', () => {
+    describe('linear', () => {
+        it('should return input unchanged', () => {
+            expect(easings.linear(0)).toBe(0);
+            expect(easings.linear(0.5)).toBe(0.5);
+            expect(easings.linear(1)).toBe(1);
+        });
+    });
+    describe('easeIn', () => {
+        it('should start slow', () => {
+            expect(easings.easeIn(0)).toBe(0);
+            expect(easings.easeIn(0.5)).toBe(0.25);
+            expect(easings.easeIn(1)).toBe(1);
+        });
+    });
+    describe('easeOut', () => {
+        it('should end slow', () => {
+            expect(easings.easeOut(0)).toBe(0);
+            expect(easings.easeOut(0.5)).toBe(0.75);
+            expect(easings.easeOut(1)).toBe(1);
+        });
+    });
+    describe('easeInOut', () => {
+        it('should start and end slow', () => {
+            expect(easings.easeInOut(0)).toBe(0);
+            expect(easings.easeInOut(0.5)).toBe(0.5);
+            expect(easings.easeInOut(1)).toBe(1);
+        });
+        it('should be symmetric around 0.5', () => {
+            const val1 = easings.easeInOut(0.25);
+            const val2 = 1 - easings.easeInOut(0.75);
+            expect(val1).toBeCloseTo(val2, 5);
+        });
+    });
+    describe('sineIn', () => {
+        it('should return 0 at start and 1 at end', () => {
+            expect(easings.sineIn(0)).toBe(0);
+            expect(easings.sineIn(1)).toBeCloseTo(1, 5);
+        });
+    });
+    describe('sineOut', () => {
+        it('should return 0 at start and 1 at end', () => {
+            expect(easings.sineOut(0)).toBe(0);
+            expect(easings.sineOut(1)).toBeCloseTo(1, 5);
+        });
+    });
+    describe('sineInOut', () => {
+        it('should return 0 at start, 0.5 at middle, 1 at end', () => {
+            expect(easings.sineInOut(0)).toBeCloseTo(0, 5);
+            expect(easings.sineInOut(0.5)).toBeCloseTo(0.5, 5);
+            expect(easings.sineInOut(1)).toBeCloseTo(1, 5);
+        });
+    });
+    describe('bounceOut', () => {
+        it('should return 0 at start and 1 at end', () => {
+            expect(easings.bounceOut(0)).toBe(0);
+            expect(easings.bounceOut(1)).toBeCloseTo(1, 5);
+        });
+        it('should overshoot intermediate values', () => {
+            // bounceOut creates bouncing effect with values close to 1
+            const val = easings.bounceOut(0.9);
+            expect(val).toBeGreaterThan(0.9);
+        });
+    });
+});
+describe('createAnimationLoop', () => {
+    it('should return control functions', () => {
+        const loop = createAnimationLoop({
+            onFrame: () => { },
+        });
+        expect(typeof loop.start).toBe('function');
+        expect(typeof loop.stop).toBe('function');
+        expect(typeof loop.pause).toBe('function');
+        expect(typeof loop.resume).toBe('function');
+        expect(typeof loop.getState).toBe('function');
+    });
+    it('should initialize with correct default state', () => {
+        const loop = createAnimationLoop({
+            fps: 60,
+            onFrame: () => { },
+        });
+        const state = loop.getState();
+        expect(state.isRunning).toBe(false);
+        expect(state.frameId).toBeNull();
+        expect(state.frameInterval).toBeCloseTo(1000 / 60, 1);
+        expect(state.elapsedTime).toBe(0);
+        expect(state.frameCount).toBe(0);
+    });
+    it('should use default FPS of 30', () => {
+        const loop = createAnimationLoop({
+            onFrame: () => { },
+        });
+        const state = loop.getState();
+        expect(state.frameInterval).toBeCloseTo(1000 / 30, 1);
+    });
+});

package/dist/characters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"characters.d.ts","sourceRoot":"","sources":["../src/characters.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAoFvD,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEtE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,MAAW,EACxB,OAAO,GAAE,MAAM,EAAO,GACrB,YAAY,CAOd;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAIhE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE3D"}
+{"version":3,"file":"characters.d.ts","sourceRoot":"","sources":["../src/characters.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CA2IvD,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEtE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,MAAW,EACxB,OAAO,GAAE,MAAM,EAAO,GACrB,YAAY,CAOd;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAIhE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/characters.js

@@ -0,0 +1,176 @@
+/**
+ * Gossamer Character Sets
+ *
+ * Predefined character sets for ASCII rendering, ordered from light to dark.
+ * Character density determines which character represents each brightness level.
+ */
+/**
+ * Standard character sets for ASCII rendering
+ */
+export const CHARACTER_SETS = {
+    standard: {
+        name: 'Standard',
+        description: 'Classic ASCII art character set',
+        characters: ' .:-=+*#%@',
+        bestFor: ['general', 'images', 'patterns'],
+    },
+    dense: {
+        name: 'Dense',
+        description: 'High detail character set with many gradations',
+        characters: " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+        bestFor: ['detailed images', 'portraits', 'high contrast'],
+    },
+    minimal: {
+        name: 'Minimal',
+        description: 'Clean and simple with few characters',
+        characters: ' .:*#',
+        bestFor: ['backgrounds', 'subtle effects', 'clean aesthetic'],
+    },
+    grove: {
+        name: 'Grove',
+        description: 'Organic, soft characters inspired by nature',
+        characters: ' ·∙•◦○◉●',
+        bestFor: ['organic patterns', 'soft backgrounds', 'nature themes'],
+    },
+    dots: {
+        name: 'Dots',
+        description: 'Braille-like dot patterns',
+        characters: ' ⋅∘∙●',
+        bestFor: ['stipple effects', 'pointillism', 'dotted textures'],
+    },
+    blocks: {
+        name: 'Blocks',
+        description: 'Block-based characters for sharp edges',
+        characters: ' ░▒▓█',
+        bestFor: ['retro effects', 'pixel art', 'bold patterns'],
+    },
+    lines: {
+        name: 'Lines',
+        description: 'Line-based characters for directional effects',
+        characters: ' -─═╌│┃',
+        bestFor: ['rain effects', 'streaks', 'motion blur'],
+    },
+    stars: {
+        name: 'Stars',
+        description: 'Star and sparkle characters',
+        characters: ' ·✧✦✫✬✯★',
+        bestFor: ['sparkle effects', 'night sky', 'magical themes'],
+    },
+    nature: {
+        name: 'Nature',
+        description: 'Nature-themed decorative characters',
+        characters: ' .~≈∿⌇☘',
+        bestFor: ['decorative', 'themed effects', 'organic patterns'],
+    },
+    weather: {
+        name: 'Weather',
+        description: 'Weather-related symbols',
+        characters: ' ·.:*❄❅❆',
+        bestFor: ['snow effects', 'weather simulations', 'seasonal themes'],
+    },
+    binary: {
+        name: 'Binary',
+        description: 'Digital-style binary characters',
+        characters: ' 01',
+        bestFor: ['digital effects', 'matrix style', 'tech themes'],
+    },
+    math: {
+        name: 'Math',
+        description: 'Mathematical symbols',
+        characters: ' +-×÷=≠≈∞',
+        bestFor: ['abstract patterns', 'tech themes', 'decorative'],
+    },
+    // ==========================================================================
+    // GLASS-OPTIMIZED CHARACTER SETS
+    // Designed for subtle overlays on Glass components
+    // More characters = more visible gradations
+    // ==========================================================================
+    'glass-dots': {
+        name: 'Glass Dots',
+        description: 'Soft dot gradations for glass overlays',
+        characters: ' ·∘∙○•●',
+        bestFor: ['glass overlays', 'subtle backgrounds', 'mist effects'],
+    },
+    'glass-mist': {
+        name: 'Glass Mist',
+        description: 'Ethereal mist effect for glass',
+        characters: ' .·∙•◦○◉●',
+        bestFor: ['glass overlays', 'fog effects', 'ambient backgrounds'],
+    },
+    'glass-dust': {
+        name: 'Glass Dust',
+        description: 'Floating dust particles',
+        characters: ' ˙·∘°•◦○',
+        bestFor: ['glass overlays', 'particle effects', 'light scatter'],
+    },
+    'glass-soft': {
+        name: 'Glass Soft',
+        description: 'Soft block gradations for glass',
+        characters: ' ·░▒▓',
+        bestFor: ['glass overlays', 'soft gradients', 'frosted effect'],
+    },
+    'glass-sparkle': {
+        name: 'Glass Sparkle',
+        description: 'Subtle sparkles for glass',
+        characters: ' ·.✧✦✫★',
+        bestFor: ['glass overlays', 'highlight effects', 'magical themes'],
+    },
+    'glass-wave': {
+        name: 'Glass Wave',
+        description: 'Flowing wave patterns for glass',
+        characters: ' .~∼≈≋',
+        bestFor: ['glass overlays', 'water effects', 'flowing motion'],
+    },
+    'glass-organic': {
+        name: 'Glass Organic',
+        description: 'Natural, organic feel for glass',
+        characters: ' .·:;∘○◦•●',
+        bestFor: ['glass overlays', 'nature themes', 'grove aesthetic'],
+    },
+};
+/**
+ * Get a character set by name
+ */
+export function getCharacterSet(name) {
+    return CHARACTER_SETS[name];
+}
+/**
+ * Get just the characters string from a named set
+ */
+export function getCharacters(name) {
+    return CHARACTER_SETS[name]?.characters || CHARACTER_SETS.standard.characters;
+}
+/**
+ * List all available character set names
+ */
+export function getCharacterSetNames() {
+    return Object.keys(CHARACTER_SETS);
+}
+/**
+ * Create a custom character set
+ */
+export function createCharacterSet(name, characters, description = '', bestFor = []) {
+    return {
+        name,
+        description,
+        characters,
+        bestFor,
+    };
+}
+/**
+ * Validate that a character string is suitable for ASCII rendering
+ * (should start with space and have at least 2 characters)
+ */
+export function validateCharacterSet(characters) {
+    if (characters.length < 2)
+        return false;
+    if (characters[0] !== ' ')
+        return false;
+    return true;
+}
+/**
+ * Reverse a character set (for inverted brightness mapping)
+ */
+export function invertCharacters(characters) {
+    return characters.split('').reverse().join('');
+}

package/dist/characters.test.js

@@ -0,0 +1,115 @@
+/**
+ * Tests for character set utilities
+ */
+import { describe, it, expect } from 'vitest';
+import { CHARACTER_SETS, getCharacterSet, getCharacters, getCharacterSetNames, createCharacterSet, validateCharacterSet, invertCharacters, } from './characters';
+describe('CHARACTER_SETS', () => {
+    it('should contain standard character set', () => {
+        expect(CHARACTER_SETS.standard).toBeDefined();
+        expect(CHARACTER_SETS.standard.characters).toBe(' .:-=+*#%@');
+    });
+    it('should have all expected character sets', () => {
+        const expectedSets = [
+            'standard',
+            'dense',
+            'minimal',
+            'grove',
+            'dots',
+            'blocks',
+            'lines',
+            'stars',
+            'nature',
+            'weather',
+            'binary',
+            'math',
+        ];
+        for (const setName of expectedSets) {
+            expect(CHARACTER_SETS[setName]).toBeDefined();
+        }
+    });
+    it('should have all character sets start with space', () => {
+        for (const [name, set] of Object.entries(CHARACTER_SETS)) {
+            expect(set.characters[0]).toBe(' ');
+        }
+    });
+});
+describe('getCharacterSet', () => {
+    it('should return character set by name', () => {
+        const result = getCharacterSet('standard');
+        expect(result).toBeDefined();
+        expect(result?.name).toBe('Standard');
+        expect(result?.characters).toBe(' .:-=+*#%@');
+    });
+    it('should return undefined for unknown set', () => {
+        const result = getCharacterSet('nonexistent');
+        expect(result).toBeUndefined();
+    });
+});
+describe('getCharacters', () => {
+    it('should return characters string for valid set', () => {
+        expect(getCharacters('minimal')).toBe(' .:*#');
+        expect(getCharacters('blocks')).toBe(' ░▒▓█');
+    });
+    it('should return standard characters for unknown set', () => {
+        expect(getCharacters('nonexistent')).toBe(' .:-=+*#%@');
+    });
+});
+describe('getCharacterSetNames', () => {
+    it('should return array of all set names', () => {
+        const names = getCharacterSetNames();
+        expect(Array.isArray(names)).toBe(true);
+        expect(names).toContain('standard');
+        expect(names).toContain('minimal');
+        expect(names).toContain('blocks');
+    });
+    it('should return same count as CHARACTER_SETS keys', () => {
+        const names = getCharacterSetNames();
+        expect(names.length).toBe(Object.keys(CHARACTER_SETS).length);
+    });
+});
+describe('createCharacterSet', () => {
+    it('should create character set with all properties', () => {
+        const result = createCharacterSet('custom', ' abc', 'A custom set', ['testing']);
+        expect(result.name).toBe('custom');
+        expect(result.characters).toBe(' abc');
+        expect(result.description).toBe('A custom set');
+        expect(result.bestFor).toEqual(['testing']);
+    });
+    it('should use defaults for optional parameters', () => {
+        const result = createCharacterSet('minimal', ' xy');
+        expect(result.name).toBe('minimal');
+        expect(result.characters).toBe(' xy');
+        expect(result.description).toBe('');
+        expect(result.bestFor).toEqual([]);
+    });
+});
+describe('validateCharacterSet', () => {
+    it('should return true for valid character sets', () => {
+        expect(validateCharacterSet(' .:-=+*#%@')).toBe(true);
+        expect(validateCharacterSet(' ab')).toBe(true);
+        expect(validateCharacterSet(' ░▒▓█')).toBe(true);
+    });
+    it('should return false for too short sets', () => {
+        expect(validateCharacterSet('')).toBe(false);
+        expect(validateCharacterSet(' ')).toBe(false);
+    });
+    it('should return false for sets not starting with space', () => {
+        expect(validateCharacterSet('abc')).toBe(false);
+        expect(validateCharacterSet('.:-=')).toBe(false);
+    });
+});
+describe('invertCharacters', () => {
+    it('should reverse character string', () => {
+        expect(invertCharacters(' abc')).toBe('cba ');
+        expect(invertCharacters(' .:-=')).toBe('=-:. ');
+    });
+    it('should handle single character', () => {
+        expect(invertCharacters(' ')).toBe(' ');
+    });
+    it('should be reversible', () => {
+        const original = ' .:-=+*#%@';
+        const inverted = invertCharacters(original);
+        const restored = invertCharacters(inverted);
+        expect(restored).toBe(original);
+    });
+});