@nativedesktop/react 0.1.0

package/dist/packages/react/src/generated/protocol.d.ts

@@ -0,0 +1,140 @@
+export declare const NDP_VERSION = 1;
+export type WidgetName = "Window" | "Box" | "Label" | "Button" | "TextInput" | "TextArea" | "Checkbox" | "Radio" | "Select" | "Slider" | "ProgressBar" | "Image" | "ScrollView" | "Separator" | "Spinner" | "TabView" | "Grid" | "ListView" | "WebView" | "NativeView" | "SplitView" | "HeaderBar" | "ToolbarView" | "SearchInput" | "SourceList" | "SourceTree" | "Menubar" | "Menu" | "MenuItem" | "SettingsGroup" | "Row" | "SwitchRow" | "Clamp" | "Switch" | "ToggleButton" | "SegmentedControl" | "NumberInput" | "LinkButton" | "LevelIndicator" | "ColorPicker" | "Banner" | "MenuButton" | "SplitButton" | "Popover" | "Expander" | "StatusPage" | "ToastOverlay" | "DatePicker" | "Table" | "TreeView" | "FontPicker" | "Video" | "TrayItem" | "ShareButton" | "Terminal" | "Paned" | "CommandPalette";
+/** Child runtime identity, carried inside the hello frame. */
+export interface Runtime {
+    name: string;
+    version: string;
+}
+/** Typed event payload. Exactly one field is set per event name (see widgets.json events[].payload): changed/activate/navigate/titleChanged -> text, toggled/loadingChanged/backAvailable/forwardAvailable -> checked, valueChanged -> value, selectionChanged -> index, clicked -> none, styleError -> key (the offending style key, M5c-D7), positionChanged -> position (Paned's 0..1 divider fraction, a dedicated field rather than reusing `value` — app-panes-and-tabs codes against the literal name `position`). Serialized with emit_null_optional_fields=false, so clicked still wires as "payload":{} — byte-compatible with M4. */
+export interface EventPayload {
+    text?: string;
+    checked?: boolean;
+    value?: number;
+    index?: number;
+    key?: string;
+    nativeName?: string;
+    data?: unknown;
+    position?: number;
+}
+export type Op = {
+    op: "create";
+    id: number;
+    widget: WidgetName;
+    props: Record<string, unknown>;
+} | {
+    op: "append";
+    parent: number;
+    child: number;
+} | {
+    op: "insertBefore";
+    parent: number;
+    child: number;
+    before: number | null;
+} | {
+    op: "remove";
+    id: number;
+} | {
+    op: "setText";
+    id: number;
+    text: string;
+} | {
+    op: "update";
+    id: number;
+    props: Record<string, unknown>;
+} | {
+    op: "hide";
+    id: number;
+} | {
+    op: "unhide";
+    id: number;
+};
+export interface HelloMsg {
+    type: "hello";
+    ndpVersion: number;
+    runtime: Runtime;
+}
+/** Handshake reply. `encodings` lists CommitBatch encodings the host accepts, host-preference order (ndp-binary spec §2); the runtime picks the first one it supports. `backend` names the host's active widget backend ("gtk" | "appkit") — the authoritative source for `Platform.backend`, since the OS alone can't distinguish it (GTK runs on macOS too). `hostWidgets`/`hostCommands` are the host build's capability manifest: every intrinsic it knows, and every "<intrinsic>.<command>" it dispatches — the source for hasWidget()/hasCommand(); optional so a runtime can still talk to an older host (both absent = fall back to the runtime's own schema tables). */
+export interface HelloAckMsg {
+    type: "helloAck";
+    ndpVersion: number;
+    encodings: string[];
+    backend: string;
+    hostWidgets?: string[];
+    hostCommands?: string[];
+}
+export interface ErrorMsg {
+    type: "error";
+    message: string;
+    expected: number;
+    got: number;
+}
+/** `name` is one of widgets.json's event ndpNames (clicked | changed | activate | toggled | valueChanged | selectionChanged | ...) or styleError. */
+export interface EventMsg {
+    type: "event";
+    seq: number;
+    priority: string;
+    nodeId: number;
+    name: string;
+    payload: EventPayload;
+}
+export interface CommitBatch {
+    type: "commitBatch";
+    commitId: number;
+    generation: number;
+    ops: Op[];
+}
+export interface PingMsg {
+    type: "ping";
+}
+export interface PongMsg {
+    type: "pong";
+}
+/** Best-effort report of an uncaught error. fatal=true means the child exits after sending (the host stashes the text for the crash overlay, M8); fatal=false means the app survived (host prints ND_RUNTIME_ERROR_NONFATAL and must NOT stash, so a stale report never becomes overlay text). */
+export interface RuntimeErrorMsg {
+    type: "runtimeError";
+    message: string;
+    stack: string;
+    fatal: boolean;
+}
+/** Dispatches a loaded native plugin's command (M10); gated on the plugin:<plugin>.<command> capability host-side. */
+export interface PluginCommandMsg {
+    type: "pluginCommand";
+    plugin: string;
+    command: string;
+    arg: unknown;
+}
+/** Reply to pluginCommand, carrying the plugin's JSON result verbatim (host-validated to be well-formed JSON before splicing). */
+export interface PluginResultMsg {
+    type: "pluginResult";
+    result: unknown;
+}
+/** Imperative command on a live widget node (M14 WebView: goBack/goForward/reload/stop). `command` must be one of the node's widget's schema-declared commands (widgets.json commands[]); unknown commands are dropped host-side with ND_WARN. Ordered on the same socket as commitBatch, so a command sent after a commit always sees that commit applied. */
+export interface WidgetCommandMsg {
+    type: "widgetCommand";
+    nodeId: number;
+    command: string;
+    arg: unknown;
+}
+/** App->host request for a native system capability (dialogs, clipboard, notifications, credentials, recent documents, audio). `id` correlates the eventual systemResponse; `method` is a dotted capability method (e.g. "dialog.openFile"); `params` is its JSON argument object. Gated host-side on the method's core:<group> capability. */
+export interface SystemRequestMsg {
+    type: "systemRequest";
+    id: number;
+    method: string;
+    params: unknown;
+}
+/** Reply to a systemRequest, correlated by `id`. On success `ok` is true and `result` carries the method's JSON result; on failure `ok` is false and `errorMessage` carries a message. (The failure field is `errorMessage`, not `error`, because `error` is a Zig keyword the generated host struct can't name.) */
+export interface SystemResponseMsg {
+    type: "systemResponse";
+    id: number;
+    ok: boolean;
+    result?: unknown;
+    errorMessage?: string;
+}
+/** Host-originated app-level event not tied to a widget node: app activation/deactivation, OS open-url/open-file launch, notification clicks, file drops, and capability event streams. `channel` names the stream; `data` carries its JSON payload. */
+export interface SystemEventMsg {
+    type: "systemEvent";
+    channel: string;
+    data: unknown;
+}
+export type RuntimeToHostMsg = HelloMsg | CommitBatch | PingMsg | RuntimeErrorMsg | PluginCommandMsg | WidgetCommandMsg | SystemRequestMsg;
+export type HostToRuntimeMsg = HelloAckMsg | ErrorMsg | EventMsg | PongMsg | PluginResultMsg | SystemResponseMsg | SystemEventMsg;

