textmode.js 0.8.1 → 0.8.5

package/dist/types/Textmode.d.ts

@@ -24,18 +24,7 @@ export declare class Textmode {
      *     t.rect(10, 10);
      * });
      * ```
-     * @exampleAuthor
-     * <div style="display:flex;align-items:center;gap:0.75rem;flex-wrap:wrap;">
-     *   <img src="https://github.com/humanbydefinition.png" alt="@humanbydefinition avatar" width="72" height="72" style="border-radius:12px;box-shadow:0 2px 6px rgba(0,0,0,0.35);" />
-     *   <div style="display:flex;flex-direction:column;gap:0.25rem;">
-     *     <strong><a href="https://github.com/humanbydefinition">@humanbydefinition</a></strong>
-     *     <span style="font-size:0.95em;">
-     *       📷 <a href="https://instagram.com/humanbydefinition">Instagram</a>
-     *       &nbsp;•&nbsp; 🐘 <a href="https://mastodon.social/@humanbydefinition">Mastodon</a>
-     *       &nbsp;•&nbsp; 🦋 <a href="https://bsky.app/profile/humanbydefinition.bsky.social">BlueSky</a>
-     *     </span>
-     *   </div>
-     * </div>
+     * <!-- example-author: humanbydefinition -->
      */
     static create(opts?: TextmodeOptions): Textmodifier;
     /**

package/dist/types/exports/conversion.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/conversion';

package/dist/types/exports/filters.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/filters';

package/dist/types/exports/input.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/managers';

package/dist/types/exports/layering.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/layers';

package/dist/types/exports/loadables.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/loadables';

package/dist/types/exports/loading.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/loading';

package/dist/types/exports/plugins.d.ts

@@ -0,0 +1 @@
+export type { TextmodePlugin, TextmodePluginAPI, TextmodePluginHook, LayerLifecycleHook, LayerRenderHook, SetupLifecycleHook, } from '../textmode/managers/PluginManager';

package/dist/types/index.d.ts

@@ -16,7 +16,40 @@ export type { TextmodeFramebufferOptions } from './rendering/webgl';
  * but custom strategies can be registered via {@link TextmodeConversionManager.register}.
  */
 export * as conversion from './textmode/conversion';
-export type { TextmodePlugin, TextmodePluginAPI } from './textmode/managers/PluginManager';
+/**
+ * Plugin system types for extending textmode.js functionality.
+ *
+ * Plugins can:
+ * - Add methods to TextmodeLayer instances (e.g., `.synth()`)
+ * - Hook into the render lifecycle (pre/post draw, per-layer rendering)
+ * - React to layer creation and disposal events
+ * - Access the WebGL renderer, framebuffers, and other internals
+ *
+ * @example
+ * ```ts
+ * import type { TextmodePlugin, TextmodePluginAPI } from 'textmode.js/plugins';
+ *
+ * const MyPlugin: TextmodePlugin = {
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *   install(textmodifier, api) {
+ *     // Extend layers with a new method
+ *     api.extendLayer('myMethod', function(value) {
+ *       this.setPluginState('my-plugin', { value });
+ *     });
+ *
+ *     // Hook into layer rendering
+ *     api.registerLayerPreRenderHook((layer, ctx) => {
+ *       const state = layer.getPluginState('my-plugin');
+ *       if (state) {
+ *         // Render plugin content to layer.drawFramebuffer
+ *       }
+ *     });
+ *   }
+ * };
+ * ```
+ */
+export * as plugins from './textmode/managers/PluginManager';
 /**
  * All filter related modules and types.
  *
@@ -28,6 +61,7 @@ export type { TextmodePlugin, TextmodePluginAPI } from './textmode/managers/Plug
  */
 export * as filters from './textmode/filters';
 export { TextmodeErrorLevel } from './errors/ErrorHandler';
+export { GLShader as TextmodeShader } from './rendering/webgl/core/Shader';
 export { Textmode as textmode } from './Textmode';
 /** All loading screen related modules and types. */
 export * as loading from './textmode/loading';

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

@@ -81,7 +81,7 @@ export declare class GLFramebuffer implements IFramebuffer {
      * @ignore
      */
     private _updateMaterial;
-    $dispose(): void;
+    dispose(): void;
     /** Get the width of the framebuffer */
     get width(): number;
     /** Get the height of the framebuffer */

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

@@ -4,8 +4,13 @@ import { GLFramebuffer } from './Framebuffer';
  */
 export type UniformValue = number | boolean | number[] | number[][] | Float32Array | Int32Array | GLFramebuffer | WebGLTexture;
 /**
- * WebGL implementation of the shader abstraction.
- * Provides GPU shader program management with automatic uniform handling and minification support.
+ *
+ * Shader class for managing WebGL shader programs initialized via {@link Textmodifier.createFilterShader} or {@link Textmodifier.createShader}.
+ *
+ * Use shaders and set uniforms via {@link Textmodifier.shader}, {@link Textmodifier.setUniform}, and {@link Textmodifier.setUniforms}.
+ *
+ * With a shader active, the next {@link Textmodifier.rect} call will use the shader for rendering,
+ * and automatically unuse it afterwards.
  */
 export declare class GLShader {
     private _gl;
@@ -28,22 +33,31 @@ export declare class GLShader {
     private _createShader;
     /**
      * Use this shader program
+     * @ignore
      */
     $use(): void;
     /**
      * Reset texture unit counter and other state
      */
     private _resetState;
+    /**
+     * Set multiple uniform values at once.
+     * @param uniforms An object mapping uniform names to their values.
+     * @ignore
+     */
     $setUniforms(uniforms: Record<string, any>): void;
     /**
      * Set a single uniform value with automatic texture unit management and proper type detection
+     * @param name The name of the uniform variable in the shader
+     * @param value The value to set for the uniform
+     * @ignore
      */
     $setUniform(name: string, value: UniformValue): void;
     private _acquireTextureUnit;
     /**
      * Get the WebGL program
      */
-    get $glProgram(): WebGLProgram;
+    get program(): WebGLProgram;
     /**
      * Dispose of WebGL resources used by this shader.
      */

package/dist/types/rendering/webgl/core/interfaces/IFramebuffer.d.ts

@@ -89,15 +89,8 @@ export interface IFramebuffer {
     /**
      * Dispose of WebGL resources used by this framebuffer.
      *
-     * This releases:
-     * - The WebGL framebuffer object
-     * - All associated texture objects
-     * - Any cached pixel data
-     *
      * This method is idempotent and safe to call multiple times.
      * After disposal, the framebuffer should not be used for rendering.
-     *
-     * @ignore
      */
-    $dispose(): void;
+    dispose(): void;
 }

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

@@ -4,6 +4,7 @@
  */
 export declare class AnimationController {
     private _frameInterval;
+    private _targetFrameRate;
     private _animationFrameId;
     private _lastFrameTime;
     private _isLooping;
@@ -11,7 +12,9 @@ export declare class AnimationController {
     private _lastRenderTime;
     private _frameTimeHistory;
     private _frameTimeHistorySize;
+    private _deltaTime;
     private _frameCount;
+    private _millisStart;
     /**
      * Creates an AnimationController instance.
      * @param frameRateLimit Maximum frames per second. Defaults to 60.
@@ -55,6 +58,15 @@ export declare class AnimationController {
      * Get the current measured frame rate.
      */
     get $currentFrameRate(): number;
+    /**
+     * Get the target frame rate limit.
+     */
+    get $targetFrameRate(): number;
+    /**
+     * Set the target frame rate limit.
+     * @param value The new target frame rate in frames per second
+     */
+    set $targetFrameRate(value: number);
     /**
      * Get the current frame count.
      */
@@ -68,4 +80,31 @@ export declare class AnimationController {
      * Should be called on each render to track total frames rendered.
      */
     $incrementFrame(): void;
+    /**
+     * Get the number of milliseconds since the animation started.
+     * Returns 0 if the animation has not started yet.
+     */
+    get $millis(): number;
+    /**
+     * Set the elapsed milliseconds by adjusting the start time.
+     * This allows seeking/scrubbing in animations.
+     * @param value The new elapsed time in milliseconds
+     */
+    set $millis(value: number);
+    /**
+     * Get the number of seconds since the animation started.
+     * Returns 0 if the animation has not started yet.
+     */
+    get $secs(): number;
+    /**
+     * Set the elapsed seconds by adjusting the start time.
+     * This allows seeking/scrubbing in animations.
+     * @param value The new elapsed time in seconds
+     */
+    set $secs(value: number);
+    /**
+     * Get the time in milliseconds between the current frame and the last frame.
+     * Useful for frame-rate-independent animations.
+     */
+    get $deltaTime(): number;
 }

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

@@ -80,6 +80,8 @@ export declare class TextmodeGrid {
     get offsetY(): number;
     /**
      * Restores responsive sizing so subsequent `t.resizeCanvas` calls recompute cols/rows.
+     *
+     * A grid becomes non-responsive when either `cols` or `rows` is manually set.
      */
     responsive(): void;
     /**

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

@@ -7,8 +7,8 @@ import { AnimationController } from './AnimationController';
 import { MouseManager } from './managers/MouseManager';
 import { KeyboardManager } from './managers/KeyboardManager';
 import { TouchManager } from './managers/TouchManager';
+import { TextmodePluginManager } from './managers/PluginManager';
 import type { ITextmodifier } from './interfaces';
-import type { GLShader } from '../rendering';
 import type { TextmodeOptions } from './types';
 import type { IAnimationMixin } from './mixins/interfaces/IAnimationMixin';
 import type { IRenderingMixin } from './mixins/interfaces/IRenderingMixin';
@@ -17,8 +17,8 @@ import type { ITouchMixin } from './mixins/interfaces/ITouchMixin';
 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 { TextmodeLayer, TextmodeLayerManager } from './layers';
+import type { TextmodeFilterManager } from './filters';
 import type { FilterName, BuiltInFilterName, BuiltInFilterParams } from './filters';
 import { TextmodeConversionManager } from './conversion';
 declare const Textmodifier_base: {
@@ -40,23 +40,16 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     _touchManager: TouchManager;
     _keyboardManager: KeyboardManager;
     _loading: LoadingScreenManager;
-    _textmodeConversionShader: GLShader;
-    _presentShader: GLShader;
     _layerManager: TextmodeLayerManager;
-    _activeFont?: TextmodeFont;
-    _activeGrid?: TextmodeGrid;
-    _filterManager: TextmodeFilterManager;
+    _activeLayer?: TextmodeLayer;
     _conversionManager: TextmodeConversionManager;
-    private _globalFilterQueue;
-    private _preFilterFramebuffer;
-    private _postFilterFramebuffer;
-    private _pluginManager;
+    /** @ignore */
+    _pluginManager: TextmodePluginManager;
     private _destroyRequested;
     private _isRenderingFrame;
     private _isDisposed;
     private _setupComplete;
     private _setupCallback;
-    private _drawCallback;
     private _resizedCallback;
     private _windowResizeListener;
     private _resizeObserver?;
@@ -81,17 +74,16 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     private _performDestroy;
     filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
     filter(name: FilterName, params?: unknown): void;
+    draw(callback: () => void): void;
     loadFont(fontSource: string): Promise<TextmodeFont>;
     fontSize(size: number): void;
     inputGrid(target?: 'topmost' | TextmodeGrid): 'topmost' | TextmodeGrid | void;
     /**
      * Get the grid used for input coordinate mapping.
      * Returns the override grid/layer's grid if set, otherwise the topmost visible layer's grid.
-     * @ignore
      */
     private _getInputGrid;
     setup(callback: () => void | Promise<void>): Promise<void>;
-    draw(callback: () => void): void;
     windowResized(callback: () => void): void;
     get grid(): TextmodeGrid | undefined;
     get font(): TextmodeFont;
@@ -104,6 +96,7 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     get layers(): LayerManager;
     get filters(): TextmodeFilterManager;
     get conversions(): TextmodeConversionManager;
+    get isRenderingFrame(): boolean;
 }
 export interface Textmodifier extends IRenderingMixin, IAnimationMixin, IMouseMixin, ITouchMixin, IKeyboardMixin {
 }

package/dist/types/textmode/interfaces/ITextmodifier.d.ts

@@ -3,7 +3,6 @@ import type { TextmodeFont } from '../loadables/font';
 import type { TextmodeImage } from '../loadables/TextmodeImage';
 import type { TextmodeCanvas } from '../Canvas';
 import type { AnimationController } from '../AnimationController';
-import type { GLShader } from '../../rendering';
 import type { GLRenderer } from '../../rendering/webgl/core/Renderer';
 import type { MouseManager } from '../managers/MouseManager';
 import type { KeyboardManager } from '../managers/KeyboardManager';
@@ -15,6 +14,7 @@ import type { IMouseMixin } from '../mixins/interfaces/IMouseMixin';
 import type { IAnimationMixin } from '../mixins/interfaces/IAnimationMixin';
 import type { LoadingScreenManager } from '../loading/LoadingScreenManager';
 import type { TextmodeLayerManager } from '../layers';
+import type { TextmodeLayer } from '../layers/TextmodeLayer';
 import type { BuiltInFilterName, BuiltInFilterParams, TextmodeFilterManager, FilterName } from '../filters';
 import type { TextmodeConversionManager } from '../conversion';
 /**
@@ -38,22 +38,14 @@ export interface ITextmodifier extends IRenderingMixin, IAnimationMixin, IMouseM
     readonly _touchManager: TouchManager;
     /** Keyboard interaction manager @ignore */
     readonly _keyboardManager: KeyboardManager;
-    /** Shader used for converting pixels to textmode grid format @ignore */
-    readonly _textmodeConversionShader: GLShader;
-    /** Shader used for final presentation to the screen @ignore */
-    readonly _presentShader: GLShader;
     /** Loading screen manager for boot-time UX @ignore */
     readonly _loading: LoadingScreenManager;
     /** Conversion manager for image-to-ASCII conversion @ignore */
     readonly _conversionManager: TextmodeConversionManager;
-    /** Filter manager for applying post-processing effects @ignore */
-    readonly _filterManager: TextmodeFilterManager;
     /** Layer manager for handling multiple layers @ignore */
     readonly _layerManager: TextmodeLayerManager;
-    /** Active font based on layer, or loading screen font override @ignore */
-    _activeFont?: TextmodeFont;
-    /** Active grid based on layer currently being rendered @ignore */
-    _activeGrid?: TextmodeGrid;
+    /** Active layer currently being rendered @ignore */
+    _activeLayer?: TextmodeLayer;
     /** Main render method @ignore */
     $render(): void;
     /**
@@ -117,7 +109,7 @@ export interface ITextmodifier extends IRenderingMixin, IAnimationMixin, IMouseM
      * - The specific `TextmodeGrid` if locked
      *
      * @example
-     * ```javascript
+     * ```js
      * const t = textmode.create();
      *
      * // Add a UI layer on top
@@ -131,7 +123,7 @@ export interface ITextmodifier extends IRenderingMixin, IAnimationMixin, IMouseM
      *
      * t.draw(() => {
      *   // Mouse positions now always use base layer's grid
-     *   t.text(`Mouse: ${t.mouseX}, ${t.mouseY}`, 0, 0);
+     *   console.log(`Mouse: ${t.mouseX}, ${t.mouseY}`);
      * });
      *
      * // Switch back to responsive mode
@@ -446,4 +438,8 @@ export interface ITextmodifier extends IRenderingMixin, IAnimationMixin, IMouseM
      * ```
      */
     readonly loading: LoadingScreenManager;
