textmode.js 0.7.0-beta.2 → 0.7.0

package/dist/types/index.d.ts

@@ -9,8 +9,8 @@ export type { TextmodeFramebufferOptions } from './rendering/webgl';
 export { registerConversionStrategy, unregisterConversionStrategy, getConversionStrategy, } from './textmode/conversion';
 export type { TextmodeConversionStrategy, TextmodeConversionContext, TextmodeConversionMode, } from './textmode/conversion';
 export type { TextmodePlugin, TextmodePluginAPI, } from './textmode/managers/PluginManager';
-export { FilterRegistry } from './textmode/layers';
-export type { FilterName, BuiltInFilterName, BuiltInFilterParams, FilterContext, TextmodeFilterStrategy, } from './textmode/layers';
+/** All filter related modules and types. */
+export * as filters from './textmode/filters';
 export { TextmodeErrorLevel } from './errors/ErrorHandler';
 export { Textmode as textmode } from './Textmode';
 /** All loading screen related modules and types. */

package/dist/types/rendering/webgl/core/Framebuffer.d.ts

@@ -21,7 +21,14 @@ export type TextmodeFramebufferOptions = {
     width?: number;
     /** Height of the framebuffer in grid cells */
     height?: number;
-    /** Number of color attachments (1-8) */
+    /**
+     * Number of color attachments *(1-8)*
+     *
+     * Defaults to 3 for textmode framebuffers *(character/transform data, primary color, secondary color)*.
+     * You probably do not want to go below 3 for textmode rendering, otherwise rendering will not function correctly.
+     *
+     * Going above 3 is only recommended for advanced use cases involving custom shaders that utilize additional attachments.
+     */
     attachments?: number;
 };
 /**

package/dist/types/textmode/Textmodifier.d.ts

@@ -20,6 +20,8 @@ import type { IMouseMixin } from './mixins/interfaces/IMouseMixin';
 import { LoadingScreenManager } from './loading/LoadingScreenManager';
 import { LayerManager } from './layers/LayerManager';
 import type { TextmodeLayerManager } from './layers';
+import { TextmodeFilterManager } from './filters';
+import type { FilterName, BuiltInFilterName, BuiltInFilterParams } from './filters';
 declare const Textmodifier_base: {
     new (): {};
 };
@@ -46,6 +48,11 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     _textmodeFramebuffer: GLFramebuffer;
     _presentShader: GLShader;
     _layerManager: TextmodeLayerManager;
+    /** @internal */
+    _filterManager: TextmodeFilterManager;
+    private _globalFilterQueue;
+    private _preFilterFramebuffer;
+    private _postFilterFramebuffer;
     private _pluginManager;
     private _destroyRequested;
     private _isRenderingFrame;
@@ -88,6 +95,64 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     get overlay(): TextmodeImage | undefined;
     get loading(): LoadingScreenManager;
     get layers(): LayerManager;
