restty 0.1.34 → 0.2.0

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

@@ -1,46 +1,2 @@
-import type { InputHandler } from "../../input";
-import type { PtyResizeMeta, PtyTransport } from "../../pty";
-import type { PtyOutputBufferController } from "../pty-output-buffer";
-type CursorPosition = {
-    row: number;
-    col: number;
-};
-type SendInput = (text: string, source?: string, options?: {
-    skipHooks?: boolean;
-}) => void;
-export type CreatePtyInputRuntimeOptions = {
-    ptyTransport: PtyTransport;
-    ptyOutputBuffer: PtyOutputBufferController;
-    inputHandler: InputHandler;
-    ptyStatusEl?: HTMLElement | null;
-    mouseStatusEl?: HTMLElement | null;
-    onPtyStatus?: ((status: string) => void) | null;
-    onMouseStatus?: ((status: string) => void) | null;
-    appendLog: (line: string) => void;
-    getGridSize: () => {
-        cols: number;
-        rows: number;
-    };
-    getResizeMeta?: () => PtyResizeMeta | null;
-    getCursorForCpr: () => CursorPosition;
-    sendInput: SendInput;
-    runBeforeInputHook: (text: string, source: string) => string | null;
-    shouldClearSelection: () => boolean;
-    clearSelection: () => void;
-    syncOutputResetMs: number;
-    syncOutputResetSeq: string;
-};
-export type PtyInputRuntime = {
-    setPtyStatus: (text: string) => void;
-    updateMouseStatus: () => void;
-    scheduleSyncOutputReset: () => void;
-    cancelSyncOutputReset: () => void;
-    connectPty: (url?: string) => void;
-    disconnectPty: () => void;
-    sendKeyInput: (text: string, source?: string) => void;
-    sendPasteText: (text: string) => void;
-    sendPastePayloadFromDataTransfer: (dataTransfer: DataTransfer | null | undefined) => boolean;
-    getCprPosition: () => CursorPosition;
-};
-export declare function createPtyInputRuntime(options: CreatePtyInputRuntimeOptions): PtyInputRuntime;
-export {};
+import type { PtyInputRuntime, PtyInputRuntimeOptions } from "./pty-input-runtime.types";
+export declare function createPtyInputRuntime(options: PtyInputRuntimeOptions): PtyInputRuntime;

package/dist/runtime/create-runtime/pty-input-runtime.types.d.ts

@@ -0,0 +1,41 @@
+import type { InputHandler } from "../../input";
+import type { PtyResizeMeta, PtyTransport } from "../../pty";
+import type { ResttyRuntimeEvent } from "../core/runtime-events";
+export type CursorPosition = {
+    row: number;
+    col: number;
+};
+export type RuntimeSendInput = (text: string, source?: string, options?: {
+    skipHooks?: boolean;
+}) => void;
+export type PtyInputRuntimeOptions = {
+    ptyTransport: PtyTransport;
+    inputHandler: InputHandler;
+    emitRuntimeEvent?: (event: Extract<ResttyRuntimeEvent, {
+        type: "pty-status";
+    }>) => void;
+    getGridSize: () => {
+        cols: number;
+        rows: number;
+    };
+    getResizeMeta?: () => PtyResizeMeta | null;
+    getCursorForCpr: () => CursorPosition;
+    sendInput: RuntimeSendInput;
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    shouldClearSelection: () => boolean;
+    clearSelection: () => void;
+    syncOutputResetMs: number;
+    syncOutputResetSeq: string;
+};
+export type PtyInputRuntime = {
+    setPtyStatus: (text: string) => void;
+    updateMouseStatus: () => void;
+    scheduleSyncOutputReset: () => void;
+    cancelSyncOutputReset: () => void;
+    connectPty: (url?: string) => void;
+    disconnectPty: () => void;
+    sendKeyInput: (text: string, source?: string) => void;
+    sendPasteText: (text: string) => void;
+    sendPastePayloadFromDataTransfer: (dataTransfer: DataTransfer | null | undefined) => boolean;
+    getCprPosition: () => CursorPosition;
+};

