textmode.js 0.8.1 → 0.9.0-beta.2

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

@@ -1,16 +1,19 @@
 import type { GLFramebuffer } from '../../rendering';
 import type { Textmodifier } from '../Textmodifier';
 import { TextmodeLayer } from './TextmodeLayer';
+import { Camera3D } from './Camera3D';
 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 +22,20 @@ 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 _compositor3D;
+    private readonly _filterManager;
+    private readonly _textmodeConversionShader;
+    private readonly _presentShader;
+    private readonly _camera3D;
+    private readonly _layers;
     private readonly _baseLayer;
     private _isReady;
+    private _renderMode;
     private readonly _gridDimensionChangeCallbacks;
+    private _globalFilterQueue;
+    private _preFilterFramebuffer;
+    private _postFilterFramebuffer;
     /**
      * Create a new LayerManager.
      * @param textmodifier The Textmodifier instance this manager belongs to.
@@ -33,42 +43,89 @@ 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().
+     */
+    $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;
+    mode(mode?: '2d' | '3d'): '2d' | '3d';
+    rotation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    translation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    zoom(zoom?: number): number | 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.
+     * Composite base + user layers in 3D mode using voxel raymarching.
+     * In 3D mode, MRT framebuffers are stacked vertically and rendered through the 3D shader.
+     */
+    private _compositeLayers3D;
+    /**
+     * 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 the 3D camera used for voxel rendering.
+     *
+     * The camera provides fine-grained control over rotation, translation, and zoom
+     * in 3D mode. For simple use cases, you can use the `rotation()`, `translation()`,
+     * and `zoom()` methods directly on the layer manager instead.
+     *
+     * @example
+     * ```ts
+     * // Direct camera access for advanced control
+     * const camera = t.layers.camera;
+     * camera.rotateY(camera.rotateY() + 1);
+     *
+     * // Reset camera to defaults
+     * t.layers.camera.reset();
+     * ```
+     */
+    get camera(): Camera3D;
     /**
      * 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 +148,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,35 +70,20 @@ 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.
      * @param textmodifier The Textmodifier instance.
      * @param conversionShader The shader used for conversion.
+     * @param mode The rendering mode, either '2d' or '3d'.
      * @ignore
      */
-    $render(textmodifier: Textmodifier, conversionShader: GLShader, options?: {
-        fallbackDraw?: () => void;
-    }): void;
+    $render(textmodifier: Textmodifier, conversionShader: GLShader, mode: '2d' | '3d'): void;
     /**
      * Resize the layer's framebuffers to match the given grid dimensions.
      * @param grid The TextmodeGrid instance.
@@ -118,29 +95,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/index.d.ts

@@ -1,4 +1,8 @@
 export { TextmodeLayer } from './TextmodeLayer';
 export { LayerManager as TextmodeLayerManager } from './LayerManager';
 export { Layer2DCompositor as LayerCompositor } from './Layer2DCompositor';
+export { Layer3DCompositor } from './Layer3DCompositor';
+export { Camera3D } from './Camera3D';
 export type { TextmodeLayerOptions, TextmodeLayerBlendMode } from './types';
+export type { Layer3DOptions, Composite3DParams } from './Layer3DCompositor';
+export type { Camera3DOptions, Camera3DShaderUniforms } from './Camera3D';

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 { Camera3D } from '../Camera3D';
 export interface ILayerManager {
     /**
      * Get all user layers as a readonly array.
@@ -11,6 +12,24 @@ export interface ILayerManager {
      * This layer represents the main drawing content before any user layers are composited.
      */
     readonly base: TextmodeLayer;
+    /**
+     * The 3D camera used for voxel rendering.
+     *
+     * The camera provides fine-grained control over rotation, translation, and zoom
+     * in 3D mode. For simple use cases, you can use the `rotation()`, `translation()`,
+     * and `zoom()` methods directly on the layer manager instead.
+     *
+     * @example
+     * ```ts
+     * // Direct camera access for advanced control
+     * const camera = t.layers.camera;
+     * camera.rotateY(camera.rotateY() + 1);
+     *
+     * // Reset camera to defaults
+     * t.layers.camera.reset();
+     * ```
+     */
+    readonly camera: Camera3D;
     /**
      * Add a new layer to the manager.
      * @param options Layer configuration options.
@@ -41,6 +60,39 @@ export interface ILayerManager {
      * and layers need to be recreated from scratch.
      */
     clear(): void;