package/dist/packages/react/src/generated/rpc.d.ts

@@ -0,0 +1,299 @@
+/** Logical units (not device pixels), relative to the window's top-left corner (coordinateSpace "logical-window-topleft"). */
+export interface Geometry {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** SourceList's per-row shape on the wire (M11 SourceList Wave 1) — camelCase iconName, matching the schema prop shape. testID carries SourceTree's per-node testID (null for SourceList rows, which have none). */
+export interface RowJson {
+    title: string;
+    badge: string | null;
+    iconName: string | null;
+    testID: string | null;
+}
+/** One tree-snapshot node. itemCount is ListView's row count (M5c-D4), null for every widget that isn't data-driven; rows is SourceList's ordered row data, null for every widget that isn't row-driven. role/enabled/focused/value are the accessibility-tree fields (M16): role is the widget's schema-declared automation role (null when the type declares none); enabled/focused/value come from a live per-node backend probe and default to true/false/null on backends without the probe. */
+export interface JsonNode {
+    ref: number;
+    type: string;
+    testID: string | null;
+    text: string | null;
+    visible: boolean;
+    geometry: Geometry | null;
+    children: JsonNode[];
+    itemCount: number | null;
+    rows: RowJson[] | null;
+    role: string | null;
+    enabled: boolean;
+    focused: boolean;
+    value: unknown | null;
+}
+export interface GetTreeResult {
+    coordinateSpace: string;
+    root: JsonNode;
+}
+export interface ScreenshotResult {
+    path: string;
+    width: number;
+    height: number;
+}
+export interface ClickResult {
+    ref: number;
+    dispatched: boolean;
+}
+/** ref is the winning match (ranked like resolve: actionable first, key window first, then tree order), so a caller needs no follow-up getTree; count is the number of nodes that satisfied the predicate. */
+export interface WaitForResult {
+    matched: boolean;
+    ref: number | null;
+    count: number;
+}
+export interface SetValueResult {
+    ref: number;
+    applied: boolean;
+}
+/** text is the full text after the insert. */
+export interface TypeResult {
+    ref: number;
+    text: string;
+}
+/** x/y are the resulting adjustment values. */
+export interface ScrollResult {
+    ref: number;
+    x: number;
+    y: number;
+}
+/** Exactly one selector: textContains | refVisible | testId. With testId, `state` (default "present", one of present|gone|visible|enabled|disabled|focused) picks the predicate and countAtLeast/valueEquals/valueContains refine it. valueEquals/valueContains compare against the node's a11y value STRING RENDERING (numbers stringified, bools "true"/"false") so one predicate works for TextInput and Slider alike. Every predicate is evaluated host-side on the retained tree plus the live a11y probe, once per ~50ms tick — never a getTree round trip. */
+export interface WaitCondition {
+    textContains?: string;
+    refVisible?: number;
+    testId?: string;
+    state?: string;
+    countAtLeast?: number;
+    valueEquals?: string;
+    valueContains?: string;
+}
+export interface ResolveResult {
+    ref: number | null;
+    refs: number[];
+    count: number;
+}
+/** key/main/visible/title come from the live windowState probe on the Window node's handle; tabGroup is the create-time prop (null for plain windows). */
+export interface WindowInfo {
+    ref: number;
+    title: string | null;
+    key: boolean;
+    main: boolean;
+    visible: boolean;
+    tabGroup: string | null;
+}
+export interface WindowsResult {
+    windows: WindowInfo[];
+}
+export interface PointerResult {
+    dispatched: boolean;
+}
+/** fromX/fromY/toX/toY are the resolved endpoints in logical-window-topleft coordinates. */
+export interface DragResult {
+    dispatched: boolean;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+    steps: number;
+}
+export interface KeysResult {
+    dispatched: boolean;
+}
+/** Full tree snapshot with stable refs, testIDs, text, logical geometry, and accessibility state (role/enabled/focused/value). window (if given) must be a Window node ref and scopes the snapshot to that window's subtree; absent, the root/first window is used and other windows' nodes attach as orphans. */
+export interface GetTreeParams {
+    window?: number;
+}
+/** In-process render of the window to a PNG at the given absolute path; window (if given) must match the root ref. */
+export interface ScreenshotParams {
+    path: string;
+    window?: number;
+}
+/** Actionability-checked semantic click; emits clicked exactly like real user input. On CommandPalette activates the currently-highlighted row. Target by exactly one of ref / testId (window optionally scopes testId resolution). */
+export interface ClickParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+}
+/** Polls the tree at ~50ms until the condition holds or timeoutMs elapses. window (if given) scopes every predicate to that Window node's subtree. */
+export interface WaitForParams {
+    condition: WaitCondition;
+    timeoutMs?: number;
+    window?: number;
+}
+/** Kind-dispatched: TextInput/TextArea need a string, Checkbox/Radio a bool, Slider a number, Select an integer index. CommandPalette (routed to the presented dialog): a string sets the query text (fires queryChanged), an integer activates the row at that index (fires onActivate), a bool true submits the raw query (fires onSubmit). Target by exactly one of ref / testId. */
+export interface SetValueParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+    value: unknown;
+}
+/** TextInput (and CommandPalette, appending to its query); semantic append via GtkEditable.insertText, never synthetic keysyms. Target by exactly one of ref / testId. */
+export interface TypeParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+    text: string;
+}
+/** ScrollView only — adjusts the wrapping GtkScrolledWindow's adjustments by dx/dy. Target by exactly one of ref / testId. */
+export interface ScrollParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+    dx?: number;
+    dy?: number;
+}
+/** Actionability-checked double-click at the widget's center via real input synthesis (macOS: posted NSEvents, drives doubleAction row activation). Unsupported on GTK (-32003). Target by exactly one of ref / testId. */
+export interface DoubleClickParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+}
+/** Actionability-checked right-click at the widget's center via real input synthesis; opens native context menus where the widget has one (dismiss with keys "escape"). Unsupported on GTK (-32003). Target by exactly one of ref / testId. */
+export interface RightClickParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+}
+/** Best-effort pointer hover at the widget's center (macOS: posted mouseMoved). Unsupported on GTK (-32003). Target by exactly one of ref / testId. */
+export interface HoverParams {
+    ref?: number;
+    testId?: string;
+    window?: number;
+}
+/** Resolves a testID to the single ACTIONABLE instance. Candidates are ranked: actionable (the checkActionable predicate passes) before not; then key/front window before background. `refs` is every match in tree order, `ref` the winner (null when none is actionable and `actionable` is true). */
+export interface ResolveParams {
+    testId: string;
+    window?: number;
+    actionable?: boolean;
+}
+/** Low-level single pointer phase (down|move|up) at logical-window-topleft coordinates in the target window (default: root window). button is left|right (default left). Caution: a lone down on a tracking control (slider, button) enters the control's mouse-tracking loop until an up arrives — prefer drag for press-move-release sequences. Unsupported on GTK (-32003). */
+export interface PointerParams {
+    phase: string;
+    x: number;
+    y: number;
+    button?: string;
+    clickCount?: number;
+    window?: number;
+}
+/** Press-move-release gesture. Endpoints are widget refs (their centers; fromRef/toRef must share a window) or explicit coordinates (fromX/fromY/toX/toY in the target window, default root). The full down/dragged.../up sequence is posted as one batch so native mouse-tracking loops (slider thumbs, split dividers) consume it like a real drag. Unsupported on GTK (-32003). */
+export interface DragParams {
+    fromRef?: number;
+    toRef?: number;
+    fromX?: number;
+    fromY?: number;
+    toX?: number;
+    toY?: number;
+    steps?: number;
+    durationMs?: number;
+    button?: string;
+    window?: number;
+}
+/** Keyboard synthesis into the target window (default: root window). A chord spec like "cmd+shift+n" / "escape" / "tab" presses one combination (driving menu key equivalents); a plain multi-character string like "hello" types each character into the focused widget. Unsupported on GTK (-32003). */
+export interface KeysParams {
+    keys: string;
+    window?: number;
+}
+export interface RpcMethods {
+    getTree: {
+        params: GetTreeParams;
+        result: GetTreeResult;
+    };
+    screenshot: {
+        params: ScreenshotParams;
+        result: ScreenshotResult;
+    };
+    click: {
+        params: ClickParams;
+        result: ClickResult;
+    };
+    waitFor: {
+        params: WaitForParams;
+        result: WaitForResult;
+    };
+    setValue: {
+        params: SetValueParams;
+        result: SetValueResult;
+    };
+    type: {
+        params: TypeParams;
+        result: TypeResult;
+    };
+    scroll: {
+        params: ScrollParams;
+        result: ScrollResult;
+    };
+    doubleClick: {
+        params: DoubleClickParams;
+        result: ClickResult;
+    };
+    rightClick: {
+        params: RightClickParams;
+        result: ClickResult;
+    };
+    hover: {
+        params: HoverParams;
+        result: ClickResult;
+    };
+    resolve: {
+        params: ResolveParams;
+        result: ResolveResult;
+    };
+    windows: {
+        params: undefined;
+        result: WindowsResult;
+    };
+    pointer: {
+        params: PointerParams;
+        result: PointerResult;
+    };
+    drag: {
+        params: DragParams;
+        result: DragResult;
+    };
+    keys: {
+        params: KeysParams;
+        result: KeysResult;
+    };
+}
+export type RpcMethodName = keyof RpcMethods;
+export type RpcParams<M extends RpcMethodName> = RpcMethods[M]["params"];
+export type RpcResult<M extends RpcMethodName> = RpcMethods[M]["result"];
+export declare const RPC_ERRORS: {
+    /** data: {ref, reason: "unknown" | "invisible" | "unmapped" | "offscreen"} */
+    readonly notActionable: {
+        readonly code: -32001;
+        readonly message: "not actionable";
+    };
+    /** data: {timeoutMs} */
+    readonly waitForTimeout: {
+        readonly code: -32002;
+        readonly message: "waitFor timeout";
+    };
+    /** pointer/drag/keys/doubleClick/rightClick/hover on a backend without synthetic input (GTK4 removed app-constructible events) */
+    readonly inputUnsupported: {
+        readonly code: -32003;
+        readonly message: "input synthesis unsupported on this backend";
+    };
+    readonly methodNotFound: {
+        readonly code: -32601;
+        readonly message: "method not found";
+    };
+    /** data: {ref} where applicable; message may carry the specific missing/invalid param */
+    readonly invalidParams: {
+        readonly code: -32602;
+        readonly message: "invalid params";
+    };
+    readonly internalError: {
+        readonly code: -32603;
+        readonly message: "internal error";
+    };
+    readonly parseError: {
+        readonly code: -32700;
+        readonly message: "parse error";
+    };
+};

