@felipe-software/react-native-gpui 0.0.0-stage → 1.0.1

package/cli/hotReload.ts

@@ -0,0 +1,210 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync, watch, type FSWatcher } from "node:fs";
+import { createConnection } from "node:net";
+import { extname, join, relative, resolve, sep } from "node:path";
+
+export type HotReloadOptions = {
+    socketPath?: string;
+    roots: string[];
+    entryPath?: string;
+    buildCommand?: string;
+    bundlePath?: string;
+    ignores?: string[];
+    extensions?: string[];
+    debounceMs?: number;
+    label?: string;
+    once?: boolean;
+};
+
+const DEFAULT_IGNORES = ["node_modules", ".git", ".gpui", ".gpui-out", "dist"];
+const DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".css"];
+const SOCKET_READY_TIMEOUT_MS = 5_000;
+const BUNDLE_SCRIPT = join(import.meta.dirname, "..", "scripts", "bundle-app.mjs");
+
+export async function runHotReload(options: HotReloadOptions): Promise<number> {
+    const socketPath = options.socketPath || process.env.RNGPUI_CONTROL_SOCKET;
+    if (!socketPath) {
+        console.error("  dev needs --socket <control.sock> or RNGPUI_CONTROL_SOCKET");
+        return 1;
+    }
+    if (!options.buildCommand && !options.entryPath) {
+        console.error("  dev needs --launch <entry.tsx> or --build <shell-command>");
+        return 1;
+    }
+    if (!options.bundlePath) {
+        console.error("  dev needs --bundle <bundle.js>");
+        return 1;
+    }
+
+    const label = options.label || "rngpui-hot";
+    const run = () => buildAndPush({ ...options, socketPath, label });
+    if (options.once) return (await run()) ? 0 : 1;
+
+    const roots = [
+        ...new Set(options.roots.map((root) => resolve(root)).filter((root) => existsSync(root) && statSync(root).isDirectory())),
+    ];
+    if (roots.length === 0) {
+        console.error("  dev needs at least one existing --root <dir>");
+        return 1;
+    }
+
+    const ignores = new Set([...DEFAULT_IGNORES, ...(options.ignores ?? [])].filter(Boolean));
+    const extensions = new Set(normalizeExtensions(options.extensions?.length ? options.extensions : DEFAULT_EXTENSIONS));
+    const debounceMs = options.debounceMs ?? 80;
+    const watchers: FSWatcher[] = [];
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    let building = false;
+    let pending = false;
+    let lastTrigger = "";
+
+    const ignored = (path: string) => path.split(sep).some((part) => ignores.has(part));
+    const schedule = (path: string) => {
+        if (ignored(path) || !extensions.has(extname(path))) return;
+        lastTrigger = relative(process.cwd(), path);
+        pending = true;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(runPending, debounceMs);
+    };
+    const runPending = async () => {
+        timer = null;
+        if (building || !pending) return;
+        pending = false;
+        building = true;
+        console.log(`[${label}] ${lastTrigger || "source change"} -> hot update`);
+        try {
+            await run();
+        } catch (error) {
+            console.error(`[${label}] hot update error: ${error instanceof Error ? error.message : String(error)}`);
+        } finally {
+            building = false;
+            if (pending) void runPending();
+        }
+    };
+    for (const root of roots) {
+        const watcher = watch(root, { recursive: true }, (_event, file) => {
+            if (file) schedule(resolve(root, String(file)));
+        });
+        watcher.on("error", (error) => {
+            console.error(`[${label}] watch error ${root}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        watchers.push(watcher);
+    }
+
+    console.log(`[${label}] Fast Refresh armed: ${roots.map((root) => relative(process.cwd(), root) || root).join(", ")}`);
+    console.log(`[${label}] control socket: ${socketPath}`);
+    await new Promise<void>((resolveDone) => {
+        const close = () => {
+            closeWatchers(watchers);
+            resolveDone();
+        };
+        process.once("SIGINT", close);
+        process.once("SIGTERM", close);
+    });
+    return 0;
+}
+
+async function buildAndPush(options: HotReloadOptions & { socketPath: string; label: string }) {
+    const started = Date.now();
+    const env = { ...process.env, NODE_ENV: "development", RNGPUI_HOT_UPDATE: "1" };
+    const status = options.entryPath
+        ? await runProcess(process.execPath, [BUNDLE_SCRIPT, resolve(options.entryPath), resolve(options.bundlePath!)], env)
+        : await runProcess("/bin/sh", ["-lc", options.buildCommand!], env);
+    if (status !== 0) {
+        console.error(`[${options.label}] build failed with status ${status}; current app remains active`);
+        return false;
+    }
+    const bundlePath = resolve(options.bundlePath!);
+    const code = readFileSync(bundlePath, "utf8");
+    let response: { ok: boolean; error?: string };
+    try {
+        response = await requestSocketWithRetry<{ ok: boolean; error?: string }>(
+            options.socketPath,
+            {
+                $cmd: "hotEval",
+                url: bundlePath,
+                code,
+            },
+            SOCKET_READY_TIMEOUT_MS,
+        );
+    } catch (error) {
+        console.error(`[${options.label}] hot update request failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    if (response.ok) {
+        console.log(`[${options.label}] hot update applied in ${Date.now() - started}ms`);
+        return true;
+    }
+    console.error(`[${options.label}] hot update failed: ${response.error || "unknown error"}`);
+    return false;
+}
+
+function runProcess(command: string, args: string[], env: NodeJS.ProcessEnv): Promise<number> {
+    return new Promise((resolveStatus, reject) => {
+        const child = spawn(command, args, { cwd: process.cwd(), stdio: "inherit", env });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => resolveStatus(code ?? (signal ? 1 : 0)));
+    });
+}
+
+function requestSocket<T>(socketPath: string, body: object): Promise<T> {
+    return new Promise((resolveRequest, reject) => {
+        const socket = createConnection(socketPath);
+        let buffer = "";
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error(`control request timed out on ${socketPath}`));
+        }, 10_000);
+        socket.on("connect", () => {
+            socket.write(JSON.stringify(body) + "\n");
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const idx = buffer.indexOf("\n");
+            if (idx < 0) return;
+            clearTimeout(timer);
+            socket.end();
+            resolveRequest(JSON.parse(buffer.slice(0, idx)) as T);
+        });
+        socket.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+
+async function requestSocketWithRetry<T>(socketPath: string, body: object, timeoutMs: number): Promise<T> {
+    const deadline = Date.now() + timeoutMs;
+    let lastError: unknown;
+    while (Date.now() < deadline) {
+        try {
+            return await requestSocket<T>(socketPath, body);
+        } catch (error) {
+            if (!isTransientSocketError(error)) throw error;
+            lastError = error;
+            await sleep(50);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`control socket was not ready: ${socketPath}`);
+}
+
+function isTransientSocketError(error: unknown): boolean {
+    const code = typeof error === "object" && error ? (error as { code?: unknown }).code : undefined;
+    return code === "ENOENT" || code === "ECONNREFUSED";
+}
+
+function sleep(ms: number) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+
+function normalizeExtensions(values: string[]): string[] {
+    return values
+        .flatMap((value) => value.split(","))
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => (value.startsWith(".") ? value : `.${value}`));
+}
+
+function closeWatchers(watchers: FSWatcher[]) {
+    for (const watcher of watchers) watcher.close();
+    watchers.length = 0;
+}

package/cli/run.ts

@@ -0,0 +1,66 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { constants, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { resolveServiceBinary, uiRuntimeEnv } from "../scripts/service-binary.mjs";
+import { bundleApp } from "./bundle";
+
+export type RunOptions = {
+    entry?: string;
+    bundle?: string;
+    development: boolean;
+    size?: string;
+};
+
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
+
+export async function runApp(options: RunOptions): Promise<number> {
+    if (!options.entry && !options.bundle) {
+        console.error("  run needs an entry (rngpui run app.tsx) or --bundle <app.js>");
+        return 1;
+    }
+    const windowSize = parseSize(options.size);
+    const workdir = options.bundle ? null : mkdtempSync(join(tmpdir(), "rngpui-run-"));
+    const cleanup = () => {
+        if (workdir) rmSync(workdir, { recursive: true, force: true });
+    };
+    try {
+        const bundlePath = options.bundle
+            ? resolve(options.bundle)
+            : bundleApp(options.entry!, join(workdir!, "app.js"), { development: options.development, inheritOutput: true });
+        const service = resolveServiceBinary();
+        console.error(`[rngpui] ${service.path} (${service.source})`);
+        const child = spawn(service.path, [], {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                ...uiRuntimeEnv(service.path),
+                RNGPUI_BUNDLE: bundlePath,
+                ...(windowSize ? { RNGPUI_WINDOW_SIZE: windowSize } : {}),
+            },
+        });
+        const forward = (signal: NodeJS.Signals) => child.kill(signal);
+        for (const signal of FORWARDED_SIGNALS) process.on(signal, forward);
+        const code = await new Promise<number>((resolveExit) => {
+            child.on("error", (error) => {
+                console.error(`  failed to start ${service.path}: ${error.message}`);
+                resolveExit(1);
+            });
+            child.on("exit", (exitCode, signal) => {
+                const signalCode = signal ? 128 + (constants.signals[signal] ?? 0) : 1;
+                resolveExit(exitCode ?? signalCode);
+            });
+        });
+        for (const signal of FORWARDED_SIGNALS) process.off(signal, forward);
+        return code;
+    } finally {
+        cleanup();
+    }
+}
+
+function parseSize(size: string | undefined): string | null {
+    if (!size) return null;
+    const match = /^(\d+)x(\d+)$/.exec(size);
+    if (!match) throw new Error(`--size must look like 1280x860, got ${size}`);
+    return `${match[1]},${match[2]}`;
+}

package/cli/selectors.ts

@@ -0,0 +1,205 @@
+// Selector resolution for the `rngpui` CLI, modeled on sootsim's tap-id / tap-text
+// ergonomics. A selector is one of:
+//   #<globalId>      exact node id
+//   <substring>      case-insensitive substring match on testID / accessibility
+//                    identifier / nativeID / label / text / type (in that priority)
+//   <x>,<y>          a literal window-coordinate point (handled by the caller)
+//
+// Resolution prefers the SMALLEST visible matching node (the most specific target),
+// matching how a human reads "the composer input" as the input itself, not its
+// container.
+
+import type { DumpNode } from "./host";
+
+export type ResolvedNode = {
+    node: DumpNode;
+    matchedField: string;
+    matchedValue: string;
+};
+
+export function parsePoint(selector: string): { x: number; y: number } | null {
+    const m = /^(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/.exec(selector.trim());
+    if (!m) return null;
+    return { x: Number(m[1]), y: Number(m[2]) };
+}
+
+export function isVisible(node: DumpNode): boolean {
+    const b = node.bounds;
+    return !!b && b.width > 0.5 && b.height > 0.5;
+}
+
+function fieldsOf(node: DumpNode): Array<{ field: string; value: string }> {
+    const out: Array<{ field: string; value: string }> = [];
+    const a = node.accessibility ?? {};
+    if (a.testID) out.push({ field: "testID", value: a.testID });
+    if (a.identifier) out.push({ field: "identifier", value: a.identifier });
+    if (a.nativeID) out.push({ field: "nativeID", value: a.nativeID });
+    if (a.label) out.push({ field: "label", value: a.label });
+    if (typeof node.text === "string" && node.text.trim()) out.push({ field: "text", value: node.text });
+    if (typeof node.value === "string" && node.value.trim()) out.push({ field: "value", value: node.value });
+    out.push({ field: "type", value: node.type });
+    return out;
+}
+
+function area(node: DumpNode): number {
+    const b = node.bounds;
+    return b ? b.width * b.height : Infinity;
+}
+
+export function* walk(root: DumpNode): Generator<DumpNode> {
+    yield root;
+    for (const child of root.children ?? []) yield* walk(child);
+}
+
+export function findById(root: DumpNode, id: number): DumpNode | null {
+    for (const node of walk(root)) if (node.globalId === id) return node;
+    return null;
+}
+
+// Resolve a selector to the best-matching node. Ranks by field priority (testID >
+// identifier > nativeID > label > text > value > type), then prefers visible nodes,
+// then the smallest area (most specific). Returns all candidates for diagnostics.
+export function resolve(root: DumpNode, selector: string): { best: ResolvedNode | null; candidates: ResolvedNode[] } {
+    if (selector.startsWith("#")) {
+        const id = Number(selector.slice(1));
+        const node = Number.isFinite(id) ? findById(root, id) : null;
+        const best = node ? { node, matchedField: "globalId", matchedValue: String(id) } : null;
+        return { best, candidates: best ? [best] : [] };
+    }
+
+    const needle = selector.toLowerCase();
+    const fieldRank: Record<string, number> = {
+        testID: 0,
+        identifier: 1,
+        nativeID: 2,
+        label: 3,
+        text: 4,
+        value: 5,
+        type: 6,
+    };
+
+    const candidates: Array<ResolvedNode & { rank: number; exact: boolean }> = [];
+    for (const node of walk(root)) {
+        for (const { field, value } of fieldsOf(node)) {
+            const v = value.toLowerCase();
+            if (v.includes(needle)) {
+                candidates.push({
+                    node,
+                    matchedField: field,
+                    matchedValue: value,
+                    rank: fieldRank[field] ?? 9,
+                    exact: v === needle,
+                });
+                break; // one match per node, highest-priority field
+            }
+        }
+    }
+
+    candidates.sort((a, b) => {
+        // exact match beats substring
+        if (a.exact !== b.exact) return a.exact ? -1 : 1;
+        // higher-priority field
+        if (a.rank !== b.rank) return a.rank - b.rank;
+        // visible beats not
+        const av = isVisible(a.node) ? 0 : 1;
+        const bv = isVisible(b.node) ? 0 : 1;
+        if (av !== bv) return av - bv;
+        // smallest area (most specific)
+        return area(a.node) - area(b.node);
+    });
+
+    const best = candidates[0] ? { node: candidates[0].node, matchedField: candidates[0].matchedField, matchedValue: candidates[0].matchedValue } : null;
+    return { best, candidates: candidates.map((c) => ({ node: c.node, matchedField: c.matchedField, matchedValue: c.matchedValue })) };
+}
+
+// Topmost painted surface at a window point. Later or higher-z siblings paint above
+// earlier siblings; a transparent layout wrapper does not cover an underlay surface.
+export function nodeAtPoint(root: DumpNode, x: number, y: number): DumpNode | null {
+    let fallback: { node: DumpNode; depth: number; z: number } | null = null;
+
+    // visit() walks topmost siblings FIRST, so on a full depth/z tie the
+    // earlier-seen candidate is the topmost in paint order — never replace it.
+    const rememberFallback = (node: DumpNode, depth: number) => {
+        const z = zIndexOf(node);
+        const candidate = { node, depth, z };
+        if (
+            !fallback ||
+            candidate.depth > fallback.depth ||
+            (candidate.depth === fallback.depth && candidate.z > fallback.z)
+        ) {
+            fallback = candidate;
+        }
+    };
+
+    const visit = (node: DumpNode, depth: number): DumpNode | null => {
+        // gpui inherits group opacity — an opacity:0 ancestor hides its whole
+        // subtree, so nothing under it can be the painted surface at the point.
+        if (Number(node.style?.opacity ?? 1) === 0) return null;
+        const inside = containsPoint(node, x, y);
+        if (inside) rememberFallback(node, depth);
+
+        const clipsChildren = ["hidden", "scroll", "auto"].includes(String(node.style?.overflow ?? ""));
+        if (inside || !clipsChildren) {
+            const children = [...(node.children ?? [])]
+                .map((child, index) => ({ child, index, z: zIndexOf(child) }))
+                .sort((a, b) => a.z - b.z || a.index - b.index);
+            for (let i = children.length - 1; i >= 0; i--) {
+                const hit = visit(children[i].child, depth + 1);
+                if (hit) return hit;
+            }
+        }
+
+        return inside && paintsSurface(node) ? node : null;
+    };
+
+    return visit(root, 0) ?? fallback?.node ?? null;
+}
+
+function containsPoint(node: DumpNode, x: number, y: number): boolean {
+    if (!isVisible(node)) return false;
+    const b = node.bounds!;
+    return x >= b.x && x <= b.x + b.width && y >= b.y && y <= b.y + b.height;
+}
+
+function zIndexOf(node: DumpNode): number {
+    const z = Number(node.style?.zIndex ?? 0);
+    return Number.isFinite(z) ? z : 0;
+}
+
+function borderWidthOf(style: Record<string, unknown>): number {
+    return Math.max(
+        Number(style.borderWidth ?? 0) || 0,
+        Number(style.borderTopWidth ?? 0) || 0,
+        Number(style.borderRightWidth ?? 0) || 0,
+        Number(style.borderBottomWidth ?? 0) || 0,
+        Number(style.borderLeftWidth ?? 0) || 0,
+    );
+}
+
+function paintsSurface(node: DumpNode): boolean {
+    if (!isVisible(node)) return false;
+    if (["webview", "image", "svg", "text", "textinput", "textarea"].includes(node.type)) return true;
+
+    const style = node.style ?? {};
+    if (style.backgroundImage) return true;
+    if (isVisibleColor(style.backgroundColor)) return true;
+    if (isVisibleColor(style.borderColor) && borderWidthOf(style) > 0) return true;
+    return typeof style.boxShadow === "string" && style.boxShadow !== "" && style.boxShadow !== "none";
+}
+
+function isVisibleColor(value: unknown): boolean {
+    if (typeof value !== "string") return false;
+    const color = value.trim().toLowerCase();
+    if (!color || color === "transparent") return false;
+    const hex8 = /^#([0-9a-f]{8})$/.exec(color);
+    if (hex8) return hex8[1].slice(6) !== "00";
+    const hex4 = /^#([0-9a-f]{4})$/.exec(color);
+    if (hex4) return hex4[1].slice(3) !== "0";
+    return !/rgba\([^)]*,\s*0(?:\.0+)?\s*\)$/.test(color);
+}
+
+export function centerOf(node: DumpNode): { x: number; y: number } | null {
+    const b = node.bounds;
+    if (!b) return null;
+    return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+}

package/dist/Animated.d.ts

@@ -0,0 +1,120 @@
+type EndCallback = (result: {
+    finished: boolean;
+}) => void;
+interface CompositeAnimation {
+    start(cb?: EndCallback): void;
+    stop(): void;
+    reset(): void;
+}
+export declare class AnimatedValue {
+    _value: number;
+    private _listeners;
+    private _nextListenerId;
+    constructor(value?: number);
+    setValue(value: number): void;
+    setOffset(_offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    addListener(_cb: (state: {
+        value: number;
+    }) => void): string;
+    removeListener(_id: string): void;
+    removeAllListeners(): void;
+    stopAnimation(cb?: (value: number) => void): void;
+    resetAnimation(cb?: (value: number) => void): void;
+    interpolate(config: InterpolationConfig): AnimatedInterpolation;
+    __getValue(): number;
+    private _emit;
+}
+type InterpolationConfig = {
+    inputRange: number[];
+    outputRange: Array<number | string>;
+    extrapolate?: "extend" | "clamp" | "identity";
+    extrapolateLeft?: "extend" | "clamp" | "identity";
+    extrapolateRight?: "extend" | "clamp" | "identity";
+};
+export declare class AnimatedInterpolation {
+    private parent;
+    private config;
+    constructor(parent: AnimatedValue, config: InterpolationConfig);
+    addListener(cb: (state: {
+        value: number;
+    }) => void): string;
+    removeListener(id: string): void;
+    __getValue(): number | string;
+}
+declare class AnimatedValueXY {
+    x: AnimatedValue;
+    y: AnimatedValue;
+    constructor(value?: {
+        x?: number;
+        y?: number;
+    });
+    setValue(value: {
+        x: number;
+        y: number;
+    }): void;
+    getLayout(): {
+        left: AnimatedValue;
+        top: AnimatedValue;
+    };
+    getTranslateTransform(): ({
+        translateX: AnimatedValue;
+        translateY?: undefined;
+    } | {
+        translateY: AnimatedValue;
+        translateX?: undefined;
+    })[];
+}
+type AnimationConfig = {
+    toValue?: unknown;
+    duration?: number;
+    delay?: number;
+    easing?: (value: number) => number;
+};
+export declare const Animated: {
+    View: (props: Record<string, unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    Text: (props: Record<string, unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    Image: (props: Record<string, unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    ScrollView: (props: Record<string, unknown>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    timing: (value: unknown, config: AnimationConfig) => CompositeAnimation;
+    spring: (value: unknown, config: AnimationConfig) => CompositeAnimation;
+    decay: (value: unknown, config: AnimationConfig) => CompositeAnimation;
+    parallel: (anims: CompositeAnimation[]) => CompositeAnimation;
+    sequence: (anims: CompositeAnimation[]) => CompositeAnimation;
+    stagger: (_ms: number, anims: CompositeAnimation[]) => CompositeAnimation;
+    loop: (anim: CompositeAnimation, config?: {
+        iterations?: number;
+    }) => CompositeAnimation;
+    delay: (ms: number) => CompositeAnimation;
+    event: (_argMapping: unknown, _config?: unknown) => () => void;
+    createAnimatedComponent: <T>(component: T) => T;
+    add: (a: AnimatedValue) => AnimatedValue;
+    subtract: (a: AnimatedValue) => AnimatedValue;
+    multiply: (a: AnimatedValue) => AnimatedValue;
+    divide: (a: AnimatedValue) => AnimatedValue;
+    modulo: (a: AnimatedValue) => AnimatedValue;
+    diffClamp: () => AnimatedValue;
+};
+export declare const Easing: {
+    linear: (t: number) => number;
+    ease: (t: number) => number;
+    quad: (t: number) => number;
+    cubic: (t: number) => number;
+    poly: (n: number) => (t: number) => number;
+    sin: (t: number) => number;
+    circle: (t: number) => number;
+    exp: (t: number) => number;
+    elastic: () => (t: number) => number;
+    back: () => (t: number) => number;
+    bounce: (t: number) => number;
+    bezier: () => (t: number) => number;
+    in: (fn: (t: number) => number) => (t: number) => number;
+    out: (fn: (t: number) => number) => (t: number) => number;
+    inOut: (fn: (t: number) => number) => (t: number) => number;
+    step0: (n: number) => 0 | 1;
+    step1: (n: number) => 0 | 1;
+};
+export {};

package/dist/ChatList.d.ts

@@ -0,0 +1,28 @@
+import type { ChatListHandle } from "./chat-list-types";
+export declare const ChatList: import("react").ForwardRefExoticComponent<import("./types").ViewProps & {
+    fontSize?: number;
+    fontFamily?: string;
+    textColor?: string;
+    mutedColor?: string;
+    linkColor?: string;
+    selectionColor?: string;
+    separatorColor?: string;
+    alternateBackground?: string;
+    scrollbarColor?: string;
+    disabledOpacity?: number;
+    historicalOpacity?: number;
+    showTimestamps?: boolean;
+    emoteScale?: number;
+    animateEmotes?: boolean;
+    maxMessages?: number;
+    pauseOnHover?: boolean;
+    onPress?: (event: {
+        nativeEvent: import("./chat-list-types").ChatListPressEvent;
+    }) => void;
+    onHover?: (event: {
+        nativeEvent: import("./chat-list-types").ChatListHoverEvent | null;
+    }) => void;
+    onScrollState?: (event: {
+        nativeEvent: import("./chat-list-types").ChatListScrollState;
+    }) => void;
+} & import("react").RefAttributes<ChatListHandle>>;

package/dist/Dimensions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * RN-compatible Dimensions API, backed by the GPUI window's real size.
+ *
+ * The service emits a `{type:"resize",width,height}` event whenever the window
+ * content box changes; the runtime calls `_setWindow(...)`, which updates the
+ * cached size and fires every `change` listener — exactly like RN's Dimensions.
+ */
+export type ScaledSize = {
+    width: number;
+    height: number;
+    scale: number;
+    fontScale: number;
+};
+type ChangeHandler = (dims: {
+    window: ScaledSize;
+    screen: ScaledSize;
+}) => void;
+export declare const Dimensions: {
+    get(dim: "window" | "screen"): ScaledSize;
+    set(_dims: Record<string, ScaledSize>): void;
+    addEventListener(type: "change", handler: ChangeHandler): {
+        remove: () => void;
+    };
+    removeEventListener(type: "change", handler: ChangeHandler): void;
+    /** internal: called by the runtime when the window reports a new size.
+     *  Debounced to avoid rapid re-renders during OS-level window resize drag,
+     *  which can fire at 120Hz. Pass false while seeding the first render, before
+     *  subscribers exist. Returns true if the size actually changed. */
+    _setWindow(width: number, height: number, notifyListeners?: boolean): boolean;
+};
+export {};

package/dist/StyleSheet.d.ts

@@ -0,0 +1,18 @@
+/**
+ * StyleSheet — RN-compatible. `create` is an identity helper; `flatten` collapses
+ * arrays; `normalize` expands RN shorthands (paddingHorizontal, shadow*, …) into
+ * the flat style the GPUI bridge understands.
+ */
+import type { ViewStyle, TextStyle, ImageStyle, StyleProp } from "./types";
+type AnyStyle = Record<string, unknown>;
+export declare const StyleSheet: {
+    create<T extends Record<string, ViewStyle | TextStyle | ImageStyle>>(styles: T): T;
+    hairlineWidth: number;
+    absoluteFill: ViewStyle;
+    absoluteFillObject: ViewStyle;
+    flatten<T>(style?: StyleProp<T>): T;
+};
+/** Expand RN shorthands → the flat camelCase keys the Rust bridge reads. */
+export declare function normalizeStyle(style: StyleProp<ViewStyle | TextStyle | ImageStyle>): AnyStyle | undefined;
+export declare function cssColorString(value: unknown): string | undefined;
+export {};