+    /**
+     * Set or get the rendering mode.
+     * - '2d': Traditional 2D layer compositing with ASCII conversion per layer.
+     * - '3d': 3D voxel rendering with raymarching through stacked layer data.
+     * @param mode The rendering mode to set.
+     * @returns Current mode if no argument provided.
+     */
+    mode(mode?: '2d' | '3d'): '2d' | '3d';
+    /**
+     * Set or get the 3D rotation angles (in degrees) for voxel rendering.
+     * Only applies when renderMode is '3d'.
+     * @param x Rotation around X axis in degrees.
+     * @param y Rotation around Y axis in degrees.
+     * @param z Rotation around Z axis in degrees.
+     * @returns Current rotation if no arguments provided.
+     */
+    rotation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    /**
+     * Set or get the 3D translation offset for voxel rendering.
+     * Only applies when renderMode is '3d'.
+     * @param x Translation along X axis.
+     * @param y Translation along Y axis.
+     * @param z Translation along Z axis.
+     * @returns Current translation if no arguments provided.
+     */
+    translation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    /**
+     * Set or get the 3D zoom level for voxel rendering.
+     * Only applies when renderMode is '3d'.
+     * @param zoom Zoom factor (1 = no zoom, >1 = zoom in, <1 = zoom out).
+     * @returns Current zoom if no argument provided.
+     */
+    zoom(zoom?: number): number | void;
     /**
      * 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.

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

@@ -2,6 +2,7 @@ import type { GLFramebuffer } from '../../../rendering';
 import type { TextmodeFont } from '../../loadables/font';
 import type { TextmodeLayerBlendMode } from '../types';
 import type { FilterName, BuiltInFilterName, BuiltInFilterParams } from '../../filters';
+import type { TextmodeGrid } from '../../Grid';
 /**
  * A single layer within a multi-layered textmode rendering context.
  *
@@ -12,6 +13,10 @@ import type { FilterName, BuiltInFilterName, BuiltInFilterParams } from '../../f
  * 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.
+ *
  * You can also apply a sequence of post-processing filters to each layer's
  * rendered output using the {@link ITextmodeLayer.filter} method.
  *
@@ -24,6 +29,10 @@ export interface ITextmodeLayer {
      * If the layer is not yet initialized, returns undefined.
      */
     readonly texture: WebGLTexture | undefined;
+    /**
+     * Get the grid associated with this layer.
+     */
+    readonly grid: TextmodeGrid | undefined;
     /**
      * Returns the width of the final ASCII framebuffer in pixels.
      * If the layer is not yet initialized, returns 0.
@@ -39,7 +48,13 @@ export interface ITextmodeLayer {
      * If the layer is not yet initialized, returns undefined.
      */
     readonly drawFramebuffer: GLFramebuffer | undefined;
-    /** The font used by this layer. */
+    /**
+     * Get the framebuffer containing the rendered textmode output for this layer.
+     */
+    readonly asciiFramebuffer: GLFramebuffer | undefined;
+    /**
+     * The font used by this layer.
+     */
     readonly font: TextmodeFont;
     /**
      * Define this layer's draw callback. The callback is executed each frame
@@ -121,10 +136,41 @@ export interface ITextmodeLayer {
      * ```
      */
     draw(callback: () => void): void;
+    /**
+     * Store plugin-specific state on this layer.
+     * Plugins can use this to attach their own data to layer instances.
+     *
+     * @param pluginName Unique identifier for the plugin.
+     * @param state The state object to store.
+     * @ignore
+     */
+    setPluginState<T>(pluginName: string, state: T): void;
+    /**
+     * Retrieve plugin-specific state stored on this layer.
+     *
+     * @param pluginName Unique identifier for the plugin.
+     * @returns The stored state object, or undefined if not set.
+     * @ignore
+     */
+    getPluginState<T>(pluginName: string): T | undefined;
+    /** Check if plugin-specific state exists on this layer.
+     *
+     * @param pluginName Unique identifier for the plugin.
+     * @returns True if state exists, false otherwise.
+     * @ignore
+     */
+    hasPluginState(pluginName: string): boolean;
+    /** Delete plugin-specific state from this layer.
+     *
+     * @param pluginName Unique identifier for the plugin.
+     * @ignore
+     */
+    deletePluginState(pluginName: string): void;
     /** Get or set the font size for this layer. */
     fontSize(size?: number): number | void;
     /**
-     * Load a font from the given source into this layer.
+     * 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.
@@ -134,6 +180,7 @@ export interface ITextmodeLayer {
      * const layer = t.layers.add();
      *
      * t.setup(async () => {
+     *   // Load a custom font for this layer
      *   await layer.loadFont('./fonts/custom.ttf');
      * });
      * ```

package/dist/types/textmode/managers/PluginManager.d.ts

@@ -4,32 +4,118 @@ import type { GLFramebuffer } from '../../rendering';
 import type { TextmodeFont } from '../loadables/font';
 import type { TextmodeGrid } from '../Grid';
 import type { TextmodeCanvas } from '../Canvas';
+import type { TextmodeLayer } from '../layers/TextmodeLayer';
+import type { TextmodeLayerManager } from '../layers';
+/**
+ * Callback type for simple plugin hooks without parameters.
+ */
 export type TextmodePluginHook = () => void;