package/dist/packages/react/src/generated/schema-meta.d.ts

@@ -0,0 +1,29 @@
+export interface WidgetMeta {
+    role: string;
+    textFrom: string | null;
+    childModel: "single" | "multi" | null;
+}
+export declare const widgetMeta: Record<string, WidgetMeta>;
+export declare const intrinsicToName: Record<string, string>;
+export interface WidgetEvent {
+    name: string;
+    handler: string;
+    payload: "none" | "text" | "checked" | "value" | "index" | "data";
+}
+export declare const widgetEvents: Record<string, WidgetEvent[]>;
+export declare const handlerPropNames: Record<string, string[]>;
+/** Imperative commands each widget accepts via the widgetCommand NDP frame
+ *  (M14) — the runtime validation table behind sendCommand(). */
+export declare const widgetCommands: Record<string, readonly string[]>;
+/** Compile-time command-name map (only widgets with commands appear). */
+export type WidgetCommandNames = {
+    "window": "showAlert" | "openFile" | "saveFile" | "showAbout" | "showTabOverview" | "present";
+    "webview": "goBack" | "goForward" | "reload" | "stop" | "executeJavaScript" | "setZoom" | "setUserAgent" | "openDevTools";
+    "toastoverlay": "showToast" | "dismissToast";
+    "terminal": "copy" | "paste" | "selectAll" | "clearSelection" | "focus";
+};
+/** Platform availability (schema `platforms`): null = every platform. A
+ *  widget listing only some platforms renders natively there and is an
+ *  invisible no-op placeholder everywhere else — JS may warn but must not
+ *  treat mounting one on another platform as an error. */
+export declare const widgetPlatforms: Record<string, readonly ("macos" | "linux")[] | null>;