+    /**
+     * Check if rendering is currently in progress for this frame.
+     */
+    readonly isRenderingFrame: boolean;
 }

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

@@ -5,12 +5,14 @@ import type { TextmodeLayerOptions } from './types';
 import type { ILayerManager } from './interfaces/ILayerManager';
 import type { TextmodeOptions } from '../types';
 import type { TextmodeGrid } from '../Grid';
+import { type FilterName, type BuiltInFilterName, type BuiltInFilterParams, TextmodeFilterManager } from '../filters';
 /**
  * Manages all user-defined layers within a Textmodifier in addition to the base layer.
  *
- * This manager is responsible for:
+ * Responsibilities:
  * - Managing the collection of user layers (add, remove, move, swap)
  * - Coordinating layer rendering and compositing
+ * - Owning the global post-processing pipeline (global filters + present to screen)
  *
  * The instance of this class can be accessed via {@link Textmodifier.layers}.
  *
@@ -19,13 +21,17 @@ import type { TextmodeGrid } from '../Grid';
 export declare class LayerManager implements ILayerManager {
     private readonly _textmodifier;
     private readonly _renderer;
-    private readonly _conversionShader;
     private readonly _compositor2D;
-    private _pendingLayers;
-    private _layers;
+    private readonly _filterManager;
+    private readonly _textmodeConversionShader;
+    private readonly _presentShader;
+    private readonly _layers;
     private readonly _baseLayer;
     private _isReady;
     private readonly _gridDimensionChangeCallbacks;
+    private _globalFilterQueue;
+    private _preFilterFramebuffer;
+    private _postFilterFramebuffer;
     /**
      * Create a new LayerManager.
      * @param textmodifier The Textmodifier instance this manager belongs to.
@@ -33,42 +39,64 @@ export declare class LayerManager implements ILayerManager {
      */
     constructor(textmodifier: Textmodifier, opts: TextmodeOptions);
     /**
-     * Initialize all pending layers and the compositor.
+     * Initialize all pending layers, compositor, and global post-processing resources.
      * @ignore
      */
     $initialize(): Promise<void>;