+/**
+ * Callback type for setup lifecycle hooks.
+ * Can be synchronous or return a Promise for async operations.
+ */
+export type SetupLifecycleHook = () => void | Promise<void>;
+/**
+ * Callback type for layer lifecycle events.
+ */
+export type LayerLifecycleHook = (layer: TextmodeLayer) => void;
+/**
+ * Callback type for layer render hooks.
+ */
+export type LayerRenderHook = (layer: TextmodeLayer) => void;
 /**
  * An extended API provided to plugins when they are installed on a {@link Textmodifier} instance.
  */
 export interface TextmodePluginAPI {
     /** The WebGL renderer used by the Textmodifier instance. */
     renderer: GLRenderer;
-    /** The font used by the Textmodifier instance. */
+    /** The font used by the Textmodifier instance (from base layer). */
     font: TextmodeFont;
-    /** The grid used by the Textmodifier instance. */
+    /** The grid used by the Textmodifier instance (from base layer). */
     grid: TextmodeGrid;
     /** The canvas used by the Textmodifier instance. */
     canvas: TextmodeCanvas;
-    /** The framebuffer the user draws to with 3 render targets. */
+    /** The framebuffer the user draws to with 3 render targets (from base layer). */
     drawFramebuffer: GLFramebuffer;
-    /** The framebuffer containing the ASCII representation.<br/>
-     * This framebuffer only has a single render target. */
+    /**
+     * The framebuffer containing the ASCII representation (from base layer).<br/>
+     * This framebuffer only has a single render target.
+     */
     asciiFramebuffer: GLFramebuffer;
+    /** The layer manager for accessing and managing all layers. */
+    layerManager: TextmodeLayerManager;
     /**
-     * Register a callback to be invoked before each draw cycle. Happens just before the draw framebuffer is being bound.
+     * Register a callback to be invoked before each draw cycle.
+     * Happens just before any framebuffer
+     * @returns A function to unregister the hook.
      */
     registerPreDrawHook(callback: () => void): () => void;
     /**
-     * Register a callback to be invoked after each draw cycle. Happens outside of the draw framebuffer being bound after the final result is drawn to the screen.
+     * Register a callback to be invoked after each draw cycle.
+     * Happens outside of the draw framebuffer being bound after the final result is drawn to the screen.
+     * @returns A function to unregister the hook.
      */
     registerPostDrawHook(callback: () => void): () => void;
+    /**
+     * Register a callback to be invoked when a layer is about to be disposed.
+     * @param callback The callback to invoke with the layer being disposed.
+     * @returns A function to unregister the hook.
+     */
+    registerLayerDisposedHook(callback: LayerLifecycleHook): () => void;
+    /**
+     * Register a callback to be invoked before each layer's render cycle.
+     * This happens after the layer's visibility check but before any drawing operations.
+     * Useful for rendering content to the layer's framebuffer before user draw callbacks.
+     * @param callback The callback to invoke with the layer and render context.
+     * @returns A function to unregister the hook.
+     */
+    registerLayerPreRenderHook(callback: LayerRenderHook): () => void;
+    /**
+     * Register a callback to be invoked after each layer's render cycle.
+     * This happens after the user draw callback but before ASCII conversion.
+     * @param callback The callback to invoke with the layer and render context.
+     * @returns A function to unregister the hook.
+     */
+    registerLayerPostRenderHook(callback: LayerRenderHook): () => void;
+    /**
+     * Register a callback to be invoked before the user's setup callback runs.
+     * This happens after the Textmodifier and all layers are fully initialized,
+     * but before user code in `setup()` executes.
+     * Useful for plugins that need to prepare resources or state before user setup.
+     * @param callback The callback to invoke before setup.
+     * @returns A function to unregister the hook.
+     */
+    registerPreSetupHook(callback: () => void | Promise<void>): () => void;
+    /**
+     * Register a callback to be invoked after the user's setup callback completes.
+     * This happens after user code in `setup()` has finished executing,
+     * but before the loading screen finishes and the main render loop begins.
+     * Useful for plugins that need to finalize initialization after user setup.
+     * @param callback The callback to invoke after setup.
+     * @returns A function to unregister the hook.
+     */
+    registerPostSetupHook(callback: () => void | Promise<void>): () => void;
+    /**
+     * Extend TextmodeLayer instances with a new method.
+     * The method will be available on all existing and future layer instances.
+     *
+     * @param methodName The name of the method to add.
+     * @param implementation The implementation function. `this` will be bound to the TextmodeLayer instance.
+     *
+     * @example
+     * ```typescript
+     * api.extendLayer('synth', function(source: SynthSource) {
+     *   // `this` is the TextmodeLayer instance
+     *   this.setPluginState('synth', { source, compiled: compile(source) });
+     * });
+     * ```
+     */
+    extendLayer<TArgs extends unknown[], TReturn>(methodName: string, implementation: (this: TextmodeLayer, ...args: TArgs) => TReturn): void;
+    /**
+     * Remove a method extension from TextmodeLayer.
+     * @param methodName The name of the method to remove.
+     */
+    removeLayerExtension(methodName: string): void;
 }
 /**
  * A plugin interface for extending the functionality of a {@link Textmodifier} instance.
@@ -59,20 +145,82 @@ export interface TextmodePlugin {
      */
     uninstall?(textmodifier: Textmodifier, api: TextmodePluginAPI): void | Promise<void>;
 }
