@endge/nova 0.13.5 → 0.13.11

package/dist/model/render/schema/nova-color-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Описывает контракт NovaParsedColor.
+ */
+export interface NovaParsedColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    packed: number;
+}
+/**
+ * Парсит nova color.
+ */
+export declare function parseNovaColor(input: string | undefined, fallback?: number): NovaParsedColor;
+/**
+ * Парсит nova color packed.
+ */
+export declare function parseNovaColorPacked(input: string | undefined, fallback?: number): number;

package/dist/model/render/schema/nova-style-compiler.d.ts

@@ -0,0 +1,88 @@
+import { NovaArc, NovaBorder, NovaCircle, NovaLine, NovaPolygon, NovaRect, NovaStylePadding, NovaText } from '../../../domain/types/renderer.types';
+import { NovaParsedColor } from './nova-color-parser';
+/**
+ * Описывает контракт NovaCompiledBoxStyle.
+ */
+export interface NovaCompiledBoxStyle {
+    fill: NovaParsedColor;
+    opacity: number;
+    borderColor: NovaParsedColor;
+    borderWidth: number;
+    borderRadius: number;
+    dashPattern?: Array<number>;
+}
+/**
+ * Описывает контракт NovaCompiledTextStyle.
+ */
+export interface NovaCompiledTextStyle {
+    color: NovaParsedColor;
+    opacity: number;
+    font: string;
+    fontSize: number;
+    lineHeight: number;
+    padding: Required<NovaCompiledPadding>;
+    horizontalAlign: 'left' | 'center' | 'right';
+    verticalAlign: 'top' | 'middle' | 'bottom';
+    overflowAlign: 'start' | 'preserve';
+    ellipsis: boolean;
+}
+/**
+ * Описывает контракт NovaCompiledArcStyle.
+ */
+export interface NovaCompiledArcStyle {
+    color: NovaParsedColor;
+    width: number;
+    opacity: number;
+    lineCap: 'butt' | 'round' | 'square';
+}
+/**
+ * Описывает контракт NovaCompiledPadding.
+ */
+export interface NovaCompiledPadding {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/**
+ * Компилирует nova rect style.
+ */
+export declare function compileNovaRectStyle(rect: NovaRect): NovaCompiledBoxStyle;
+/**
+ * Компилирует nova border style.
+ */
+export declare function compileNovaBorderStyle(border: NovaBorder): NovaCompiledBoxStyle;
+/**
+ * Компилирует nova circle style.
+ */
+export declare function compileNovaCircleStyle(circle: NovaCircle): NovaCompiledBoxStyle;
+/**
+ * Компилирует nova arc style.
+ */
+export declare function compileNovaArcStyle(arc: NovaArc): NovaCompiledArcStyle;
+/**
+ * Компилирует nova line style.
+ */
+export declare function compileNovaLineStyle(line: NovaLine): {
+    color: NovaParsedColor;
+    width: number;
+    opacity: number;
+    dashPattern?: Array<number>;
+};
+/**
+ * Компилирует nova polygon style.
+ */
+export declare function compileNovaPolygonStyle(polygon: NovaPolygon): {
+    fill: NovaParsedColor;
+    stroke: NovaParsedColor;
+    lineWidth: number;
+    opacity: number;
+};
+/**
+ * Компилирует nova text style.
+ */
+export declare function compileNovaTextStyle(text: NovaText): NovaCompiledTextStyle;
+/**
+ * Компилирует nova padding.
+ */
+export declare function compileNovaPadding(padding?: NovaStylePadding): Required<NovaCompiledPadding>;

package/dist/model/render/targets/NovaRenderTargetManager.d.ts

@@ -0,0 +1,51 @@
+import { NovaRenderTarget, NovaRenderTargetKind } from '../../../domain/types/rendering/index';
+/**
+ * Описывает контракт CreateNovaRenderTargetOptions.
+ */
+export interface CreateNovaRenderTargetOptions {
+    id: string;
+    kind: NovaRenderTargetKind;
+    width: number;
+    height: number;
+    dpr: number;
+    ownerGroupId?: string;
+}
+/**
+ * Управляет allocation и lifecycle render targets.
+ */
+export declare class NovaRenderTargetManager {
+    private readonly _targets;
+    private _memoryBytes;
+    /**
+     * Возвращает targets.
+     */
+    get targets(): Array<NovaRenderTarget>;
+    /**
+     * Возвращает memory bytes.
+     */
+    get memoryBytes(): number;
+    /**
+     * Возвращает memory mb.
+     */
+    get memoryMB(): number;
+    /**
+     * Выполняет внутреннюю операцию get.
+     */
+    get(id: string): NovaRenderTarget | undefined;
+    /**
+     * Выполняет внутреннюю операцию ensure.
+     */
+    ensure(options: CreateNovaRenderTargetOptions): NovaRenderTarget;
+    /**
+     * Выполняет внутреннюю операцию delete.
+     */
+    delete(id: string): boolean;
+    /**
+     * Очищает внутреннее состояние.
+     */
+    clear(): void;
+    /**
+     * Выполняет внутреннюю операцию estimate target bytes.
+     */
+    protected estimateTargetBytes(target: NovaRenderTarget): number;
+}

package/dist/model/render/targets/nova-render-target-resource.d.ts

@@ -0,0 +1,14 @@
+import { NovaRenderTarget } from '../../../domain/types/rendering/index';
+/**
+ * Физический ресурс backend за логическим render target.
+ */
+export interface NovaRenderTargetResource<TTexture = unknown, TFramebuffer = unknown> {
+    readonly target: NovaRenderTarget;
+    readonly texture?: TTexture;
+    readonly framebuffer?: TFramebuffer;
+    readonly canvas?: HTMLCanvasElement | OffscreenCanvas;
+    readonly context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+    resize: (width: number, height: number, dpr: number) => void;
+    clear: () => void;
+    destroy: () => void;
+}

package/dist/model/render/utils/nova-icon-rendering.d.ts

@@ -0,0 +1,9 @@
+import { NovaIcon } from '../../../domain/types/renderer.types';
+export interface NovaResolvedIconRenderRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function resolveNovaIconRenderRect(icon: NovaIcon, dpr: number): NovaResolvedIconRenderRect;
+export declare function resolveNovaIconRenderOpacity(icon: NovaIcon, dpr: number): number;

package/dist/model/runtime/app/Nova.d.ts

@@ -0,0 +1,167 @@
+import { EventList, OneOrMany } from '@endge/utils';
+import { NovaAppCreateOptions } from '../../../domain/types/base.types';
+import { NovaElementConstructor } from '../../../domain/types/component.types';
+import { NovaContextToken } from '../../../domain/types/context.types';
+import { NovaThemeId, NovaThemeTokens } from '../../../domain/types/theme.types';
+import { NovaDefinedComponentInput, NovaDefinedComponentOptions } from '../components/nova-defined-component';
+import { NovaSchemaRegistry } from '../components/NovaSchemaRegistry';
+import { NovaComputed, NovaSignal, NovaTrackNodeOptions } from '../reactivity/nova-reactivity';
+import { NovaRef, NovaRefMap, NovaScope } from '../refs/nova-ref';
+import { NovaCreateStoreOptions } from '../state/nova-store-runtime';
+import { NovaCompiledNodeConstructor } from '../template/NovaTemplateRuntime';
+import { NovaNode } from '../tree/NovaNode';
+import { NovaSurface } from '../tree/NovaSurface';
+import { NovaGlobalThemeAsset, NovaThemeSelectorTarget } from '../../theme/NovaGlobalThemeRegistry';
+import { NovaApp } from './NovaApp';
+export type NovaSchemaPlugin = (registry: NovaSchemaRegistry) => void;
+export interface NovaMountOptions<E extends EventList = Record<string, any>> {
+    app: NovaApp<E>;
+    surface: NovaSurface<E>;
+    scope?: NovaScope;
+    props?: Record<string, unknown>;
+    listeners?: Record<string, (...args: Array<any>) => void>;
+    slots?: Record<string, (...args: Array<any>) => Array<any>>;
+}
+export interface NovaMountHandle {
+    node: {
+        setProps?: (patch: Record<string, unknown>) => unknown;
+        setListeners?: (listeners: Record<string, (...args: Array<any>) => void>) => unknown;
+        remove: () => void;
+    };
+    updateProps: (patch: Record<string, unknown>) => void;
+    updateListeners: (listeners: Record<string, (...args: Array<any>) => void>) => void;
+    destroy: () => void;
+}
+/**
+ * Предоставляет статические фабрики для создания Nova runtime и связанных объектов.
+ */
+export declare class Nova {
+    /**
+     * Глобальный facade для typed assets.
+     */
+    static readonly assets: Readonly<{
+        global: import('../assets/NovaAssetRegistry').NovaAssetRegistry;
+        define: typeof import('../assets/NovaAssetRegistry').defineNovaAssets;
+        svg: typeof import('../assets/NovaAssetRegistry').createNovaSvgAsset;
+        image: typeof import('../assets/NovaAssetRegistry').createNovaImageAsset;
+        canvas: typeof import('../assets/NovaAssetRegistry').createNovaCanvasAsset;
+        pattern: typeof import('../assets/NovaAssetRegistry').createNovaPatternAsset;
+        stripe: typeof import('../assets/NovaAssetRegistry').createNovaStripeAsset;
+        linearGradient: typeof import('../assets/NovaAssetRegistry').createNovaLinearGradientAsset;
+        radialGradient: typeof import('../assets/NovaAssetRegistry').createNovaRadialGradientAsset;
+        conicGradient: typeof import('../assets/NovaAssetRegistry').createNovaConicGradientAsset;
+        noise: typeof import('../assets/NovaAssetRegistry').createNovaNoiseAsset;
+        meshGradient: typeof import('../assets/NovaAssetRegistry').createNovaMeshGradientAsset;
+        nineSliceImage: typeof import('../assets/NovaAssetRegistry').createNovaNineSliceImageAsset;
+        font: typeof import('../assets/NovaAssetRegistry').createNovaFontAsset;
+        ref<K extends import('../assets/NovaAssetRegistry').NovaAssetKind>(namespace: string, kind: K, name: string): import('../assets/NovaAssetRegistry').NovaAssetRef<K>;
+    }>;
+    /**
+     * Глобальный facade для prop descriptors в Nova DSL.
+     */
+    static readonly Prop: {
+        model: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        object: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        options: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        array: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        string: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        number: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        boolean: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+        function: <T = unknown>(options?: import('../components/nova-component-metadata').NovaPropDecoratorOptions<T>) => (target: object, propertyKey: string | symbol, _descriptor?: PropertyDescriptor) => void;
+    };
+    private static readonly _schemaPlugins;
+    private static _uiKitPlugin;
+    /**
+     * Создает app.
+     */
+    static createApp<E extends EventList = Record<string, any>>(options: NovaAppCreateOptions<E>): NovaApp<E>;
+    /**
+     * Регистрирует NovaCSS asset глобально для новых и уже созданных NovaApp.
+     */
+    static import(asset: NovaGlobalThemeAsset): void;
+    /**
+     * Возвращает или меняет активную глобальную тему Nova.
+     */
+    static theme(): NovaThemeId | null;
+    static theme(id: NovaThemeId): NovaThemeId;
+    /**
+     * Подписывается на глобальные изменения импортированных themes.
+     */
+    static onThemeChange(listener: () => void): () => void;
+    /**
+     * Резолвит глобальные theme tokens для selector target.
+     */
+    static resolveThemeTokens(target: NovaThemeSelectorTarget): NovaThemeTokens;
+    /**
+     * Сбрасывает global theme registry в unit-тестах.
+     */
+    static __resetGlobalThemesForTests(): void;
+    /**
+     * Подключает schema-плагин ко всем новым NovaApp.
+     */
+    static use(plugin: NovaSchemaPlugin): void;
+    /**
+     * Подключает Nova UI Kit ко всем новым NovaApp.
+     */
+    static useUIKit(plugin?: NovaSchemaPlugin): void;
+    /**
+     * Привязывает component metadata к class-конструктору без глобальной регистрации.
+     */
+    static defineComponent<E extends EventList = Record<string, any>, T extends NovaElementConstructor<E> = NovaElementConstructor<E>>(component: T, options?: NovaDefinedComponentOptions<E>): T;
+    /**
+     * Регистрирует один или несколько class-компонентов в конкретном schema registry.
+     */
+    static registerComponents<E extends EventList = Record<string, any>>(registry: NovaSchemaRegistry, definitions: OneOrMany<NovaElementConstructor<E> | NovaDefinedComponentInput<E>>): void;
+    /**
+     * Создает proxy-ref на публичный API Nova component.
+     */
+    static ref<T extends object>(name?: string): NovaRef<T>;
+    /**
+     * Создает коллекцию refs для keyed template nodes.
+     */
+    static refMap<T extends object>(): NovaRefMap<T>;
+    /**
+     * Создает типизированный token для scoped dependency в Nova tree.
+     */
+    static createContextToken<T>(name: string): NovaContextToken<T>;
+    /**
+     * DSL intrinsic для inject. В class-компонентах используйте this.inject(token).
+     */
+    static inject<T>(_token: NovaContextToken<T>): T;
+    /**
+     * DSL intrinsic для optional inject. В class-компонентах используйте this.injectOptional(token).
+     */
+    static injectOptional<T>(_token: NovaContextToken<T>, _fallback?: T): T | undefined;
+    /**
+     * Создает reactive business store поверх Raph data graph.
+     */
+    static createStore<T extends object>(instance: T, options?: NovaCreateStoreOptions): T;
+    /**
+     * Выполняет несколько store mutations в одной Raph transaction.
+     */
+    static batchStore<T>(store: object, callback: () => T): T;
+    /**
+     * Создает mutable reactive value для Nova DSL.
+     */
+    static signal<T>(initialValue: T): NovaSignal<T>;
+    /**
+     * Создает lazy computed reactive value для Nova DSL.
+     */
+    static computed<T>(compute: () => T): NovaComputed<T>;
+    /**
+     * Выполняет callback с привязкой signal reads к NovaNode.
+     */
+    static trackNode<T>(node: NovaNode<any>, callback: () => T, options?: NovaTrackNodeOptions): T;
+    /**
+     * Создает scope refs для template runtime.
+     */
+    static createScope(input?: Partial<NovaScope>): NovaScope;
+    /**
+     * Монтирует compiled Nova template в существующий app/surface.
+     */
+    static mount<E extends EventList = Record<string, any>>(component: NovaCompiledNodeConstructor<E>, options: NovaMountOptions<E>): NovaMountHandle;
+    /**
+     * Применяет глобальные schema-плагины к registry конкретного app.
+     */
+    private static applySchemaPlugins;
+}

package/dist/model/runtime/app/NovaApp.d.ts

@@ -0,0 +1,305 @@
+import { RaphApp, RaphLocalPhaseContext } from '@endge/raph';
+import { EventList, EventBus } from '@endge/utils';
+import { NovaAppCreateOptions, NovaAppOptions, NovaNodeProperties, NovaSizeOptions, ResolvedNovaInputOptions } from '../../../domain/types/base.types';
+import { NovaNodeEventHandlers } from '../../../domain/types/events.types';
+import { NovaExportImageOptions, NovaExportImageResult } from '../../../domain/types/export.types';
+import { NovaHitTestMode, RendererType } from '../../../domain/types/renderer.types';
+import { NovaRendererConfig, NovaRendererConfigInput } from '../../../domain/types/rendering/index';
+import { NovaScene } from '../scene/NovaScene';
+import { NovaMotionEngine } from '../../motion/NovaMotionEngine';
+import { NovaCanvas } from '../../platform/NovaCanvas';
+import { NovaAssetRegistry } from '../assets/NovaAssetRegistry';
+import { NovaCommandBus } from '../commands/NovaCommandBus';
+import { NovaComponentRegistry } from '../components/NovaComponentRegistry';
+import { NovaSchemaRegistry } from '../components/NovaSchemaRegistry';
+import { NovaCursorManager } from '../cursor/NovaCursorManager';
+import { NovaDebug } from '../debug/NovaDebug';
+import { NovaMetrics } from '../debug/NovaMetrics';
+import { NovaDiagnostics_Module } from '../diagnostics/NovaDiagnostics_Module';
+import { NovaEvents } from '../interaction/NovaEvents';
+import { NovaStore } from '../state/NovaStore';
+import { NovaSyncScope } from '../sync/NovaSyncScope';
+import { NovaNode } from '../tree/NovaNode';
+import { NovaSurface } from '../tree/NovaSurface';
+import { NovaSemanticService } from '../../semantic/NovaSemanticService';
+import { NovaSoundEngine } from '../../sound/NovaSoundEngine';
+import { NovaThemeService } from '../../theme/NovaThemeService';
+/**
+ * Управляет жизненным циклом Nova runtime, canvas, input, surfaces и фазами Raph.
+ */
+export declare class NovaApp<E extends EventList = Record<string, any>> {
+    private readonly _raph;
+    private readonly _ownsRaphKernel;
+    private readonly _canvas;
+    private readonly _backend;
+    private readonly _orchestrator;
+    private readonly _mainRendererType;
+    private readonly _events;
+    private readonly _inputOptions;
+    private readonly _webglAttributes?;
+    private _rendererConfig;
+    private readonly _surfaceOrder;
+    private readonly _orderedSurfaces;
+    private readonly _dirtySurfaces;
+    private _surfaceOrderCounter;
+    private _textRasterContinuationPending;
+    readonly store: NovaStore;
+    readonly schema: NovaSchemaRegistry;
+    readonly components: NovaComponentRegistry;
+    readonly motion: NovaMotionEngine;
+    readonly sound: NovaSoundEngine;
+    readonly theme: NovaThemeService<E>;
+    readonly cursors: NovaCursorManager<E>;
+    readonly bus: EventBus<E>;
+    readonly commands: NovaCommandBus;
+    readonly metrics: NovaMetrics;
+    readonly assets: NovaAssetRegistry;
+    readonly sync: NovaSyncScope;
+    readonly semantics: NovaSemanticService;
+    private _debugOptions;
+    private readonly _debugger;
+    private readonly _diagnostics;
+    private _keyboardActive;
+    private _keyboardHovered;
+    private _contextVersion;
+    private readonly _ownsSyncScope;
+    private _globalThemeDispose;
+    /**
+     * Создает приложение, подключает canvas, input, renderer и Raph-loop.
+     */
+    constructor(options: NovaAppCreateOptions<E>);
+    /**
+     * Запускает начало кадра, motion engine и frame-level diagnostics.
+     */
+    before(p: RaphLocalPhaseContext<NovaNodeProperties>): void;
+    /**
+     * Выполняет preupdate-фазу для dirty nodes.
+     */
+    preupdate(p: RaphLocalPhaseContext<NovaNodeProperties>): void;
+    /**
+     * Выполняет update-фазу для dirty nodes.
+     */
+    update(p: RaphLocalPhaseContext<NovaNodeProperties>): void;
+    /**
+     * Выполняет matrix-фазу и обновляет transform state dirty nodes.
+     */
+    matrix(p: RaphLocalPhaseContext<NovaNodeProperties>): void;
+    /**
+     * Собирает dirty surfaces и запускает render от корня каждого surface.
+     */
+    render(p: RaphLocalPhaseContext<NovaNodeProperties>): void;
+    /**
+     * Компилирует dirty surfaces и replay-ит все retained frames в основной canvas.
+     */
+    flush(): void;
+    /**
+     * Проверяет, нужно ли дорендерить deferred text atlas без пользовательского input.
+     */
+    private shouldContinueTextRaster;
+    /**
+     * Планирует continuation repaint вне текущего flush stack.
+     */
+    private scheduleTextRasterContinuation;
+    /**
+     * Завершает кадр и обновляет frame-level metrics.
+     */
+    after(): void;
+    /**
+     * Планирует выполнение Raph-фаз при наличии dirty nodes.
+     */
+    invalidate(): void;
+    /**
+     * Помечает render surfaces dirty после async asset updates.
+     */
+    private invalidateAssets;
+    /**
+     * Увеличивает версию scoped context для lazy invalidation inject-cache.
+     */
+    bumpContextVersion(): number;
+    /**
+     * Запускает постоянный scheduler loop.
+     */
+    startLoop(): void;
+    /**
+     * Останавливает постоянный scheduler loop.
+     */
+    stopLoop(): void;
+    /**
+     * Применяет runtime-настройки приложения без пересоздания NovaApp.
+     */
+    options(opts: Partial<NovaAppOptions>): void;
+    /**
+     * Передает DOM-событие в Nova event system.
+     */
+    handleEvent(type: keyof NovaNodeEventHandlers, event: Event): boolean;
+    /**
+     * Переключает стратегию hit-test для интерактивных nodes.
+     */
+    setHitTestMode(mode: NovaHitTestMode): void;
+    /**
+     * Обновляет глобальный renderer config с учетом текущих defaults.
+     */
+    configureRenderer(config: NovaRendererConfigInput): NovaRendererConfig;
+    /**
+     * Экспортирует текущий canvas frame и опционально добавляет semantic snapshot.
+     */
+    exportImage(options?: NovaExportImageOptions): Promise<NovaExportImageResult>;
+    /**
+     * Создает, монтирует и возвращает сцену, привязанную к этому приложению.
+     */
+    createScene<T extends NovaScene<E>>(SceneClass: new (app: NovaApp<E>, ...args: Array<any>) => T, ...args: Array<any>): T;
+    /**
+     * Возвращает Raph runtime приложения.
+     */
+    get raph(): RaphApp<NovaNodeProperties>;
+    /**
+     * Возвращает версию scoped context приложения.
+     */
+    get contextVersion(): number;
+    /**
+     * Возвращает canvas wrapper приложения.
+     */
+    get canvas(): NovaCanvas;
+    /**
+     * Обновляет CSS cursor основного canvas независимо от active renderer backend.
+     */
+    cursor(value: string): void;
+    /**
+     * Возвращает Nova event system.
+     */
+    get events(): NovaEvents<E>;
+    /**
+     * Возвращает surfaces, подключенные к root Raph graph.
+     */
+    get surfaces(): Array<NovaSurface<E>>;
+    /**
+     * Возвращает количество dirty surfaces текущего frame.
+     */
+    get dirtySurfaceCount(): number;
+    /**
+     * Возвращает runtime debugger приложения.
+     */
+    get debugger(): NovaDebug;
+    /**
+     * Возвращает runtime diagnostics приложения.
+     */
+    get diagnostics(): NovaDiagnostics_Module<E>;
+    /**
+     * Возвращает текущую ширину root canvas в logical pixels.
+     */
+    get width(): number;
+    /**
+     * Возвращает текущую высоту root canvas в logical pixels.
+     */
+    get height(): number;
+    /**
+     * Возвращает фактический device pixel ratio canvas.
+     */
+    get dpr(): number;
+    /**
+     * Возвращает верхнее ограничение device pixel ratio.
+     */
+    get maxDpr(): number;
+    /**
+     * Возвращает WebGL context attributes, переданные при создании приложения.
+     */
+    get webglAttributes(): WebGLContextAttributes | undefined;
+    /**
+     * Возвращает основной renderer type приложения.
+     */
+    get mainRendererType(): RendererType;
+    /**
+     * Возвращает актуальный глобальный renderer config.
+     */
+    get rendererConfig(): NovaRendererConfig;
+    /**
+     * Возвращает resolved input options.
+     */
+    get inputOptions(): ResolvedNovaInputOptions;
+    /**
+     * Создает logical surface для app-level backend.
+     */
+    createSurface<T extends NovaSurface<E>>(name: string, SurfaceClass?: new (...args: Array<any>) => T, ...args: Array<any>): T;
+    /**
+     * Добавляет surface в Raph graph, монтирует subtree и обновляет порядок слоев.
+     */
+    addSurface<T extends NovaSurface<E>>(surface: T): T;
+    /**
+     * Удаляет logical surface из app-level render graph и retained frame cache.
+     */
+    removeSurface(surface: NovaSurface<E>): void;
+    /**
+     * Возвращает surfaces в порядке compositing.
+     */
+    private getOrderedSurfaces;
+    /**
+     * Фиксирует стабильный порядок добавления surface, если он еще не был сохранен.
+     */
+    private ensureSurfaceOrder;
+    /**
+     * Возвращает стабильный индекс добавления surface.
+     */
+    private surfaceOrderOf;
+    /**
+     * Регистрирует node в интерактивном индексе событий.
+     */
+    registerInteractiveNode(node: NovaNode<E>): void;
+    /**
+     * Удаляет node из всех event indexes и active references.
+     */
+    unregisterInteractiveNode(node: NovaNode<E>): void;
+    /**
+     * Сравнивает две nodes по итоговому visual order с учетом surface и hierarchy.
+     */
+    compareRenderOrder(a: NovaNode<E>, b: NovaNode<E>): number;
+    /**
+     * Строит числовой stamp, который описывает положение node в render order.
+     */
+    getRenderOrderStamp(node: NovaNode<E>): Array<number>;
+    /**
+     * Возвращает путь от surface root до указанной node.
+     */
+    private getRenderPath;
+    /**
+     * Меняет размеры root canvas и синхронизирует dimensions всех surfaces.
+     */
+    resize(size?: Partial<NovaSizeOptions>): void;
+    /**
+     * Освобождает runtime, события, metrics, surfaces и canvas.
+     */
+    destroy(): void;
+    /**
+     * Подключает cleanup для глобального theme registry.
+     */
+    setGlobalThemeDispose(dispose: (() => void) | null): void;
+    /**
+     * Включает или выключает backend-level retained diagnostics.
+     */
+    private setRendererDiagnosticsEnabled;
+    private _boundWindowEvents;
+    private _boundCanvasEvents;
+    /**
+     * Подключает pointer и keyboard listeners согласно input options.
+     */
+    private setupEventListeners;
+    /**
+     * Переводит DOM focus на canvas для focused keyboard scope.
+     */
+    private focusCanvasKeyboardTarget;
+    /**
+     * Нормализует пользовательские input options в полный resolved config.
+     */
+    private resolveInputOptions;
+    /**
+     * Проверяет, должен ли NovaApp обрабатывать конкретное keyboard event.
+     */
+    private shouldHandleKeyboardEvent;
+    /**
+     * Применяет preventDefault для keyboard event согласно настройкам input.
+     */
+    private applyKeyboardPreventDefault;
+    /**
+     * Проверяет, является ли target редактируемым DOM-элементом.
+     */
+    private isEditableTarget;
+}

package/dist/model/runtime/app/createNovaRaphRuntime.d.ts

@@ -0,0 +1,17 @@
+import { RaphKernel, RaphSchedulerType, RaphApp } from '@endge/raph';
+import { EventList } from '@endge/utils';
+import { NovaNodeProperties } from '../../../domain/types/base.types';
+import { NovaApp } from './NovaApp';
+/**
+ * Описывает параметры создания Raph runtime для Nova.
+ */
+interface CreateNovaRaphRuntimeOptions {
+    kernel?: RaphKernel;
+    runtimeId?: string;
+    scheduler: RaphSchedulerType;
+}
+/**
+ * Создает Raph runtime lane с зарегистрированными Nova local phases и properties.
+ */
+export declare function createNovaRaphRuntime<E extends EventList>(appInstance: NovaApp<E>, options: CreateNovaRaphRuntimeOptions): RaphApp<NovaNodeProperties>;
+export {};