+    /**
+     * Queue a global filter to be applied after all layers are composited.
+     * Intended to be called by Textmodifier.filter().
+     * @ignore
+     */
+    $queueGlobalFilter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
+    $queueGlobalFilter(name: FilterName, params?: unknown): void;
+    /**
+     * Clear any queued global filters for the current frame.
+     * @ignore
+     */
+    $clearGlobalFilterQueue(): void;
     add(options?: TextmodeLayerOptions): TextmodeLayer;
     remove(layer: TextmodeLayer): void;
     move(layer: TextmodeLayer, newIndex: number): void;
     swap(layerA: TextmodeLayer, layerB: TextmodeLayer): void;
+    /**
+     * Remove and dispose all user layers (keeps base layer intact).
+     */
     clear(): void;
     /**
-     * Render all layers (base and user) and composite them to the target framebuffer.
+     * Render all layers (base and user) and composite them to the provided target framebuffer.
+     * This performs ONLY layer rendering + compositing (no global filters, no present).
+     *
      * @param targetFramebuffer The framebuffer to render the final composited result to.
-     * @param backgroundColor The background color as RGBA values (0-1 range).
      * @ignore
      */
-    $renderAndComposite(targetFramebuffer: GLFramebuffer, fallbackBaseDraw: () => void): void;
+    $renderAndComposite(targetFramebuffer: GLFramebuffer): void;
     /**
-     * Render all user layers to their respective framebuffers.
+     * Render, composite, apply global filters, present to screen, run post-draw hooks.
+     * This replaces the removed "Pass 3/4 + post hooks" section from Textmodifier.$render().
+     *
+     * @param fallbackBaseDraw Fallback draw callback for the base layer if it has no own draw callback.
+     * @ignore
      */