+/**
+ * Manager for handling TextmodePlugin installation, uninstallation, and hook execution.
+ * @ignore
+ */
 export declare class TextmodePluginManager {
     private readonly _textmodifier;
     private readonly _plugins;
     private readonly _installationOrder;
     private readonly _preDrawHooks;
     private readonly _postDrawHooks;
+    private readonly _layerDisposedHooks;
+    private readonly _layerPreRenderHooks;
+    private readonly _layerPostRenderHooks;
+    private readonly _preSetupHooks;
+    private readonly _postSetupHooks;
+    private readonly _layerExtensions;
     constructor(textmodifier: Textmodifier);
+    /**
+     * Install plugins synchronously.
+     * This is called from the constructor to ensure layer method extensions
+     * are available immediately after textmode.create() returns.
+     *
+     * Plugin install() methods should be synchronous or return void.
+     * Any async operations in install() will be started but not awaited.
+     *
+     * @ignore
+     */
+    $installManySync(plugins: TextmodePlugin[]): void;
     $installMany(plugins: TextmodePlugin[]): Promise<void>;
     $unuse(pluginName: string): Promise<void>;
     $runPreDrawHooks(): void;
     $runPostDrawHooks(): void;
+    /**
+     * Notify plugins that a layer is about to be disposed.
+     * Called by LayerManager/TextmodeLayer before disposal.
+     * @ignore
+     */
+    $notifyLayerDisposed(layer: TextmodeLayer): void;
+    /**
+     * Run all registered pre-render hooks for a layer.
+     * Called by TextmodeLayer.$render() before drawing.
+     * @ignore
+     */
+    $runLayerPreRenderHooks(layer: TextmodeLayer): void;
+    /**
+     * Run all registered post-render hooks for a layer.
+     * Called by TextmodeLayer.$render() after drawing but before ASCII conversion.
+     * @ignore
+     */
+    $runLayerPostRenderHooks(layer: TextmodeLayer): void;
+    /**
+     * Run all registered pre-setup hooks.
+     * Called by Textmodifier before the user's setup callback.
+     * @ignore
+     */
+    $runPreSetupHooks(): Promise<void>;
+    /**
+     * Run all registered post-setup hooks.
+     * Called by Textmodifier after the user's setup callback completes.
+     * @ignore
+     */
+    $runPostSetupHooks(): Promise<void>;
     $disposeAll(): Promise<void>;
     private _createAPI;
     private _registerHook;
     private _removePluginHooks;
     private _runHooks;
+    private _runLayerLifecycleHooks;
+    private _runLayerRenderHooks;
+    /**
+     * Run setup lifecycle hooks in plugin installation order.
+     * Supports both synchronous and async hooks.
+     */
+    private _runSetupHooks;
+    private _addLayerExtension;
+    private _removeLayerExtension;
+    private _addMethodToLayerPrototype;
+    private _removeMethodFromLayerPrototype;
 }