package/dist/packages/react/src/generated/widget-types.d.ts

@@ -0,0 +1,2 @@
+export declare const WIDGET_TYPE_RESERVED = 0;
+export declare const WIDGET_TYPE: Record<string, number>;

package/dist/packages/react/src/hmr.d.ts

@@ -0,0 +1,53 @@
+import type { Ndp } from "../../../runtime/ndp.ts";
+import * as RefreshRuntimeFirstEval from "react-refresh/runtime";
+declare global {
+    var __nd_refresh_runtime: typeof RefreshRuntimeFirstEval | undefined;
+}
+export interface HmrState {
+    ndp: Ndp;
+    root: unknown;
+    reconciler: {
+        updateContainer: (...a: unknown[]) => void;
+    };
+    bootCount: number;
+}
+declare global {
+    var __nd_hmr: HmrState | undefined;
+}
+export declare function getHmrState(): HmrState | undefined;
+export declare function setHmrState(s: HmrState): void;
+export declare function isHot(): boolean;
+interface RefreshableReconciler {
+    setRefreshHandler?: (h: unknown) => void;
+    injectIntoDevTools?: () => unknown;
+}
+/** Wires react-refresh's runtime into the reconciler.
+ *  `injectIntoGlobalHook`/`injectIntoDevTools`/`setRefreshHandler`/manual
+ *  `$RefreshReg$`/`$RefreshSig$` must all be installed before any app React
+ *  code runs — render() calls this before createContainer, and the app
+ *  module's import of @nativedesktop/react runs this module first, so
+ *  ordering holds. Bun's `--hot` does NOT inject `$RefreshReg$`/`$RefreshSig$`,
+ *  so they are installed manually here. */
+export declare function setupRefresh(reconciler: RefreshableReconciler): void;
+/** Call from the app entry after a hot re-eval re-runs its modules. */
+export declare function performRefresh(): void;
+/** Registers a module's exported components by name — the babel Fast Refresh
+ *  transform's job, done manually because Bun's `--hot` does not run it.
+ *  Call once per hot re-eval, before performRefresh(). */
+export declare function registerExports(mod: Record<string, unknown>, moduleId: string): void;
+/** Called by render() on first boot, before the first updateContainer, so a
+ *  family exists for the NEXT eval's hotUpdateRoot() call to match against. */
+export declare function registerRoot(rootComponentType: unknown): void;
+/** Called by render() on every hot re-eval (never on first boot). Registers
+ *  the new root element's type under the SAME family key used on the
+ *  previous eval, then asks react-refresh to patch the live fiber tree in
+ *  place — this is what makes a hot edit state-preserving instead of a full
+ *  remount. Must NOT be combined with a normal updateContainer call on the
+ *  same eval (see above). */
+export declare function hotUpdateRoot(rootComponentType: unknown): void;
+/** Bumps the generation counter (ids.ts) so the next commit's CommitBatch
+ *  carries a higher generation, triggering the host's generation GC of
+ *  orphaned widgets. Used for structural / non-refreshable edits that
+ *  react-refresh cannot preserve state across. */
+export declare function fullReload(): void;
+export {};

