restty 0.1.35 → 0.2.0

package/dist/runtime/create-runtime/render-tick-webgl.types.d.ts

@@ -1,8 +1,8 @@
 import type { FontEntry } from "../../fonts";
 import type { Color, WebGLState } from "../../renderer";
 import type { CursorInfo, RenderState, ResttyWasmExports } from "../../wasm";
-import type { CompiledWebGLShaderStage, WebGLStageTargets } from "../create-app-types";
-import type { BuildFontAtlasParams, BuildFontAtlasResult, GlyphConstraintMeta } from "../atlas-builder";
+import type { CompiledWebGLShaderStage, WebGLStageTargets } from "./render-stage-runtime.types";
+import type { BuildFontAtlasParams, BuildFontAtlasResult, GlyphConstraintMeta } from "../fonts/atlas-builder";
 import type { AlphaBlendingMode } from "./blend-utils";
 import type { CursorPosition, GlyphQueueItem, NerdMetrics, SharedTickDeps, WebGPURenderInput } from "./render-tick-webgpu.types";
 type AtlasBuilderDeps = BuildFontAtlasParams["deps"];
@@ -12,9 +12,6 @@ export type WebGLTickDeps = SharedTickDeps & {
     setShaderStagesDirty: (value: boolean) => void;
     getCompiledWebGLShaderStages: () => CompiledWebGLShaderStage[];
     ensureWebGLStageTargets: (state: WebGLState) => WebGLStageTargets | null;
-    fontError: Error | null;
-    termDebug: HTMLElement | null;
-    reportDebugText: (text: string) => void;
     updateGrid: () => void;
     getRenderState: () => RenderState | null;
     resolveBlendFlags: (alphaMode: AlphaBlendingMode, backend: "webgl2") => {

package/dist/runtime/create-runtime/render-tick-webgpu-cell-pass.d.ts

@@ -1,4 +1,4 @@
-import type { GlyphConstraintMeta } from "../atlas-builder";
+import type { GlyphConstraintMeta } from "../fonts/atlas-builder";
 import type { CollectWebGPUCellPassParams, GlyphQueueItem } from "./render-tick-webgpu.types";
 export declare function collectWebGPUCellPass(params: CollectWebGPUCellPassParams): {
     bgData: number[];

package/dist/runtime/create-runtime/render-tick-webgpu.types.d.ts

@@ -1,12 +1,12 @@
 import type { FontEntry, FontManagerState } from "../../fonts";
 import type { NerdConstraint } from "../../fonts/nerd-constraints";
 import type { Color, WebGPUState } from "../../renderer";
-import type { RuntimeTerminalColor } from "./highlight-terminal-color-utils";
-import type { CompiledWebGPUShaderStage, WebGPUStageTargets } from "../create-app-types";
-import type { GlyphConstraintMeta } from "../atlas-builder";
+import type { RuntimeTerminalColor } from "./highlight-terminal-color-utils.types";
+import type { CompiledWebGPUShaderStage, WebGPUStageTargets } from "./render-stage-runtime.types";
+import type { GlyphConstraintMeta } from "../fonts/atlas-builder";
 import type { KittyPlacement, RenderState, ResttyWasm, ResttyWasmExports, SearchViewportMatch } from "../../wasm";
-import type { KittyDrawPlan, KittyDrawSlice } from "./kitty-render-runtime";
-import type { ResttyFontHintTarget } from "../types";
+import type { KittyDrawPlan, KittyDrawSlice } from "./kitty-render-runtime.types";
+import type { ResttyFontHintTarget } from "../core/models";
 export type CursorPosition = {
     col: number;
     row: number;
@@ -252,9 +252,6 @@ export type RuntimeTickDeps = SharedTickDeps & {
     setShaderStagesDirty: (value: boolean) => void;
     getCompiledWebGPUShaderStages: () => CompiledWebGPUShaderStage[];
     ensureWebGPUStageTargets: (state: WebGPUState) => WebGPUStageTargets | null;
-    fontError: Error | null;
-    termDebug: HTMLElement | null;
-    reportDebugText: (text: string) => void;
     updateGrid: () => void;
     getRenderState: () => RenderState | null;
     resolveBlendFlags: (alphaMode: string, backend: "webgpu", state: WebGPUState) => {
@@ -287,7 +284,6 @@ export type RuntimeTickDeps = SharedTickDeps & {
         row: number;
         col: number;
     } | null;
-    dbgEl: HTMLElement | null;
     wasmExports: ResttyWasmExports | null;
     wasmHandle: number;
     gridState: {

package/dist/runtime/create-runtime/runtime-controller.api.types.d.ts

@@ -0,0 +1,96 @@
+import type { InputHandler } from "../../input";
+import type { PtyTransport } from "../../pty";
+import type { WebGPUState, WebGLState } from "../../renderer";
+import type { GhosttyTheme } from "../../theme";
+import type { ResttyRuntime, ResttyRuntimeInteractionApi, ResttyRuntimeRenderApi, ResttyRuntimeSearchApi, ResttyRuntimeTerminalApi } from "../core/api";
+import type { ResttyRuntimeEventHub } from "../core/runtime-events";
+import type { ResttyRuntimeSession } from "../core/resources";
+import type { RuntimeInteraction } from "./interaction-runtime/runtime.types";
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+import type { PreferredRenderer, RuntimeControllerSharedState } from "./runtime-controller.state.types";
+export type RuntimeSendInput = (text: string, source?: string, options?: {
+    skipHooks?: boolean;
+}) => void;
+export type RuntimeControllerPublicCapabilities = {
+    terminal: Pick<ResttyRuntimeTerminalApi, "setFontSize" | "setLigatures" | "setFontHinting" | "setFontHintTarget" | "setFonts" | "resetTheme">;
+    search: ResttyRuntimeSearchApi;
+    interaction: Pick<ResttyRuntimeInteractionApi, "resize" | "focus" | "blur" | "updateSize">;
+    render: Pick<ResttyRuntimeRenderApi, "setShaderStages" | "getShaderStages">;
+};
+export type RuntimeController = {
+    sendInput: RuntimeSendInput;
+    createPublicApi: (capabilities: RuntimeControllerPublicCapabilities) => ResttyRuntime;
+};
+export type LifecycleThemeRuntime = {
+    cancelScheduledSizeUpdate: () => void;
+    getActiveTheme: () => GhosttyTheme | null;
+};
+export type RuntimeControllerRuntimeDeps = {
+    session: ResttyRuntimeSession;
+    ptyTransport: PtyTransport;
+    forwardTerminalReplies?: boolean;
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    interaction: RuntimeInteraction;
+    lifecycleThemeSizeRuntime: LifecycleThemeRuntime;
+};
+export type RuntimeControllerStateDeps = {
+    readState: () => RuntimeControllerSharedState;
+    writeState: (patch: Partial<RuntimeControllerSharedState>) => void;
+    resizeState: {
+        lastAt: number;
+    };
+    gridState: {
+        cols: number;
+        rows: number;
+    };
+    getCanvas: () => HTMLCanvasElement;
+};
+export type RuntimeControllerPlatformDeps = {
+    imeInput: HTMLTextAreaElement | null;
+    attachWindowEvents: boolean;
+    isMacPlatform: boolean;
+    KITTY_FLAG_REPORT_EVENTS: number;
+};
+export type RuntimeControllerHookDeps = {
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
+    getSelectionText: () => string;
+    markSearchDirty: () => void;
+    handleSearchWasmReset: () => void;
+};
+export type RuntimeControllerRenderDeps = {
+    initialPreferredRenderer: PreferredRenderer;
+    CURSOR_BLINK_MS: number;
+    RESIZE_ACTIVE_MS: number;
+    BACKGROUND_RENDER_FPS: number;
+    tickWebGPU: (state: WebGPUState) => void;
+    tickWebGL: (state: WebGLState) => void;
+};
+export type RuntimeControllerLifecycleDeps = {
+    cleanupFns: Array<() => void>;
+    cleanupCanvasFns: Array<() => void>;
+    updateGrid: () => void;
+    applyTheme: ResttyRuntimeTerminalApi["applyTheme"];
+    ensureFont: () => Promise<void>;
+    updateSize: ResttyRuntimeInteractionApi["updateSize"];
+    replaceCanvas: () => void;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+    setShaderStagesDirty: (dirty: boolean) => void;
+    clearWebGPUShaderStages: () => void;
+    destroyWebGPUStageTargets: () => void;
+    clearWebGLShaderStages: (state?: WebGLState) => void;
+    destroyWebGLStageTargets: (state?: WebGLState) => void;
+    maxScrollbackBytes?: number;
+    maxScrollback?: number;
+};
+export type RuntimeControllerOptions = {
+    runtimeEvents: ResttyRuntimeEventHub;
+    runtime: RuntimeControllerRuntimeDeps;
+    state: RuntimeControllerStateDeps;
+    platform: RuntimeControllerPlatformDeps;
+    hooks: RuntimeControllerHookDeps;
+    render: RuntimeControllerRenderDeps;
+    lifecycle: RuntimeControllerLifecycleDeps;
+};

package/dist/runtime/create-runtime/runtime-controller.clipboard.d.ts

@@ -0,0 +1,10 @@
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+type CreateRuntimeControllerClipboardOptions = {
+    getSelectionText: () => string;
+    ptyInputRuntime: Pick<PtyInputRuntime, "sendPasteText">;
+};
+export declare function createRuntimeControllerClipboard(options: CreateRuntimeControllerClipboardOptions): {
+    copySelectionToClipboard: () => Promise<boolean>;
+    pasteFromClipboard: () => Promise<boolean>;
+};
+export {};

package/dist/runtime/create-runtime/runtime-controller.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeController, RuntimeControllerOptions } from "./runtime-controller.api.types";
+export type { RuntimeControllerSharedState } from "./runtime-controller.state.types";
+export declare function createRuntimeController(options: RuntimeControllerOptions): RuntimeController;

package/dist/runtime/create-runtime/runtime-controller.input.d.ts

@@ -0,0 +1,24 @@
+import type { InputHandler } from "../../input";
+import type { PtyTransport } from "../../pty";
+import type { RuntimeInteraction } from "./interaction-runtime/runtime.types";
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+import type { RuntimeSendInput } from "./runtime-controller.api.types";
+import type { RuntimeControllerSharedState } from "./runtime-controller.state.types";
+type CreateRuntimeControllerInputOptions = {
+    ptyTransport: PtyTransport;
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    interaction: RuntimeInteraction;
+    readState: () => RuntimeControllerSharedState;
+    writeState: (patch: Partial<RuntimeControllerSharedState>) => void;
+    getCanvas: () => HTMLCanvasElement;
+    forwardTerminalReplies?: boolean;
+    markSearchDirty: () => void;
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
+};
+export declare function createRuntimeControllerInput(options: CreateRuntimeControllerInputOptions): {
+    clearScreen: () => void;
+    sendInput: RuntimeSendInput;
+};
+export {};

package/dist/runtime/create-runtime/runtime-controller.keyboard.d.ts

@@ -0,0 +1,19 @@
+import type { InputHandler } from "../../input";
+import type { RuntimeInteraction } from "./interaction-runtime/runtime.types";
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+import type { RuntimeControllerSharedState } from "./runtime-controller.state.types";
+type CreateRuntimeControllerKeyboardOptions = {
+    cleanupFns: Array<() => void>;
+    imeInput: HTMLTextAreaElement | null;
+    isMacPlatform: boolean;
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    interaction: RuntimeInteraction;
+    readState: () => RuntimeControllerSharedState;
+    writeState: (patch: Partial<RuntimeControllerSharedState>) => void;
+    getCanvas: () => HTMLCanvasElement;
+    copySelectionToClipboard: () => Promise<boolean>;
+    KITTY_FLAG_REPORT_EVENTS: number;
+};
+export declare function attachRuntimeControllerKeyboardEvents(options: CreateRuntimeControllerKeyboardOptions): void;
+export {};

package/dist/runtime/create-runtime/runtime-controller.lifecycle.d.ts

@@ -0,0 +1,50 @@
+import { type WebGPUState, type WebGLState } from "../../renderer";
+import type { PtyTransport } from "../../pty";
+import type { ResttyRuntimeTerminalApi } from "../core/api";
+import type { ResttyRuntimeLifecycleState } from "../core/lifecycle";
+import type { ResttyRuntimeEventHub } from "../core/runtime-events";
+import type { ResttyRuntimeSession } from "../core/resources";
+import type { LifecycleThemeRuntime } from "./runtime-controller.api.types";
+import type { RuntimeControllerInternalState, RuntimeControllerSharedState } from "./runtime-controller.state.types";
+type RuntimeControllerLifecycleOptions = {
+    runtimeEvents: ResttyRuntimeEventHub;
+    session: ResttyRuntimeSession;
+    ptyTransport: Pick<PtyTransport, "destroy">;
+    ptyInputRuntime: {
+        cancelSyncOutputReset: () => void;
+        disconnectPty: () => void;
+    };
+    lifecycleThemeSizeRuntime: LifecycleThemeRuntime;
+    cleanupFns: Array<() => void>;
+    cleanupCanvasFns: Array<() => void>;
+    readState: () => RuntimeControllerSharedState;
+    writeState: (patch: Partial<RuntimeControllerSharedState>) => void;
+    gridState: {
+        cols: number;
+        rows: number;
+    };
+    getCanvas: () => HTMLCanvasElement;
+    applyTheme: ResttyRuntimeTerminalApi["applyTheme"];
+    ensureFont: () => Promise<void>;
+    updateSize: () => void;
+    updateGrid: () => void;
+    replaceCanvas: () => void;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+    setShaderStagesDirty: (dirty: boolean) => void;
+    clearWebGPUShaderStages: () => void;
+    destroyWebGPUStageTargets: () => void;
+    clearWebGLShaderStages: (state?: WebGLState) => void;
+    destroyWebGLStageTargets: (state?: WebGLState) => void;
+    handleSearchWasmReset: () => void;
+    internalState: RuntimeControllerInternalState;
+    maxScrollbackBytes: number;
+    loop: (state: WebGPUState | WebGLState) => void;
+};
+type RuntimeControllerLifecycle = {
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+    init: () => Promise<void>;
+    destroy: () => void;
+};
+export declare function createRuntimeControllerLifecycle(options: RuntimeControllerLifecycleOptions): RuntimeControllerLifecycle;
+export {};

package/dist/runtime/create-runtime/runtime-controller.public-api.capabilities.d.ts

@@ -0,0 +1,57 @@
+import type { InputHandler } from "../../input";
+import type { PtyTransport } from "../../pty";
+import type { ResttyRuntimeEventsView, ResttyRuntimeInteractionApi, ResttyRuntimeIoApi, ResttyRuntimeLifecycleView, ResttyRuntimeRenderApi, ResttyRuntimeSearchApi, ResttyRuntimeTerminalApi } from "../core/api";
+import type { ResttyRuntimeLifecycleState } from "../core/lifecycle";
+import type { ResttyRuntimeEventHub } from "../core/runtime-events";
+import type { RuntimeInteraction } from "./interaction-runtime/runtime.types";
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+import type { RuntimeControllerPublicCapabilities, RuntimeSendInput } from "./runtime-controller.api.types";
+import type { RuntimeControllerInternalState } from "./runtime-controller.state.types";
+type RuntimeLifecycleDeps = {
+    init: () => Promise<void>;
+    destroy: () => void;
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+};
+type RuntimeEventsDeps = {
+    runtimeEvents: ResttyRuntimeEventHub;
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+};
+type RuntimeTerminalDeps = {
+    init: () => Promise<void>;
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+    internalState: RuntimeControllerInternalState;
+    applyTheme: ResttyRuntimeTerminalApi["applyTheme"];
+    clearScreen: () => void;
+    terminalCapabilities: RuntimeControllerPublicCapabilities["terminal"];
+};
+type RuntimeIoDeps = {
+    runtimeEvents: Pick<ResttyRuntimeEventHub, "subscribe">;
+    init: () => Promise<void>;
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+    sendInput: RuntimeSendInput;
+    ptyInputRuntime: PtyInputRuntime;
+    ptyTransport: Pick<PtyTransport, "isConnected">;
+};
+type RuntimeInteractionDeps = {
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    interaction: Pick<RuntimeInteraction, "selectWordAtClientPoint">;
+    interactionCapabilities: RuntimeControllerPublicCapabilities["interaction"];
+    copySelectionToClipboard: ResttyRuntimeInteractionApi["copySelectionToClipboard"];
+    pasteFromClipboard: ResttyRuntimeInteractionApi["pasteFromClipboard"];
+};
+type RuntimeSearchDeps = {
+    searchCapabilities: RuntimeControllerPublicCapabilities["search"];
+};
+type RuntimeRenderDeps = {
+    internalState: RuntimeControllerInternalState;
+    renderCapabilities: RuntimeControllerPublicCapabilities["render"];
+};
+export declare function createRuntimeLifecycleView({ init, destroy, getLifecycleState, }: RuntimeLifecycleDeps): ResttyRuntimeLifecycleView;
+export declare function createRuntimeEventsView({ runtimeEvents, getLifecycleState, }: RuntimeEventsDeps): ResttyRuntimeEventsView;
+export declare function createRuntimeTerminalView({ init, getLifecycleState, internalState, applyTheme, clearScreen, terminalCapabilities, }: RuntimeTerminalDeps): ResttyRuntimeTerminalApi;
+export declare function createRuntimeIoView({ runtimeEvents, init, getLifecycleState, sendInput, ptyInputRuntime, ptyTransport, }: RuntimeIoDeps): ResttyRuntimeIoApi;
+export declare function createRuntimeInteractionView({ inputHandler, ptyInputRuntime, interaction, interactionCapabilities, copySelectionToClipboard, pasteFromClipboard, }: RuntimeInteractionDeps): ResttyRuntimeInteractionApi;
+export declare function createRuntimeSearchView({ searchCapabilities, }: RuntimeSearchDeps): ResttyRuntimeSearchApi;
+export declare function createRuntimeRenderView({ internalState, renderCapabilities, }: RuntimeRenderDeps): ResttyRuntimeRenderApi;
+export {};

package/dist/runtime/create-runtime/runtime-controller.public-api.d.ts

@@ -0,0 +1,28 @@
+import type { InputHandler } from "../../input";
+import type { PtyTransport } from "../../pty";
+import type { ResttyRuntime, ResttyRuntimeInteractionApi, ResttyRuntimeTerminalApi } from "../core/api";
+import type { ResttyRuntimeLifecycleState } from "../core/lifecycle";
+import type { ResttyRuntimeEventHub } from "../core/runtime-events";
+import type { RuntimeInteraction } from "./interaction-runtime/runtime.types";
+import type { PtyInputRuntime } from "./pty-input-runtime.types";
+import type { RuntimeControllerPublicCapabilities, RuntimeSendInput } from "./runtime-controller.api.types";
+import type { RuntimeControllerInternalState } from "./runtime-controller.state.types";
+type RuntimeControllerPublicApiDeps = {
+    runtimeEvents: ResttyRuntimeEventHub;
+    getLifecycleState: () => ResttyRuntimeLifecycleState;
+    internalState: RuntimeControllerInternalState;
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    ptyTransport: Pick<PtyTransport, "isConnected">;
+    interaction: Pick<RuntimeInteraction, "selectWordAtClientPoint">;
+    init: () => Promise<void>;
+    destroy: () => void;
+    applyTheme: ResttyRuntimeTerminalApi["applyTheme"];
+    clearScreen: () => void;
+    sendInput: RuntimeSendInput;
+    copySelectionToClipboard: ResttyRuntimeInteractionApi["copySelectionToClipboard"];
+    pasteFromClipboard: ResttyRuntimeInteractionApi["pasteFromClipboard"];
+    publicApiCapabilities: RuntimeControllerPublicCapabilities;
+};
+export declare function createRuntimePublicApi(deps: RuntimeControllerPublicApiDeps): ResttyRuntime;
+export {};

package/dist/runtime/create-runtime/runtime-controller.render-loop.d.ts

@@ -0,0 +1,20 @@
+import type { WebGPUState, WebGLState } from "../../renderer";
+import type { RuntimeControllerInternalState, RuntimeControllerSharedState } from "./runtime-controller.state.types";
+type CreateRuntimeControllerRenderLoopOptions = {
+    internalState: RuntimeControllerInternalState;
+    readState: () => RuntimeControllerSharedState;
+    writeState: (patch: Partial<RuntimeControllerSharedState>) => void;
+    resizeState: {
+        lastAt: number;
+    };
+    CURSOR_BLINK_MS: number;
+    RESIZE_ACTIVE_MS: number;
+    BACKGROUND_RENDER_FPS: number;
+    isSynchronizedOutput: () => boolean;
+    tickWebGPU: (state: WebGPUState) => void;
+    tickWebGL: (state: WebGLState) => void;
+};
+export declare function createRuntimeControllerRenderLoop(options: CreateRuntimeControllerRenderLoopOptions): {
+    loop: (state: WebGPUState | WebGLState) => void;
+};
+export {};

package/dist/runtime/create-runtime/runtime-controller.state.types.d.ts

@@ -0,0 +1,24 @@
+import type { WebGPUState, WebGLState } from "../../renderer";
+import type { ResttyWasm, ResttyWasmExports } from "../../wasm";
+export type RuntimeControllerSharedState = {
+    wasm: ResttyWasm | null;
+    wasmExports: ResttyWasmExports | null;
+    wasmHandle: number;
+    wasmReady: boolean;
+    activeState: WebGPUState | WebGLState | null;
+    needsRender: boolean;
+    lastRenderTime: number;
+    currentContextType: "webgpu" | "webgl2" | null;
+    isFocused: boolean;
+    lastKeydownSeq: string;
+    lastKeydownSeqAt: number;
+};
+export type RuntimeBackend = "none" | "webgpu" | "webgl2";
+export type PreferredRenderer = "auto" | "webgpu" | "webgl2";
+export type RuntimeControllerInternalState = {
+    paused: boolean;
+    backend: RuntimeBackend;
+    preferredRenderer: PreferredRenderer;
+    rafId: number;
+    nextBlinkTime: number;
+};

package/dist/runtime/create-runtime/runtime-reporting.d.ts

@@ -1,23 +1,6 @@
-import type { CursorInfo, RenderState, ResttyWasm, ResttyWasmExports } from "../../wasm";
-import type { ResttyAppCallbacks } from "../types";
-import type { RuntimeSelectionState } from "./interaction-runtime/types";
-export type CreateRuntimeReportingOptions = {
-    selectionState: RuntimeSelectionState;
-    getLastRenderState: () => RenderState | null;
-    getWasmReady: () => boolean;
-    getWasm: () => ResttyWasm | null;
-    getWasmHandle: () => number;
-    getWasmExports: () => ResttyWasmExports | null;
-    callbacks?: ResttyAppCallbacks;
-    termSizeEl: HTMLElement | null;
-    cursorPosEl: HTMLElement | null;
-    dbgEl: HTMLElement | null;
-    setCursorForCpr: (pos: {
-        row: number;
-        col: number;
-    }) => void;
-};
-export declare function createRuntimeReporting(options: CreateRuntimeReportingOptions): {
+import type { CursorInfo, RenderState } from "../../wasm";
+import type { RuntimeReportingOptions } from "./runtime-reporting.types";
+export declare function createRuntimeReporting(options: RuntimeReportingOptions): {
     selectionForRow: (row: number, cols: number) => import("../../selection").SelectionRange;
     getSelectionText: () => string;
     getRenderState: () => RenderState | null;
@@ -36,5 +19,4 @@ export declare function createRuntimeReporting(options: CreateRuntimeReportingOp
         col: number;
         row: number;
     } | null) => void;
-    reportDebugText: (text: string) => void;
 };

package/dist/runtime/create-runtime/runtime-reporting.types.d.ts

@@ -0,0 +1,18 @@
+import type { RenderState, ResttyWasm, ResttyWasmExports } from "../../wasm";
+import type { ResttyRuntimeEvent } from "../core/runtime-events";
+import type { RuntimeSelectionState } from "./interaction-runtime/state.types";
+export type RuntimeReportingOptions = {
+    selectionState: RuntimeSelectionState;
+    getLastRenderState: () => RenderState | null;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    getWasmExports: () => ResttyWasmExports | null;
+    emitRuntimeEvent?: (event: Extract<ResttyRuntimeEvent, {
+        type: "term-size";
+    }>) => void;
+    setCursorForCpr: (pos: {
+        row: number;
+        col: number;
+    }) => void;
+};

package/dist/runtime/{create-app-symbols.d.ts → create-runtime/runtime-symbols.d.ts}

@@ -1,5 +1,5 @@
-import { type NerdConstraint } from "../fonts";
-import type { ResttyTouchSelectionMode } from "./types";
+import { type NerdConstraint } from "../../fonts";
+import type { ResttyTouchSelectionMode } from "../core/models";
 export declare const DEFAULT_SYMBOL_CONSTRAINT: NerdConstraint;
 export declare const DEFAULT_APPLE_SYMBOLS_CONSTRAINT: NerdConstraint;
 export declare const DEFAULT_EMOJI_CONSTRAINT: NerdConstraint;

package/dist/runtime/create-runtime/search-highlight-utils.d.ts

@@ -1,5 +1,5 @@
 import type { Color } from "../../renderer";
-import type { ResttySearchViewportMatch } from "../types";
+import type { ResttySearchViewportMatch } from "../core/models";
 export type SearchCellHighlightKind = 0 | 1 | 2;
 type AppendSearchHighlightsOptions = {
     target: number[];

package/dist/runtime/create-runtime/search-runtime/index.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSearch, RuntimeSearchOptions } from "./types";
+export declare function createRuntimeSearch(options: RuntimeSearchOptions): RuntimeSearch;

package/dist/runtime/create-runtime/{search-runtime.d.ts → search-runtime/types.d.ts}

@@ -1,14 +1,19 @@
 import type { ResttyWasm, SearchViewportMatch } from "../../wasm";
-import type { ResttyAppCallbacks, ResttySearchState } from "../types";
-type CreateRuntimeSearchOptions = {
-    callbacks?: ResttyAppCallbacks;
+import type { ResttySearchState } from "../core/models";
+import type { ResttyRuntimeCallbacks } from "../core/resources";
+import type { ResttyRuntimeEvent } from "../core/runtime-events";
+export type RuntimeSearchOptions = {
+    callbacks?: ResttyRuntimeCallbacks;
     cleanupFns: Array<() => void>;
+    emitRuntimeEvent?: (event: Extract<ResttyRuntimeEvent, {
+        type: "search-state";
+    }>) => void;
     getWasmReady: () => boolean;
     getWasm: () => ResttyWasm | null;
     getWasmHandle: () => number;
     markNeedsRender: () => void;
 };
-type RuntimeSearch = {
+export type RuntimeSearch = {
     setQuery: (query: string) => void;
     clear: () => void;
     next: () => void;
@@ -18,5 +23,3 @@ type RuntimeSearch = {
     markDirty: () => void;
     handleWasmReset: () => void;
 };
-export declare function createRuntimeSearch(options: CreateRuntimeSearchOptions): RuntimeSearch;
-export {};

package/dist/runtime/create-runtime/shader-stage-runtime.d.ts

@@ -1,29 +1,2 @@
-import type { WebGPUState, WebGLState } from "../../renderer";
-import type { CompiledWebGPUShaderStage, WebGPUStageTargets, CompiledWebGLShaderStage, WebGLStageTargets } from "../create-app-types";
-import type { ResttyShaderStage } from "../types";
-export type CreateShaderStageRuntimeOptions = {
-    appendLog: (line: string) => void;
-    getCanvasSize: () => {
-        width: number;
-        height: number;
-    };
-    getActiveWebGLState: () => WebGLState | null;
-    onShaderStagesChanged: () => void;
-};
-export type ShaderStageRuntime = {
-    setShaderStages: (stages: ResttyShaderStage[]) => void;
-    getShaderStages: () => ResttyShaderStage[];
-    isShaderStagesDirty: () => boolean;
-    setShaderStagesDirty: (value: boolean) => void;
-    getCompiledWebGPUShaderStages: () => CompiledWebGPUShaderStage[];
-    getCompiledWebGLShaderStages: () => CompiledWebGLShaderStage[];
-    clearWebGPUShaderStages: () => void;
-    clearWebGLShaderStages: (state?: WebGLState | null) => void;
-    destroyWebGPUStageTargets: () => void;
-    destroyWebGLStageTargets: (state?: WebGLState | null) => void;
-    ensureWebGPUStageTargets: (state: WebGPUState) => WebGPUStageTargets | null;
-    ensureWebGLStageTargets: (state: WebGLState) => WebGLStageTargets | null;
-    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
-    rebuildWebGLShaderStages: (state: WebGLState) => void;
-};
-export declare function createShaderStageRuntime(options: CreateShaderStageRuntimeOptions): ShaderStageRuntime;
+import type { ShaderStageRuntime, ShaderStageRuntimeOptions } from "./shader-stage-runtime.types";
+export declare function createShaderStageRuntime(options: ShaderStageRuntimeOptions): ShaderStageRuntime;

package/dist/runtime/create-runtime/shader-stage-runtime.types.d.ts

@@ -0,0 +1,27 @@
+import type { WebGPUState, WebGLState } from "../../renderer";
+import type { CompiledWebGLShaderStage, CompiledWebGPUShaderStage, WebGLStageTargets, WebGPUStageTargets } from "./render-stage-runtime.types";
+import type { ResttyShaderStage } from "../core/models";
+export type ShaderStageRuntimeOptions = {
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+    };
+    getActiveWebGLState: () => WebGLState | null;
+    onShaderStagesChanged: () => void;
+};
+export type ShaderStageRuntime = {
+    setShaderStages: (stages: ResttyShaderStage[]) => void;
+    getShaderStages: () => ResttyShaderStage[];
+    isShaderStagesDirty: () => boolean;
+    setShaderStagesDirty: (value: boolean) => void;
+    getCompiledWebGPUShaderStages: () => CompiledWebGPUShaderStage[];
+    getCompiledWebGLShaderStages: () => CompiledWebGLShaderStage[];
+    clearWebGPUShaderStages: () => void;
+    clearWebGLShaderStages: (state?: WebGLState | null) => void;
+    destroyWebGPUStageTargets: () => void;
+    destroyWebGLStageTargets: (state?: WebGLState | null) => void;
+    ensureWebGPUStageTargets: (state: WebGPUState) => WebGPUStageTargets | null;
+    ensureWebGLStageTargets: (state: WebGLState) => WebGLStageTargets | null;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+};

package/dist/runtime/{text-decoration.d.ts → create-runtime/text-decoration.d.ts}

@@ -1,4 +1,4 @@
-import { type Color } from "../renderer";
+import { type Color } from "../../renderer";
 export declare function drawUnderlineStyle(underlineData: number[], style: number, x: number, rowY: number, cellW: number, cellH: number, baseY: number, underlineOffsetPx: number, underlineThicknessPx: number, color: Color): void;
 export declare function drawStrikethrough(underlineData: number[], x: number, rowY: number, cellW: number, cellH: number, color: Color): void;
 export declare function drawOverline(underlineData: number[], x: number, rowY: number, cellW: number, color: Color): void;

package/dist/runtime/create-runtime.d.ts

@@ -1,7 +1,7 @@
-import type { ResttyApp, ResttyAppOptions } from "./types";
-export { createResttyAppSession, getDefaultResttyAppSession } from "./session";
-export { createResttyPaneManager } from "../surface/panes/manager";
-export { createDefaultResttyPaneContextMenuItems, getResttyShortcutModifierLabel, } from "../surface/panes/default-context-menu-items";
-export type { ResttyAppElements, ResttyAppCallbacks, FontSource, ResttyFontHintTarget, ResttyFontSource, ResttyTouchSelectionMode, ResttyUrlFontSource, ResttyBufferFontSource, ResttyLocalFontSource, ResttyWasmLogListener, ResttyAppSession, ResttyAppInputPayload, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, ResttyAppOptions, ResttyApp, } from "./types";
-export type { ResttyPaneSplitDirection, ResttyPaneContextMenuItem, ResttyPaneDefinition, ResttyPaneStyleOptions, ResttyPaneStylesOptions, ResttyPaneShortcutsOptions, ResttyPaneContextMenuOptions, CreateResttyPaneManagerOptions, ResttyPaneManager, ResttyPaneWithApp, CreateDefaultResttyPaneContextMenuItemsOptions, } from "../surface/panes-types";
-export declare function createResttyApp(options: ResttyAppOptions): ResttyApp;
+import type { ResttyRuntime } from "./core/api";
+import type { ResttyRuntimeConfig } from "./core/config";
+export { createResttyRuntimeSession, getDefaultResttyRuntimeSession } from "./core/session";
+export type { ResttyRuntime } from "./core/api";
+export type { ResttyRuntimeConfig } from "./core/config";
+export type { ResttyRuntimeCallbacks, ResttyFontData, ResttyFontInput, ResttyFontUrlInput, ResttyFontPathInput, ResttyFontBufferInput, ResttyFontFamilyInput, ResttyFontFallbackInput, ResttyFontStyle, ResttyLocalFontMode, ResttyFontHintTarget, ResttyTouchSelectionMode, ResttyWasmLogListener, ResttyRuntimeSession, ResttyRuntimeInputPayload, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, ResttyRuntimeEvent, ResttyRuntimeLifecycleState, } from "./types";
+export declare function createResttyRuntime(options: ResttyRuntimeConfig): ResttyRuntime;

package/dist/runtime/font-atlas-utils/glyph-atlas-builder.d.ts

@@ -1,5 +1,5 @@
 import { type Font, type FontAtlas, type FontSizeMode } from "../../fonts";
-import type { GlyphConstraintMeta, AtlasConstraintContext } from "../atlas-builder";
+import type { GlyphConstraintMeta, AtlasConstraintContext } from "../fonts/atlas-builder";
 import type { GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph } from "text-shaper";
 export type RasterizeGlyphTransformOptions = GlyphRasterizeOptions & {
     offsetX26?: number;

package/dist/runtime/font-atlas-utils/nerd-metrics-utils.d.ts

@@ -1,5 +1,5 @@
 import type { Font } from "../../fonts";
-import type { GlyphConstraintMeta, AtlasConstraintContext } from "../atlas-builder";
+import type { GlyphConstraintMeta, AtlasConstraintContext } from "../fonts/atlas-builder";
 export declare function resolveFontScaleForAtlas(font: Font | null | undefined, fontSize: number, sizeMode?: "em" | "height" | null): number;
 export declare function fontCapHeightUnits(font: Font | null | undefined): number;
 export declare function buildNerdMetrics(cellW: number, cellH: number, lineHeight: number, primaryFont: Font | null | undefined, primaryScale: number, iconScale: number): {

package/dist/runtime/{atlas-builder.d.ts → fonts/atlas-builder.d.ts}

@@ -1,4 +1,4 @@
-import type { Font, FontAtlas, FontEntry, FontSizeMode } from "../fonts";
+import type { Font, FontAtlas, FontEntry, FontSizeMode } from "../../fonts";
 import type { AtlasOptions, GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph } from "text-shaper";
 /**
  * Metadata for constrained glyph rendering.