package/dist/runtime/{render-color-utils.d.ts → create-runtime/render-color-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { Color } from "../renderer";
+import type { Color } from "../../renderer";
 export declare function decodePackedRGBA(color: number): Color;
 export declare function decodeRGBAWithCache(bytes: Uint8Array, index: number, cache: Map<number, Color>): Color;
 export declare function clamp01(value: number): number;

package/dist/runtime/{render-stage-runtime.d.ts → create-runtime/render-stage-runtime.d.ts}

@@ -1,5 +1,5 @@
-import type { CompiledWebGPUShaderStage, WebGPUStageTargets, CompiledWebGLShaderStage, WebGLStageTargets } from "./create-app-types";
-import type { ResttyShaderStage } from "./types";
+import type { CompiledWebGPUShaderStage, WebGPUStageTargets, CompiledWebGLShaderStage, WebGLStageTargets } from "./render-stage-runtime.types";
+import type { ResttyShaderStage } from "../core/models";
 export declare function compileShaderStageProgram(options: {
     gl: WebGL2RenderingContext;
     stage: ResttyShaderStage;

package/dist/runtime/{create-app-types.d.ts → create-runtime/render-stage-runtime.types.d.ts}

@@ -1,32 +1,4 @@
-import type { ResttyShaderStage } from "./types";
-export type LocalFontsPermissionDescriptor = PermissionDescriptor & {
-    name: "local-fonts";
-};
-export type LocalFontFaceData = {
-    family?: string;
-    fullName?: string;
-    postscriptName?: string;
-    blob: () => Promise<Blob>;
-};
-export type NavigatorWithLocalFontAccess = Navigator & {
-    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
-    permissions?: {
-        query?: (permissionDesc: LocalFontsPermissionDescriptor) => Promise<PermissionStatus>;
-    };
-};
-export type GlobalWithLocalFontAccess = typeof globalThis & {
-    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
-    navigator?: NavigatorWithLocalFontAccess;
-};
-export type ResttyDebugWindow = Window & typeof globalThis & {
-    diagnoseCodepoint?: (cp: number) => void;
-    dumpGlyphMetrics?: (cp: number) => {
-        fontIndex: number;
-        glyphId: number;
-    } | null;
-    dumpAtlasRegion?: (fontIndex: number, x: number, y: number, width: number, height: number) => Promise<ImageData | null>;
-    dumpGlyphRender?: (cp: number, constraintWidth?: number) => Promise<unknown>;
-};
+import type { ResttyShaderStage } from "../core/models";
 export type CompiledWebGPUShaderStage = {
     stage: ResttyShaderStage;
     pipeline: GPURenderPipeline;

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

@@ -1,2 +1,2 @@
-import type { WebGLTickContext } from "./render-tick-webgl-context";
+import type { WebGLTickContext } from "./render-tick-webgl.types";
 export declare function populateWebGLOverlays(ctx: WebGLTickContext): void;

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

@@ -1,2 +1,2 @@
-import type { WebGLTickContext } from "./render-tick-webgl-context";
+import type { WebGLTickContext } from "./render-tick-webgl.types";
 export declare function populateWebGLSceneData(ctx: WebGLTickContext): void;

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,11 +1,12 @@
 import type { FontEntry, FontManagerState } from "../../fonts";
 import type { NerdConstraint } from "../../fonts/nerd-constraints";
 import type { Color, WebGPUState } from "../../renderer";
-import type { CompiledWebGPUShaderStage, WebGPUStageTargets } from "../create-app-types";
-import type { GlyphConstraintMeta } from "../atlas-builder";
-import type { KittyPlacement, RenderState, ResttyWasm, ResttyWasmExports } from "../../wasm";
-import type { KittyDrawPlan, KittyDrawSlice } from "./kitty-render-runtime";
-import type { ResttyFontHintTarget } from "../types";
+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.types";
+import type { ResttyFontHintTarget } from "../core/models";
 export type CursorPosition = {
     col: number;
     row: number;
@@ -99,6 +100,7 @@ export type SharedTickDeps = {
         match: RegExp;
         scale: number;
     }>;
+    getLigatures: () => boolean;
     getFontHinting: () => boolean;
     getFontHintTarget: () => ResttyFontHintTarget;
     isSymbolFont: (entry: FontEntry) => boolean;
@@ -117,9 +119,15 @@ export type SharedTickDeps = {
         start: number;
         end: number;
     } | null;
+    getSearchViewportMatches: () => readonly SearchViewportMatch[];
     pushRect: (target: number[], x: number, y: number, width: number, height: number, color: Color) => void;
     pushRectBox: (target: number[], x: number, y: number, width: number, height: number, color: Color) => void;
-    selectionColor: Color;
+    selectionBackgroundColor: RuntimeTerminalColor;
+    selectionForegroundColor: RuntimeTerminalColor | null;
+    searchMatchBackgroundColor: RuntimeTerminalColor;
+    searchCurrentMatchBackgroundColor: RuntimeTerminalColor;
+    searchMatchTextColor: RuntimeTerminalColor;
+    searchCurrentMatchTextColor: RuntimeTerminalColor;
     STYLE_BOLD: number;
     STYLE_ITALIC: number;
     STYLE_FAINT: number;
@@ -197,7 +205,7 @@ export type SharedTickDeps = {
         lastOffset: number;
         lastLen: number;
     };
-    appendOverlayScrollbar: (target: number[], total: number, offset: number, len: number) => void;
+    syncScrollbar: (total: number, offset: number, len: number) => void;
     webgpuUniforms: Float32Array;
     ensureInstanceBuffer: (state: WebGPUState, kind: "rect" | "glyph", minBytes: number) => void;
     GLYPH_INSTANCE_FLOATS: number;
@@ -244,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) => {
@@ -279,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;
+};