package/dist/packages/react/src/hooks.d.ts

@@ -0,0 +1,4 @@
+/** One-time external sync on mount; the returned cleanup runs on unmount.
+ * The named wrapper marks the one useEffect shape that has no derived-state
+ * replacement, so call sites don't carry a raw `useEffect(fn, [])`. */
+export declare function useMountEffect(effect: () => void | (() => void)): void;

package/dist/packages/react/src/host-config.d.ts

@@ -0,0 +1,72 @@
+import { Batch, NodeRegistry } from "./ops.ts";
+import type { WidgetType } from "./generated/intrinsics.ts";
+export type { WidgetType };
+export interface Instance {
+    id: number;
+    type: WidgetType;
+    props: Record<string, unknown>;
+    /** Populated by appendInitialChild during render; only meaningful until the
+     *  instance's first commit-time attach, at which point emitCreateIfNew
+     *  flushes it into create+append ops (see note below). */
+    children: Instance[];
+}
+export declare let activeBatch: Batch;
+export declare let registry: NodeRegistry;
+export declare function bindCommitTargets(b: Batch, r: NodeRegistry): void;
+export interface Container {
+    rootId: number | null;
+}
+export declare function setPriorityFor(kind: "discrete" | "continuous" | "default"): void;
+export declare const hostConfig: {
+    supportsMutation: boolean;
+    supportsPersistence: boolean;
+    supportsHydration: boolean;
+    isPrimaryRenderer: boolean;
+    noTimeout: -1;
+    supportsMicrotasks: boolean;
+    scheduleMicrotask: (fn: () => void) => void;
+    scheduleTimeout: (fn: (...args: unknown[]) => void, delay?: number) => NodeJS.Timeout;
+    cancelTimeout: (id: ReturnType<typeof setTimeout>) => void;
+    getRootHostContext: () => {
+        root: boolean;
+    };
+    getChildHostContext: (parent: unknown) => unknown;
+    prepareForCommit: () => null;
+    resetAfterCommit: () => void;
+    clearContainer: () => void;
+    preparePortalMount: () => void;
+    createInstance(type: WidgetType, props: Record<string, unknown>): Instance;
+    createTextInstance(text: string): {
+        text: string;
+    };
+    shouldSetTextContent: (type: WidgetType) => type is "label";
+    appendInitialChild(parent: Instance, child: Instance): void;
+    finalizeInitialChildren: () => boolean;
+    appendChild(parent: Instance, child: Instance): void;
+    appendChildToContainer(_container: Container, child: Instance): void;
+    insertBefore(parent: Instance, child: Instance, before: Instance): void;
+    insertInContainerBefore(_c: Container, child: Instance, _b: Instance): void;
+    removeChild(_parent: Instance, child: Instance): void;
+    removeChildFromContainer(_c: Container, child: Instance): void;
+    commitUpdate(inst: Instance, type: WidgetType, oldProps: Record<string, unknown>, newProps: Record<string, unknown>): void;
+    commitTextUpdate(): void;
+    hideInstance(inst: Instance): void;
+    unhideInstance(inst: Instance): void;
+    hideTextInstance(): void;
+    unhideTextInstance(): void;
+    getPublicInstance: (i: Instance) => Instance;
+    detachDeletedInstance(): void;
+    maySuspendCommit: () => boolean;
+    preloadInstance: () => boolean;
+    startSuspendingCommit(): void;
+    suspendInstance(): void;
+    waitForCommitToBeReady: () => null;
+    resolveUpdatePriority: () => number;
+    getCurrentUpdatePriority: () => number;
+    setCurrentUpdatePriority: (p: number) => void;
+    shouldAttemptEagerTransition: () => boolean;
+    trackSchedulerEvent(): void;
+    resolveEventType: () => null;
+    resolveEventTimeStamp: () => number;
+    requestPostPaintCallback(): void;
+};

