@nativedesktop/react 0.1.0

package/dist/index.js

@@ -0,0 +1,2089 @@
+// src/renderer.ts
+import ReconcilerFactory from "react-reconciler";
+import { ConcurrentRoot } from "react-reconciler/constants";
+
+// src/generated/widget-types.ts
+var WIDGET_TYPE = {
+  Window: 1,
+  Box: 2,
+  Label: 3,
+  Button: 4,
+  TextInput: 5,
+  TextArea: 6,
+  Checkbox: 7,
+  Radio: 8,
+  Select: 9,
+  Slider: 10,
+  ProgressBar: 11,
+  Image: 12,
+  ScrollView: 13,
+  Separator: 14,
+  Spinner: 15,
+  TabView: 16,
+  Grid: 17,
+  ListView: 18,
+  WebView: 19,
+  NativeView: 20,
+  SplitView: 21,
+  HeaderBar: 22,
+  ToolbarView: 23,
+  SearchInput: 24,
+  SourceList: 25,
+  SourceTree: 26,
+  Menubar: 27,
+  Menu: 28,
+  MenuItem: 29,
+  SettingsGroup: 30,
+  Row: 31,
+  SwitchRow: 32,
+  Clamp: 33,
+  Switch: 34,
+  ToggleButton: 35,
+  SegmentedControl: 36,
+  NumberInput: 37,
+  LinkButton: 38,
+  LevelIndicator: 39,
+  ColorPicker: 40,
+  Banner: 41,
+  MenuButton: 42,
+  SplitButton: 43,
+  Popover: 44,
+  Expander: 45,
+  StatusPage: 46,
+  ToastOverlay: 47,
+  DatePicker: 48,
+  Table: 49,
+  TreeView: 50,
+  FontPicker: 51,
+  Video: 52,
+  TrayItem: 53,
+  ShareButton: 54,
+  Terminal: 55,
+  Paned: 56,
+  CommandPalette: 57
+};
+
+// ../../runtime/ndp-binary.ts
+class BinaryUnsupportedValue extends Error {
+  constructor(key, value) {
+    super(`ndp-binary: unsupported prop value for "${key}" (${typeof value}) — spec §5.3 has no array/object tag`);
+    this.name = "BinaryUnsupportedValue";
+  }
+}
+var textEncoder = new TextEncoder;
+
+class ByteWriter {
+  ab = new ArrayBuffer(256);
+  buf = new Uint8Array(this.ab);
+  view = new DataView(this.ab);
+  len = 0;
+  ensure(n) {
+    if (this.len + n <= this.ab.byteLength)
+      return;
+    let cap = this.ab.byteLength * 2;
+    while (cap < this.len + n)
+      cap *= 2;
+    const nextAb = new ArrayBuffer(cap);
+    new Uint8Array(nextAb).set(this.buf.subarray(0, this.len));
+    this.ab = nextAb;
+    this.buf = new Uint8Array(nextAb);
+    this.view = new DataView(nextAb);
+  }
+  u8(v) {
+    this.ensure(1);
+    this.buf[this.len++] = v & 255;
+  }
+  u16(v) {
+    this.ensure(2);
+    this.view.setUint16(this.len, v, true);
+    this.len += 2;
+  }
+  u32(v) {
+    this.ensure(4);
+    this.view.setUint32(this.len, v >>> 0, true);
+    this.len += 4;
+  }
+  i64(v) {
+    this.ensure(8);
+    this.view.setBigInt64(this.len, BigInt(v), true);
+    this.len += 8;
+  }
+  f64(v) {
+    this.ensure(8);
+    this.view.setFloat64(this.len, v, true);
+    this.len += 8;
+  }
+  bytes(b) {
+    this.ensure(b.length);
+    this.buf.set(b, this.len);
+    this.len += b.length;
+  }
+  lenString(s) {
+    this.ensure(4 + s.length * 3);
+    const lenPos = this.len;
+    const { written } = textEncoder.encodeInto(s, this.buf.subarray(this.len + 4));
+    this.view.setUint32(lenPos, written, true);
+    this.len += 4 + written;
+  }
+  slice() {
+    return this.buf.slice(0, this.len);
+  }
+}
+function encodeCommitBatchBinary(batch) {
+  const strings = [];
+  const index = new Map;
+  const intern = (s) => {
+    const hit = index.get(s);
+    if (hit !== undefined)
+      return hit;
+    const i = strings.length;
+    strings.push(s);
+    index.set(s, i);
+    return i;
+  };
+  const ops = new ByteWriter;
+  const writeProps = (props) => {
+    const keys = Object.keys(props);
+    ops.u16(keys.length);
+    for (const k of keys) {
+      ops.u32(intern(k));
+      const v = props[k];
+      if (v === null || v === undefined) {
+        ops.u8(0);
+      } else if (typeof v === "boolean") {
+        ops.u8(1);
+        ops.u8(v ? 1 : 0);
+      } else if (typeof v === "number") {
+        if (Number.isInteger(v)) {
+          ops.u8(2);
+          ops.i64(v);
+        } else {
+          ops.u8(3);
+          ops.f64(v);
+        }
+      } else if (typeof v === "string") {
+        ops.u8(4);
+        ops.u32(intern(v));
+      } else {
+        throw new BinaryUnsupportedValue(k, v);
+      }
+    }
+  };
+  for (const op of batch.ops) {
+    switch (op.op) {
+      case "create": {
+        ops.u8(1);
+        ops.u32(op.id);
+        const wt = WIDGET_TYPE[op.widget];
+        if (wt === undefined)
+          throw new Error(`ndp-binary: unknown widget "${op.widget}"`);
+        ops.u16(wt);
+        writeProps(op.props);
+        break;
+      }
+      case "append":
+        ops.u8(2);
+        ops.u32(op.parent);
+        ops.u32(op.child);
+        break;
+      case "insertBefore":
+        ops.u8(3);
+        ops.u32(op.parent);
+        ops.u32(op.child);
+        ops.u32(op.before ?? 0);
+        break;
+      case "remove":
+        ops.u8(4);
+        ops.u32(op.id);
+        break;
+      case "setText":
+        ops.u8(5);
+        ops.u32(op.id);
+        ops.u32(intern(op.text));
+        break;
+      case "update":
+        ops.u8(6);
+        ops.u32(op.id);
+        writeProps(op.props);
+        break;
+      case "hide":
+        ops.u8(7);
+        ops.u32(op.id);
+        break;
+      case "unhide":
+        ops.u8(8);
+        ops.u32(op.id);
+        break;
+    }
+  }
+  const opBytes = ops.slice();
+  const stringTableOffset = 28 + opBytes.length;
+  const out = new ByteWriter;
+  out.u8(78);
+  out.u8(1);
+  for (let i = 0;i < 6; i++)
+    out.u8(0);
+  out.i64(batch.commitId);
+  out.u32(batch.generation);
+  out.u32(batch.ops.length);
+  out.u32(stringTableOffset);
+  out.bytes(opBytes);
+  out.u32(strings.length);
+  for (const s of strings)
+    out.lenString(s);
+  return out.slice();
+}
+
+// src/generated/protocol.ts
+var NDP_VERSION = 1;
+
+// ../../runtime/ndp.ts
+var TRACE = process.env.NDP_TRACE === "1";
+
+class Ndp {
+  socket;
+  inbox = new Uint8Array(0);
+  eventCb = null;
+  helloAckResolve = null;
+  outbox = [];
+  outboxOffset = 0;
+  encoding = "json";
+  backendName = "unknown";
+  hostWidgetsSet = null;
+  hostCommandsSet = null;
+  pending = new Map;
+  nextRequestId = 1;
+  systemEventCb = null;
+  constructor(socket) {
+    this.socket = socket;
+  }
+  get backend() {
+    return this.backendName;
+  }
+  get hostWidgets() {
+    return this.hostWidgetsSet;
+  }
+  get hostCommands() {
+    return this.hostCommandsSet;
+  }
+  static async connect() {
+    const path = process.env.ND_SOCKET;
+    if (!path)
+      throw new Error("ND_SOCKET not set");
+    let self;
+    const socket = await Bun.connect({
+      unix: path,
+      socket: {
+        data(_sock, chunk) {
+          self.onData(chunk);
+        },
+        close() {
+          for (const call of self.pending.values())
+            call.reject(new Error("ndp connection closed"));
+          self.pending.clear();
+          process.exit(0);
+        },
+        drain(sock) {
+          self.pump(sock);
+        }
+      }
+    });
+    self = new Ndp(socket);
+    return self;
+  }
+  pump(sock) {
+    while (this.outbox.length > 0) {
+      const front = this.outbox[0];
+      const remaining = front.subarray(this.outboxOffset);
+      const n = sock.write(remaining);
+      if (n <= 0)
+        return;
+      this.outboxOffset += n;
+      if (this.outboxOffset >= front.length) {
+        this.outbox.shift();
+        this.outboxOffset = 0;
+      } else {
+        return;
+      }
+    }
+  }
+  onData(chunk) {
+    const merged = new Uint8Array(this.inbox.length + chunk.length);
+    merged.set(this.inbox, 0);
+    merged.set(chunk, this.inbox.length);
+    this.inbox = merged;
+    while (this.inbox.length >= 4) {
+      const view = new DataView(this.inbox.buffer, this.inbox.byteOffset, 4);
+      const len = view.getUint32(0, true);
+      if (this.inbox.length < 4 + len)
+        break;
+      const json = new TextDecoder().decode(this.inbox.subarray(4, 4 + len));
+      this.inbox = this.inbox.subarray(4 + len);
+      if (TRACE)
+        console.error("<< " + json);
+      this.dispatch(JSON.parse(json));
+    }
+  }
+  dispatch(msg) {
+    if (msg.type === "helloAck") {
+      if (msg.ndpVersion !== NDP_VERSION)
+        throw new Error(`ndp mismatch: host ${msg.ndpVersion}`);
+      if (msg.encodings?.includes("binary") && process.env.ND_FORCE_JSON !== "1")
+        this.encoding = "binary";
+      this.backendName = msg.backend;
+      this.hostWidgetsSet = msg.hostWidgets ? new Set(msg.hostWidgets) : null;
+      this.hostCommandsSet = msg.hostCommands ? new Set(msg.hostCommands) : null;
+      this.helloAckResolve?.();
+    } else if (msg.type === "error") {
+      throw new Error(`host error: ${msg.message} (expected ${msg.expected}, got ${msg.got})`);
+    } else if (msg.type === "event") {
+      this.eventCb?.(msg);
+    } else if (msg.type === "systemResponse") {
+      const call = this.pending.get(msg.id);
+      if (!call)
+        return;
+      this.pending.delete(msg.id);
+      if (msg.ok)
+        call.resolve(msg.result);
+      else
+        call.reject(new Error(msg.errorMessage ?? "system request failed"));
+    } else if (msg.type === "systemEvent") {
+      this.systemEventCb?.(msg.channel, msg.data);
+    }
+  }
+  send(obj) {
+    const json = new TextEncoder().encode(JSON.stringify(obj));
+    const frame = new Uint8Array(4 + json.length);
+    new DataView(frame.buffer).setUint32(0, json.length, true);
+    frame.set(json, 4);
+    if (TRACE)
+      console.error(">> " + new TextDecoder().decode(json));
+    const wasEmpty = this.outbox.length === 0;
+    this.outbox.push(frame);
+    if (wasEmpty)
+      this.pump(this.socket);
+  }
+  async handshake(runtime) {
+    const done = new Promise((res) => this.helloAckResolve = res);
+    this.send({ type: "hello", ndpVersion: NDP_VERSION, runtime });
+    await done;
+  }
+  sendCommit(batch) {
+    if (this.encoding === "binary") {
+      try {
+        this.sendBinaryFrame(encodeCommitBatchBinary(batch));
+        return;
+      } catch (err) {
+        if (!(err instanceof BinaryUnsupportedValue))
+          throw err;
+        if (TRACE)
+          console.error(`>> [binary fallback to json: ${err.message}]`);
+      }
+    }
+    this.send({ type: "commitBatch", ...batch });
+  }
+  sendBinaryFrame(payload) {
+    const frame = new Uint8Array(4 + payload.length);
+    new DataView(frame.buffer).setUint32(0, payload.length, true);
+    frame.set(payload, 4);
+    if (TRACE)
+      console.error(`>> [binary commitBatch ${payload.length}B]`);
+    const wasEmpty = this.outbox.length === 0;
+    this.outbox.push(frame);
+    if (wasEmpty)
+      this.pump(this.socket);
+  }
+  sendWidgetCommand(nodeId, command, arg = null) {
+    this.send({ type: "widgetCommand", nodeId, command, arg });
+  }
+  onEvent(cb) {
+    this.eventCb = cb;
+  }
+  request(method, params) {
+    const id = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.send({ type: "systemRequest", id, method, params: params ?? {} });
+    });
+  }
+  onSystemEvent(cb) {
+    this.systemEventCb = cb;
+  }
+  ping() {
+    this.send({ type: "ping" });
+  }
+  sendRuntimeError(message, stack, fatal) {
+    this.send({ type: "runtimeError", message, stack, fatal });
+  }
+}
+
+// src/generated/schema-meta.ts
+var intrinsicToName = {
+  window: "Window",
+  box: "Box",
+  label: "Label",
+  button: "Button",
+  textinput: "TextInput",
+  textarea: "TextArea",
+  checkbox: "Checkbox",
+  radio: "Radio",
+  select: "Select",
+  slider: "Slider",
+  progressbar: "ProgressBar",
+  image: "Image",
+  scrollview: "ScrollView",
+  separator: "Separator",
+  spinner: "Spinner",
+  tabview: "TabView",
+  grid: "Grid",
+  listview: "ListView",
+  webview: "WebView",
+  nativeview: "NativeView",
+  splitview: "SplitView",
+  headerbar: "HeaderBar",
+  toolbarview: "ToolbarView",
+  searchinput: "SearchInput",
+  sourcelist: "SourceList",
+  sourcetree: "SourceTree",
+  menubar: "Menubar",
+  menu: "Menu",
+  menuitem: "MenuItem",
+  settingsgroup: "SettingsGroup",
+  row: "Row",
+  switchrow: "SwitchRow",
+  clamp: "Clamp",
+  switch: "Switch",
+  togglebutton: "ToggleButton",
+  segmentedcontrol: "SegmentedControl",
+  numberinput: "NumberInput",
+  linkbutton: "LinkButton",
+  levelindicator: "LevelIndicator",
+  colorpicker: "ColorPicker",
+  banner: "Banner",
+  menubutton: "MenuButton",
+  splitbutton: "SplitButton",
+  popover: "Popover",
+  expander: "Expander",
+  statuspage: "StatusPage",
+  toastoverlay: "ToastOverlay",
+  datepicker: "DatePicker",
+  table: "Table",
+  treeview: "TreeView",
+  fontpicker: "FontPicker",
+  video: "Video",
+  trayitem: "TrayItem",
+  sharebutton: "ShareButton",
+  terminal: "Terminal",
+  paned: "Paned",
+  commandpalette: "CommandPalette"
+};
+var widgetEvents = {
+  window: [{ name: "alertResult", handler: "onAlertResult", payload: "data" }, { name: "openFileResult", handler: "onOpenFileResult", payload: "data" }, { name: "saveFileResult", handler: "onSaveFileResult", payload: "data" }, { name: "newTabRequested", handler: "onNewTabRequested", payload: "data" }, { name: "closed", handler: "onClosed", payload: "data" }, { name: "focused", handler: "onFocused", payload: "checked" }, { name: "sizeChanged", handler: "onSizeChanged", payload: "data" }],
+  box: [{ name: "hoverChanged", handler: "onHoverChanged", payload: "checked" }],
+  label: [],
+  button: [{ name: "clicked", handler: "onClick", payload: "none" }, { name: "hoverChanged", handler: "onHoverChanged", payload: "checked" }],
+  textinput: [{ name: "changed", handler: "onChanged", payload: "text" }, { name: "activate", handler: "onActivate", payload: "text" }],
+  textarea: [{ name: "changed", handler: "onChanged", payload: "text" }],
+  checkbox: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  radio: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  select: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "index" }],
+  slider: [{ name: "valueChanged", handler: "onValueChanged", payload: "value" }],
+  progressbar: [],
+  image: [],
+  scrollview: [],
+  separator: [],
+  spinner: [],
+  tabview: [],
+  grid: [],
+  listview: [{ name: "rowActivated", handler: "onRowActivated", payload: "index" }],
+  webview: [{ name: "navigate", handler: "onNavigate", payload: "text" }, { name: "titleChanged", handler: "onTitleChanged", payload: "text" }, { name: "loadingChanged", handler: "onLoadingChanged", payload: "checked" }, { name: "backAvailable", handler: "onBackAvailable", payload: "checked" }, { name: "forwardAvailable", handler: "onForwardAvailable", payload: "checked" }, { name: "loadProgress", handler: "onLoadProgress", payload: "value" }, { name: "loadFailed", handler: "onLoadFailed", payload: "data" }, { name: "newWindow", handler: "onNewWindow", payload: "text" }, { name: "downloadRequested", handler: "onDownloadRequested", payload: "data" }, { name: "javaScriptResult", handler: "onJavaScriptResult", payload: "data" }],
+  nativeview: [{ name: "nativeEvent", handler: "onNativeEvent", payload: "data" }],
+  splitview: [],
+  headerbar: [{ name: "back", handler: "onBack", payload: "none" }, { name: "forward", handler: "onForward", payload: "none" }],
+  toolbarview: [],
+  searchinput: [{ name: "changed", handler: "onChanged", payload: "text" }, { name: "activate", handler: "onActivate", payload: "text" }],
+  sourcelist: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "index" }, { name: "rowActivated", handler: "onRowActivated", payload: "index" }],
+  sourcetree: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "data" }, { name: "rowActivated", handler: "onRowActivated", payload: "data" }, { name: "nodeExpanded", handler: "onNodeExpanded", payload: "data" }, { name: "nodeCollapsed", handler: "onNodeCollapsed", payload: "data" }, { name: "actionClicked", handler: "onActionClicked", payload: "data" }],
+  menubar: [],
+  menu: [],
+  menuitem: [{ name: "selected", handler: "onSelect", payload: "none" }],
+  settingsgroup: [],
+  row: [{ name: "activated", handler: "onActivate", payload: "none" }],
+  switchrow: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  clamp: [],
+  switch: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  togglebutton: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  segmentedcontrol: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "index" }],
+  numberinput: [{ name: "valueChanged", handler: "onValueChanged", payload: "value" }],
+  linkbutton: [{ name: "activate", handler: "onActivate", payload: "text" }],
+  levelindicator: [],
+  colorpicker: [{ name: "colorChanged", handler: "onColorChanged", payload: "text" }],
+  banner: [{ name: "buttonClicked", handler: "onButtonClicked", payload: "none" }],
+  menubutton: [],
+  splitbutton: [{ name: "clicked", handler: "onClick", payload: "none" }],
+  popover: [{ name: "closed", handler: "onClosed", payload: "none" }],
+  expander: [{ name: "toggled", handler: "onToggled", payload: "checked" }],
+  statuspage: [],
+  toastoverlay: [{ name: "toastButtonClicked", handler: "onToastButtonClicked", payload: "data" }, { name: "toastDismissed", handler: "onToastDismissed", payload: "data" }],
+  datepicker: [{ name: "dateChanged", handler: "onDateChanged", payload: "text" }],
+  table: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "index" }, { name: "rowActivated", handler: "onRowActivated", payload: "index" }, { name: "sortChanged", handler: "onSortChanged", payload: "data" }],
+  treeview: [{ name: "selectionChanged", handler: "onSelectionChanged", payload: "data" }, { name: "rowActivated", handler: "onRowActivated", payload: "data" }, { name: "nodeExpanded", handler: "onNodeExpanded", payload: "data" }, { name: "nodeCollapsed", handler: "onNodeCollapsed", payload: "data" }],
+  fontpicker: [{ name: "fontChanged", handler: "onFontChanged", payload: "text" }],
+  video: [],
+  trayitem: [],
+  sharebutton: [],
+  terminal: [{ name: "titleChanged", handler: "onTitleChanged", payload: "text" }, { name: "bell", handler: "onBell", payload: "none" }, { name: "exited", handler: "onExited", payload: "data" }, { name: "connectionState", handler: "onConnectionState", payload: "data" }, { name: "selectionChanged", handler: "onSelectionChanged", payload: "checked" }, { name: "imagePaste", handler: "onImagePaste", payload: "data" }, { name: "focusChanged", handler: "onFocusChanged", payload: "checked" }],
+  paned: [{ name: "positionChanged", handler: "onPositionChanged", payload: "position" }],
+  commandpalette: [{ name: "queryChanged", handler: "onQueryChanged", payload: "text" }, { name: "activate", handler: "onActivate", payload: "text" }, { name: "submit", handler: "onSubmit", payload: "text" }, { name: "cancel", handler: "onCancel", payload: "none" }]
+};
+var handlerPropNames = {
+  window: ["onAlertResult", "onOpenFileResult", "onSaveFileResult", "onNewTabRequested", "onClosed", "onFocused", "onSizeChanged"],
+  box: ["onHoverChanged"],
+  label: [],
+  button: ["onClick", "onHoverChanged"],
+  textinput: ["onChanged", "onActivate"],
+  textarea: ["onChanged"],
+  checkbox: ["onToggled"],
+  radio: ["onToggled"],
+  select: ["onSelectionChanged"],
+  slider: ["onValueChanged"],
+  progressbar: [],
+  image: [],
+  scrollview: [],
+  separator: [],
+  spinner: [],
+  tabview: [],
+  grid: [],
+  listview: ["onRowActivated"],
+  webview: ["onNavigate", "onTitleChanged", "onLoadingChanged", "onBackAvailable", "onForwardAvailable", "onLoadProgress", "onLoadFailed", "onNewWindow", "onDownloadRequested", "onJavaScriptResult"],
+  nativeview: ["onNativeEvent"],
+  splitview: [],
+  headerbar: ["onBack", "onForward"],
+  toolbarview: [],
+  searchinput: ["onChanged", "onActivate"],
+  sourcelist: ["onSelectionChanged", "onRowActivated"],
+  sourcetree: ["onSelectionChanged", "onRowActivated", "onNodeExpanded", "onNodeCollapsed", "onActionClicked"],
+  menubar: [],
+  menu: [],
+  menuitem: ["onSelect"],
+  settingsgroup: [],
+  row: ["onActivate"],
+  switchrow: ["onToggled"],
+  clamp: [],
+  switch: ["onToggled"],
+  togglebutton: ["onToggled"],
+  segmentedcontrol: ["onSelectionChanged"],
+  numberinput: ["onValueChanged"],
+  linkbutton: ["onActivate"],
+  levelindicator: [],
+  colorpicker: ["onColorChanged"],
+  banner: ["onButtonClicked"],
+  menubutton: [],
+  splitbutton: ["onClick"],
+  popover: ["onClosed"],
+  expander: ["onToggled"],
+  statuspage: [],
+  toastoverlay: ["onToastButtonClicked", "onToastDismissed"],
+  datepicker: ["onDateChanged"],
+  table: ["onSelectionChanged", "onRowActivated", "onSortChanged"],
+  treeview: ["onSelectionChanged", "onRowActivated", "onNodeExpanded", "onNodeCollapsed"],
+  fontpicker: ["onFontChanged"],
+  video: [],
+  trayitem: [],
+  sharebutton: [],
+  terminal: ["onTitleChanged", "onBell", "onExited", "onConnectionState", "onSelectionChanged", "onImagePaste", "onFocusChanged"],
+  paned: ["onPositionChanged"],
+  commandpalette: ["onQueryChanged", "onActivate", "onSubmit", "onCancel"]
+};
+var widgetCommands = {
+  window: ["showAlert", "openFile", "saveFile", "showAbout", "showTabOverview", "present"],
+  box: [],
+  label: [],
+  button: [],
+  textinput: [],
+  textarea: [],
+  checkbox: [],
+  radio: [],
+  select: [],
+  slider: [],
+  progressbar: [],
+  image: [],
+  scrollview: [],
+  separator: [],
+  spinner: [],
+  tabview: [],
+  grid: [],
+  listview: [],
+  webview: ["goBack", "goForward", "reload", "stop", "executeJavaScript", "setZoom", "setUserAgent", "openDevTools"],
+  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: ["showToast", "dismissToast"],
+  datepicker: [],
+  table: [],
+  treeview: [],
+  fontpicker: [],
+  video: [],
+  trayitem: [],
+  sharebutton: [],
+  terminal: ["copy", "paste", "selectAll", "clearSelection", "focus"],
+  paned: [],
+  commandpalette: []
+};
+var widgetPlatforms = {
+  window: null,
+  box: null,
+  label: null,
+  button: null,
+  textinput: null,
+  textarea: null,
+  checkbox: null,
+  radio: null,
+  select: null,
+  slider: null,
+  progressbar: null,
+  image: null,
+  scrollview: null,
+  separator: null,
+  spinner: null,
+  tabview: null,
+  grid: null,
+  listview: null,
+  webview: null,
+  nativeview: null,
+  splitview: null,
+  headerbar: null,
+  toolbarview: null,
+  searchinput: null,
+  sourcelist: null,
+  sourcetree: null,
+  menubar: null,
+  menu: null,
+  menuitem: null,
+  settingsgroup: null,
+  row: null,
+  switchrow: null,
+  clamp: null,
+  switch: null,
+  togglebutton: null,
+  segmentedcontrol: null,
+  numberinput: null,
+  linkbutton: null,
+  levelindicator: null,
+  colorpicker: null,
+  banner: null,
+  menubutton: null,
+  splitbutton: null,
+  popover: null,
+  expander: null,
+  statuspage: null,
+  toastoverlay: null,
+  datepicker: null,
+  table: null,
+  treeview: null,
+  fontpicker: null,
+  video: null,
+  trayitem: ["macos"],
+  sharebutton: ["macos"],
+  terminal: null,
+  paned: null,
+  commandpalette: null
+};
+
+// src/host-config.ts
+import { DiscreteEventPriority, ContinuousEventPriority, DefaultEventPriority } from "react-reconciler/constants";
+
+// src/ids.ts
+var generation = 0;
+var seq = 0;
+function currentGeneration() {
+  return generation;
+}
+function newGeneration() {
+  generation += 1;
+  seq = 0;
+}
+function nextNodeId() {
+  seq += 1;
+  return generation << 24 | seq & 16777215;
+}
+
+// src/ops.ts
+class Batch {
+  ops = [];
+  push(op) {
+    this.ops.push(op);
+  }
+  drain() {
+    const o = this.ops;
+    this.ops = [];
+    return o;
+  }
+  get length() {
+    return this.ops.length;
+  }
+}
+
+class NodeRegistry {
+  byId = new Map;
+  register(rec) {
+    this.byId.set(rec.id, rec);
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  unregister(id) {
+    this.byId.delete(id);
+  }
+}
+
+// src/generated/intrinsics.ts
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var styleKeySpec = {
+  background: null,
+  color: null,
+  font: ["fontSize", "fontWeight", "fontFamily"],
+  padding: null,
+  margin: null,
+  hexpand: null,
+  vexpand: null,
+  halign: null,
+  valign: null,
+  border: ["borderWidth", "borderColor", "borderRadius"]
+};
+var cssClassSpec = ["suggested-action", "destructive-action", "flat", "raised", "circular", "pill", "linked", "toolbar", "spacer", "title-1", "title-2", "title-3", "title-4", "heading", "document", "body", "caption-heading", "caption", "monospace", "numeric", "accent", "success", "warning", "error", "boxed-list", "boxed-list-separate", "card", "activatable", "navigation-sidebar", "nd-native-sidebar", "selection-mode", "osd", "dimmed", "background", "view", "frame", "compact", "menu", "inline", "large-title", "property", "round", "opaque", "devel", "icon-dropshadow", "lowres-icon"];
+
+// src/style-validate.ts
+class StyleError extends Error {
+}
+var validTop = Object.keys(styleKeySpec);
+function nearest(bad, valid) {
+  let best = null, bestD = Infinity;
+  for (const v of valid) {
+    const d = lev(bad, v);
+    if (d < bestD) {
+      bestD = d;
+      best = v;
+    }
+  }
+  return bestD <= 3 ? best : null;
+}
+function lev(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+  for (let j = 0;j <= n; j++)
+    dp[0][j] = j;
+  for (let i = 1;i <= m; i++)
+    for (let j = 1;j <= n; j++)
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return dp[m][n];
+}
+function reject(bad, valid, where) {
+  const near = nearest(bad, valid);
+  const hint = near ? `Did you mean "${near}"?` : `Valid keys: ${valid.join(", ")}.`;
+  throw new StyleError(`Invalid style key "${bad}"${where} — GTK styling is not web CSS. ${hint} See docs/styling.md`);
+}
+function validateStyle(style) {
+  if (style == null || typeof style !== "object")
+    return;
+  for (const [k, v] of Object.entries(style)) {
+    if (!(k in styleKeySpec))
+      reject(k, validTop, "");
+    const nested = styleKeySpec[k];
+    if (nested && v != null && typeof v === "object" && !Array.isArray(v)) {
+      for (const nk of Object.keys(v)) {
+        if (!nested.includes(nk))
+          reject(nk, nested, ` in "${k}"`);
+      }
+    }
+  }
+}
+
+// src/css-classes-validate.ts
+class CssClassError extends Error {
+}
+function nearest2(bad, valid) {
+  let best = null, bestD = Infinity;
+  for (const v of valid) {
+    const d = lev2(bad, v);
+    if (d < bestD) {
+      bestD = d;
+      best = v;
+    }
+  }
+  return bestD <= 3 ? best : null;
+}
+function lev2(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+  for (let j = 0;j <= n; j++)
+    dp[0][j] = j;
+  for (let i = 1;i <= m; i++)
+    for (let j = 1;j <= n; j++)
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return dp[m][n];
+}
+function validateCssClasses(classes) {
+  if (classes == null)
+    return;
+  if (!Array.isArray(classes))
+    throw new CssClassError(`cssClasses must be a string[] — got ${typeof classes}. See docs/styling.md`);
+  for (const c of classes) {
+    if (typeof c !== "string")
+      throw new CssClassError(`cssClasses entries must be strings — got ${typeof c}. See docs/styling.md`);
+    if (!cssClassSpec.includes(c)) {
+      const near = nearest2(c, cssClassSpec);
+      const hint = near ? `Did you mean "${near}"?` : `Valid classes: ${cssClassSpec.join(", ")}.`;
+      throw new CssClassError(`Unknown CSS class "${c}" — only Adwaita/GTK design-system classes are allowed. ${hint} See docs/styling.md`);
+    }
+  }
+}
+
+// src/hmr.ts
+import * as RefreshRuntimeFirstEval from "react-refresh/runtime";
+function pinnedRefreshRuntime() {
+  if (!globalThis.__nd_refresh_runtime)
+    globalThis.__nd_refresh_runtime = RefreshRuntimeFirstEval;
+  return globalThis.__nd_refresh_runtime;
+}
+function getHmrState() {
+  return globalThis.__nd_hmr;
+}
+function setHmrState(s) {
+  globalThis.__nd_hmr = s;
+}
+function isHot() {
+  return process.env.ND_DEV === "1";
+}
+var refreshReady = false;
+function setupRefresh(reconciler) {
+  if (refreshReady)
+    return;
+  pinnedRefreshRuntime().injectIntoGlobalHook(globalThis);
+  globalThis.$RefreshReg$ = (type, id) => {
+    pinnedRefreshRuntime().register(type, id);
+  };
+  globalThis.$RefreshSig$ = () => pinnedRefreshRuntime().createSignatureFunctionForTransform();
+  reconciler.setRefreshHandler?.((type) => pinnedRefreshRuntime().getFamilyByType(type));
+  reconciler.injectIntoDevTools?.();
+  refreshReady = true;
+}
+function performRefresh() {
+  pinnedRefreshRuntime().performReactRefresh();
+}
+function registerExports(mod, moduleId) {
+  for (const [name, val] of Object.entries(mod)) {
+    if (typeof val === "function" && /^[A-Z]/.test(name)) {
+      pinnedRefreshRuntime().register(val, `${moduleId} ${name}`);
+    }
+  }
+}
+var ROOT_FAMILY_KEY = "nd-root";
+function registerRoot(rootComponentType) {
+  pinnedRefreshRuntime().register(rootComponentType, ROOT_FAMILY_KEY);
+}
+function hotUpdateRoot(rootComponentType) {
+  pinnedRefreshRuntime().register(rootComponentType, ROOT_FAMILY_KEY);
+  pinnedRefreshRuntime().performReactRefresh();
+}
+function fullReload() {
+  newGeneration();
+}
+
+// src/platform.ts
+function state() {
+  if (!globalThis.__nd_platform) {
+    globalThis.__nd_platform = { backend: "unknown", hostWidgets: null, hostCommands: null };
+  }
+  return globalThis.__nd_platform;
+}
+var backendListeners = [];
+function onBackendKnown(cb) {
+  backendListeners.push(cb);
+  if (state().backend !== "unknown")
+    cb();
+}
+function setBackend(name) {
+  state().backend = name;
+  for (const cb of backendListeners)
+    cb();
+}
+function setHostManifest(widgets, commands) {
+  state().hostWidgets = widgets;
+  state().hostCommands = commands;
+}
+function hasWidget(type) {
+  const { hostWidgets } = state();
+  if (hostWidgets)
+    return hostWidgets.has(type);
+  return type in intrinsicToName;
+}
+function hasCommand(type, command) {
+  const { hostCommands } = state();
+  if (hostCommands)
+    return hostCommands.has(`${type}.${command}`);
+  return (widgetCommands[type] ?? []).includes(command);
+}
+function currentOS() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return "linux";
+  }
+}
+var Platform = {
+  get backend() {
+    return state().backend;
+  },
+  get os() {
+    return currentOS();
+  },
+  select(spec) {
+    const { backend } = state();
+    return backend in spec ? spec[backend] : spec.default;
+  }
+};
+
+// src/host-config.ts
+var activeBatch = new Batch;
+var registry = new NodeRegistry;
+function bindCommitTargets(b, r) {
+  activeBatch = b;
+  registry = r;
+}
+var currentUpdatePriority = DefaultEventPriority;
+function textOf(children) {
+  if (typeof children === "string")
+    return children;
+  if (typeof children === "number")
+    return String(children);
+  if (Array.isArray(children) && children.every((c) => typeof c === "string" || typeof c === "number"))
+    return children.join("");
+  return;
+}
+function collectHandlers(type, props) {
+  const out = {};
+  for (const ev of widgetEvents[type] ?? []) {
+    const h = props[ev.handler];
+    if (typeof h === "function")
+      out[ev.name] = h;
+  }
+  return out;
+}
+function emitCreateIfNew(inst) {
+  if (registry.get(inst.id))
+    return;
+  const props = { ...inst.props };
+  if ("style" in props)
+    validateStyle(props.style);
+  if ("cssClasses" in props)
+    validateCssClasses(props.cssClasses);
+  const text = textOf(props.children);
+  if (inst.type === "label" && text !== undefined)
+    props.text = text;
+  delete props.children;
+  for (const h of handlerPropNames[inst.type] ?? [])
+    delete props[h];
+  activeBatch.push({ op: "create", id: inst.id, widget: intrinsicToName[inst.type], props });
+  registry.register({ id: inst.id, type: inst.type, props: inst.props, handlers: collectHandlers(inst.type, inst.props) });
+  for (const child of inst.children) {
+    emitCreateIfNew(child);
+    activeBatch.push({ op: "append", parent: inst.id, child: child.id });
+  }
+}
+function setPriorityFor(kind) {
+  currentUpdatePriority = kind === "discrete" ? DiscreteEventPriority : kind === "continuous" ? ContinuousEventPriority : DefaultEventPriority;
+}
+var PLATFORM_LABEL = { macos: "macOS", linux: "Linux" };
+var warnedPlatformMismatch = new Set;
+function checkPlatform(type) {
+  if (!isHot() || warnedPlatformMismatch.has(type))
+    return;
+  const allowed = widgetPlatforms[type];
+  if (!allowed || allowed.includes(Platform.os))
+    return;
+  warnedPlatformMismatch.add(type);
+  const label = allowed.map((p) => PLATFORM_LABEL[p]).join("/");
+  console.warn(`<${type}> is ${label}-only; it renders nothing on ${Platform.os}. Gate it with Platform.os.`);
+}
+var hostConfig = {
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  isPrimaryRenderer: true,
+  noTimeout: -1,
+  supportsMicrotasks: true,
+  scheduleMicrotask: (fn) => queueMicrotask(fn),
+  scheduleTimeout: (fn, delay) => setTimeout(fn, delay),
+  cancelTimeout: (id) => clearTimeout(id),
+  getRootHostContext: () => ({ root: true }),
+  getChildHostContext: (parent) => parent,
+  prepareForCommit: () => null,
+  resetAfterCommit: () => {},
+  clearContainer: () => {},
+  preparePortalMount: () => {},
+  createInstance(type, props) {
+    checkPlatform(type);
+    const id = nextNodeId();
+    return { id, type, props, children: [] };
+  },
+  createTextInstance(text) {
+    return { text };
+  },
+  shouldSetTextContent: (type) => type === "label",
+  appendInitialChild(parent, child) {
+    parent.children.push(child);
+  },
+  finalizeInitialChildren: () => false,
+  appendChild(parent, child) {
+    emitCreateIfNew(child);
+    activeBatch.push({ op: "append", parent: parent.id, child: child.id });
+  },
+  appendChildToContainer(_container, child) {
+    emitCreateIfNew(child);
+  },
+  insertBefore(parent, child, before) {
+    emitCreateIfNew(child);
+    activeBatch.push({ op: "insertBefore", parent: parent.id, child: child.id, before: before.id });
+  },
+  insertInContainerBefore(_c, child, _b) {
+    emitCreateIfNew(child);
+  },
+  removeChild(_parent, child) {
+    activeBatch.push({ op: "remove", id: child.id });
+    registry.unregister(child.id);
+  },
+  removeChildFromContainer(_c, child) {
+    activeBatch.push({ op: "remove", id: child.id });
+    registry.unregister(child.id);
+  },
+  commitUpdate(inst, type, oldProps, newProps) {
+    if ("style" in newProps)
+      validateStyle(newProps.style);
+    if ("cssClasses" in newProps)
+      validateCssClasses(newProps.cssClasses);
+    if (type === "label") {
+      const t = textOf(newProps.children) ?? newProps.text;
+      const old = textOf(oldProps.children) ?? oldProps.text;
+      if (t !== undefined && t !== old)
+        activeBatch.push({ op: "setText", id: inst.id, text: t });
+    }
+    const skip = handlerPropNames[type] ?? [];
+    const changed = {};
+    for (const k of Object.keys(newProps)) {
+      if (k === "children" || skip.includes(k))
+        continue;
+      if (type === "label" && k === "text")
+        continue;
+      if (newProps[k] !== oldProps[k])
+        changed[k] = newProps[k];
+    }
+    if (Object.keys(changed).length)
+      activeBatch.push({ op: "update", id: inst.id, props: changed });
+    inst.props = newProps;
+    const rec = registry.get(inst.id);
+    if (rec)
+      rec.handlers = collectHandlers(type, newProps);
+  },
+  commitTextUpdate() {},
+  hideInstance(inst) {
+    activeBatch.push({ op: "hide", id: inst.id });
+  },
+  unhideInstance(inst) {
+    activeBatch.push({ op: "unhide", id: inst.id });
+  },
+  hideTextInstance() {},
+  unhideTextInstance() {},
+  getPublicInstance: (i) => i,
+  detachDeletedInstance() {},
+  maySuspendCommit: () => false,
+  preloadInstance: () => true,
+  startSuspendingCommit() {},
+  suspendInstance() {},
+  waitForCommitToBeReady: () => null,
+  resolveUpdatePriority: () => currentUpdatePriority,
+  getCurrentUpdatePriority: () => currentUpdatePriority,
+  setCurrentUpdatePriority: (p) => {
+    currentUpdatePriority = p;
+  },
+  shouldAttemptEagerTransition: () => false,
+  trackSchedulerEvent() {},
+  resolveEventType: () => null,
+  resolveEventTimeStamp: () => -1.1,
+  requestPostPaintCallback() {}
+};
+
+// src/system.ts
+function requireHost(name) {
+  if (!getHmrState())
+    throw new Error(`${name}() used before render(): no host connection yet`);
+}
+function call(method, params = {}) {
+  requireHost(method);
+  return getHmrState().ndp.request(method, params);
+}
+function registry2() {
+  if (!globalThis.__nd_system_events)
+    globalThis.__nd_system_events = new Map;
+  return globalThis.__nd_system_events;
+}
+function subscribe(channel, name, handler) {
+  requireHost(name);
+  let handlers = registry2().get(channel);
+  if (!handlers)
+    registry2().set(channel, handlers = new Set);
+  handlers.add(handler);
+  return () => handlers.delete(handler);
+}
+function dispatchSystemEvent(channel, data) {
+  if (channel === "app.activate")
+    globalThis.__nd_app_active = true;
+  else if (channel === "app.deactivate")
+    globalThis.__nd_app_active = false;
+  for (const handler of registry2().get(channel) ?? [])
+    handler(data);
+  if (channel === "notification.click") {
+    const id = data?.id;
+    if (id !== undefined)
+      notificationData().delete(id);
+  }
+}
+var NOTIFICATION_DATA_CAP = 128;
+function notificationData() {
+  if (!globalThis.__nd_notification_data)
+    globalThis.__nd_notification_data = new Map;
+  return globalThis.__nd_notification_data;
+}
+var dialog = {
+  openFile(options = {}) {
+    return call("dialog.openFile", options);
+  },
+  saveFile(options = {}) {
+    return call("dialog.saveFile", options);
+  },
+  showMessage(options) {
+    return call("dialog.showMessage", options);
+  }
+};
+var clipboard = {
+  readText() {
+    return call("clipboard.readText");
+  },
+  async writeText(text) {
+    await call("clipboard.writeText", { text });
+  },
+  readImage() {
+    return call("clipboard.readImage");
+  }
+};
+var notifications = {
+  async show(options) {
+    const { data, ...wire } = options;
+    const id = await call("notification.show", wire);
+    if (data !== undefined) {
+      const map = notificationData();
+      map.set(id, data);
+      while (map.size > NOTIFICATION_DATA_CAP) {
+        const oldest = map.keys().next().value;
+        if (oldest === undefined)
+          break;
+        map.delete(oldest);
+      }
+    }
+    return id;
+  },
+  onClick(handler) {
+    return subscribe("notification.click", "notifications.onClick", (raw) => {
+      const { id } = raw;
+      const data = notificationData().get(id);
+      handler(data === undefined ? { id } : { id, data });
+    });
+  }
+};
+var recentDocuments = {
+  async add(path) {
+    await call("recent.add", { path });
+  },
+  async clear() {
+    await call("recent.clear");
+  }
+};
+var credentials = {
+  async set(service, account, secret) {
+    await call("credentials.set", { service, account, secret });
+  },
+  get(service, account) {
+    return call("credentials.get", { service, account });
+  },
+  async delete(service, account) {
+    await call("credentials.delete", { service, account });
+  }
+};
+var app = {
+  isActive() {
+    return globalThis.__nd_app_active ?? true;
+  },
+  onActivate(handler) {
+    return subscribe("app.activate", "app.onActivate", () => handler());
+  },
+  onDeactivate(handler) {
+    return subscribe("app.deactivate", "app.onDeactivate", () => handler());
+  },
+  onOpenUrl(handler) {
+    return subscribe("app.openUrl", "app.onOpenUrl", (data) => handler(data.url));
+  },
+  onOpenFile(handler) {
+    return subscribe("app.openFile", "app.onOpenFile", (data) => handler(data.paths));
+  },
+  onFileDrop(handler) {
+    return subscribe("fileDrop", "app.onFileDrop", (data) => handler(data));
+  }
+};
+var system = {
+  getAppearance() {
+    return call("system.getAppearance");
+  },
+  onAppearanceChange(handler) {
+    return subscribe("appearance", "system.onAppearanceChange", (data) => handler(data));
+  }
+};
+var audio = {
+  play(options) {
+    return call("audio.play", options);
+  },
+  async pause(handle) {
+    await call("audio.pause", { handle });
+  },
+  async resume(handle) {
+    await call("audio.resume", { handle });
+  },
+  async stop(handle) {
+    await call("audio.stop", { handle });
+  },
+  async seek(handle, positionMs) {
+    await call("audio.seek", { handle, position: positionMs });
+  },
+  async setVolume(handle, volume) {
+    await call("audio.setVolume", { handle, volume });
+  },
+  onState(handler) {
+    return subscribe("audio.state", "audio.onState", (data) => handler(data));
+  },
+  onSpectrum(handler) {
+    return subscribe("audio.spectrum", "audio.onSpectrum", (data) => handler(data));
+  }
+};
+
+// src/errors.ts
+var RATE_MAX = 20;
+var RATE_WINDOW_MS = 1e4;
+function state2() {
+  if (!globalThis.__nd_errors) {
+    globalThis.__nd_errors = {
+      policy: {},
+      handlers: new Set,
+      stamps: [],
+      suppressedLogged: false,
+      hintShown: false,
+      renderFatal: new WeakSet
+    };
+  }
+  return globalThis.__nd_errors;
+}
+function decide(kind, p) {
+  switch (kind) {
+    case "renderUncaught":
+      return "fatal";
+    case "renderCaught":
+    case "renderRecoverable":
+      return "report";
+    case "uncaughtException":
+      return p.uncaughtException ?? "fatal";
+    case "unhandledRejection":
+      return p.unhandledRejection ?? (process.env.ND_FATAL_REJECTIONS === "1" ? "fatal" : "report");
+  }
+}
+function onUnhandledError(handler) {
+  const handlers = state2().handlers;
+  handlers.add(handler);
+  return () => handlers.delete(handler);
+}
+function setUnhandledErrorPolicy(p) {
+  const s = state2();
+  s.policy = { ...s.policy, ...p };
+}
+var KIND_LABEL = {
+  unhandledRejection: "unhandled rejection",
+  uncaughtException: "uncaught exception",
+  renderUncaught: "render error",
+  renderCaught: "render error (caught by boundary)",
+  renderRecoverable: "render error (recoverable)"
+};
+function toError(raw) {
+  return raw instanceof Error ? raw : new Error(String(raw));
+}
+function admitReport() {
+  const s = state2();
+  const now = Date.now();
+  while (s.stamps.length && now - s.stamps[0] > RATE_WINDOW_MS)
+    s.stamps.shift();
+  if (s.stamps.length >= RATE_MAX) {
+    if (!s.suppressedLogged) {
+      s.suppressedLogged = true;
+      console.error("[nd] further error reports suppressed (rate limit)");
+    }
+    return false;
+  }
+  s.suppressedLogged = false;
+  s.stamps.push(now);
+  return true;
+}
+function report(raw, kind, fatal, componentStack) {
+  const s = state2();
+  const error = toError(raw);
+  if (fatal || admitReport()) {
+    if (s.policy.log !== false) {
+      let line = `[nd] ${KIND_LABEL[kind]}: ${error.message}
+${error.stack ?? ""}`;
+      if (!fatal && isHot() && !s.hintShown) {
+        s.hintShown = true;
+        line += `
+[nd] the app kept running. Register onUnhandledError() from @nativedesktop/react to handle these.`;
+      }
+      console.error(line);
+    }
+    getHmrState()?.ndp.sendRuntimeError(error.message, error.stack ?? "", fatal);
+  }
+  const context = { kind, fatal, raw };
+  if (componentStack !== undefined)
+    context.componentStack = componentStack;
+  for (const handler of s.handlers) {
+    try {
+      handler(error, context);
+    } catch (handlerErr) {
+      console.error(`[nd] onUnhandledError handler threw: ${String(handlerErr)}`);
+    }
+  }
+}
+function reportRenderError(raw, kind, componentStack) {
+  if (kind === "renderUncaught") {
+    if (typeof raw === "object" && raw !== null)
+      state2().renderFatal.add(raw);
+    report(raw, kind, true, componentStack);
+    return;
+  }
+  report(raw, kind, false, componentStack);
+}
+function installErrorHandlers() {
+  if (globalThis.__nd_errors_installed)
+    return;
+  globalThis.__nd_errors_installed = true;
+  process.on("unhandledRejection", (reason) => {
+    const fatal = decide("unhandledRejection", state2().policy) === "fatal";
+    report(reason, "unhandledRejection", fatal);
+    if (fatal)
+      process.exit(1);
+  });
+  process.on("uncaughtException", (err) => {
+    const s = state2();
+    if (typeof err === "object" && err !== null && s.renderFatal.has(err))
+      process.exit(1);
+    const fatal = decide("uncaughtException", s.policy) === "fatal";
+    report(err, "uncaughtException", fatal);
+    if (fatal)
+      process.exit(1);
+  });
+}
+
+// src/renderer.ts
+async function render(element) {
+  installErrorHandlers();
+  let state3 = getHmrState();
+  if (!state3) {
+    const ndp = await Ndp.connect();
+    ndp.onSystemEvent((channel, data) => dispatchSystemEvent(channel, data));
+    await ndp.handshake({ name: "bun", version: Bun.version });
+    setBackend(ndp.backend);
+    setHostManifest(ndp.hostWidgets, ndp.hostCommands);
+    const batch = new Batch;
+    const registry3 = new NodeRegistry;
+    bindCommitTargets(batch, registry3);
+    let commitId = 0;
+    const configWithFlush = {
+      ...hostConfig,
+      resetAfterCommit() {
+        const ops = batch.drain();
+        if (ops.length)
+          ndp.sendCommit({ commitId: commitId++, generation: currentGeneration(), ops });
+      }
+    };
+    ndp.onEvent((e) => {
+      setPriorityFor(e.priority ?? "discrete");
+      registry3.get(e.nodeId)?.handlers[e.name]?.(e.payload);
+    });
+    const Reconciler = ReconcilerFactory(configWithFlush);
+    if (isHot())
+      setupRefresh(Reconciler);
+    const container = { rootId: null };
+    const root = Reconciler.createContainer(container, ConcurrentRoot, null, false, null, "nd", (e, info) => {
+      reportRenderError(e, "renderUncaught", info?.componentStack);
+      throw e;
+    }, (e, info) => {
+      reportRenderError(e, "renderCaught", info?.componentStack);
+    }, (e, info) => {
+      reportRenderError(e, "renderRecoverable", info?.componentStack);
+    }, null);
+    state3 = { ndp, root, reconciler: Reconciler, bootCount: 0 };
+    setHmrState(state3);
+  }
+  state3.bootCount += 1;
+  if (state3.bootCount === 1) {
+    if (isHot())
+      registerRoot(element.type);
+    state3.reconciler.updateContainer(element, state3.root, null, () => {});
+  } else if (isHot()) {
+    hotUpdateRoot(element.type);
+  } else {
+    state3.reconciler.updateContainer(element, state3.root, null, () => {});
+  }
+  if (state3.bootCount === 1)
+    await new Promise(() => {});
+}
+function dispatchWidgetCommand(caller, node, command, arg) {
+  const state3 = getHmrState();
+  if (!state3)
+    throw new Error(`${caller}() before render(): no NDP connection yet`);
+  state3.ndp.sendWidgetCommand(node.id, command, arg ?? null);
+}
+function sendCommand(node, command, arg) {
+  const allowed = widgetCommands[node.type] ?? [];
+  if (!allowed.includes(command)) {
+    throw new Error(`<${node.type}> does not accept command "${command}" (valid: ${allowed.join(", ") || "none"})`);
+  }
+  if (isHot() && !hasCommand(node.type, command)) {
+    const key = `${node.type}.${command}`;
+    if (!warnedHostUnknownCommand.has(key)) {
+      warnedHostUnknownCommand.add(key);
+      console.warn(`sendCommand: the connected host does not dispatch "${key}" — gate it with hasCommand("${node.type}", "${command}").`);
+    }
+  }
+  dispatchWidgetCommand("sendCommand", node, command, arg);
+}
+var warnedHostUnknownCommand = new Set;
+function sendNativeCommand(node, command, arg) {
+  if (!command)
+    throw new Error("sendNativeCommand() requires a non-empty command");
+  dispatchWidgetCommand("sendNativeCommand", node, command, arg);
+}
+var defaultPool = { rootId: null };
+function createPool() {
+  return { rootId: null };
+}
+function createPortal(children, pool = defaultPool) {
+  const state3 = getHmrState();
+  if (!state3)
+    throw new Error("createPortal() before render(): no reconciler yet");
+  const reconciler = state3.reconciler;
+  return reconciler.createPortal(children, pool, null);
+}
+function moveNode(node, toParent, before) {
+  dispatchWidgetCommand("moveNode", node, "__ndReparent", { parent: toParent.id, before: before?.id ?? null });
+}
+// src/metrics.ts
+var APPLE = { xs: 4, sm: 8, md: 12, lg: 20, xl: 24 };
+var GNOME = { xs: 3, sm: 6, md: 12, lg: 18, xl: 24 };
+function appleLanguage() {
+  const backend = Platform.backend;
+  if (backend !== "unknown")
+    return backend === "appkit";
+  return Platform.os === "macos";
+}
+var Spacing = {
+  get xs() {
+    return (appleLanguage() ? APPLE : GNOME).xs;
+  },
+  get sm() {
+    return (appleLanguage() ? APPLE : GNOME).sm;
+  },
+  get md() {
+    return (appleLanguage() ? APPLE : GNOME).md;
+  },
+  get lg() {
+    return (appleLanguage() ? APPLE : GNOME).lg;
+  },
+  get xl() {
+    return (appleLanguage() ? APPLE : GNOME).xl;
+  }
+};
+var ContentMargin = appleLanguage() ? 20 : 12;
+onBackendKnown(() => {
+  ContentMargin = appleLanguage() ? 20 : 12;
+});
+// src/paths.ts
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+function appName() {
+  let dir = process.cwd();
+  while (true) {
+    const manifest = resolve(dir, "nd-app.json");
+    if (existsSync(manifest)) {
+      const name = JSON.parse(readFileSync(manifest, "utf8")).name;
+      if (name)
+        return name;
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  const pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf8"));
+  if (!pkg.name)
+    throw new Error("nd: could not resolve app name from package.json");
+  return pkg.name;
+}
+function getAppDataDir() {
+  const name = appName();
+  switch (process.platform) {
+    case "darwin":
+      return resolve(homedir(), "Library", "Application Support", name);
+    case "win32":
+      return resolve(process.env.APPDATA ?? homedir(), name);
+    default:
+      return resolve(process.env.XDG_DATA_HOME || resolve(homedir(), ".local", "share"), name);
+  }
+}
+function ensureAppDataDir() {
+  const dir = getAppDataDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+// src/dev-react.ts
+import * as ReactFirstEval from "react";
+function pinnedReact() {
+  if (!globalThis.__nd_react)
+    globalThis.__nd_react = ReactFirstEval;
+  return globalThis.__nd_react;
+}
+var useState = (...a) => pinnedReact().useState(...a);
+var useEffect = (...a) => pinnedReact().useEffect(...a);
+var useLayoutEffect = (...a) => pinnedReact().useLayoutEffect(...a);
+var useMemo = (...a) => pinnedReact().useMemo(...a);
+var useCallback = (...a) => pinnedReact().useCallback(...a);
+var useRef = (...a) => pinnedReact().useRef(...a);
+var useContext = (...a) => pinnedReact().useContext(...a);
+var useReducer = (...a) => pinnedReact().useReducer(...a);
+var useTransition = (...a) => pinnedReact().useTransition(...a);
+var useDeferredValue = (...a) => pinnedReact().useDeferredValue(...a);
+var useSyncExternalStore = (...a) => pinnedReact().useSyncExternalStore(...a);
+var useId = (...a) => pinnedReact().useId(...a);
+var use = (a) => pinnedReact().use(a);
+var startTransition = (...a) => pinnedReact().startTransition(...a);
+var memo = (...a) => pinnedReact().memo(...a);
+var forwardRef = (...a) => pinnedReact().forwardRef(...a);
+var createContext = (...a) => pinnedReact().createContext(...a);
+var Suspense2 = ReactFirstEval.Suspense;
+var Fragment3 = ReactFirstEval.Fragment;
+
+// src/native-component.ts
+import { createElement } from "react";
+function defineNativeComponent(options) {
+  return forwardRef(function NativeComponent(componentProps, ref) {
+    const { props, onNativeEvent, ...hostProps } = componentProps;
+    const setRef = useCallback((instance) => {
+      if (typeof ref === "function") {
+        ref(instance ? makeRef(instance) : null);
+      } else if (ref) {
+        ref.current = instance ? makeRef(instance) : null;
+      }
+    }, [ref]);
+    return createElement("nativeview", {
+      ...hostProps,
+      viewKind: options.viewKind,
+      props: JSON.stringify(props),
+      onNativeEvent: onNativeEvent ? (event) => onNativeEvent({ name: event.nativeName ?? "", data: event.data }) : undefined,
+      ref: setRef
+    });
+  });
+}
+var refCache = new WeakMap;
+function makeRef(instance) {
+  let wrapper = refCache.get(instance);
+  if (!wrapper) {
+    wrapper = {
+      id: instance.id,
+      type: "nativeview",
+      send(command, arg) {
+        sendNativeCommand({ id: instance.id, type: "nativeview" }, command, arg);
+      }
+    };
+    refCache.set(instance, wrapper);
+  }
+  return wrapper;
+}
+// src/webview.ts
+var pending = new Map;
+var seq2 = 0;
+function executeJavaScript(node, code) {
+  const id = `js${++seq2}`;
+  return new Promise((resolve2, reject2) => {
+    pending.set(id, { resolve: resolve2, reject: reject2 });
+    sendCommand(node, "executeJavaScript", { id, code });
+  });
+}
+function onJavaScriptResult(e) {
+  const result = e.data;
+  const call2 = pending.get(result.id);
+  if (!call2)
+    return;
+  pending.delete(result.id);
+  if (result.ok)
+    call2.resolve(result.value ?? "");
+  else
+    call2.reject(new Error(result.error ?? "executeJavaScript failed"));
+}
+// src/dialogs.ts
+var pending2 = new Map;
+function checkAvailable(node, reject2) {
+  const existing = pending2.get(node.id);
+  if (!existing)
+    return true;
+  reject2(new Error(`<window> already has a "${existing.kind}" dialog pending; only one modal dialog per window is allowed at a time`));
+  return false;
+}
+function settle(node, kind, data) {
+  const call2 = pending2.get(node.id);
+  if (!call2 || call2.kind !== kind)
+    return;
+  pending2.delete(node.id);
+  switch (call2.kind) {
+    case "showAlert":
+      call2.resolve(data);
+      break;
+    case "openFile":
+      call2.resolve(data);
+      break;
+    case "saveFile":
+      call2.resolve(data);
+      break;
+  }
+}
+function showAlert(node, options) {
+  return new Promise((resolve2, reject2) => {
+    if (!checkAvailable(node, reject2))
+      return;
+    pending2.set(node.id, { kind: "showAlert", resolve: resolve2, reject: reject2 });
+    sendCommand(node, "showAlert", options);
+  });
+}
+function openFile(node, options = {}) {
+  return new Promise((resolve2, reject2) => {
+    if (!checkAvailable(node, reject2))
+      return;
+    pending2.set(node.id, { kind: "openFile", resolve: resolve2, reject: reject2 });
+    sendCommand(node, "openFile", options);
+  });
+}
+function saveFile(node, options = {}) {
+  return new Promise((resolve2, reject2) => {
+    if (!checkAvailable(node, reject2))
+      return;
+    pending2.set(node.id, { kind: "saveFile", resolve: resolve2, reject: reject2 });
+    sendCommand(node, "saveFile", options);
+  });
+}
+function showAbout(node, options) {
+  sendCommand(node, "showAbout", options);
+}
+function showTabOverview(node) {
+  sendCommand(node, "showTabOverview", {});
+}
+function onAlertResult(node, e) {
+  settle(node, "showAlert", e.data);
+}
+function onOpenFileResult(node, e) {
+  settle(node, "openFile", e.data);
+}
+function onSaveFileResult(node, e) {
+  settle(node, "saveFile", e.data);
+}
+// src/toast.ts
+var pending3 = new Map;
+var seq3 = 0;
+function showToast(node, options) {
+  const id = `toast${++seq3}`;
+  return new Promise((resolve2) => {
+    pending3.set(id, { resolve: resolve2 });
+    sendCommand(node, "showToast", { id, ...options });
+  });
+}
+function dismissToast(node, id) {
+  sendCommand(node, "dismissToast", id ? { id } : {});
+}
+function onToastButtonClicked(e) {
+  const { id } = e.data;
+  const toast = pending3.get(id);
+  if (!toast)
+    return;
+  pending3.delete(id);
+  toast.resolve({ buttonClicked: true });
+}
+function onToastDismissed(e) {
+  const { id } = e.data;
+  const toast = pending3.get(id);
+  if (!toast)
+    return;
+  pending3.delete(id);
+  toast.resolve({ buttonClicked: false });
+}
+// src/shell.ts
+import { dirname as dirname2 } from "node:path";
+async function run(cmd) {
+  const proc = Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+  const code = await proc.exited;
+  if (code !== 0)
+    throw new Error(`${cmd.join(" ")} exited with code ${code}`);
+}
+async function openExternal(url) {
+  await run(Platform.os === "macos" ? ["open", url] : ["xdg-open", url]);
+}
+async function openPath(path) {
+  await run(Platform.os === "macos" ? ["open", path] : ["xdg-open", path]);
+}
+async function revealPath(path) {
+  if (Platform.os === "macos") {
+    await run(["open", "-R", path]);
+    return;
+  }
+  try {
+    await run([
+      "dbus-send",
+      "--session",
+      "--dest=org.freedesktop.FileManager1",
+      "--type=method_call",
+      "/org/freedesktop/FileManager1",
+      "org.freedesktop.FileManager1.ShowItems",
+      `array:string:file://${path}`,
+      "string:"
+    ]);
+  } catch {
+    await run(["xdg-open", dirname2(path)]);
+  }
+}
+// src/hooks.ts
+function useMountEffect(effect) {
+  useEffect(effect, []);
+}
+// src/store.ts
+import { mkdirSync as mkdirSync2, renameSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join, resolve as resolve2 } from "node:path";
+class StoreImpl {
+  name;
+  path;
+  corruptPath;
+  loadError;
+  #options;
+  #value;
+  #loaded = false;
+  #loadPromise;
+  #subscribers = new Set;
+  #timer;
+  #dirty = false;
+  #pendingSnapshot;
+  #writeChain = Promise.resolve();
+  constructor(options, path) {
+    this.#options = options;
+    this.name = options.name;
+    this.path = path;
+    this.corruptPath = join(dirname3(path), `${options.name}.corrupt.json`);
+  }
+  load() {
+    if (!this.#loadPromise)
+      this.#loadPromise = this.#doLoad();
+    return this.#loadPromise;
+  }
+  async#doLoad() {
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch {}
+    let value;
+    if (raw !== undefined) {
+      let parsed;
+      let rejected;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (err) {
+        rejected = new Error(`nd: store "${this.name}" file is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (!rejected) {
+        const { data, fromVersion } = unwrapEnvelope(parsed);
+        const migrate = this.#options.migrate;
+        if (migrate) {
+          let migrated;
+          try {
+            migrated = migrate(data, fromVersion);
+          } catch (err) {
+            migrated = null;
+            rejected = new Error(`nd: store "${this.name}" migrate threw: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          if (migrated === null) {
+            rejected ??= new Error(`nd: store "${this.name}" migrate rejected the file (version ${fromVersion})`);
+          } else {
+            value = migrated;
+          }
+        } else if (fromVersion === this.#options.version) {
+          value = data;
+        } else {
+          rejected = new Error(`nd: store "${this.name}" is version ${fromVersion}, expected ${this.#options.version}, and no migrate hook is set`);
+        }
+      }
+      if (value === undefined) {
+        this.loadError = rejected;
+        try {
+          await rename(this.path, this.corruptPath);
+        } catch {}
+      }
+    }
+    this.#value = value ?? this.#options.defaults;
+    this.#loaded = true;
+    return this.#value;
+  }
+  get() {
+    if (!this.#loaded)
+      throw this.#beforeLoadError();
+    return this.#value;
+  }
+  set(next) {
+    if (!this.#loaded)
+      throw this.#beforeLoadError();
+    if (Object.is(next, this.#value))
+      return;
+    this.#value = next;
+    for (const cb of this.#subscribers)
+      cb(next);
+    this.#scheduleWrite();
+  }
+  update(fn) {
+    this.set(fn(this.get()));
+  }
+  subscribe(cb) {
+    this.#subscribers.add(cb);
+    return () => this.#subscribers.delete(cb);
+  }
+  flush() {
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = undefined;
+    }
+    if (this.#dirty)
+      this.#queueWrite();
+    return this.#writeChain;
+  }
+  #beforeLoadError() {
+    return new Error(`nd: store "${this.name}" read before load(); await store.load() before render()`);
+  }
+  #scheduleWrite() {
+    this.#dirty = true;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      this.#queueWrite();
+    }, this.#options.debounceMs ?? 250);
+  }
+  #queueWrite() {
+    this.#dirty = false;
+    const snapshot = this.#serialize();
+    this.#pendingSnapshot = snapshot;
+    this.#writeChain = this.#writeChain.then(async () => {
+      await mkdir(dirname3(this.path), { recursive: true });
+      const tmp = `${this.path}.tmp-${process.pid}`;
+      await writeFile(tmp, snapshot);
+      await rename(tmp, this.path);
+      if (this.#pendingSnapshot === snapshot)
+        this.#pendingSnapshot = undefined;
+    }).catch((err) => {
+      console.error(`[nd] store "${this.name}" write failed:`, err);
+    });
+  }
+  #serialize() {
+    const envelope = { version: this.#options.version, data: this.#value };
+    return JSON.stringify(envelope);
+  }
+  writeSyncPending() {
+    if (!this.#loaded || !this.#dirty && this.#pendingSnapshot === undefined)
+      return;
+    this.#dirty = false;
+    this.#pendingSnapshot = undefined;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = undefined;
+    }
+    try {
+      mkdirSync2(dirname3(this.path), { recursive: true });
+      const tmp = `${this.path}.tmp-exit-${process.pid}`;
+      writeFileSync(tmp, this.#serialize());
+      renameSync(tmp, this.path);
+    } catch (err) {
+      console.error(`[nd] store "${this.name}" exit flush failed:`, err);
+    }
+  }
+}
+function unwrapEnvelope(parsed) {
+  if (typeof parsed === "object" && parsed !== null && typeof parsed.version === "number" && "data" in parsed) {
+    return { data: parsed.data, fromVersion: parsed.version };
+  }
+  return { data: parsed, fromVersion: 0 };
+}
+function registry3() {
+  if (!globalThis.__nd_stores)
+    globalThis.__nd_stores = { stores: new Map, exitHooked: false };
+  return globalThis.__nd_stores;
+}
+function hookExit(reg) {
+  if (reg.exitHooked)
+    return;
+  reg.exitHooked = true;
+  const flushAll = () => {
+    for (const store of reg.stores.values())
+      store.writeSyncPending();
+  };
+  process.once("exit", flushAll);
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => {
+      flushAll();
+      if (process.listenerCount(signal) === 0)
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    });
+  }
+}
+function createStore(options) {
+  const dir = options.dir ?? getAppDataDir();
+  const path = resolve2(join(dir, `${options.name}.json`));
+  const reg = registry3();
+  const existing = reg.stores.get(path);
+  if (existing)
+    return existing;
+  const store = new StoreImpl(options, path);
+  reg.stores.set(path, store);
+  hookExit(reg);
+  return store;
+}
+function useStoreValue(store, select) {
+  const getSnapshot = useMemo(() => {
+    let lastValue;
+    let lastSelected;
+    let primed = false;
+    return () => {
+      const value = store.get();
+      if (!primed || !Object.is(value, lastValue)) {
+        lastValue = value;
+        lastSelected = select ? select(value) : value;
+        primed = true;
+      }
+      return lastSelected;
+    };
+  }, [store, select]);
+  const subscribe2 = useMemo(() => {
+    return (onChange) => store.subscribe(() => onChange());
+  }, [store]);
+  return useSyncExternalStore(subscribe2, getSnapshot);
+}
+export {
+  useTransition,
+  useSyncExternalStore,
+  useStoreValue,
+  useState,
+  useRef,
+  useReducer,
+  useMountEffect,
+  useMemo,
+  useLayoutEffect,
+  useId,
+  useEffect,
+  useDeferredValue,
+  useContext,
+  useCallback,
+  use,
+  system,
+  startTransition,
+  showToast,
+  showTabOverview,
+  showAlert,
+  showAbout,
+  setUnhandledErrorPolicy,
+  sendNativeCommand,
+  sendCommand,
+  saveFile,
+  revealPath,
+  render,
+  registerExports,
+  recentDocuments,
+  performRefresh,
+  openPath,
+  openFile,
+  openExternal,
+  onUnhandledError,
+  onToastDismissed,
+  onToastButtonClicked,
+  onSaveFileResult,
+  onOpenFileResult,
+  onJavaScriptResult,
+  onAlertResult,
+  notifications,
+  moveNode,
+  memo,
+  hasWidget,
+  hasCommand,
+  getAppDataDir,
+  fullReload,
+  forwardRef,
+  executeJavaScript,
+  ensureAppDataDir,
+  dismissToast,
+  dialog,
+  defineNativeComponent,
+  credentials,
+  createStore,
+  createPortal,
+  createPool,
+  createContext,
+  clipboard,
+  audio,
+  app,
+  Suspense2 as Suspense,
+  Spacing,
+  Platform,
+  Fragment3 as Fragment,
+  ContentMargin
+};