+    /**
+     * Access the filter manager for this Textmodifier instance.
+     *
+     * Use this to register custom filters that can be applied both globally
+     * (via {@link filter}) and on individual layers (via {@link TextmodeLayer.filter}).
+     * Filters only need to be registered once and are available everywhere.
+     *
+     * @example
+     * ```typescript
+     * // Register a custom filter once
+     * await t.filters.register('vignette', vignetteShader, {
+     *     u_intensity: ['intensity', 0.5]
+     * });
+     *
+     * t.draw(() => {
+     *     t.background(0);
+     *     t.char('A');
+     *     t.rect(10, 10);
+     *
+     *     // Apply filter globally to final output
+     *     t.filter('vignette', { intensity: 0.8 });
+     *
+     *     // Or apply to a specific layer
+     *     t.layers.base.filter('vignette', 0.5);
+     * });
+     * ```
+     */
+    get filters(): TextmodeFilterManager;
+    /**
+     * Apply a filter to the final composited output.
+     *
+     * Filters are applied after all layers are composited but before
+     * the result is presented to the canvas. Multiple filters can be
+     * queued per frame and will be applied in order.
+     *
+     * @param name The name of the filter to apply (built-in or custom)
+     * @param params Optional parameters for the filter
+     *
+     * @example
+     * ```typescript
+     * t.draw(() => {
+     *     t.background(0);
+     *     t.charColor(255);
+     *     t.char('A');
+     *     t.rect(10, 10);
+     *
+     *     // Apply built-in filters
+     *     t.filter('grayscale', 0.5);
+     *     t.filter('invert');
+     *
+     *     // Chain multiple filters
+     *     t.filter('sepia', { amount: 0.3 });
+     *     t.filter('threshold', 0.5);
+     * });
+     * ```
+     */
+    filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
+    filter(name: FilterName, params?: unknown): void;
     $registerSource(source: TextmodeSource): void;
 }
 export interface Textmodifier extends IRenderingMixin, IFontMixin, IAnimationMixin, IMouseMixin, ITouchMixin, IKeyboardMixin {

package/dist/types/textmode/filters/FilterManager.d.ts

@@ -0,0 +1,137 @@
+import type { GLRenderer, GLShader, GLFramebuffer } from '../../rendering';
+import type { QueuedFilter, FilterName } from './types';
+/**
+ * Manages filter registration, shader compilation, and filter chain application.
+ *
+ * This class provides:
+ * - A registry for custom and built-in filter strategies
+ * - Lazy shader compilation and caching
+ * - Ping-pong rendering for efficient multi-filter chains
+ *
+ * Used both for layer-level filters and global post-processing filters.
+ *
+ * @example
+ * ```typescript
+ * // Register a custom filter
+ * await t.filters.register('brightness', brightnessShader, {
+ *     u_amount: ['amount', 1.0]
+ * });
+ *
+ * // Use the filter globally
+ * t.filter('brightness', 1.5);
+ *
+ * // Or on a layer
+ * t.layers.base.filter('brightness', { amount: 0.8 });
+ * ```
+ */
+export declare class TextmodeFilterManager {
+    private readonly _renderer;
+    private readonly _shaderCache;
+    private readonly _copyShader;
+    private _pingPongBuffers;
+    private _isInitialized;
+    private _filterRegistry;
+    /**
+     * Create a new TextmodeFilterManager.
+     * @param renderer The WebGL renderer instance
+     * @ignore
+     */
+    constructor(renderer: GLRenderer);
+    /**
+     * Register a custom filter with the given ID, shader, and uniform definitions.
+     *
+     * @param id Unique filter identifier
+     * @param shader Pre-compiled GLShader, fragment shader source string, or path to a .frag/.glsl file
+     * @param uniformDefs Maps uniform names to [paramName, defaultValue] tuples
+     *
+     * @example
+     * ```typescript
+     * // Register with inline shader source
+     * await t.filters.register('blur', blurFragSource, {
+     *     u_radius: ['radius', 5.0],
+     *     u_direction: ['direction', [1.0, 0.0]]
+     * });
+     *
+     * // Register with file path
+     * await t.filters.register('vignette', './vignette.frag', {
+     *     u_intensity: ['intensity', 0.5]
+     * });
+     *
+     * // Register with pre-compiled shader
+     * const shader = await t.createShader(vertSrc, fragSrc);
+     * await t.filters.register('custom', shader, {});
+     * ```
+     */
+    register(id: FilterName, shader: GLShader | string, uniformDefs?: Record<string, [paramName: string, defaultValue: unknown]>): Promise<void>;
+    /**
+     * Unregister a filter by its ID.
+     *
+     * @param id The filter ID to unregister
+     * @returns true if the filter was unregistered, false if it wasn't found
+     */
+    unregister(id: FilterName): boolean;
+    /**
+     * Check if a filter with the given ID is registered.
+     *
+     * @param id The filter ID to check
+     * @returns true if the filter exists
+     */
+    has(id: FilterName): boolean;
+    /**
+     * Initialize ping-pong buffers for filter chain processing.
+     * @param width Buffer width in pixels
+     * @param height Buffer height in pixels
+     * @ignore
+     */
+    $initialize(width: number, height: number): void;
+    /**
+     * Apply a chain of filters to the source texture, outputting to target.
+     * Uses the manager's internal ping-pong buffers.
+     *
+     * @param sourceTexture The input texture
+     * @param targetFramebuffer The output framebuffer
+     * @param filters The queue of filters to apply in order
+     * @param width Framebuffer width
+     * @param height Framebuffer height
+     * @ignore
+     */
+    $applyFilters(sourceTexture: WebGLTexture, targetFramebuffer: GLFramebuffer, filters: QueuedFilter[], width: number, height: number): void;
+    /**
+     * Apply a chain of filters using external ping-pong buffers.
+     * This allows sharing the filter registry while using different buffer sizes
+     * (e.g., layer filters at grid dimensions vs global filters at canvas dimensions).
+     *
+     * @param sourceTexture The input texture
+     * @param targetFramebuffer The output framebuffer
+     * @param filters The queue of filters to apply in order
+     * @param width Framebuffer width
+     * @param height Framebuffer height
+     * @param pingPongBuffers External ping-pong buffers to use
+     * @ignore
+     */
+    $applyFiltersWithBuffers(sourceTexture: WebGLTexture, targetFramebuffer: GLFramebuffer, filters: QueuedFilter[], width: number, height: number, pingPongBuffers: [GLFramebuffer, GLFramebuffer]): void;
+    /**
+     * Apply a single filter pass with explicit source buffer.
+     */
+    private _applyFilterWithBuffer;
+    /**
+     * Get or create a cached shader for the given filter.
+     */
+    private _getOrCreateShader;
+    /**
+     * Copy a texture to a framebuffer using the copy shader.
+     */
+    private _copyTexture;
+    /**
+     * Resize the ping-pong buffers.
+     * @param width New width in pixels
+     * @param height New height in pixels
+     * @ignore
+     */
+    $resize(width: number, height: number): void;
+    /**
+     * Dispose of all resources.
+     * @ignore
+     */
+    $dispose(): void;
+}

package/dist/types/textmode/{layers/filters → filters}/FilterRegistry.d.ts

@@ -1,28 +1,21 @@
-import type { GLRenderer, GLShader } from '../../../rendering';
+import type { GLRenderer, GLShader } from '../../rendering';
 import type { TextmodeFilterStrategy, FilterName } from './types';
 /**
  * Instance-based registry for filter strategies.
  *
- * Each {@link Textmodifier} instance has its own FilterRegistry, allowing
- * filters to be scoped to a specific instance rather than registered globally.
- *
- * Access via `t.layers.filters`.
+ * Each {@link FilterManager} instance has its own FilterRegistry, allowing
+ * filters to be scoped to a specific context rather than registered globally.
  *
  * @example
  * ```typescript
  * // Define a simple filter with the declarative API
- * t.layers.filters.define('blur', blurShader, { radius: 5.0 });
- *
- * // Register a custom filter strategy
- * t.layers.filters.register({
- *     id: 'custom',
- *     createShader(ctx) { ... },
- *     createUniforms(params, ctx) { ... }
- * });
+ * t.filters.register('blur', blurShader, { radius: 5.0 });
  *
  * // Use the filter
- * t.layers.base.filter('blur', { radius: 10 });
+ * t.filter('blur', { radius: 10 });
  * ```
+ *
+ * @ignore
  */
 export declare class FilterRegistry {
     private readonly _renderer;
@@ -31,7 +24,6 @@ export declare class FilterRegistry {
     /**
      * Create a new FilterRegistry.
      * @param renderer The WebGL renderer instance
-     * @internal
      */
     constructor(renderer: GLRenderer);
     /**
@@ -48,14 +40,14 @@ export declare class FilterRegistry {
      * ```typescript
      * // With pre-compiled shader (recommended for add-ons)
      * const shader = await t.createShader(vertSrc, fragSrc);
-     * t.layers.filters.define('brightness', shader, { u_amount: ['amount', 1.0] });
+     * t.filters.register('brightness', shader, { u_amount: ['amount', 1.0] });
      *
      * // With a path to a fragment shader file
-     * await t.layers.filters.define('brightness', './brightness.frag', { u_amount: ['amount', 1.0] });
+     * await t.filters.register('brightness', './brightness.frag', { u_amount: ['amount', 1.0] });
      *
      * // Usage:
-     * t.layers.base.filter('brightness', 1.5);
-     * t.layers.base.filter('brightness', { amount: 1.5 });
+     * t.filter('brightness', 1.5);
+     * t.filter('brightness', { amount: 1.5 });
      * ```
      */
     $register(id: FilterName, shader: GLShader | string, defs?: Record<string, [paramName: string, defaultValue: unknown]>): Promise<void>;

package/dist/types/textmode/filters/index.d.ts

@@ -0,0 +1,3 @@
+export type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter, FilterContext, TextmodeFilterStrategy } from './types';
+export { FilterRegistry } from './FilterRegistry';
+export { TextmodeFilterManager } from './FilterManager';

package/dist/types/textmode/{layers/filters → filters}/types.d.ts

@@ -1,13 +1,13 @@
-import type { GLShader } from '../../../rendering';
-import type { GLRenderer } from '../../../rendering/webgl/core/Renderer';
+import type { GLShader } from '../../rendering';
+import type { GLRenderer } from '../../rendering/webgl/core/Renderer';
 /**
  * Built-in filter names provided by textmode.js
  */
-export type BuiltInFilterName = 'invert' | 'grayscale' | 'sepia' | 'hueRotate' | 'saturate' | 'brightness' | 'contrast' | 'threshold' | 'chromaticAberration' | 'pixelate';
+export type BuiltInFilterName = 'invert' | 'grayscale' | 'sepia' | 'threshold';
 /**
  * Filter name type that allows both built-in and custom filter names
  */
-export type FilterName = BuiltInFilterName | (string & {});
+export type FilterName = BuiltInFilterName | string;
 /**
  * Filter parameter types for built-in filters.
  *
@@ -25,39 +25,14 @@ export interface BuiltInFilterParams {
     sepia: number | {
         amount?: number;
     } | void;
-    /** Rotates hue. Angle in degrees */
-    hueRotate: number | {
-        angle?: number;
-    };
-    /** Adjusts saturation. Amount: 1 = normal, >1 = more saturated */
-    saturate: number | {
-        amount?: number;
-    };
-    /** Adjusts brightness. Amount: 1 = normal, >1 = brighter */
-    brightness: number | {
-        amount?: number;
-    };
-    /** Adjusts contrast. Amount: 1 = normal, >1 = more contrast */
-    contrast: number | {
-        amount?: number;
-    };
-    /** Black/white threshold. Threshold: 0-1 */
+    /** Black/white threshold. Threshold: 0-1, default 0.5 */
     threshold: number | {
         threshold?: number;
     };
-    /** Chromatic aberration (color fringing) */
-    chromaticAberration: number | {
-        amount?: number;
-        direction?: [number, number];
-    };
-    /** Pixelate effect. PixelSize in pixels */
-    pixelate: number | {
-        pixelSize?: number;
-    };
 }
 /**
  * A queued filter operation to be applied during rendering
- * @internal
+ * @ignore
  */
 export interface QueuedFilter {
     name: FilterName;
@@ -65,6 +40,7 @@ export interface QueuedFilter {
 }
 /**
  * Context provided to filter strategies for shader creation
+ * @ignore
  */
 export interface FilterContext {
     /** The WebGL renderer instance */
@@ -78,29 +54,7 @@ export interface FilterContext {
 }
 /**
  * Interface for implementing custom filter strategies.
- *
- * Custom filters can be registered using {@link registerFilterStrategy} and will
- * be available for use with `layer.filter('myFilter', params)`.
- *
- * @example
- * ```typescript
- * import { registerFilterStrategy } from 'textmode.js';
- *
- * const myCustomFilter: TextmodeFilterStrategy = {
- *     id: 'myFilter',
- *     createShader(context) {
- *         return context.renderer.$createShader(vertexSource, fragmentSource);
- *     },
- *     createUniforms(params, context) {
- *         return {
- *             u_intensity: params?.intensity ?? 1.0,
- *             u_resolution: [context.width, context.height]
- *         };
- *     }
- * };
- *
- * registerFilterStrategy(myCustomFilter);
- * ```
+ * @ignore
  */
 export interface TextmodeFilterStrategy {
     /** Unique identifier for this filter */

package/dist/types/textmode/layers/LayerManager.d.ts

@@ -1,9 +1,8 @@
 import type { GLFramebuffer } from '../../rendering';
 import type { Textmodifier } from '../Textmodifier';
 import { TextmodeLayer } from './TextmodeLayer';
-import { LayerFilterManager } from './filters';
 import type { TextmodeLayerOptions } from './types';
-import type { ILayerManager } from './ILayerManager';
+import type { ILayerManager } from './interfaces/ILayerManager';
 /**
  * Manages all user-defined layers within a Textmodifier instance.
  *
@@ -13,20 +12,19 @@ import type { ILayerManager } from './ILayerManager';
  *
  * The instance of this class can be accessed via {@link Textmodifier.layers}.
  *
- * The base layer at {@link Textmodifier.baseLayer} is not part of this manager's
- * public layer stack, but is instead managed internally.
+ * The {@link base} layer is not part of the public layer stack, but is instead managed internally.
  */
 export declare class LayerManager implements ILayerManager {
     private readonly _textmodifier;
     private readonly _renderer;
     private readonly _conversionShader;
     private readonly _compositor2D;
-    private readonly _filterManager;
     private readonly _pendingLayers;
     private readonly _layers;
     private readonly _baseLayer;
     private _baseFramebuffer;
     private _baseRawFramebuffer;
+    private _layerPingPongBuffers;
     private _isReady;
     /**
      * Create a new LayerManager.
@@ -70,29 +68,6 @@ export declare class LayerManager implements ILayerManager {
     $dispose(): void;
     get all(): readonly TextmodeLayer[];
     get base(): TextmodeLayer;
-    /**
-     * Access the filter registry for this Textmodifier instance.
-     *
-     * Use this to define or register custom filters scoped to this instance.
-     *
-     * @example
-     * ```typescript
-     * // Define a filter using the simplified API
-     * const shader = await t.createShader(vertSrc, fragSrc);
-     * t.layers.filters.define('brightness', shader, { amount: 1.0 });
-     *
-     * // Register a custom filter strategy
-     * t.layers.filters.register({
-     *     id: 'custom',
-     *     createShader() { return shader; },
-     *     createUniforms(params, ctx) { return { ... }; }
-     * });
-     *
-     * // Use the filter
-     * t.layers.base.filter('brightness', 1.5);
-     * ```
-     */
-    get filters(): LayerFilterManager;
     /**
      * Initialize a single layer with required dependencies.
      */

package/dist/types/textmode/layers/TextmodeLayer.d.ts

@@ -2,7 +2,8 @@ import type { GLFramebuffer, GLShader } from '../../rendering';
 import type { TextmodeGrid } from '../Grid';
 import type { Textmodifier } from '../Textmodifier';
 import type { TextmodeLayerBlendMode, TextmodeLayerOptions, LayerDependencies } from './types';
-import type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter } from './filters';
+import type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter } from '../filters';
+import type { ITextmodeLayer } from './interfaces/ITextmodeLayer';
 /**
  * A single layer within a multi-layered textmode rendering context.
  *
@@ -12,11 +13,8 @@ import type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter }
  *
  * You can draw on each layer by providing a draw callback function,
  * like you would with the base layer's {@link Textmodifier.draw} method.
- *
- * The base layer, which is always present at the bottom of the layer stack,
- * can be accessed via {@link Textmodifier.baseLayer}.
  */
-export declare class TextmodeLayer {
+export declare class TextmodeLayer implements ITextmodeLayer {
     /** @ignore */
     $visible: boolean;
     /** @ignore */
@@ -59,86 +57,15 @@ export declare class TextmodeLayer {
      * @ignore
      */
     $runDraw(textmodifier: Textmodifier): void;
-    /**
-     * Define this layers draw callback.
-     * @param callback The function to call when drawing this layer.
-     */
     draw(callback: () => void): void;
-    /**
-     * Show this layer for rendering.
-     */
     show(): void;
-    /**
-     * Hide this layer from rendering.
-     */
     hide(): void;
-    /**
-     * Define or retrieve the layer's opacity.
-     * @param opacity The opacity value to set (between 0 and 1).
-     * @returns The current opacity if no parameter is provided.
-     */
     opacity(opacity?: number): number | void;
-    /**
-     * Set or get the layer's blend mode.
-     * @param mode The blend mode to set.
-     * @returns The current blend mode if no parameter is provided.
-     */
     blendMode(mode: TextmodeLayerBlendMode): TextmodeLayerBlendMode | void;
-    /**
-     * Set or get the layer's offset in pixels.
-     * @param x The x offset in pixels.
-     * @param y The y offset in pixels.
-     * @returns The current offset if no parameters are provided.
-     */
     offset(x?: number, y?: number): {
         x: number;
         y: number;
     } | void;
-    /**
-     * Apply a post-processing filter to this layer's rendered output.
-     *
-     * Filters are applied after ASCII conversion in the order they are called.
-     * Call this method within your layer's draw callback to apply effects.
-     *
-     * @param name The name of the filter to apply (built-in or custom registered filter)
-     * @param params Optional parameters for the filter
-     *
-     * @example
-     * ```typescript
-     * layer.draw(function() {
-     *     // Drawing commands...
-     *     this.rect(10, 10);
-     *
-     *     // Apply filters in sequence
-     *     layer.filter('invert');
-     *     layer.filter('hueRotate', 45);
-     *     layer.filter('glow', { intensity: 0.8, radius: 10 });
-     *     layer.filter('crt');
-     * });
-     * ```
-     *
-     * **Color Adjustment Filters:**
-     * - `'invert'` - Inverts all colors
-     * - `'grayscale'` - Converts to grayscale (param: amount 0-1, default 1)
-     * - `'sepia'` - Applies sepia tone (param: amount 0-1, default 1)
-     * - `'hueRotate'` - Rotates hue (param: angle in degrees)
-     * - `'saturate'` - Adjusts saturation (param: amount, 1 = normal)
-     * - `'brightness'` - Adjusts brightness (param: amount, 1 = normal)
-     * - `'contrast'` - Adjusts contrast (param: amount, 1 = normal)
-     * - `'threshold'` - Black/white threshold (param: threshold 0-1)
-     *
-     * **Post-Processing Effects:**
-     * - `'blur'` - Gaussian blur (param: radius in pixels)
-     * - `'glow'` - Bloom/glow effect (params: intensity, radius, threshold)
-     * - `'chromaticAberration'` - RGB color fringing (param: amount, direction)
-     * - `'scanlines'` - Horizontal scanlines (params: spacing, intensity, offset)
-     * - `'crt'` - Full CRT monitor effect (params: curvature, scanlineIntensity, vignetteIntensity, brightness)
-     * - `'vignette'` - Darkened edges (params: intensity, softness)
-     * - `'pixelate'` - Pixelation effect (param: pixelSize)
-     * - `'noise'` - Random noise overlay (params: intensity, seed)
-     *
-     * Custom filters can be registered using {@link registerFilterStrategy}.
-     */
     filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
     filter(name: FilterName, params?: unknown): void;
     /**
@@ -165,29 +92,14 @@ export declare class TextmodeLayer {
      * @ignore
      */
     $dispose(): void;
-    /**
-     * Returns the WebGL texture of the final ASCII framebuffer.
-     * If the layer is not yet initialized, returns undefined.
-     */
     get texture(): WebGLTexture | undefined;
-    /**
-     * Returns the width of the final ASCII framebuffer in pixels.
-     * If the layer is not yet initialized, returns 0.
-     */
     get width(): number;
-    /**
-     * Returns the height of the final ASCII framebuffer in pixels.
-     * If the layer is not yet initialized, returns 0.
-     */
     get height(): number;
     /**
      * Return true when this layer has renderable content.
      * @ignore
      */
     get $hasRenderableContent(): boolean;
-    /**
-     * Returns the draw framebuffer for this layer. If the layer is not yet initialized, returns undefined.
-     */
     get drawFramebuffer(): GLFramebuffer | undefined;
     private _initializeFramebuffers;
 }

package/dist/types/textmode/layers/filters/index.d.ts

@@ -1,3 +1,6 @@
-export type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter, FilterContext, TextmodeFilterStrategy } from './types';
-export { FilterRegistry } from './FilterRegistry';
-export { LayerFilterManager } from './LayerFilterManager';
+export type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter, FilterContext, TextmodeFilterStrategy } from '../../filters';
+export { FilterRegistry, TextmodeFilterManager as FilterManager } from '../../filters';
+/**
+ * @deprecated Use `FilterManager` instead. This alias exists for backwards compatibility.
+ */
+export { TextmodeFilterManager as LayerFilterManager } from '../../filters';

package/dist/types/textmode/layers/index.d.ts

@@ -2,5 +2,3 @@ export { TextmodeLayer } from './TextmodeLayer';
 export { LayerManager as TextmodeLayerManager } from './LayerManager';
 export { Layer2DCompositor as LayerCompositor } from './Layer2DCompositor';
 export type { TextmodeLayerOptions, TextmodeLayerBlendMode } from './types';
-export { FilterRegistry } from './filters';
-export type { FilterName, BuiltInFilterName, BuiltInFilterParams, FilterContext, TextmodeFilterStrategy } from './filters';

package/dist/types/textmode/layers/{ILayerManager.d.ts → interfaces/ILayerManager.d.ts}

@@ -1,5 +1,5 @@
-import type { TextmodeLayer } from './TextmodeLayer';
-import type { TextmodeLayerOptions } from './types';
+import type { TextmodeLayer } from '../TextmodeLayer';
+import type { TextmodeLayerOptions } from '../types';
 export interface ILayerManager {
     /**
      * Get all user layers as a readonly array.