package/dist/packages/react/src/ids.d.ts

@@ -0,0 +1,4 @@
+export declare function currentGeneration(): number;
+export declare function newGeneration(): void;
+/** Generation-tagged monotonic node id: (generation << 24) | (seq & 0xFFFFFF). */
+export declare function nextNodeId(): number;

package/dist/packages/react/src/index.d.ts

@@ -0,0 +1,26 @@
+export { render, sendCommand, sendNativeCommand, createPortal, createPool, moveNode } from "./renderer.ts";
+export type { Pool } from "./renderer.ts";
+export { Platform, hasWidget, hasCommand } from "./platform.ts";
+export type { Backend, OS } from "./platform.ts";
+export { Spacing, ContentMargin } from "./metrics.ts";
+export type { SpacingScale } from "./metrics.ts";
+export { getAppDataDir, ensureAppDataDir } from "./paths.ts";
+export { defineNativeComponent } from "./native-component.ts";
+export type { NativeComponentOptions, NativeComponentProps, NativeComponentRef } from "./native-component.ts";
+export { executeJavaScript, onJavaScriptResult } from "./webview.ts";
+export { showAlert, openFile, saveFile, showAbout, showTabOverview, onAlertResult, onOpenFileResult, onSaveFileResult, } from "./dialogs.ts";
+export type { DialogButton, ShowAlertOptions, AlertResult, OpenFileOptions as WindowOpenFileOptions, OpenFileResult as WindowOpenFileResult, SaveFileOptions as WindowSaveFileOptions, SaveFileResult as WindowSaveFileResult, ShowAboutOptions, } from "./dialogs.ts";
+export { showToast, dismissToast, onToastButtonClicked, onToastDismissed } from "./toast.ts";
+export type { ToastPriority, ShowToastOptions, ToastResult } from "./toast.ts";
+export type { Instance } from "./host-config.ts";
+export type { NdNodeRef, WidgetType, TableColumn, TableRow, TreeNode, SourceTreeAction, SourceTreeNode } from "./generated/intrinsics.ts";
+export { performRefresh, registerExports, fullReload } from "./hmr.ts";
+export { useState, useEffect, useLayoutEffect, useMemo, useCallback, useRef, useContext, useReducer, useTransition, useDeferredValue, useSyncExternalStore, useId, use, startTransition, memo, forwardRef, createContext, Suspense, Fragment, } from "./dev-react.ts";
+export { dialog, clipboard, notifications, recentDocuments, credentials, app, system, audio } from "./system.ts";
+export type { FileFilter, OpenFileOptions, SaveFileOptions, MessageLevel, MessageOptions, NotificationOptions, Appearance, AppearanceInfo, AudioPlayOptions, AudioState, AudioStateEvent, AudioSpectrumEvent, } from "./system.ts";
+export { openExternal, openPath, revealPath } from "./shell.ts";
+export { onUnhandledError, setUnhandledErrorPolicy } from "./errors.ts";
+export type { NdErrorKind, NdErrorContext, NdErrorHandler, UnhandledErrorPolicy } from "./errors.ts";
+export { useMountEffect } from "./hooks.ts";
+export { createStore, useStoreValue } from "./store.ts";
+export type { Store, StoreOptions } from "./store.ts";

package/dist/packages/react/src/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export { jsxDEV, Fragment } from "react/jsx-dev-runtime";
+export type { JSX } from "./generated/intrinsics.ts";

package/dist/packages/react/src/jsx-runtime.d.ts

@@ -0,0 +1,2 @@
+export { jsx, jsxs, Fragment } from "./generated/intrinsics.ts";
+export type { JSX } from "./generated/intrinsics.ts";

package/dist/packages/react/src/metrics.d.ts

@@ -0,0 +1,12 @@
+export interface SpacingScale {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+}
+export declare const Spacing: SpacingScale;
+/** The platform's standard margin between window edge and content. A live
+ * binding (a number export cannot be a getter): read it at render time, not
+ * into a module-scope constant. */
+export declare let ContentMargin: number;