-    private _renderUserLayers;
+    $renderAndPresent(): void;
     /**
-     * Composite all layers onto the target framebuffer.
+     * Composite base + user layers onto the target framebuffer.
      */
     private _compositeLayers;
     /**
-     * Resize all layers and the compositor to match the current grid dimensions.
+     * Resize all layers, compositor, and global post-processing buffers.
      * @ignore
      */
     $resize(): void;
     /**
-     * Dispose of the layer manager, all layers, and the compositor.
+     * Dispose of the layer manager, all layers, compositor, and global post-processing resources.
      * @ignore
      */
     $dispose(): void;
     get all(): readonly TextmodeLayer[];
     get base(): TextmodeLayer;
+    get filters(): TextmodeFilterManager;
+    get resultFramebuffer(): GLFramebuffer;
     /**
      * Get the grid of the topmost visible layer.
      * Returns the topmost user layer's grid if any are visible, otherwise returns the base layer's grid.
@@ -91,16 +119,4 @@ export declare class LayerManager implements ILayerManager {
      * Initialize a single layer with required dependencies.
      */
     private _initializeLayer;
-    /**
-     * Remove a layer from a collection and dispose it.
-     */
-    private _removeFromCollection;
-    /**
-     * Move a layer to a new index within a collection.
-     */
-    private _moveInCollection;
-    /**
-     * Swap two layers within a collection.
-     */
-    private _swapInCollection;
 }

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

@@ -14,6 +14,10 @@ import type { ITextmodeLayer } from './interfaces/ITextmodeLayer';
  *
  * You can draw on each layer by providing a draw callback function,
  * like you would with the base layer's {@link Textmodifier.draw} method.
+ *
+ * Plugins can extend TextmodeLayer with additional methods using the plugin API's
+ * `extendLayer` function. For example, the `textmode-synth` plugin adds a `.synth()`
+ * method for hydra-like procedural generation.
  */
 export declare class TextmodeLayer implements ITextmodeLayer {
     /** @ignore */
@@ -40,8 +44,8 @@ export declare class TextmodeLayer implements ITextmodeLayer {
     private _rawAsciiFramebuffer?;
     private _pingPongBuffers?;
     private _drawCallback;
-    private _hasRenderableContent;
     private _filterQueue;
+    private _pluginState;
     /**
      * Create a new TextmodeLayer with the given options.
      * @param options Layer configuration options.
@@ -54,18 +58,6 @@ export declare class TextmodeLayer implements ITextmodeLayer {
      * @ignore
      */
     $attachDependencies(deps: LayerDependencies): Promise<void>;
-    /**
-     * Return true when this layer has a user-provided draw callback.
-     * @ignore
-     */
-    $hasDraw(): boolean;
-    /**
-     * Run the layer's draw callback in the calling context. This does NOT
-     * manage framebuffer binding; the caller must ensure the correct
-     * framebuffer is bound before invoking this.
-     * @ignore
-     */
-    $runDraw(textmodifier: Textmodifier): void;
     draw(callback: () => void): void;
     show(): void;
     hide(): void;
@@ -78,25 +70,11 @@ export declare class TextmodeLayer implements ITextmodeLayer {
     rotateZ(z?: number): number | void;
     filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
     filter(name: FilterName, params?: unknown): void;
-    /** Get or set the font size for this layer's font. */
-    fontSize(size?: number): number | void;
-    /**
-     * Load a font into this layer from a URL/path or reuse an existing {@link TextmodeFont} instance.
-     * Creates a new font instance for this layer and loads the font data when a string source is provided.
-     *
-     * @param fontSource The URL or path to the font file.
-     * @returns The loaded TextmodeFont instance.
-     *
-     * @example
-     * ```js
-     * const layer = t.layers.add();
-     *
-     * t.setup(async () => {
-     *   // Load a custom font for this layer
-     *   await layer.loadFont('./fonts/custom.ttf');
-     * });
-     * ```
-     */
+    setPluginState<T>(pluginName: string, state: T): void;
+    getPluginState<T>(pluginName: string): T | undefined;
+    hasPluginState(pluginName: string): boolean;
+    deletePluginState(pluginName: string): boolean;
+    fontSize(size?: number): void;
     loadFont(fontSource: string | TextmodeFont): Promise<TextmodeFont>;
     /**
      * Render the layer's content into its ASCII framebuffer.
@@ -104,9 +82,7 @@ export declare class TextmodeLayer implements ITextmodeLayer {
      * @param conversionShader The shader used for conversion.
      * @ignore
      */
-    $render(textmodifier: Textmodifier, conversionShader: GLShader, options?: {
-        fallbackDraw?: () => void;
-    }): void;
+    $render(textmodifier: Textmodifier, conversionShader: GLShader): void;
     /**
      * Resize the layer's framebuffers to match the given grid dimensions.
      * @param grid The TextmodeGrid instance.
@@ -118,29 +94,12 @@ export declare class TextmodeLayer implements ITextmodeLayer {
      * @ignore
      */
     $dispose(): void;
-    /**
-     * Get the texture containing the rendered textmode output for this layer.
-     */
     get texture(): WebGLTexture | undefined;
-    /**
-     * Get the grid associated with this layer.
-     */
     get grid(): TextmodeGrid | undefined;
     get font(): TextmodeFont;
     get width(): number;
     get height(): number;
-    /**
-     * Return true when this layer has renderable content.
-     * @ignore
-     */
-    get $hasRenderableContent(): boolean;
-    /**
-     * Get the framebuffer used for drawing operations on this layer.
-     */
     get drawFramebuffer(): GLFramebuffer | undefined;
-    /**
-     * Get the framebuffer containing the rendered textmode output for this layer.
-     */
     get asciiFramebuffer(): GLFramebuffer | undefined;
     private _syncGridToFont;
 }

package/dist/types/textmode/layers/interfaces/ILayerManager.d.ts

@@ -1,6 +1,7 @@
 import type { TextmodeLayer } from '../TextmodeLayer';
 import type { TextmodeLayerOptions } from '../types';
 import type { TextmodeGrid } from '../../Grid';
+import type { GLFramebuffer } from '../../../rendering/webgl/core/Framebuffer';
 export interface ILayerManager {
     /**
      * Get all user layers as a readonly array.
@@ -11,6 +12,10 @@ export interface ILayerManager {
      * This layer represents the main drawing content before any user layers are composited.
      */
     readonly base: TextmodeLayer;
+    /**
+     * The framebuffer containing the final composited result after all layers and filters have been applied.
+     */
+    readonly resultFramebuffer: GLFramebuffer;
     /**
      * Add a new layer to the manager.
      * @param options Layer configuration options.