@xnetjs/react 0.0.2

package/dist/index.js

@@ -0,0 +1,4798 @@
+import {
+  InstrumentationContext,
+  METABRIDGE_ORIGIN,
+  METABRIDGE_SEED_ORIGIN,
+  NodeStoreSyncProvider,
+  PluginRegistryContext,
+  SecurityProvider,
+  TelemetryContext,
+  XNetContext,
+  XNetProvider,
+  createConnectionManager,
+  createMetaBridge,
+  createNodePool,
+  createOfflineQueue,
+  createRegistry,
+  createSyncManager,
+  downloadBackup,
+  uploadBackup,
+  useCommand,
+  useCommands,
+  useContributions,
+  useDataBridge,
+  useEditorExtensions,
+  useEditorExtensionsSafe,
+  useInstrumentation,
+  useNodeStore,
+  usePluginRegistry,
+  usePluginRegistryOptional,
+  usePlugins,
+  useSecurityContext,
+  useSecurityContextOptional,
+  useSidebarItems,
+  useSlashCommands,
+  useTelemetryReporter,
+  useView,
+  useViews,
+  useXNet
+} from "./chunk-CWHCGYDW.js";
+
+// src/hooks/useQuery.ts
+import { useSyncExternalStore, useMemo, useCallback, useEffect, useRef } from "react";
+
+// src/utils/flattenNode.ts
+function flattenNode(node, options) {
+  const { properties, timestamps, deletedAt, documentContent, _unknown, _schemaVersion, ...base } = node;
+  const migrationInfo = options?.migrationInfo ?? node._migrationInfo;
+  return {
+    ...base,
+    ...properties,
+    // Include version compatibility fields if present
+    ...options?.unknownSchema && { _unknownSchema: true },
+    ..._unknown && Object.keys(_unknown).length > 0 && { _unknown },
+    ..._schemaVersion && { _schemaVersion },
+    // Include migration fields if present
+    ...migrationInfo && {
+      _migratedFrom: migrationInfo.from,
+      _migrationInfo: migrationInfo
+    }
+  };
+}
+function flattenNodes(nodes, options) {
+  return nodes.map((node) => flattenNode(node, options));
+}
+function flattenUnknownSchemaNode(node) {
+  return flattenNode(node, { unknownSchema: true });
+}
+function flattenNodesWithSchemaCheck(nodes, isSchemaKnown) {
+  return nodes.map((node) => flattenNode(node, { unknownSchema: !isSchemaKnown(node.schemaId) }));
+}
+
+// src/hooks/useQuery.ts
+function useQuery(schema, idOrFilter) {
+  const bridge = useDataBridge();
+  const instrumentation = useInstrumentation();
+  const telemetry = useTelemetryReporter();
+  const schemaId = schema._schemaId;
+  const queryStartRef = useRef(Date.now());
+  const isSingleQuery = typeof idOrFilter === "string";
+  const filter = typeof idOrFilter === "object" ? idOrFilter : {};
+  const nodeId = isSingleQuery ? idOrFilter : null;
+  const whereKey = useMemo(() => JSON.stringify(filter.where), [filter.where]);
+  const orderByKey = useMemo(() => JSON.stringify(filter.orderBy), [filter.orderBy]);
+  const options = useMemo(() => {
+    if (isSingleQuery && nodeId) {
+      return { nodeId };
+    }
+    return {
+      where: filter.where,
+      includeDeleted: filter.includeDeleted,
+      orderBy: filter.orderBy,
+      limit: filter.limit,
+      offset: filter.offset
+    };
+  }, [
+    isSingleQuery,
+    nodeId,
+    whereKey,
+    filter.includeDeleted,
+    orderByKey,
+    filter.limit,
+    filter.offset
+  ]);
+  const subscription = useMemo(() => {
+    if (!bridge) {
+      return {
+        getSnapshot: () => null,
+        subscribe: () => () => {
+        }
+      };
+    }
+    return bridge.query(schema, options);
+  }, [bridge, schema, options]);
+  const reloadCountRef = useRef(0);
+  const reload = useCallback(() => {
+    reloadCountRef.current++;
+  }, []);
+  const rawData = useSyncExternalStore(
+    subscription.subscribe,
+    subscription.getSnapshot,
+    subscription.getSnapshot
+    // Server snapshot (same as client for now)
+  );
+  const { data, migrationWarnings } = useMemo(() => {
+    if (rawData === null) {
+      return {
+        data: isSingleQuery ? null : [],
+        migrationWarnings: []
+      };
+    }
+    const warnings = [];
+    if (isSingleQuery) {
+      const node = rawData[0] ?? null;
+      if (node) {
+        const flat = flattenNode(node);
+        if (flat._migrationInfo && !flat._migrationInfo.lossless) {
+          warnings.push({
+            nodeId: flat.id,
+            from: flat._migrationInfo.from,
+            to: flat._migrationInfo.to,
+            warnings: flat._migrationInfo.warnings
+          });
+        }
+        return { data: flat, migrationWarnings: warnings };
+      }
+      return { data: null, migrationWarnings: warnings };
+    }
+    const flattened = flattenNodes(rawData);
+    for (const flat of flattened) {
+      if (flat._migrationInfo && !flat._migrationInfo.lossless) {
+        warnings.push({
+          nodeId: flat.id,
+          from: flat._migrationInfo.from,
+          to: flat._migrationInfo.to,
+          warnings: flat._migrationInfo.warnings
+        });
+      }
+    }
+    return { data: flattened, migrationWarnings: warnings };
+  }, [rawData, isSingleQuery]);
+  const loading = rawData === null;
+  const queryIdRef = useRef(
+    `useQuery-${schemaId}-${nodeId || "list"}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  useEffect(() => {
+    if (!instrumentation?.queryTracker) return;
+    const mode = isSingleQuery ? "single" : filter.where ? "filtered" : "list";
+    const queryId = queryIdRef.current;
+    instrumentation.queryTracker.register(queryId, {
+      type: "useQuery",
+      schemaId,
+      mode,
+      filter: filter.where,
+      nodeId: nodeId || void 0
+    });
+    return () => {
+      instrumentation.queryTracker.unregister(queryId);
+    };
+  }, [instrumentation, schemaId, isSingleQuery, nodeId, filter.where]);
+  useEffect(() => {
+    if (!instrumentation?.queryTracker || loading) return;
+    const count = isSingleQuery ? data ? 1 : 0 : Array.isArray(data) ? data.length : 0;
+    instrumentation.queryTracker.recordUpdate(queryIdRef.current, count, 0);
+  }, [data, instrumentation, isSingleQuery, loading]);
+  useEffect(() => {
+    if (!telemetry) return;
+    telemetry.reportUsage("react.useQuery", 1);
+    return () => {
+      telemetry.reportUsage("react.useQuery.unmount", 1);
+    };
+  }, [telemetry]);
+  const hasReportedTimingRef = useRef(false);
+  useEffect(() => {
+    if (!telemetry || loading || hasReportedTimingRef.current) return;
+    hasReportedTimingRef.current = true;
+    const elapsed = Date.now() - queryStartRef.current;
+    telemetry.reportPerformance("react.useQuery", elapsed);
+    if (elapsed < 5) {
+      telemetry.reportUsage("react.useQuery.cache_hit", 1);
+    } else {
+      telemetry.reportUsage("react.useQuery.cache_miss", 1);
+    }
+  }, [loading, telemetry]);
+  return {
+    data,
+    loading,
+    error: null,
+    // Errors are handled by the bridge
+    reload,
+    migrationWarnings
+  };
+}
+
+// src/hooks/useMutate.ts
+import { isTempId } from "@xnetjs/data";
+import { useCallback as useCallback2, useState, useRef as useRef2 } from "react";
+function hasTempIdInValue(value) {
+  if (isTempId(value)) return true;
+  if (Array.isArray(value)) {
+    return value.some((item) => hasTempIdInValue(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some((item) => hasTempIdInValue(item));
+  }
+  return false;
+}
+function hasTempIdsInOps(ops) {
+  return ops.some((op) => {
+    switch (op.type) {
+      case "create":
+        return Boolean(op.id && isTempId(op.id) || hasTempIdInValue(op.data));
+      case "update":
+        return isTempId(op.id) || hasTempIdInValue(op.data);
+      case "delete":
+      case "restore":
+        return isTempId(op.id);
+    }
+  });
+}
+function toTransactionOperations(ops) {
+  return ops.map((op) => {
+    switch (op.type) {
+      case "create":
+        return {
+          type: "create",
+          options: {
+            id: op.id,
+            schemaId: op.schema._schemaId,
+            properties: op.data
+          }
+        };
+      case "update":
+        return {
+          type: "update",
+          nodeId: op.id,
+          options: {
+            properties: op.data
+          }
+        };
+      case "delete":
+        return {
+          type: "delete",
+          nodeId: op.id
+        };
+      case "restore":
+        return {
+          type: "restore",
+          nodeId: op.id
+        };
+    }
+  });
+}
+function useMutate() {
+  const bridge = useDataBridge();
+  const telemetry = useTelemetryReporter();
+  const [pendingCount, setPendingCount] = useState(0);
+  const pendingRef = useRef2(0);
+  const withPending = useCallback2(async (fn) => {
+    pendingRef.current++;
+    setPendingCount(pendingRef.current);
+    try {
+      return await fn();
+    } finally {
+      pendingRef.current--;
+      setPendingCount(pendingRef.current);
+    }
+  }, []);
+  const create = useCallback2(
+    async (schema, data, id) => {
+      if (!bridge) return null;
+      const start = telemetry ? Date.now() : 0;
+      try {
+        const result = await withPending(async () => {
+          const node = await bridge.create(schema, data, id);
+          return flattenNode(node);
+        });
+        telemetry?.reportPerformance("react.useMutate.create", Date.now() - start);
+        telemetry?.reportUsage("react.useMutate.create.success", 1);
+        return result;
+      } catch (err) {
+        telemetry?.reportUsage("react.useMutate.create.failure", 1);
+        telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), {
+          codeNamespace: "react.useMutate.create"
+        });
+        throw err;
+      }
+    },
+    [bridge, telemetry, withPending]
+  );
+  const update = useCallback2(
+    async (_schema, id, data) => {
+      if (!bridge) return null;
+      const start = telemetry ? Date.now() : 0;
+      try {
+        const result = await withPending(async () => {
+          const node = await bridge.update(id, data);
+          return flattenNode(node);
+        });
+        telemetry?.reportPerformance("react.useMutate.update", Date.now() - start);
+        telemetry?.reportUsage("react.useMutate.update.success", 1);
+        return result;
+      } catch (err) {
+        telemetry?.reportUsage("react.useMutate.update.failure", 1);
+        telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), {
+          codeNamespace: "react.useMutate.update",
+          nodeId: id
+        });
+        throw err;
+      }
+    },
+    [bridge, telemetry, withPending]
+  );
+  const remove = useCallback2(
+    async (id) => {
+      if (!bridge) return;
+      const start = telemetry ? Date.now() : 0;
+      try {
+        await withPending(async () => {
+          await bridge.delete(id);
+        });
+        telemetry?.reportPerformance("react.useMutate.delete", Date.now() - start);
+        telemetry?.reportUsage("react.useMutate.delete.success", 1);
+      } catch (err) {
+        telemetry?.reportUsage("react.useMutate.delete.failure", 1);
+        telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), {
+          codeNamespace: "react.useMutate.delete",
+          nodeId: id
+        });
+        throw err;
+      }
+    },
+    [bridge, telemetry, withPending]
+  );
+  const restore = useCallback2(
+    async (id) => {
+      if (!bridge) return null;
+      const start = telemetry ? Date.now() : 0;
+      try {
+        const result = await withPending(async () => {
+          const node = await bridge.restore(id);
+          return flattenNode(node);
+        });
+        telemetry?.reportPerformance("react.useMutate.restore", Date.now() - start);
+        telemetry?.reportUsage("react.useMutate.restore.success", 1);
+        return result;
+      } catch (err) {
+        telemetry?.reportUsage("react.useMutate.restore.failure", 1);
+        telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), {
+          codeNamespace: "react.useMutate.restore",
+          nodeId: id
+        });
+        throw err;
+      }
+    },
+    [bridge, telemetry, withPending]
+  );
+  const mutate = useCallback2(
+    async (ops) => {
+      if (!bridge || ops.length === 0) return null;
+      const start = telemetry ? Date.now() : 0;
+      try {
+        const result = await withPending(async () => {
+          const nodeStore = bridge.nodeStore;
+          const canUseStoreTransactions = nodeStore && typeof nodeStore.transaction === "function";
+          const usesTempIds = hasTempIdsInOps(ops);
+          if (usesTempIds && !canUseStoreTransactions) {
+            throw new Error(
+              "Temp IDs in useMutate.mutate() require a transaction-capable bridge (NodeStore.transaction). Current bridge executes operations sequentially and cannot resolve temp IDs."
+            );
+          }
+          if (canUseStoreTransactions) {
+            const tx = await nodeStore.transaction(toTransactionOperations(ops));
+            return {
+              results: tx.results,
+              batchId: tx.batchId,
+              tempIds: tx.tempIds
+            };
+          }
+          const results = [];
+          for (const op of ops) {
+            switch (op.type) {
+              case "create": {
+                const node = await bridge.create(
+                  op.schema,
+                  op.data,
+                  op.id
+                );
+                results.push(node);
+                break;
+              }
+              case "update": {
+                const node = await bridge.update(op.id, op.data);
+                results.push(node);
+                break;
+              }
+              case "delete": {
+                await bridge.delete(op.id);
+                results.push(null);
+                break;
+              }
+              case "restore": {
+                const node = await bridge.restore(op.id);
+                results.push(node);
+                break;
+              }
+            }
+          }
+          return { results };
+        });
+        telemetry?.reportPerformance("react.useMutate.transaction", Date.now() - start);
+        telemetry?.reportUsage("react.useMutate.transaction.success", 1);
+        return result;
+      } catch (err) {
+        telemetry?.reportUsage("react.useMutate.transaction.failure", 1);
+        telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), {
+          codeNamespace: "react.useMutate.transaction",
+          opCount: ops.length
+        });
+        throw err;
+      }
+    },
+    [bridge, telemetry, withPending]
+  );
+  return {
+    create,
+    update,
+    remove,
+    restore,
+    mutate,
+    isPending: pendingCount > 0,
+    pendingCount
+  };
+}
+
+// src/hooks/useNode.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback3, useRef as useRef3, useMemo as useMemo2 } from "react";
+import * as Y2 from "yjs";
+
+// src/sync/WebSocketSyncProvider.ts
+import {
+  Awareness,
+  applyAwarenessUpdate,
+  encodeAwarenessUpdate,
+  removeAwarenessStates
+} from "y-protocols/awareness";
+import * as Y from "yjs";
+function log(provider, ...args) {
+  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
+    console.log(`[WSSyncProvider:${provider.room}]`, ...args);
+  }
+}
+function toBase64(data) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(data).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var WebSocketSyncProvider = class {
+  doc;
+  room;
+  url;
+  awareness;
+  ws = null;
+  reconnectDelay;
+  maxReconnectAttempts;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  destroyed = false;
+  connected = false;
+  synced = false;
+  peerId;
+  remotePeerIds = /* @__PURE__ */ new Set();
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(doc, options) {
+    this.doc = doc;
+    this.room = options.room;
+    this.url = options.url;
+    this.reconnectDelay = options.reconnectDelay ?? 2e3;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? Infinity;
+    this.peerId = Math.random().toString(36).slice(2, 10);
+    this.awareness = new Awareness(doc);
+    this.doc.on("update", this._onDocUpdate);
+    this.awareness.on("update", this._onAwarenessUpdate);
+    this._connect();
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  get isSynced() {
+    return this.synced;
+  }
+  /** Helper to get XML fragment length for debug logging */
+  _getFragmentLength() {
+    try {
+      const fragment = this.doc.getXmlFragment("default");
+      return fragment?.length ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
+  }
+  destroy() {
+    this.destroyed = true;
+    this.doc.off("update", this._onDocUpdate);
+    this.awareness.off("update", this._onAwarenessUpdate);
+    removeAwarenessStates(this.awareness, [this.doc.clientID], this);
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this._send({ type: "unsubscribe", topics: [this.room] });
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.emit("status", { connected: false });
+    this.eventHandlers.clear();
+  }
+  _connect() {
+    if (this.destroyed) return;
+    try {
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        log(this, "WebSocket connected to", this.url);
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.emit("status", { connected: true });
+        log(this, "Subscribing to room:", this.room);
+        this._send({ type: "subscribe", topics: [this.room] });
+        const sv = Y.encodeStateVector(this.doc);
+        log(this, "Sending sync-step1, state vector size:", sv.length);
+        this._publish({
+          type: "sync-step1",
+          from: this.peerId,
+          sv: toBase64(sv)
+        });
+        const awarenessUpdate = encodeAwarenessUpdate(this.awareness, [this.doc.clientID]);
+        log(this, "Sending initial awareness update");
+        this._publish({
+          type: "awareness",
+          from: this.peerId,
+          update: toBase64(awarenessUpdate)
+        });
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "publish" && msg.topic === this.room) {
+            this._handleSyncMessage(msg.data);
+          } else if (msg.type === "pong") {
+          }
+        } catch {
+        }
+      };
+      this.ws.onclose = (event) => {
+        log(this, "WebSocket closed, code:", event.code, "reason:", event.reason || "(none)");
+        this.connected = false;
+        this.synced = false;
+        this.remotePeerIds.clear();
+        this.emit("peers", { count: 0 });
+        this.emit("status", { connected: false });
+        this._scheduleReconnect();
+      };
+      this.ws.onerror = (event) => {
+        log(this, "WebSocket error:", event);
+      };
+    } catch {
+      this._scheduleReconnect();
+    }
+  }
+  _scheduleReconnect() {
+    if (this.destroyed) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this._connect();
+    }, this.reconnectDelay);
+  }
+  _send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  _publish(data) {
+    this._send({
+      type: "publish",
+      topic: this.room,
+      data
+    });
+  }
+  /** Handle incoming sync messages from other peers */
+  _handleSyncMessage(data) {
+    if (!data || data.from === this.peerId) return;
+    if (data.from && typeof data.from === "string") {
+      const hadPeer = this.remotePeerIds.has(data.from);
+      this.remotePeerIds.add(data.from);
+      if (!hadPeer) {
+        this.emit("peers", { count: this.remotePeerIds.size });
+      }
+    }
+    log(this, "Received message type:", data.type, "from:", data.from);
+    switch (data.type) {
+      case "sync-step1": {
+        const remoteSV = fromBase64(data.sv);
+        const diff = Y.encodeStateAsUpdate(this.doc, remoteSV);
+        log(
+          this,
+          "Received sync-step1 from peer, their SV size:",
+          remoteSV.length,
+          "our diff size:",
+          diff.length
+        );
+        log(this, "Sending sync-step2 to peer:", data.from, "update size:", diff.length);
+        this._publish({
+          type: "sync-step2",
+          from: this.peerId,
+          to: data.from,
+          update: toBase64(diff)
+        });
+        if (!this.synced) {
+          const sv = Y.encodeStateVector(this.doc);
+          log(this, "Sending our sync-step1 in response, SV size:", sv.length);
+          this._publish({
+            type: "sync-step1",
+            from: this.peerId,
+            sv: toBase64(sv)
+          });
+        }
+        const awarenessUpdate = encodeAwarenessUpdate(this.awareness, [this.doc.clientID]);
+        this._publish({
+          type: "awareness",
+          from: this.peerId,
+          update: toBase64(awarenessUpdate)
+        });
+        break;
+      }
+      case "sync-step2": {
+        if (data.to && data.to !== this.peerId) {
+          log(this, "Ignoring sync-step2 addressed to different peer:", data.to);
+          return;
+        }
+        const update = fromBase64(data.update);
+        log(
+          this,
+          "Received sync-step2, applying update size:",
+          update.length,
+          "doc content before:",
+          this.doc.getMap("meta").size,
+          "keys"
+        );
+        Y.applyUpdate(this.doc, update, this);
+        log(
+          this,
+          "After applying update, doc content:",
+          this.doc.getMap("meta").size,
+          "keys, XML fragment length:",
+          this._getFragmentLength()
+        );
+        if (!this.synced) {
+          this.synced = true;
+          log(this, "Sync complete! Emitting synced event");
+          this.emit("synced", { synced: true });
+        }
+        break;
+      }
+      case "sync-update": {
+        const update = fromBase64(data.update);
+        log(this, "Received sync-update, size:", update.length);
+        Y.applyUpdate(this.doc, update, this);
+        break;
+      }
+      case "awareness": {
+        const update = fromBase64(data.update);
+        log(this, "Received awareness update");
+        applyAwarenessUpdate(this.awareness, update, this);
+        break;
+      }
+      case "awareness-snapshot": {
+        const users = Array.isArray(data.users) ? data.users : [];
+        this.emit("awareness-snapshot", users);
+        break;
+      }
+    }
+  }
+  /** Broadcast local doc updates to peers */
+  _onDocUpdate = (update, origin) => {
+    if (origin === this) return;
+    if (this.connected) {
+      this._publish({
+        type: "sync-update",
+        from: this.peerId,
+        update: toBase64(update)
+      });
+    }
+  };
+  /** Broadcast local awareness changes to peers */
+  _onAwarenessUpdate = ({ added, updated, removed }, origin) => {
+    if (origin === this) return;
+    const changedClients = [...added, ...updated, ...removed];
+    if (changedClients.length === 0) return;
+    if (this.connected) {
+      const update = encodeAwarenessUpdate(this.awareness, changedClients);
+      this._publish({
+        type: "awareness",
+        from: this.peerId,
+        update: toBase64(update)
+      });
+    }
+  };
+};
+
+// src/hooks/useSyncManager.ts
+import { useContext } from "react";
+function useSyncManager() {
+  const context = useContext(XNetContext);
+  return context?.syncManager ?? null;
+}
+
+// src/hooks/useNode.ts
+function log2(...args) {
+  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
+    console.log("[useNode]", ...args);
+  }
+}
+var DEFAULT_SIGNALING_SERVERS = ["ws://localhost:4444"];
+var DEFAULT_PERSIST_DEBOUNCE = 1e3;
+function generateColor(seed) {
+  let hash = 0;
+  for (let i = 0; i < seed.length; i++) {
+    hash = seed.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash % 360);
+  const s = 0.7;
+  const l = 0.5;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (hue < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (hue < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (hue < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (hue < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (hue < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  const toHex = (v) => Math.round((v + m) * 255).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+var pendingFlushes = /* @__PURE__ */ new Map();
+function useNode(schema, id, options = {}) {
+  const {
+    signalingServers = DEFAULT_SIGNALING_SERVERS,
+    disableSync = false,
+    persistDebounce = DEFAULT_PERSIST_DEBOUNCE,
+    createIfMissing,
+    did
+  } = options;
+  const createIfMissingRef = useRef3(createIfMissing);
+  createIfMissingRef.current = createIfMissing;
+  const { store, isReady } = useNodeStore();
+  const syncManager = useSyncManager();
+  const bridge = useDataBridge();
+  const instrumentation = useInstrumentation();
+  const schemaId = schema._schemaId;
+  const hasDocument = schema.schema.document === "yjs";
+  const usingBridgeRef = useRef3(false);
+  const [data, setData] = useState2(null);
+  const [doc, setDoc] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [isDirty, setIsDirty] = useState2(false);
+  const [lastSavedAt, setLastSavedAt] = useState2(null);
+  const [syncStatus, setSyncStatus] = useState2("offline");
+  const [syncError, setSyncError] = useState2(null);
+  const [peerCount, setPeerCount] = useState2(0);
+  const [wasCreated, setWasCreated] = useState2(false);
+  const [livePresence, setLivePresence] = useState2([]);
+  const [snapshotPresence, setSnapshotPresence] = useState2([]);
+  const [awareness, setAwareness] = useState2(null);
+  const presence = useMemo2(() => {
+    if (livePresence.length === 0 && snapshotPresence.length === 0) return [];
+    const liveByDid = new Map(livePresence.map((user) => [user.did, user]));
+    const snapshotByDid = new Map(snapshotPresence.map((user) => [user.did, user]));
+    const mergedLive = livePresence.map((user) => ({
+      ...snapshotByDid.get(user.did),
+      ...user,
+      isStale: false
+    }));
+    const mergedSnapshot = snapshotPresence.filter((user) => !liveByDid.has(user.did));
+    return [...mergedLive, ...mergedSnapshot];
+  }, [livePresence, snapshotPresence]);
+  const providerRef = useRef3(null);
+  const saveTimeoutRef = useRef3(null);
+  const docRef = useRef3(null);
+  const creatingRef = useRef3(false);
+  const storeRef = useRef3(store);
+  storeRef.current = store;
+  const dataRef = useRef3(null);
+  dataRef.current = data;
+  const queryIdRef = useRef3(
+    `useNode-${schemaId}-${id || "null"}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  useEffect2(() => {
+    if (!instrumentation?.queryTracker || !id) return;
+    instrumentation.queryTracker.register(queryIdRef.current, {
+      type: "useNode",
+      schemaId,
+      mode: "document",
+      nodeId: id
+    });
+    return () => {
+      instrumentation.queryTracker.unregister(queryIdRef.current);
+    };
+  }, [instrumentation, schemaId, id]);
+  const load = useCallback3(async () => {
+    if (!store || !isReady || !id) {
+      setData(null);
+      setDoc(null);
+      setLoading(false);
+      return;
+    }
+    if (hasDocument && !disableSync && !syncManager) {
+      setLoading(true);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setWasCreated(false);
+    setSyncError(null);
+    try {
+      const pendingFlush = pendingFlushes.get(id);
+      if (pendingFlush) {
+        await pendingFlush;
+      }
+      let node = await store.get(id);
+      let justCreated = false;
+      if (!node && createIfMissingRef.current && !creatingRef.current) {
+        creatingRef.current = true;
+        try {
+          node = await store.create({
+            id,
+            schemaId,
+            properties: createIfMissingRef.current
+          });
+          justCreated = true;
+          setWasCreated(true);
+          log2("Node auto-created:", id);
+        } finally {
+          creatingRef.current = false;
+        }
+      }
+      if (node?.deleted && createIfMissingRef.current) {
+        node = await store.restore(id);
+      }
+      if (!node || node.schemaId !== schemaId) {
+        setData(null);
+        setDoc(null);
+        setLoading(false);
+        return;
+      }
+      setData(flattenNode(node));
+      if (hasDocument) {
+        if (docRef.current && docRef.current.guid === id) {
+          setDoc(docRef.current);
+          setLastSavedAt(node.updatedAt);
+        } else {
+          if (docRef.current) {
+            instrumentation?.yDocRegistry.unregister(docRef.current.guid);
+            if (!usingBridgeRef.current) {
+              if (providerRef.current) {
+                providerRef.current.destroy();
+                providerRef.current = null;
+              }
+              docRef.current.destroy();
+            } else if (docRef.current.guid) {
+              syncManager?.release(docRef.current.guid);
+            }
+            docRef.current = null;
+            setDoc(null);
+            usingBridgeRef.current = false;
+          }
+          let ydoc;
+          let acquiredAwareness = null;
+          if (bridge?.acquireDoc && !disableSync) {
+            const acquired = await bridge.acquireDoc(id);
+            ydoc = acquired.doc;
+            acquiredAwareness = acquired.awareness;
+            usingBridgeRef.current = true;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y2.applyUpdate(ydoc, storedContent, "storage");
+            }
+            if (syncManager) {
+              syncManager.track(id, schemaId);
+            }
+          } else if (syncManager && !disableSync) {
+            ydoc = await syncManager.acquire(id);
+            usingBridgeRef.current = true;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y2.applyUpdate(ydoc, storedContent, "storage");
+            }
+            syncManager.track(id, schemaId);
+          } else {
+            log2("Using fallback WebSocketSyncProvider path for:", id);
+            ydoc = new Y2.Doc({ guid: id, gc: false });
+            usingBridgeRef.current = false;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y2.applyUpdate(ydoc, storedContent);
+            }
+          }
+          if (acquiredAwareness) {
+            setAwareness(acquiredAwareness);
+          }
+          docRef.current = ydoc;
+          const metaMap = ydoc.getMap("meta");
+          if (metaMap.size === 0 && node.properties) {
+            const entries = Object.entries(node.properties);
+            const hasContent = entries.some(([, v]) => v !== "" && v !== null && v !== void 0);
+            if (hasContent || !justCreated) {
+              ydoc.transact(() => {
+                metaMap.set("_schemaId", schemaId);
+                for (const [key, value] of entries) {
+                  if (!justCreated || value !== "" && value !== null && value !== void 0) {
+                    metaMap.set(key, value);
+                  }
+                }
+              }, "local");
+            }
+          }
+          instrumentation?.yDocRegistry.register(id, ydoc);
+          setDoc(ydoc);
+          setLastSavedAt(node.updatedAt);
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [store, isReady, id, schemaId, hasDocument, syncManager, disableSync]);
+  const save = useCallback3(async () => {
+    if (!store || !id || !docRef.current) return;
+    saveTimeoutRef.current = null;
+    try {
+      const content = Y2.encodeStateAsUpdate(docRef.current);
+      await store.setDocumentContent(id, content);
+      setIsDirty(false);
+      setLastSavedAt(Date.now());
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [store, id]);
+  const saveRef = useRef3(save);
+  saveRef.current = save;
+  const scheduleSave = useCallback3(() => {
+    setIsDirty(true);
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = setTimeout(() => {
+      saveRef.current();
+    }, persistDebounce);
+  }, [persistDebounce]);
+  const update = useCallback3(
+    async (properties) => {
+      if (!store || !isReady || !id) return;
+      try {
+        const node = await store.update(id, {
+          properties
+        });
+        setData(flattenNode(node));
+        if (docRef.current) {
+          const metaMap = docRef.current.getMap("meta");
+          docRef.current.transact(() => {
+            metaMap.set("_schemaId", schemaId);
+            for (const [key, value] of Object.entries(properties)) {
+              metaMap.set(key, value);
+            }
+          }, "local");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, id]
+  );
+  const remove = useCallback3(async () => {
+    if (!store || !isReady || !id) return;
+    try {
+      await store.delete(id);
+      setData(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [store, isReady, id]);
+  useEffect2(() => {
+    load();
+  }, [load]);
+  useEffect2(() => {
+    if (!doc || !id || !hasDocument) return;
+    if (doc.guid !== id) {
+      return;
+    }
+    if (usingBridgeRef.current && syncManager) {
+      let receivedSyncData = false;
+      let syncTimeoutId = null;
+      const updateHandler2 = (_update, origin) => {
+        if (origin === "remote") {
+          receivedSyncData = true;
+          if (syncTimeoutId) {
+            clearTimeout(syncTimeoutId);
+            syncTimeoutId = null;
+          }
+          setSyncError(null);
+        }
+        scheduleSave();
+      };
+      doc.on("update", updateHandler2);
+      const metaMap = doc.getMap("meta");
+      const applyMetaToNodeStore = () => {
+        if (metaMap.size === 0 || !storeRef.current || !id) return;
+        const remoteProps = {};
+        metaMap.forEach((value, key) => {
+          if (key.startsWith("_")) return;
+          remoteProps[key] = value;
+        });
+        if (Object.keys(remoteProps).length === 0) return;
+        const currentData = dataRef.current;
+        if (currentData) {
+          let hasChanges = false;
+          for (const [key, value] of Object.entries(remoteProps)) {
+            if (currentData[key] !== value) {
+              hasChanges = true;
+              break;
+            }
+          }
+          if (!hasChanges) return;
+        }
+        storeRef.current.update(id, { properties: remoteProps }).then((node) => {
+          if (node) setData(flattenNode(node));
+        }).catch((err) => {
+          console.warn("[useNode] Failed to apply remote meta to NodeStore:", err);
+        });
+      };
+      const metaObserver = (event) => {
+        const origin = event.transaction.origin;
+        if (origin === null || origin === "local" || origin === "storage" || origin === METABRIDGE_ORIGIN || origin === METABRIDGE_SEED_ORIGIN) {
+          return;
+        }
+        applyMetaToNodeStore();
+      };
+      metaMap.observe(metaObserver);
+      if (metaMap.size > 0) {
+        applyMetaToNodeStore();
+      }
+      const statusUnsub = syncManager.on("status", (status) => {
+        setSyncStatus(
+          status === "connected" ? "connected" : status === "connecting" ? "connecting" : "offline"
+        );
+      });
+      setSyncStatus(
+        syncManager.status === "connected" ? "connected" : syncManager.status === "connecting" ? "connecting" : "offline"
+      );
+      const awareness2 = syncManager.getAwareness(id);
+      setAwareness(awareness2);
+      if (awareness2 && did) {
+        awareness2.setLocalStateField("user", {
+          did,
+          name: `${did.slice(8, 16)}...`,
+          color: generateColor(did)
+        });
+      }
+      let awarenessCleanup = null;
+      if (awareness2) {
+        const awarenessHandler = () => {
+          const states = awareness2.getStates();
+          const nextPresence = [];
+          states.forEach((state, clientId) => {
+            if (clientId === awareness2.clientID) return;
+            const user = state.user;
+            if (user?.did) {
+              nextPresence.push({
+                did: user.did,
+                name: user.name,
+                color: user.color || generateColor(user.did),
+                isStale: false
+              });
+            }
+          });
+          setLivePresence(nextPresence);
+        };
+        awareness2.on("change", awarenessHandler);
+        awarenessHandler();
+        awarenessCleanup = () => awareness2.off("change", awarenessHandler);
+      }
+      const snapshotUnsub = syncManager.onAwarenessSnapshot(id, (users) => {
+        const mapped = users.map((user) => ({
+          did: user.did,
+          name: user.state.user?.name,
+          color: user.state.user?.color ?? generateColor(user.did),
+          lastSeen: user.lastSeen,
+          isStale: user.isStale
+        }));
+        setSnapshotPresence(mapped);
+      });
+      if (wasCreated) {
+        syncTimeoutId = setTimeout(() => {
+          const fragment = doc.getXmlFragment("default");
+          const metaMap2 = doc.getMap("meta");
+          const hasContent = (fragment?.length ?? 0) > 0 || metaMap2.size > 1;
+          if (!receivedSyncData && !hasContent) {
+            const errorMsg = "Sync timeout: No content received from peers. The shared document may not exist or peers may be offline.";
+            log2("Sync timeout - no content received for:", id);
+            setSyncStatus("error");
+            setSyncError(errorMsg);
+          }
+        }, 1e4);
+      }
+      return () => {
+        if (syncTimeoutId) {
+          clearTimeout(syncTimeoutId);
+        }
+        doc.off("update", updateHandler2);
+        metaMap.unobserve(metaObserver);
+        statusUnsub();
+        if (awarenessCleanup) awarenessCleanup();
+        snapshotUnsub();
+        setAwareness(null);
+        setSyncStatus("offline");
+        setSyncError(null);
+        setPeerCount(0);
+        setLivePresence([]);
+        setSnapshotPresence([]);
+      };
+    }
+    const updateHandler = (_update, _origin) => {
+      scheduleSave();
+    };
+    doc.on("update", updateHandler);
+    if (!disableSync && signalingServers.length > 0) {
+      setSyncStatus("connecting");
+      const provider = new WebSocketSyncProvider(doc, {
+        url: signalingServers[0],
+        room: `xnet-doc-${id}`
+      });
+      providerRef.current = provider;
+      let receivedSyncData = false;
+      let syncTimeoutId = null;
+      const statusHandler = (event) => {
+        const { connected } = event;
+        setSyncStatus(connected ? "connected" : "connecting");
+      };
+      provider.on("status", statusHandler);
+      const metaMap = doc.getMap("meta");
+      const applyMetaToNodeStore = () => {
+        if (metaMap.size === 0) return;
+        const props = {};
+        metaMap.forEach((value, key) => {
+          if (key.startsWith("_")) return;
+          props[key] = value;
+        });
+        if (Object.keys(props).length > 0 && storeRef.current && id) {
+          storeRef.current.update(id, { properties: props }).then((node) => {
+            if (node) setData(flattenNode(node));
+          }).catch((err) => {
+            console.warn("[useDocument] Failed to apply remote meta to NodeStore:", err);
+          });
+        }
+      };
+      const metaObserver = (event) => {
+        const origin = event.transaction.origin;
+        if (origin === null || origin === "local" || origin === "storage" || origin === METABRIDGE_ORIGIN || origin === METABRIDGE_SEED_ORIGIN) {
+          return;
+        }
+        applyMetaToNodeStore();
+      };
+      metaMap.observe(metaObserver);
+      const syncedHandler = (event) => {
+        const { synced } = event;
+        if (synced) {
+          receivedSyncData = true;
+          if (syncTimeoutId) {
+            clearTimeout(syncTimeoutId);
+            syncTimeoutId = null;
+          }
+          setSyncError(null);
+          applyMetaToNodeStore();
+        }
+      };
+      provider.on("synced", syncedHandler);
+      if (wasCreated) {
+        syncTimeoutId = setTimeout(() => {
+          const fragment = doc.getXmlFragment("default");
+          const metaMap2 = doc.getMap("meta");
+          const hasContent = (fragment?.length ?? 0) > 0 || metaMap2.size > 1;
+          if (!receivedSyncData && !hasContent) {
+            const errorMsg = "Sync timeout: No content received from peers. The shared document may not exist or peers may be offline.";
+            log2("Sync timeout - no content received for:", id);
+            setSyncStatus("error");
+            setSyncError(errorMsg);
+          }
+        }, 1e4);
+      }
+      const peersHandler = (event) => {
+        const { count } = event;
+        setPeerCount(count);
+      };
+      provider.on("peers", peersHandler);
+      const { awareness: providerAwareness } = provider;
+      setAwareness(providerAwareness);
+      if (did) {
+        providerAwareness.setLocalStateField("user", {
+          did,
+          name: `${did.slice(8, 16)}...`,
+          color: generateColor(did)
+        });
+      }
+      const awarenessHandler = () => {
+        const states = providerAwareness.getStates();
+        const nextPresence = [];
+        states.forEach((state, clientId) => {
+          if (clientId === providerAwareness.clientID) return;
+          const user = state.user;
+          if (user?.did) {
+            nextPresence.push({
+              did: user.did,
+              name: user.name,
+              color: user.color || generateColor(user.did),
+              isStale: false
+            });
+          }
+        });
+        setLivePresence(nextPresence);
+      };
+      providerAwareness.on("change", awarenessHandler);
+      const snapshotHandler = (users) => {
+        if (!Array.isArray(users)) return;
+        const mapped = users.filter(
+          (user) => Boolean(
+            user && typeof user === "object" && typeof user.did === "string"
+          )
+        ).map(
+          (user) => ({
+            did: user.did,
+            name: user.state.user?.name,
+            color: user.state.user?.color ?? generateColor(user.did),
+            lastSeen: user.lastSeen,
+            isStale: user.isStale
+          })
+        );
+        setSnapshotPresence(mapped);
+      };
+      provider.on("awareness-snapshot", snapshotHandler);
+      return () => {
+        if (syncTimeoutId) {
+          clearTimeout(syncTimeoutId);
+        }
+        doc.off("update", updateHandler);
+        metaMap.unobserve(metaObserver);
+        providerAwareness.off("change", awarenessHandler);
+        provider.off("awareness-snapshot", snapshotHandler);
+        provider.off("synced", syncedHandler);
+        provider.off("status", statusHandler);
+        provider.off("peers", peersHandler);
+        provider.destroy();
+        providerRef.current = null;
+        setAwareness(null);
+        setSyncStatus("offline");
+        setSyncError(null);
+        setPeerCount(0);
+        setLivePresence([]);
+        setSnapshotPresence([]);
+      };
+    }
+    return () => {
+      doc.off("update", updateHandler);
+    };
+  }, [
+    doc,
+    id,
+    hasDocument,
+    disableSync,
+    signalingServers,
+    scheduleSave,
+    did,
+    syncManager,
+    wasCreated
+  ]);
+  useEffect2(() => {
+    return () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+      if (docRef.current && store && id) {
+        const content = Y2.encodeStateAsUpdate(docRef.current);
+        const flushPromise = store.setDocumentContent(id, content).catch(() => {
+        }).finally(() => {
+          pendingFlushes.delete(id);
+        });
+        pendingFlushes.set(id, flushPromise);
+      }
+      if (usingBridgeRef.current && id) {
+        if (bridge?.releaseDoc) {
+          bridge.releaseDoc(id);
+        } else if (syncManager) {
+          syncManager.release(id);
+        }
+        usingBridgeRef.current = false;
+      }
+    };
+  }, [store, id, syncManager, bridge]);
+  useEffect2(() => {
+    if (!store || !id || !hasDocument) return;
+    const handleBeforeUnload = () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+      if (docRef.current) {
+        try {
+          const content = Y2.encodeStateAsUpdate(docRef.current);
+          store.setDocumentContent(id, content).catch(() => {
+          });
+        } catch {
+        }
+      }
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+    };
+  }, [store, id, hasDocument]);
+  useEffect2(() => {
+    if (!store || !id) return;
+    const unsubscribe = store.subscribe((event) => {
+      if (event.change.payload.nodeId !== id) return;
+      if (event.node && event.node.schemaId === schemaId) {
+        setData(flattenNode(event.node));
+      }
+    });
+    return unsubscribe;
+  }, [store, id, schemaId]);
+  useEffect2(() => {
+    if (!instrumentation?.queryTracker || !id || loading) return;
+    instrumentation.queryTracker.recordUpdate(queryIdRef.current, data ? 1 : 0, 0);
+  }, [data, instrumentation, id, loading]);
+  return {
+    // Data
+    data,
+    doc,
+    // Mutations
+    update,
+    remove,
+    // State
+    loading,
+    error,
+    isDirty,
+    lastSavedAt,
+    wasCreated,
+    // Sync
+    syncStatus,
+    syncError,
+    peerCount,
+    // Presence
+    presence,
+    awareness,
+    // Actions
+    save,
+    reload: load
+  };
+}
+
+// src/hooks/useDatabaseDoc.ts
+import {
+  getColumns,
+  getColumn,
+  createColumn as createColumnOp,
+  updateColumn as updateColumnOp,
+  deleteColumn as deleteColumnOp,
+  reorderColumn as reorderColumnOp,
+  duplicateColumn as duplicateColumnOp,
+  getViews,
+  getView,
+  createView as createViewOp,
+  updateView as updateViewOp,
+  deleteView as deleteViewOp,
+  duplicateView as duplicateViewOp,
+  initializeDatabaseDoc,
+  isDatabaseDocInitialized
+} from "@xnetjs/data";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback4, useRef as useRef4 } from "react";
+import * as Y3 from "yjs";
+function useDatabaseDoc(databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [doc, setDoc] = useState3(null);
+  const [columns, setColumns] = useState3([]);
+  const [views, setViews] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const docRef = useRef4(null);
+  docRef.current = doc;
+  useEffect3(() => {
+    if (!store || !isReady || !databaseId) {
+      setDoc(null);
+      setColumns([]);
+      setViews([]);
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const loadDoc = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const ydoc = new Y3.Doc({ guid: databaseId, gc: false });
+        const storedContent = await store.getDocumentContent(databaseId);
+        if (storedContent && storedContent.length > 0) {
+          Y3.applyUpdate(ydoc, storedContent);
+        }
+        if (!mounted) {
+          ydoc.destroy();
+          return;
+        }
+        if (!isDatabaseDocInitialized(ydoc)) {
+          initializeDatabaseDoc(ydoc);
+        }
+        docRef.current = ydoc;
+        setDoc(ydoc);
+        setColumns(getColumns(ydoc));
+        setViews(getViews(ydoc));
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    loadDoc();
+    return () => {
+      mounted = false;
+      if (docRef.current && store) {
+        const content = Y3.encodeStateAsUpdate(docRef.current);
+        store.setDocumentContent(databaseId, content).catch(() => {
+        });
+        docRef.current.destroy();
+        docRef.current = null;
+      }
+    };
+  }, [store, isReady, databaseId]);
+  useEffect3(() => {
+    if (!doc) return;
+    const columnsArray = doc.getArray("columns");
+    const updateColumns = () => {
+      setColumns(getColumns(doc));
+    };
+    columnsArray.observeDeep(updateColumns);
+    return () => {
+      columnsArray.unobserveDeep(updateColumns);
+    };
+  }, [doc]);
+  useEffect3(() => {
+    if (!doc) return;
+    const viewsMap = doc.getMap("views");
+    const updateViews = () => {
+      setViews(getViews(doc));
+    };
+    viewsMap.observeDeep(updateViews);
+    return () => {
+      viewsMap.unobserveDeep(updateViews);
+    };
+  }, [doc]);
+  useEffect3(() => {
+    if (!doc || !store) return;
+    let saveTimeout = null;
+    const handleUpdate = () => {
+      if (saveTimeout) {
+        clearTimeout(saveTimeout);
+      }
+      saveTimeout = setTimeout(() => {
+        if (docRef.current && store) {
+          const content = Y3.encodeStateAsUpdate(docRef.current);
+          store.setDocumentContent(databaseId, content).catch(() => {
+          });
+        }
+      }, 500);
+    };
+    doc.on("update", handleUpdate);
+    return () => {
+      doc.off("update", handleUpdate);
+      if (saveTimeout) {
+        clearTimeout(saveTimeout);
+      }
+    };
+  }, [doc, store, databaseId]);
+  const handleCreateColumn = useCallback4(
+    (definition) => {
+      if (!docRef.current) return null;
+      return createColumnOp(docRef.current, definition);
+    },
+    []
+  );
+  const handleUpdateColumn = useCallback4(
+    (columnId, updates) => {
+      if (!docRef.current) return;
+      updateColumnOp(docRef.current, columnId, updates);
+    },
+    []
+  );
+  const handleDeleteColumn = useCallback4((columnId) => {
+    if (!docRef.current) return;
+    deleteColumnOp(docRef.current, columnId);
+  }, []);
+  const handleReorderColumn = useCallback4((columnId, newIndex) => {
+    if (!docRef.current) return;
+    reorderColumnOp(docRef.current, columnId, newIndex);
+  }, []);
+  const handleDuplicateColumn = useCallback4((columnId, newName) => {
+    if (!docRef.current) return null;
+    return duplicateColumnOp(docRef.current, columnId, newName);
+  }, []);
+  const handleGetColumn = useCallback4((columnId) => {
+    if (!docRef.current) return null;
+    return getColumn(docRef.current, columnId);
+  }, []);
+  const handleCreateView = useCallback4((config) => {
+    if (!docRef.current) return null;
+    return createViewOp(docRef.current, config);
+  }, []);
+  const handleUpdateView = useCallback4(
+    (viewId, updates) => {
+      if (!docRef.current) return;
+      updateViewOp(docRef.current, viewId, updates);
+    },
+    []
+  );
+  const handleDeleteView = useCallback4((viewId) => {
+    if (!docRef.current) return;
+    deleteViewOp(docRef.current, viewId);
+  }, []);
+  const handleDuplicateView = useCallback4((viewId, newName) => {
+    if (!docRef.current) return null;
+    return duplicateViewOp(docRef.current, viewId, newName);
+  }, []);
+  const handleGetView = useCallback4((viewId) => {
+    if (!docRef.current) return null;
+    return getView(docRef.current, viewId);
+  }, []);
+  return {
+    columns,
+    views,
+    doc,
+    loading,
+    error,
+    // Column operations
+    createColumn: handleCreateColumn,
+    updateColumn: handleUpdateColumn,
+    deleteColumn: handleDeleteColumn,
+    reorderColumn: handleReorderColumn,
+    duplicateColumn: handleDuplicateColumn,
+    getColumn: handleGetColumn,
+    // View operations
+    createView: handleCreateView,
+    updateView: handleUpdateView,
+    deleteView: handleDeleteView,
+    duplicateView: handleDuplicateView,
+    getView: handleGetView
+  };
+}
+
+// src/hooks/useDatabase.ts
+import {
+  queryRows,
+  createRow as createRowOp,
+  updateCells,
+  deleteRow as deleteRowOp,
+  moveRow,
+  fromCellProperties,
+  filterRows,
+  sortRows
+} from "@xnetjs/data";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback5, useMemo as useMemo3, useRef as useRef5 } from "react";
+function useDatabase(databaseId, options = {}) {
+  const { store, isReady } = useNodeStore();
+  const { columns, views } = useDatabaseDoc(databaseId);
+  const [rows, setRows] = useState4([]);
+  const [total, setTotal] = useState4(0);
+  const [cursor, setCursor] = useState4();
+  const [hasMore, setHasMore] = useState4(false);
+  const [loading, setLoading] = useState4(true);
+  const [loadingMore, setLoadingMore] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [activeViewId, setActiveViewId] = useState4(options.view);
+  const { pageSize = 50, filters, sorts, search } = options;
+  const storeRef = useRef5(store);
+  storeRef.current = store;
+  const activeView = useMemo3(() => {
+    if (activeViewId) {
+      return views.find((v) => v.id === activeViewId) ?? null;
+    }
+    return views[0] ?? null;
+  }, [views, activeViewId]);
+  const effectiveFilters = filters ?? activeView?.filters ?? null;
+  const effectiveSorts = sorts ?? activeView?.sorts ?? [];
+  const fetchRows = useCallback5(
+    async (reset = true) => {
+      if (!store || !isReady) return;
+      try {
+        if (reset) {
+          setLoading(true);
+          setCursor(void 0);
+        } else {
+          setLoadingMore(true);
+        }
+        const result = await queryRows(store, databaseId, {
+          limit: pageSize * 10,
+          // Fetch more for client-side filtering
+          cursor: reset ? void 0 : cursor
+        });
+        let parsedRows = result.rows.map((node) => nodeToRow(node, columns));
+        if (effectiveFilters && effectiveFilters.conditions.length > 0) {
+          parsedRows = filterRows(parsedRows, columns, effectiveFilters);
+        }
+        if (effectiveSorts.length > 0) {
+          parsedRows = sortRows(parsedRows, columns, effectiveSorts);
+        }
+        parsedRows = parsedRows.slice(0, pageSize);
+        if (reset) {
+          setRows(parsedRows);
+        } else {
+          setRows((prev) => [...prev, ...parsedRows]);
+        }
+        setTotal(parsedRows.length);
+        setCursor(result.cursor);
+        setHasMore(result.hasMore);
+        setError(null);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+        setLoadingMore(false);
+      }
+    },
+    [store, isReady, databaseId, pageSize, cursor, columns]
+  );
+  useEffect4(() => {
+    if (columns.length > 0) {
+      fetchRows(true);
+    }
+  }, [databaseId, columns.length]);
+  useEffect4(() => {
+    if (columns.length > 0) {
+      fetchRows(true);
+    }
+  }, [effectiveFilters, effectiveSorts, search]);
+  useEffect4(() => {
+    if (!store) return;
+    const unsubscribe = store.subscribe((event) => {
+      const node = event.node;
+      if (node?.schemaId === "xnet://xnet.fyi/DatabaseRow") {
+        const dbId = node.properties.database;
+        if (dbId === databaseId) {
+          fetchRows(true);
+        }
+      }
+    });
+    return unsubscribe;
+  }, [store, databaseId, fetchRows]);
+  const loadMore = useCallback5(async () => {
+    if (!hasMore || loadingMore) return;
+    await fetchRows(false);
+  }, [hasMore, loadingMore, fetchRows]);
+  const handleCreateRow = useCallback5(
+    async (values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      const lastRow = rows[rows.length - 1];
+      const rowId = await createRowOp(storeRef.current, {
+        databaseId,
+        cells: values ?? {},
+        after: lastRow?.sortKey
+      });
+      return rowId;
+    },
+    [databaseId, rows]
+  );
+  const handleUpdateRow = useCallback5(
+    async (rowId, values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      await updateCells(storeRef.current, rowId, values);
+    },
+    []
+  );
+  const handleDeleteRow = useCallback5(async (rowId) => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await deleteRowOp(storeRef.current, rowId);
+  }, []);
+  const handleReorderRow = useCallback5(
+    async (rowId, before, after) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      await moveRow(storeRef.current, rowId, { before, after });
+    },
+    []
+  );
+  const handleDeleteRows = useCallback5(async (rowIds) => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await Promise.all(rowIds.map((id) => deleteRowOp(storeRef.current, id)));
+  }, []);
+  return {
+    columns,
+    views,
+    rows,
+    total,
+    hasMore,
+    loadMore,
+    activeView,
+    setActiveView: setActiveViewId,
+    createRow: handleCreateRow,
+    updateRow: handleUpdateRow,
+    deleteRow: handleDeleteRow,
+    reorderRow: handleReorderRow,
+    deleteRows: handleDeleteRows,
+    loading,
+    loadingMore,
+    error,
+    refetch: () => fetchRows(true)
+  };
+}
+function nodeToRow(node, _columns) {
+  const cells = fromCellProperties(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey,
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useDatabaseRow.ts
+import { getRow, updateCells as updateCells2, deleteRow as deleteRowOp2 } from "@xnetjs/data";
+import { useState as useState5, useEffect as useEffect5, useCallback as useCallback6, useRef as useRef6 } from "react";
+import * as Y4 from "yjs";
+function useDatabaseRow(rowId) {
+  const { store, isReady } = useNodeStore();
+  const [row, setRow] = useState5(null);
+  const [doc, setDoc] = useState5(null);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const optimisticRef = useRef6({});
+  const storeRef = useRef6(store);
+  storeRef.current = store;
+  useEffect5(() => {
+    if (!store || !isReady || !rowId) {
+      setRow(null);
+      setDoc(null);
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const load = async () => {
+      try {
+        setLoading(true);
+        const node = await getRow(store, rowId);
+        if (!mounted) return;
+        if (node) {
+          setRow({
+            id: node.id,
+            databaseId: node.properties.database,
+            sortKey: node.properties.sortKey,
+            cells: node.cells,
+            createdAt: node.createdAt,
+            createdBy: node.createdBy
+          });
+          const storedContent = await store.getDocumentContent(rowId);
+          if (storedContent && storedContent.length > 0) {
+            const ydoc = new Y4.Doc({ guid: rowId, gc: false });
+            Y4.applyUpdate(ydoc, storedContent);
+            setDoc(ydoc);
+          }
+        } else {
+          setRow(null);
+          setDoc(null);
+        }
+        setError(null);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    load();
+    const unsubscribe = store.subscribe((event) => {
+      if (event.change.payload.nodeId === rowId) {
+        load();
+      }
+    });
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, [store, isReady, rowId]);
+  const handleUpdate = useCallback6(
+    async (values) => {
+      if (!storeRef.current) throw new Error("Store not ready");
+      optimisticRef.current = { ...optimisticRef.current, ...values };
+      setRow(
+        (prev) => prev ? {
+          ...prev,
+          cells: { ...prev.cells, ...values }
+        } : null
+      );
+      try {
+        await updateCells2(storeRef.current, rowId, values);
+        for (const key of Object.keys(values)) {
+          delete optimisticRef.current[key];
+        }
+      } catch (err) {
+        setRow((prev) => {
+          if (!prev) return null;
+          const reverted = { ...prev.cells };
+          for (const key of Object.keys(values)) {
+            delete reverted[key];
+          }
+          return { ...prev, cells: reverted };
+        });
+        throw err;
+      }
+    },
+    [rowId]
+  );
+  const handleDelete = useCallback6(async () => {
+    if (!storeRef.current) throw new Error("Store not ready");
+    await deleteRowOp2(storeRef.current, rowId);
+  }, [rowId]);
+  return {
+    row,
+    doc,
+    update: handleUpdate,
+    delete: handleDelete,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useCell.ts
+import { updateCell, cellKey } from "@xnetjs/data";
+import { useState as useState6, useEffect as useEffect6, useCallback as useCallback7, useRef as useRef7 } from "react";
+function useCell(rowId, columnId, options = {}) {
+  const { store, isReady } = useNodeStore();
+  const { debounce: debounceMs = 300 } = options;
+  const [value, setValue] = useState6(null);
+  const [saving, setSaving] = useState6(false);
+  const [error, setError] = useState6(null);
+  const debounceRef = useRef7();
+  const storeRef = useRef7(store);
+  storeRef.current = store;
+  useEffect6(() => {
+    if (!store || !isReady || !rowId) return;
+    store.get(rowId).then((node) => {
+      if (node) {
+        const key = cellKey(columnId);
+        setValue(node.properties[key] ?? null);
+      }
+    });
+  }, [store, isReady, rowId, columnId]);
+  useEffect6(() => {
+    if (!store || !rowId) return;
+    const unsubscribe = store.subscribe((event) => {
+      if (event.change.payload.nodeId === rowId && event.node) {
+        const key = cellKey(columnId);
+        setValue(event.node.properties[key] ?? null);
+      }
+    });
+    return unsubscribe;
+  }, [store, rowId, columnId]);
+  const handleSetValue = useCallback7(
+    (newValue) => {
+      setValue(newValue);
+      setError(null);
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+      debounceRef.current = setTimeout(async () => {
+        if (!storeRef.current) return;
+        try {
+          setSaving(true);
+          await updateCell(storeRef.current, rowId, columnId, newValue);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        } finally {
+          setSaving(false);
+        }
+      }, debounceMs);
+    },
+    [rowId, columnId, debounceMs]
+  );
+  const clear = useCallback7(() => {
+    handleSetValue(null);
+  }, [handleSetValue]);
+  useEffect6(() => {
+    return () => {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, []);
+  return {
+    value,
+    setValue: handleSetValue,
+    clear,
+    saving,
+    error
+  };
+}
+
+// src/hooks/useRelatedRows.ts
+import { fromCellProperties as fromCellProperties2 } from "@xnetjs/data";
+import { useState as useState7, useEffect as useEffect7, useMemo as useMemo4 } from "react";
+function useRelatedRows(rowIds) {
+  const { store, isReady } = useNodeStore();
+  const [rows, setRows] = useState7([]);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const idsKey = useMemo4(() => rowIds.join(","), [rowIds]);
+  useEffect7(() => {
+    if (!store || !isReady) return;
+    if (rowIds.length === 0) {
+      setRows([]);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const fetchRows = async () => {
+      try {
+        setLoading(true);
+        const results = await Promise.all(
+          rowIds.map(async (id) => {
+            try {
+              return await store.get(id);
+            } catch {
+              return null;
+            }
+          })
+        );
+        if (!cancelled) {
+          const loadedRows = results.filter((node) => node !== null).map((node) => nodeToRow2(node));
+          setRows(loadedRows);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+    fetchRows();
+    return () => {
+      cancelled = true;
+    };
+  }, [store, isReady, idsKey, rowIds]);
+  return { rows, loading, error };
+}
+function nodeToRow2(node) {
+  const cells = fromCellProperties2(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey ?? "",
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useReverseRelations.ts
+import { fromCellProperties as fromCellProperties3, getColumns as getColumns2, isDatabaseDocInitialized as isDatabaseDocInitialized2 } from "@xnetjs/data";
+import { useState as useState8, useEffect as useEffect8 } from "react";
+import * as Y5 from "yjs";
+function useReverseRelations(rowId, databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [relations, setRelations] = useState8([]);
+  const [loading, setLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const [refetchKey, setRefetchKey] = useState8(0);
+  useEffect8(() => {
+    if (!store || !isReady || !rowId || !databaseId) {
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const findReverseRelations = async () => {
+      try {
+        setLoading(true);
+        const allDatabases = await store.list({
+          schemaId: "xnet://xnet.fyi/Database"
+        });
+        const reverseRelations = [];
+        for (const db of allDatabases) {
+          if (cancelled) break;
+          try {
+            const docContent = await store.getDocumentContent(db.id);
+            if (!docContent || docContent.length === 0) continue;
+            const doc = new Y5.Doc({ guid: db.id });
+            Y5.applyUpdate(doc, docContent);
+            if (!isDatabaseDocInitialized2(doc)) {
+              doc.destroy();
+              continue;
+            }
+            const columns = getColumns2(doc);
+            const relationColumns = columns.filter(
+              (col) => col.type === "relation" && col.config?.targetDatabase === databaseId
+            );
+            doc.destroy();
+            if (relationColumns.length === 0) continue;
+            for (const col of relationColumns) {
+              if (cancelled) break;
+              const allRows = await store.list({
+                schemaId: "xnet://xnet.fyi/DatabaseRow"
+              });
+              const rows = allRows.filter((row) => row.properties.database === db.id);
+              for (const node of rows) {
+                const cellKey2 = `cell_${col.id}`;
+                const cellValue = node.properties[cellKey2];
+                if (Array.isArray(cellValue) && cellValue.includes(rowId)) {
+                  reverseRelations.push({
+                    row: nodeToRow3(node),
+                    column: col,
+                    sourceDatabaseId: db.id,
+                    sourceDatabaseTitle: db.properties.title ?? "Untitled"
+                  });
+                }
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (!cancelled) {
+          setRelations(reverseRelations);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    };
+    findReverseRelations();
+    return () => {
+      cancelled = true;
+    };
+  }, [store, isReady, rowId, databaseId, refetchKey]);
+  const refetch = () => setRefetchKey((k) => k + 1);
+  return { relations, loading, error, refetch };
+}
+function nodeToRow3(node) {
+  const cells = fromCellProperties3(node.properties);
+  return {
+    id: node.id,
+    sortKey: node.properties.sortKey ?? "",
+    cells,
+    createdAt: node.createdAt,
+    createdBy: node.createdBy
+  };
+}
+
+// src/hooks/useDatabaseSchema.ts
+import { extractSchemaFromDoc } from "@xnetjs/data";
+import { useState as useState9, useEffect as useEffect9, useMemo as useMemo5, useRef as useRef8 } from "react";
+import * as Y6 from "yjs";
+function useDatabaseSchema(databaseId) {
+  const { store, isReady } = useNodeStore();
+  const [schema, setSchema] = useState9(null);
+  const [metadata, setMetadata] = useState9(null);
+  const [schemaIRI, setSchemaIRI] = useState9(null);
+  const [loading, setLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const [refreshKey, setRefreshKey] = useState9(0);
+  const docRef = useRef8(null);
+  useEffect9(() => {
+    if (!store || !isReady || !databaseId) {
+      setSchema(null);
+      setMetadata(null);
+      setSchemaIRI(null);
+      setLoading(false);
+      return;
+    }
+    let mounted = true;
+    const loadSchema = async () => {
+      try {
+        setLoading(true);
+        setError(null);
+        const ydoc = new Y6.Doc({ guid: databaseId, gc: false });
+        const storedContent = await store.getDocumentContent(databaseId);
+        if (storedContent && storedContent.length > 0) {
+          Y6.applyUpdate(ydoc, storedContent);
+        }
+        if (!mounted) {
+          ydoc.destroy();
+          return;
+        }
+        docRef.current = ydoc;
+        const extractedSchema = extractSchemaFromDoc(databaseId, ydoc);
+        if (!extractedSchema) {
+          setSchema(null);
+          setMetadata(null);
+          setSchemaIRI(null);
+          return;
+        }
+        const dataMap = ydoc.getMap("data");
+        const meta = dataMap.get("schema");
+        if (!mounted) return;
+        setSchema(extractedSchema);
+        setMetadata(meta ?? null);
+        setSchemaIRI(extractedSchema["@id"]);
+      } catch (err) {
+        if (!mounted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted) setLoading(false);
+      }
+    };
+    void loadSchema();
+    return () => {
+      mounted = false;
+      if (docRef.current) {
+        docRef.current.destroy();
+        docRef.current = null;
+      }
+    };
+  }, [store, isReady, databaseId, refreshKey]);
+  useEffect9(() => {
+    const doc = docRef.current;
+    if (!doc || !databaseId) return;
+    const dataMap = doc.getMap("data");
+    const handleSchemaChange = () => {
+      const meta = dataMap.get("schema");
+      if (!meta) return;
+      const extractedSchema = extractSchemaFromDoc(databaseId, doc);
+      if (extractedSchema) {
+        setSchema(extractedSchema);
+        setMetadata(meta);
+        setSchemaIRI(extractedSchema["@id"]);
+      }
+    };
+    dataMap.observe(handleSchemaChange);
+    return () => {
+      dataMap.unobserve(handleSchemaChange);
+    };
+  }, [databaseId, schema]);
+  const refresh = useMemo5(
+    () => () => {
+      setRefreshKey((k) => k + 1);
+    },
+    []
+  );
+  return useMemo5(
+    () => ({
+      schema,
+      metadata,
+      schemaIRI,
+      loading,
+      error,
+      refresh
+    }),
+    [schema, metadata, schemaIRI, loading, error, refresh]
+  );
+}
+
+// src/hooks/useComments.ts
+import { CommentSchema } from "@xnetjs/data";
+import { useState as useState10, useEffect as useEffect10, useMemo as useMemo6, useCallback as useCallback8, useRef as useRef9 } from "react";
+function useComments({ nodeId, anchorType }) {
+  const { store, isReady } = useNodeStore();
+  const [comments, setComments] = useState10([]);
+  const [loading, setLoading] = useState10(true);
+  const [error, setError] = useState10(null);
+  const queryRef = useRef9({ nodeId, anchorType });
+  queryRef.current = { nodeId, anchorType };
+  const loadComments = useCallback8(async () => {
+    if (!store || !isReady) return;
+    try {
+      setLoading(true);
+      setError(null);
+      const nodes = await store.list({
+        schemaId: CommentSchema._schemaId
+      });
+      const filtered = nodes.filter((n) => {
+        if (n.properties.target !== queryRef.current.nodeId) return false;
+        if (queryRef.current.anchorType && n.properties.anchorType !== queryRef.current.anchorType && !n.properties.inReplyTo) {
+          return false;
+        }
+        return true;
+      });
+      const commentNodes = filtered.map((n) => nodeToComment(n));
+      setComments(commentNodes);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [store, isReady]);
+  useEffect10(() => {
+    loadComments();
+  }, [loadComments]);
+  useEffect10(() => {
+    if (!store || !isReady) return;
+    const handleChange = (event) => {
+      if (event.node?.schemaId === CommentSchema._schemaId) {
+        if (event.node.properties.target === nodeId) {
+          loadComments();
+        }
+      } else if (event.change?.payload?.schemaId === CommentSchema._schemaId) {
+        loadComments();
+      }
+    };
+    const unsubscribe = store.subscribe(handleChange);
+    return () => unsubscribe();
+  }, [store, isReady, loadComments, nodeId]);
+  const threads = useMemo6(() => {
+    const threadMap = /* @__PURE__ */ new Map();
+    for (const comment of comments) {
+      if (!comment.properties.inReplyTo) {
+        threadMap.set(comment.id, { root: comment, replies: [] });
+      }
+    }
+    for (const comment of comments) {
+      const rootId = comment.properties.inReplyTo;
+      if (rootId) {
+        const thread = threadMap.get(rootId);
+        if (thread) {
+          thread.replies.push(comment);
+        }
+      }
+    }
+    for (const thread of threadMap.values()) {
+      thread.replies.sort((a, b) => a.lamportTime - b.lamportTime);
+    }
+    return Array.from(threadMap.values());
+  }, [comments]);
+  const unresolvedCount = useMemo6(() => {
+    return threads.filter((t) => !t.root.properties.resolved).length;
+  }, [threads]);
+  const addComment = useCallback8(
+    async (options) => {
+      if (!store || !isReady) return null;
+      try {
+        const node = await store.create({
+          schemaId: CommentSchema._schemaId,
+          properties: {
+            target: nodeId,
+            targetSchema: options.targetSchema,
+            anchorType: options.anchorType,
+            anchorData: options.anchorData,
+            content: options.content,
+            resolved: false,
+            edited: false
+          }
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, nodeId]
+  );
+  const replyTo = useCallback8(
+    async (rootCommentId, content, context) => {
+      if (!store || !isReady) return null;
+      const root = threads.find((t) => t.root.id === rootCommentId)?.root;
+      if (!root) {
+        setError(new Error("Thread root not found"));
+        return null;
+      }
+      try {
+        const node = await store.create({
+          schemaId: CommentSchema._schemaId,
+          properties: {
+            target: nodeId,
+            targetSchema: root.properties.targetSchema,
+            inReplyTo: rootCommentId,
+            // Always points to root (flat threading)
+            anchorType: "node",
+            // Replies don't need positional anchors
+            anchorData: "{}",
+            content,
+            replyToUser: context?.replyToUser,
+            replyToCommentId: context?.replyToCommentId,
+            resolved: false,
+            edited: false
+          }
+        });
+        return node.id;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, isReady, nodeId, threads]
+  );
+  const resolveThread = useCallback8(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(rootCommentId, {
+          properties: {
+            resolved: true,
+            resolvedAt: Date.now()
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const reopenThread = useCallback8(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(rootCommentId, {
+          properties: {
+            resolved: false,
+            resolvedBy: null,
+            resolvedAt: null
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  const deleteComment = useCallback8(
+    async (commentId) => {
+      if (!store || !isReady) return;
+      try {
+        const thread = threads.find((t) => t.root.id === commentId);
+        const isRoot = thread !== void 0;
+        if (isRoot) {
+          if (thread.replies.length > 0) {
+            await store.update(commentId, {
+              properties: { content: "[deleted]" }
+            });
+          } else {
+            await store.delete(commentId);
+          }
+        } else {
+          await store.delete(commentId);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, threads]
+  );
+  const deleteThread = useCallback8(
+    async (rootCommentId) => {
+      if (!store || !isReady) return;
+      const thread = threads.find((t) => t.root.id === rootCommentId);
+      if (!thread) return;
+      try {
+        for (const reply of thread.replies) {
+          await store.delete(reply.id);
+        }
+        await store.delete(rootCommentId);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, threads]
+  );
+  const editComment = useCallback8(
+    async (commentId, content) => {
+      if (!store || !isReady) return;
+      try {
+        await store.update(commentId, {
+          properties: {
+            content,
+            edited: true,
+            editedAt: Date.now()
+          }
+        });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady]
+  );
+  return {
+    comments,
+    threads,
+    count: comments.length,
+    unresolvedCount,
+    loading,
+    error,
+    addComment,
+    replyTo,
+    resolveThread,
+    reopenThread,
+    deleteComment,
+    deleteThread,
+    editComment,
+    reload: loadComments
+  };
+}
+function nodeToComment(node) {
+  const firstTimestamp = Object.values(node.timestamps)[0];
+  const lamportTime = firstTimestamp?.lamport?.time ?? 0;
+  const wallTime = firstTimestamp?.wallTime ?? node.createdAt;
+  return {
+    id: node.id,
+    schemaId: node.schemaId,
+    createdAt: node.createdAt,
+    lamportTime,
+    wallTime,
+    properties: {
+      target: node.properties.target,
+      targetSchema: node.properties.targetSchema,
+      inReplyTo: node.properties.inReplyTo,
+      anchorType: node.properties.anchorType,
+      anchorData: node.properties.anchorData,
+      content: node.properties.content,
+      attachments: node.properties.attachments,
+      replyToUser: node.properties.replyToUser,
+      replyToCommentId: node.properties.replyToCommentId,
+      resolved: node.properties.resolved ?? false,
+      resolvedBy: node.properties.resolvedBy,
+      resolvedAt: node.properties.resolvedAt,
+      edited: node.properties.edited ?? false,
+      editedAt: node.properties.editedAt,
+      createdBy: node.createdBy
+    }
+  };
+}
+
+// src/hooks/useCommentCount.ts
+import { useMemo as useMemo7 } from "react";
+function useCommentCount(nodeId) {
+  const { unresolvedCount } = useComments({ nodeId });
+  return unresolvedCount;
+}
+function useCommentCounts(nodeId) {
+  const { threads } = useComments({ nodeId });
+  return useMemo7(() => {
+    const resolved = threads.filter((t) => t.root.properties.resolved).length;
+    const unresolved = threads.length - resolved;
+    return {
+      total: threads.length,
+      unresolved,
+      resolved
+    };
+  }, [threads]);
+}
+
+// src/hooks/useHistory.ts
+import {
+  HistoryEngine,
+  SnapshotCache,
+  MemorySnapshotStorage
+} from "@xnetjs/history";
+import { useState as useState11, useEffect as useEffect11, useCallback as useCallback9, useRef as useRef10 } from "react";
+function useHistory(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [timeline, setTimeline] = useState11([]);
+  const [loading, setLoading] = useState11(false);
+  const [error, setError] = useState11(null);
+  const engineRef = useRef10(null);
+  const getEngine = useCallback9(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      const snapshotStorage = new MemorySnapshotStorage();
+      const snapshots = new SnapshotCache(snapshotStorage, { interval: 50 });
+      engineRef.current = { engine: new HistoryEngine(storage, snapshots), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const loadTimeline = useCallback9(async () => {
+    if (!nodeId || !isReady) return;
+    const engine = getEngine();
+    if (!engine) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const entries = await engine.getTimeline(nodeId);
+      setTimeline(entries);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [nodeId, isReady, getEngine]);
+  useEffect11(() => {
+    loadTimeline();
+  }, [loadTimeline]);
+  useEffect11(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        loadTimeline();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, loadTimeline]);
+  const materializeAt = useCallback9(
+    async (target) => {
+      if (!nodeId) return null;
+      const engine = getEngine();
+      if (!engine) return null;
+      try {
+        return await engine.materializeAt(nodeId, target);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const diff = useCallback9(
+    async (from, to) => {
+      if (!nodeId) return [];
+      const engine = getEngine();
+      if (!engine) return [];
+      try {
+        return await engine.diff(nodeId, from, to);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return [];
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const createRevertPayload = useCallback9(
+    async (target) => {
+      if (!nodeId || !store) return null;
+      const engine = getEngine();
+      if (!engine) return null;
+      try {
+        const current = await store.get(nodeId);
+        if (!current) return null;
+        return await engine.createRevertPayload(nodeId, target, current);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [nodeId, store, getEngine]
+  );
+  return {
+    timeline,
+    changeCount: timeline.length,
+    materializeAt,
+    diff,
+    createRevertPayload,
+    loading,
+    error,
+    reload: loadTimeline
+  };
+}
+
+// src/hooks/useUndo.ts
+import { UndoManager } from "@xnetjs/history";
+import { useState as useState12, useEffect as useEffect12, useCallback as useCallback10, useRef as useRef11 } from "react";
+function useUndo(nodeId, opts) {
+  const { store } = useNodeStore();
+  const [undoCount, setUndoCount] = useState12(0);
+  const [redoCount, setRedoCount] = useState12(0);
+  const managerRef = useRef11(null);
+  useEffect12(() => {
+    if (!store) return;
+    const manager = new UndoManager(store, opts.localDID, opts.options);
+    manager.start();
+    managerRef.current = manager;
+    return () => {
+      manager.stop();
+      managerRef.current = null;
+    };
+  }, [store, opts.localDID]);
+  const syncCounts = useCallback10(() => {
+    if (!managerRef.current || !nodeId) {
+      setUndoCount(0);
+      setRedoCount(0);
+      return;
+    }
+    setUndoCount(managerRef.current.getUndoCount(nodeId));
+    setRedoCount(managerRef.current.getRedoCount(nodeId));
+  }, [nodeId]);
+  useEffect12(() => {
+    syncCounts();
+  }, [syncCounts]);
+  useEffect12(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        syncCounts();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, syncCounts]);
+  const undo = useCallback10(async () => {
+    if (!managerRef.current || !nodeId) return false;
+    const result = await managerRef.current.undo(nodeId);
+    syncCounts();
+    return result;
+  }, [nodeId, syncCounts]);
+  const redo = useCallback10(async () => {
+    if (!managerRef.current || !nodeId) return false;
+    const result = await managerRef.current.redo(nodeId);
+    syncCounts();
+    return result;
+  }, [nodeId, syncCounts]);
+  const undoBatch = useCallback10(
+    async (batchId) => {
+      if (!managerRef.current) return false;
+      const result = await managerRef.current.undoBatch(batchId);
+      syncCounts();
+      return result;
+    },
+    [syncCounts]
+  );
+  const clear = useCallback10(() => {
+    if (!managerRef.current || !nodeId) return;
+    managerRef.current.clear(nodeId);
+    syncCounts();
+  }, [nodeId, syncCounts]);
+  return {
+    undo,
+    redo,
+    undoBatch,
+    canUndo: undoCount > 0,
+    canRedo: redoCount > 0,
+    undoCount,
+    redoCount,
+    clear
+  };
+}
+
+// src/hooks/useAudit.ts
+import { AuditIndex } from "@xnetjs/history";
+import { useState as useState13, useEffect as useEffect13, useCallback as useCallback11, useRef as useRef12 } from "react";
+function useAudit(nodeId, options) {
+  const { store, isReady } = useNodeStore();
+  const [entries, setEntries] = useState13([]);
+  const [activity, setActivity] = useState13(null);
+  const [loading, setLoading] = useState13(false);
+  const [error, setError] = useState13(null);
+  const auditRef = useRef12(null);
+  const getAudit = useCallback11(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!auditRef.current || auditRef.current.storage !== storage) {
+      auditRef.current = { audit: new AuditIndex(storage), storage };
+    }
+    return auditRef.current.audit;
+  }, [store]);
+  const load = useCallback11(async () => {
+    if (!nodeId || !isReady) return;
+    const audit = getAudit();
+    if (!audit) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const query = {
+        nodeId,
+        order: options?.order ?? "desc",
+        limit: options?.limit ?? 200
+      };
+      if (options?.operations) query.operations = options.operations;
+      if (options?.author) query.author = options.author;
+      if (options?.timeRange) {
+        query.fromWallTime = options.timeRange[0];
+        query.toWallTime = options.timeRange[1];
+      }
+      const [auditEntries, activitySummary] = await Promise.all([
+        audit.query(query),
+        audit.getNodeActivity(nodeId)
+      ]);
+      setEntries(auditEntries);
+      setActivity(activitySummary);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    nodeId,
+    isReady,
+    getAudit,
+    options?.operations,
+    options?.author,
+    options?.timeRange,
+    options?.limit,
+    options?.order
+  ]);
+  useEffect13(() => {
+    load();
+  }, [load]);
+  useEffect13(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        load();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, load]);
+  return { entries, activity, loading, error, reload: load };
+}
+
+// src/hooks/useDiff.ts
+import {
+  HistoryEngine as HistoryEngine2,
+  SnapshotCache as SnapshotCache2,
+  MemorySnapshotStorage as MemorySnapshotStorage2,
+  DiffEngine
+} from "@xnetjs/history";
+import { useState as useState14, useCallback as useCallback12, useRef as useRef13 } from "react";
+function useDiff(nodeId) {
+  const { store } = useNodeStore();
+  const [result, setResult] = useState14(null);
+  const [loading, setLoading] = useState14(false);
+  const [error, setError] = useState14(null);
+  const engineRef = useRef13(null);
+  const getEngine = useCallback12(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      const snapshotStorage = new MemorySnapshotStorage2();
+      const snapshots = new SnapshotCache2(snapshotStorage, { interval: 50 });
+      const history = new HistoryEngine2(storage, snapshots);
+      engineRef.current = { diff: new DiffEngine(history), storage };
+    }
+    return engineRef.current.diff;
+  }, [store]);
+  const diff = useCallback12(
+    async (from, to) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const diffResult = await engine.diffNode(nodeId, from, to);
+        setResult(diffResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const diffFromCurrent = useCallback12(
+    async (changesAgo) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const diffResult = await engine.diffFromCurrent(nodeId, changesAgo);
+        setResult(diffResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  return { diff, diffFromCurrent, result, loading, error };
+}
+
+// src/hooks/useBlame.ts
+import { BlameEngine } from "@xnetjs/history";
+import { useState as useState15, useEffect as useEffect14, useCallback as useCallback13, useRef as useRef14 } from "react";
+function useBlame(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [blame, setBlame] = useState15([]);
+  const [loading, setLoading] = useState15(false);
+  const [error, setError] = useState15(null);
+  const engineRef = useRef14(null);
+  const getEngine = useCallback13(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      engineRef.current = { engine: new BlameEngine(storage), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const load = useCallback13(async () => {
+    if (!nodeId || !isReady) return;
+    const engine = getEngine();
+    if (!engine) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const info = await engine.getBlame(nodeId);
+      setBlame(info);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [nodeId, isReady, getEngine]);
+  useEffect14(() => {
+    load();
+  }, [load]);
+  useEffect14(() => {
+    if (!store || !nodeId) return;
+    const unsub = store.subscribe((event) => {
+      if (event.change.payload.nodeId === nodeId) {
+        load();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, load]);
+  return { blame, loading, error, reload: load };
+}
+
+// src/hooks/useVerification.ts
+import {
+  VerificationEngine
+} from "@xnetjs/history";
+import { useState as useState16, useCallback as useCallback14, useRef as useRef15 } from "react";
+function useVerification(nodeId) {
+  const { store } = useNodeStore();
+  const [result, setResult] = useState16(null);
+  const [loading, setLoading] = useState16(false);
+  const [progress, setProgress] = useState16(0);
+  const [error, setError] = useState16(null);
+  const engineRef = useRef15(null);
+  const getEngine = useCallback14(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      engineRef.current = { engine: new VerificationEngine(storage), storage };
+    }
+    return engineRef.current.engine;
+  }, [store]);
+  const verify = useCallback14(
+    async (options) => {
+      if (!nodeId) return;
+      const engine = getEngine();
+      if (!engine) return;
+      setLoading(true);
+      setProgress(0);
+      setError(null);
+      try {
+        const verifyResult = await engine.verifyNodeHistory(nodeId, {
+          ...options,
+          onProgress: (p) => {
+            setProgress(p);
+            options?.onProgress?.(p);
+          }
+        });
+        setResult(verifyResult);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+        setProgress(1);
+      }
+    },
+    [nodeId, getEngine]
+  );
+  const quickCheck = useCallback14(async () => {
+    if (!nodeId) return null;
+    const engine = getEngine();
+    if (!engine) return null;
+    try {
+      return await engine.quickCheck(nodeId);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    }
+  }, [nodeId, getEngine]);
+  return { verify, quickCheck, result, loading, progress, error };
+}
+
+// src/hooks/useHubStatus.ts
+import { useContext as useContext2 } from "react";
+function useHubStatus() {
+  const context = useContext2(XNetContext);
+  return context?.hubStatus ?? "disconnected";
+}
+
+// src/hooks/useCan.ts
+import { useEffect as useEffect15, useRef as useRef16, useState as useState17 } from "react";
+var GRANT_SCHEMA_ID = "xnet://xnet.fyi/Grant";
+var INITIAL_STATE = {
+  canRead: false,
+  canWrite: false,
+  canDelete: false,
+  canShare: false,
+  loading: true,
+  error: null,
+  isFresh: false,
+  evaluatedAt: 0
+};
+function useCan(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [state, setState] = useState17(INITIAL_STATE);
+  const requestRef = useRef16(0);
+  useEffect15(() => {
+    if (!store || !isReady) {
+      setState((prev) => ({ ...prev, loading: true }));
+      return;
+    }
+    if (!store.auth) {
+      setState({
+        ...INITIAL_STATE,
+        loading: false,
+        error: new Error("Authorization API is not configured on this NodeStore")
+      });
+      return;
+    }
+    const run = async () => {
+      const requestId = ++requestRef.current;
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const [read, write, del, share] = await Promise.all([
+          store.auth.can({ action: "read", nodeId }),
+          store.auth.can({ action: "write", nodeId }),
+          store.auth.can({ action: "delete", nodeId }),
+          store.auth.can({ action: "share", nodeId })
+        ]);
+        if (requestRef.current !== requestId) return;
+        setState({
+          canRead: read.allowed,
+          canWrite: write.allowed,
+          canDelete: del.allowed,
+          canShare: share.allowed,
+          loading: false,
+          error: null,
+          isFresh: !read.cached,
+          evaluatedAt: read.evaluatedAt
+        });
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        setState((prev) => ({ ...prev, loading: false, error: normalized }));
+      }
+    };
+    void run();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const eventNodeId = typedEvent.change?.payload?.nodeId;
+      if (eventNodeId === nodeId) {
+        void run();
+        return;
+      }
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID;
+      const grantResource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && grantResource === nodeId) {
+        void run();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, nodeId, store]);
+  return state;
+}
+
+// src/hooks/useCanEdit.ts
+import { useEffect as useEffect16, useRef as useRef17, useState as useState18 } from "react";
+var GRANT_SCHEMA_ID2 = "xnet://xnet.fyi/Grant";
+var INITIAL_STATE2 = {
+  canEdit: false,
+  canView: false,
+  loading: true,
+  error: null,
+  roles: []
+};
+function useCanEdit(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [state, setState] = useState18(INITIAL_STATE2);
+  const requestRef = useRef17(0);
+  useEffect16(() => {
+    if (!store || !isReady) {
+      setState((prev) => ({ ...prev, loading: true }));
+      return;
+    }
+    if (!store.auth) {
+      setState({
+        ...INITIAL_STATE2,
+        loading: false,
+        error: new Error("Authorization API is not configured on this NodeStore")
+      });
+      return;
+    }
+    const run = async () => {
+      const requestId = ++requestRef.current;
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const [read, write] = await Promise.all([
+          store.auth.can({ action: "read", nodeId }),
+          store.auth.can({ action: "write", nodeId })
+        ]);
+        if (requestRef.current !== requestId) return;
+        const roleSet = /* @__PURE__ */ new Set([...read.roles, ...write.roles]);
+        setState({
+          canEdit: write.allowed,
+          canView: read.allowed && !write.allowed,
+          loading: false,
+          error: null,
+          roles: Array.from(roleSet)
+        });
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        setState((prev) => ({ ...prev, loading: false, error: normalized }));
+      }
+    };
+    void run();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const eventNodeId = typedEvent.change?.payload?.nodeId;
+      if (eventNodeId === nodeId) {
+        void run();
+        return;
+      }
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID2;
+      const grantResource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && grantResource === nodeId) {
+        void run();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, nodeId, store]);
+  return state;
+}
+
+// src/hooks/useGrants.ts
+import { useCallback as useCallback15, useEffect as useEffect17, useState as useState19 } from "react";
+var GRANT_SCHEMA_ID3 = "xnet://xnet.fyi/Grant";
+function useGrants(nodeId) {
+  const { store, isReady } = useNodeStore();
+  const [grants, setGrants] = useState19([]);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const load = useCallback15(async () => {
+    if (!store || !store.auth || !isReady) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const next = await store.auth.listGrants({ nodeId });
+      setGrants(next);
+      setLoading(false);
+    } catch (err) {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      setLoading(false);
+    }
+  }, [isReady, nodeId, store]);
+  useEffect17(() => {
+    if (!store || !isReady) {
+      setLoading(true);
+      return;
+    }
+    if (!store.auth) {
+      setLoading(false);
+      setError(new Error("Authorization API is not configured on this NodeStore"));
+      return;
+    }
+    void load();
+    const unsubscribe = store.subscribe((event) => {
+      const typedEvent = event;
+      const isGrantUpdate = typedEvent.node?.schemaId === GRANT_SCHEMA_ID3;
+      const resource = typedEvent.node?.properties?.resource;
+      if (isGrantUpdate && resource === nodeId) {
+        void load();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [isReady, load, nodeId, store]);
+  const grant = useCallback15(
+    async (input) => {
+      if (!store?.auth) {
+        throw new Error("Authorization API is not configured on this NodeStore");
+      }
+      const created = await store.auth.grant({ ...input, resource: input.resource ?? nodeId });
+      await load();
+      return created;
+    },
+    [load, nodeId, store]
+  );
+  const revoke = useCallback15(
+    async (grantId) => {
+      if (!store?.auth) {
+        throw new Error("Authorization API is not configured on this NodeStore");
+      }
+      await store.auth.revoke({ grantId });
+      await load();
+    },
+    [load, store]
+  );
+  return { grants, loading, error, grant, revoke };
+}
+
+// src/hooks/useBackup.ts
+import { useCallback as useCallback16, useContext as useContext3, useMemo as useMemo8, useState as useState20 } from "react";
+function useBackup() {
+  const context = useContext3(XNetContext);
+  const [uploading, setUploading] = useState20(false);
+  const backupConfig = useMemo8(() => {
+    if (!context) return null;
+    if (!context.hubUrl || !context.encryptionKey) return null;
+    return {
+      hubUrl: context.hubUrl,
+      encryptionKey: context.encryptionKey,
+      getAuthToken: context.getHubAuthToken
+    };
+  }, [context]);
+  const upload = useCallback16(
+    async (docId, plaintext) => {
+      if (!backupConfig) {
+        throw new Error("Hub backup is not configured");
+      }
+      setUploading(true);
+      try {
+        await uploadBackup(backupConfig, docId, plaintext);
+      } finally {
+        setUploading(false);
+      }
+    },
+    [backupConfig]
+  );
+  const download = useCallback16(
+    async (docId) => {
+      if (!backupConfig) return null;
+      return downloadBackup(backupConfig, docId);
+    },
+    [backupConfig]
+  );
+  return {
+    upload,
+    download,
+    uploading
+  };
+}
+
+// src/hooks/useFileUpload.ts
+import { hashHex } from "@xnetjs/crypto";
+import { useCallback as useCallback17, useContext as useContext4, useState as useState21 } from "react";
+var toHttpUrl = (hubUrl) => {
+  try {
+    const url = new URL(hubUrl);
+    if (url.protocol === "ws:") url.protocol = "http:";
+    if (url.protocol === "wss:") url.protocol = "https:";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return hubUrl;
+  }
+};
+function useFileUpload() {
+  const context = useContext4(XNetContext);
+  const [uploading, setUploading] = useState21(false);
+  const [progress, setProgress] = useState21(0);
+  const upload = useCallback17(
+    async (file) => {
+      if (!context?.hubUrl) throw new Error("Hub URL not configured");
+      setUploading(true);
+      setProgress(0);
+      try {
+        const buffer = new Uint8Array(await file.arrayBuffer());
+        setProgress(0.3);
+        const cid = `cid:blake3:${hashHex(buffer)}`;
+        setProgress(0.5);
+        const token = context.getHubAuthToken ? await context.getHubAuthToken() : "";
+        const httpUrl = toHttpUrl(context.hubUrl);
+        const res = await fetch(`${httpUrl}/files/${cid}`, {
+          method: "PUT",
+          headers: {
+            ...token ? { Authorization: `Bearer ${token}` } : {},
+            "Content-Type": file.type || "application/octet-stream",
+            "X-File-Name": file.name
+          },
+          body: buffer
+        });
+        setProgress(0.9);
+        if (!res.ok) {
+          let message = `Upload failed: ${res.status}`;
+          try {
+            const err = await res.json();
+            if (err?.error) message = err.error;
+          } catch {
+          }
+          throw new Error(message);
+        }
+        setProgress(1);
+        return {
+          cid,
+          name: file.name,
+          mimeType: file.type || "application/octet-stream",
+          size: file.size
+        };
+      } finally {
+        setUploading(false);
+      }
+    },
+    [context]
+  );
+  return { upload, uploading, progress };
+}
+
+// src/hooks/useHubSearch.ts
+import { useCallback as useCallback18, useContext as useContext5, useEffect as useEffect18, useMemo as useMemo9, useRef as useRef18, useState as useState22 } from "react";
+var createRequestId = () => {
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj && "randomUUID" in cryptoObj) {
+    return cryptoObj.randomUUID();
+  }
+  return Math.random().toString(36).slice(2);
+};
+function useHubSearch() {
+  const context = useContext5(XNetContext);
+  const connection = context?.hubConnection ?? context?.syncManager?.connection ?? null;
+  const [results, setResults] = useState22([]);
+  const [loading, setLoading] = useState22(false);
+  const [error, setError] = useState22(null);
+  const pendingRef = useRef18(/* @__PURE__ */ new Map());
+  useEffect18(() => {
+    if (!connection) return;
+    const unsubscribe = connection.onMessage((message) => {
+      const msg = message;
+      if (!msg.type || !msg.id) return;
+      if (msg.type === "query-response") {
+        const pending = pendingRef.current.get(msg.id);
+        if (pending) {
+          pendingRef.current.delete(msg.id);
+          clearTimeout(pending.timeoutId);
+          pending.resolve(msg.results ?? []);
+        }
+      }
+      if (msg.type === "query-error") {
+        const pending = pendingRef.current.get(msg.id);
+        if (pending) {
+          pendingRef.current.delete(msg.id);
+          clearTimeout(pending.timeoutId);
+          pending.reject(new Error(msg.error ?? "Query failed"));
+        }
+      }
+    });
+    return () => {
+      unsubscribe();
+      for (const pending of pendingRef.current.values()) {
+        clearTimeout(pending.timeoutId);
+        pending.reject(new Error("Query cancelled"));
+      }
+      pendingRef.current.clear();
+    };
+  }, [connection]);
+  const search = useCallback18(
+    async (query, options) => {
+      if (!connection || connection.status !== "connected") {
+        setError(new Error("Hub connection not available"));
+        setResults([]);
+        return [];
+      }
+      setLoading(true);
+      setError(null);
+      const id = createRequestId();
+      const promise = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          pendingRef.current.delete(id);
+          reject(new Error("Query timeout"));
+        }, 5e3);
+        pendingRef.current.set(id, { resolve, reject, timeoutId });
+      });
+      connection.sendRaw({
+        type: "query-request",
+        id,
+        query,
+        filters: options?.schemaIri ? { schemaIri: options.schemaIri } : void 0,
+        limit: options?.limit,
+        offset: options?.offset
+      });
+      try {
+        const response = await promise;
+        setResults(response);
+        return response;
+      } catch (err) {
+        const errorValue = err instanceof Error ? err : new Error("Search failed");
+        setError(errorValue);
+        setResults([]);
+        return [];
+      } finally {
+        setLoading(false);
+      }
+    },
+    [connection]
+  );
+  return useMemo9(
+    () => ({
+      search,
+      results,
+      loading,
+      error
+    }),
+    [search, results, loading, error]
+  );
+}
+
+// src/hooks/useRemoteSchema.ts
+import { useContext as useContext6, useEffect as useEffect19, useMemo as useMemo10, useState as useState23 } from "react";
+var toHubHttpUrl = (hubUrl) => {
+  if (hubUrl.startsWith("http://") || hubUrl.startsWith("https://")) return hubUrl;
+  return hubUrl.replace("wss://", "https://").replace("ws://", "http://");
+};
+var useRemoteSchema = (iri) => {
+  const context = useContext6(XNetContext);
+  const hubUrl = context?.hubUrl ?? null;
+  const getHubAuthToken = context?.getHubAuthToken;
+  const [schema, setSchema] = useState23(null);
+  const [loading, setLoading] = useState23(false);
+  const [error, setError] = useState23(null);
+  useEffect19(() => {
+    if (!iri || !hubUrl) {
+      setSchema(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const controller = new AbortController();
+    const fetchSchema = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const hubHttpUrl = toHubHttpUrl(hubUrl);
+        const encodedIri = encodeURIComponent(iri);
+        const token = getHubAuthToken ? await getHubAuthToken() : "";
+        const headers = token ? { Authorization: `Bearer ${token}` } : void 0;
+        const response = await fetch(`${hubHttpUrl}/schemas/resolve/${encodedIri}`, {
+          headers,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            if (!cancelled) setSchema(null);
+            return;
+          }
+          throw new Error(`Failed to resolve schema: ${response.status}`);
+        }
+        const data = await response.json();
+        if (!cancelled) setSchema(data);
+      } catch (err) {
+        if (cancelled) return;
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const errorValue = err instanceof Error ? err : new Error("Schema lookup failed");
+        setError(errorValue);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    };
+    void fetchSchema();
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [getHubAuthToken, hubUrl, iri]);
+  return useMemo10(
+    () => ({
+      schema,
+      loading,
+      error
+    }),
+    [schema, loading, error]
+  );
+};
+
+// src/hooks/usePeerDiscovery.ts
+import { useCallback as useCallback19, useContext as useContext7, useMemo as useMemo11, useState as useState24 } from "react";
+var toHubHttpUrl2 = (hubUrl) => hubUrl.replace("wss://", "https://").replace("ws://", "http://");
+var usePeerDiscovery = () => {
+  const context = useContext7(XNetContext);
+  const hubUrl = context?.hubUrl ?? null;
+  const [peers, setPeers] = useState24([]);
+  const [loading, setLoading] = useState24(false);
+  const refresh = useCallback19(async () => {
+    if (!hubUrl) return;
+    setLoading(true);
+    try {
+      const hubHttpUrl = toHubHttpUrl2(hubUrl);
+      const res = await fetch(`${hubHttpUrl}/dids?limit=50`);
+      if (!res.ok) return;
+      const { peers: records } = await res.json();
+      const now = Date.now();
+      setPeers(
+        records.map((record) => ({
+          did: record.did,
+          displayName: record.displayName,
+          endpoints: record.endpoints,
+          lastSeen: record.lastSeen,
+          isOnline: now - record.lastSeen < 5 * 60 * 1e3
+        }))
+      );
+    } finally {
+      setLoading(false);
+    }
+  }, [hubUrl]);
+  const resolve = useCallback19(
+    async (did) => {
+      if (!hubUrl) return null;
+      const hubHttpUrl = toHubHttpUrl2(hubUrl);
+      const res = await fetch(`${hubHttpUrl}/dids/${encodeURIComponent(did)}`);
+      if (!res.ok) return null;
+      const record = await res.json();
+      return {
+        did: record.did,
+        displayName: record.displayName,
+        endpoints: record.endpoints,
+        lastSeen: record.lastSeen,
+        isOnline: Date.now() - record.lastSeen < 5 * 60 * 1e3
+      };
+    },
+    [hubUrl]
+  );
+  return useMemo11(
+    () => ({
+      peers,
+      resolve,
+      refresh,
+      loading
+    }),
+    [peers, resolve, refresh, loading]
+  );
+};
+
+// src/components/HubStatusIndicator.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var STATUS_CONFIG = {
+  disconnected: { color: "var(--muted)", label: "Offline" },
+  connecting: { color: "var(--warning)", label: "Connecting..." },
+  connected: { color: "var(--success)", label: "Synced to hub" },
+  error: { color: "var(--destructive)", label: "Connection error" }
+};
+function HubStatusIndicator() {
+  const status = useHubStatus();
+  const config = STATUS_CONFIG[status];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: { display: "flex", alignItems: "center", gap: "6px", fontSize: "12px" },
+      title: config.label,
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            style: {
+              width: "8px",
+              height: "8px",
+              borderRadius: "50%",
+              backgroundColor: config.color,
+              display: "inline-block",
+              animation: status === "connecting" ? "pulse 1.5s infinite" : void 0
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { style: { color: "var(--muted-foreground)" }, children: config.label })
+      ]
+    }
+  );
+}
+
+// src/components/ErrorBoundary.tsx
+import { Component } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  state = { hasError: false, error: null };
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("[ErrorBoundary]", error, errorInfo);
+    this.props.onError?.(error, errorInfo);
+  }
+  handleReset = () => {
+    this.setState({ hasError: false, error: null });
+  };
+  componentDidUpdate(prevProps) {
+    if (this.state.hasError && this.props.resetKey !== void 0 && prevProps.resetKey !== this.props.resetKey) {
+      this.handleReset();
+    }
+  }
+  render() {
+    if (!this.state.hasError) {
+      return this.props.children;
+    }
+    if (this.props.fallback) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback({
+          error: this.state.error ?? new Error("Unknown error"),
+          reset: this.handleReset
+        });
+      }
+      return this.props.fallback;
+    }
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        role: "alert",
+        style: {
+          padding: "2rem",
+          textAlign: "center",
+          maxWidth: "480px",
+          margin: "4rem auto"
+        },
+        children: [
+          /* @__PURE__ */ jsx2("h2", { style: { fontSize: "1.25rem", fontWeight: 600, marginBottom: "0.5rem" }, children: "Something went wrong" }),
+          /* @__PURE__ */ jsx2("p", { style: { color: "#666", marginBottom: "1rem", fontSize: "0.875rem" }, children: this.state.error?.message ?? "An unexpected error occurred." }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              onClick: this.handleReset,
+              style: {
+                padding: "0.5rem 1rem",
+                borderRadius: "6px",
+                border: "1px solid #ccc",
+                background: "#fff",
+                cursor: "pointer",
+                fontSize: "0.875rem"
+              },
+              children: "Try again"
+            }
+          )
+        ]
+      }
+    );
+  }
+};
+
+// src/components/Skeleton.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var stylesInjected = false;
+function ensureStyles() {
+  if (stylesInjected || typeof document === "undefined") return;
+  const id = "xnet-skeleton-styles";
+  if (document.getElementById(id)) {
+    stylesInjected = true;
+    return;
+  }
+  const el = document.createElement("style");
+  el.id = id;
+  el.textContent = `
+    @keyframes xnet-skeleton-pulse {
+      0% { background-position: 200% 0; }
+      100% { background-position: -200% 0; }
+    }
+  `;
+  document.head.appendChild(el);
+  stylesInjected = true;
+}
+function Skeleton({
+  width = "100%",
+  height = "1em",
+  borderRadius = "4px",
+  style,
+  lines = 1,
+  gap = "0.5rem"
+}) {
+  ensureStyles();
+  const baseStyle = {
+    display: "block",
+    width,
+    height,
+    borderRadius,
+    background: "linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%)",
+    backgroundSize: "200% 100%",
+    animation: "xnet-skeleton-pulse 1.5s ease-in-out infinite",
+    ...style
+  };
+  if (lines <= 1) {
+    return /* @__PURE__ */ jsx3("span", { "aria-hidden": "true", style: baseStyle });
+  }
+  return /* @__PURE__ */ jsx3("div", { "aria-hidden": "true", style: { display: "flex", flexDirection: "column", gap }, children: Array.from({ length: lines }, (_, i) => /* @__PURE__ */ jsx3(
+    "span",
+    {
+      style: {
+        ...baseStyle,
+        // Last line is shorter for visual realism
+        width: i === lines - 1 ? "60%" : width
+      }
+    },
+    i
+  )) });
+}
+function injectSkeletonStyles() {
+  if (typeof document === "undefined") return;
+  const id = "xnet-skeleton-styles";
+  if (document.getElementById(id)) return;
+  const style = document.createElement("style");
+  style.id = id;
+  style.textContent = `
+    @keyframes xnet-skeleton-pulse {
+      0% { background-position: 200% 0; }
+      100% { background-position: -200% 0; }
+    }
+  `;
+  document.head.appendChild(style);
+}
+
+// src/components/DemoBanner.tsx
+import { useState as useState25 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var STORAGE_KEY = "xnet:demo-banner-dismissed";
+function DemoBanner({ evictionHours, onDismiss }) {
+  const [dismissed, setDismissed] = useState25(() => {
+    if (typeof window === "undefined") return false;
+    return localStorage.getItem(STORAGE_KEY) === "true";
+  });
+  if (dismissed) return null;
+  const handleDismiss = () => {
+    localStorage.setItem(STORAGE_KEY, "true");
+    setDismissed(true);
+    onDismiss?.();
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: "fixed top-0 left-0 right-0 z-50 flex items-center justify-between px-4 py-2 bg-amber-100 dark:bg-amber-900/50 border-b border-amber-300 dark:border-amber-700 text-amber-900 dark:text-amber-100 text-sm", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxs3("span", { children: [
+        "Demo mode \u2014 data is saved locally; encrypted backups expire after ",
+        evictionHours,
+        "h of inactivity."
+      ] }),
+      /* @__PURE__ */ jsx4(
+        "a",
+        {
+          href: "https://xnet.fyi/download",
+          className: "ml-2 px-2 py-0.5 bg-amber-500 hover:bg-amber-600 text-white rounded text-xs font-medium transition-colors",
+          children: "Download desktop app"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        onClick: handleDismiss,
+        className: "p-1 hover:bg-amber-200 dark:hover:bg-amber-800 rounded transition-colors",
+        "aria-label": "Dismiss banner",
+        children: /* @__PURE__ */ jsx4("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4(
+          "path",
+          {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 2,
+            d: "M6 18L18 6M6 6l12 12"
+          }
+        ) })
+      }
+    )
+  ] });
+}
+
+// src/components/DemoQuotaIndicator.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function DemoQuotaIndicator({ usedBytes, limitBytes }) {
+  const percentage = Math.round(usedBytes / limitBytes * 100);
+  const isWarning = percentage >= 80;
+  const isCritical = percentage >= 95;
+  return /* @__PURE__ */ jsxs4("div", { className: "flex items-center gap-2 text-xs text-muted-foreground", children: [
+    /* @__PURE__ */ jsx5("div", { className: "w-16 h-1.5 bg-border rounded-full overflow-hidden", children: /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: `h-full transition-all ${isCritical ? "bg-red-500" : isWarning ? "bg-amber-500" : "bg-primary"}`,
+        style: { width: `${Math.min(percentage, 100)}%` }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs4("span", { className: isCritical ? "text-red-500" : isWarning ? "text-amber-500" : "", children: [
+      formatBytes(usedBytes),
+      " / ",
+      formatBytes(limitBytes)
+    ] })
+  ] });
+}
+
+// src/components/DemoDataExpiredScreen.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function DemoDataExpiredScreen() {
+  return /* @__PURE__ */ jsxs5("div", { className: "flex flex-col items-center justify-center min-h-screen p-6 text-center bg-background", children: [
+    /* @__PURE__ */ jsx6("div", { className: "text-6xl mb-6", children: "\u{1F550}" }),
+    /* @__PURE__ */ jsx6("h1", { className: "text-2xl font-bold mb-3 text-foreground", children: "Your demo data has expired" }),
+    /* @__PURE__ */ jsx6("p", { className: "text-muted-foreground max-w-md mb-6", children: "Your local data is still saved in this browser, but encrypted hub backups are removed after 24 hours of inactivity. Cross-device sync requires an active hub connection." }),
+    /* @__PURE__ */ jsxs5("div", { className: "flex gap-3", children: [
+      /* @__PURE__ */ jsx6(
+        "button",
+        {
+          onClick: () => window.location.reload(),
+          className: "px-4 py-2 bg-primary text-primary-foreground rounded-md hover:bg-primary/90 transition-colors",
+          children: "Start Fresh"
+        }
+      ),
+      /* @__PURE__ */ jsx6(
+        "a",
+        {
+          href: "https://xnet.fyi/download",
+          className: "px-4 py-2 border border-border rounded-md hover:bg-accent transition-colors text-foreground no-underline",
+          children: "Download Desktop App"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx6("p", { className: "mt-8 text-sm text-muted-foreground", children: "The desktop app stores data permanently on your device." })
+  ] });
+}
+
+// src/hooks/useDemoMode.ts
+import { useState as useState26, useEffect as useEffect20 } from "react";
+function useDemoMode() {
+  const { syncManager } = useXNet();
+  const [state, setState] = useState26({ isDemo: false });
+  useEffect20(() => {
+    if (!syncManager?.connection) return;
+    const connection = syncManager.connection;
+    const unsubscribe = connection.onMessage((message) => {
+      if (message.type !== "handshake") return;
+      const isDemo = message.isDemo === true;
+      if (!isDemo) {
+        setState({ isDemo: false });
+        return;
+      }
+      const demoLimits = message.demoLimits;
+      setState({
+        isDemo: true,
+        limits: demoLimits ? {
+          quotaBytes: demoLimits.quotaBytes,
+          maxDocs: demoLimits.maxDocs,
+          evictionHours: Math.round(demoLimits.evictionTtlMs / 36e5)
+        } : void 0
+      });
+    });
+    return unsubscribe;
+  }, [syncManager]);
+  return state;
+}
+
+// src/components/OfflineIndicator.tsx
+import { useState as useState27, useEffect as useEffect21 } from "react";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function useIsOffline() {
+  const [offline, setOffline] = useState27(
+    typeof navigator !== "undefined" ? !navigator.onLine : false
+  );
+  useEffect21(() => {
+    const goOffline = () => setOffline(true);
+    const goOnline = () => setOffline(false);
+    window.addEventListener("offline", goOffline);
+    window.addEventListener("online", goOnline);
+    return () => {
+      window.removeEventListener("offline", goOffline);
+      window.removeEventListener("online", goOnline);
+    };
+  }, []);
+  return offline;
+}
+function OfflineIndicator({
+  message = "You are offline. Changes will sync when reconnected.",
+  className,
+  position = "bottom"
+}) {
+  const offline = useIsOffline();
+  if (!offline) return null;
+  const positionStyle = position === "top" ? { top: 0 } : { bottom: 0 };
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      role: "status",
+      "aria-live": "polite",
+      className,
+      style: {
+        position: "fixed",
+        left: 0,
+        right: 0,
+        zIndex: 9999,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: "0.5rem",
+        padding: "0.5rem 1rem",
+        background: "#fbbf24",
+        color: "#78350f",
+        fontSize: "0.875rem",
+        fontWeight: 500,
+        ...positionStyle
+      },
+      children: [
+        /* @__PURE__ */ jsxs6(
+          "svg",
+          {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            children: [
+              /* @__PURE__ */ jsx7("line", { x1: "1", y1: "1", x2: "23", y2: "23" }),
+              /* @__PURE__ */ jsx7("path", { d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55" }),
+              /* @__PURE__ */ jsx7("path", { d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39" }),
+              /* @__PURE__ */ jsx7("path", { d: "M10.71 5.05A16 16 0 0 1 22.56 9" }),
+              /* @__PURE__ */ jsx7("path", { d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88" }),
+              /* @__PURE__ */ jsx7("path", { d: "M8.53 16.11a6 6 0 0 1 6.95 0" }),
+              /* @__PURE__ */ jsx7("line", { x1: "12", y1: "20", x2: "12.01", y2: "20" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx7("span", { children: message })
+      ]
+    }
+  );
+}
+
+// src/hooks/useIdentity.ts
+function useIdentity() {
+  const { identity, authorDID } = useXNet();
+  return {
+    identity: identity ?? null,
+    isAuthenticated: !!identity || !!authorDID,
+    did: identity?.did ?? authorDID ?? null
+  };
+}
+
+// src/onboarding/machine.ts
+var TRANSITIONS = {
+  welcome: {
+    AUTHENTICATE: "authenticating",
+    CREATE_NEW: "authenticating",
+    IMPORT_EXISTING: "import-identity",
+    BROWSER_UNSUPPORTED: "unsupported-browser"
+  },
+  authenticating: {
+    PASSKEY_SUCCESS: "connecting-hub",
+    PASSKEY_FAILED: "auth-error"
+  },
+  "auth-error": {
+    RETRY_AUTH: "authenticating",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "import-identity": {
+    SCAN_QR: "qr-scan",
+    ENTER_PHRASE: "recovery-phrase",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "qr-scan": {
+    IDENTITY_IMPORTED: "connecting-hub",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "recovery-phrase": {
+    IDENTITY_IMPORTED: "connecting-hub",
+    BACK_TO_WELCOME: "welcome"
+  },
+  "connecting-hub": {
+    HUB_CONNECTED: "ready",
+    HUB_FAILED: "ready"
+    // Continue anyway — hub is optional
+  },
+  ready: {
+    CREATE_FIRST_PAGE: "complete"
+  }
+  // 'unsupported-browser' and 'complete' have no transitions (terminal)
+};
+function onboardingReducer(current, event) {
+  const transitions = TRANSITIONS[current.state];
+  const nextState = transitions?.[event.type];
+  if (!nextState) {
+    return current;
+  }
+  const nextContext = { ...current.context };
+  switch (event.type) {
+    case "PASSKEY_SUCCESS":
+      nextContext.identity = event.identity;
+      nextContext.keyBundle = event.keyBundle;
+      nextContext.error = null;
+      break;
+    case "PASSKEY_FAILED":
+      nextContext.error = event.error;
+      break;
+    case "IDENTITY_IMPORTED":
+      nextContext.identity = event.identity;
+      nextContext.keyBundle = event.keyBundle;
+      nextContext.error = null;
+      break;
+    case "HUB_FAILED":
+      nextContext.error = event.error;
+      break;
+    case "HUB_CONNECTED":
+      nextContext.error = null;
+      break;
+    case "RETRY_AUTH":
+    case "AUTHENTICATE":
+    case "CREATE_NEW":
+      nextContext.error = null;
+      break;
+  }
+  return { state: nextState, context: nextContext };
+}
+function createInitialState(hubUrl) {
+  return {
+    state: "welcome",
+    context: {
+      identity: null,
+      keyBundle: null,
+      hubUrl: hubUrl ?? null,
+      error: null,
+      isDemo: false
+    }
+  };
+}
+
+// src/onboarding/OnboardingProvider.tsx
+import { detectPasskeySupport, createIdentityManager, isTestBypassEnabled } from "@xnetjs/identity";
+import {
+  createContext,
+  useContext as useContext8,
+  useReducer,
+  useCallback as useCallback20,
+  useEffect as useEffect22,
+  useRef as useRef19,
+  useMemo as useMemo12
+} from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var OnboardingCtx = createContext(null);
+function OnboardingProvider({
+  children,
+  defaultHubUrl = "wss://hub.xnet.fyi",
+  onComplete
+}) {
+  const [{ state, context }, dispatch] = useReducer(
+    onboardingReducer,
+    createInitialState(defaultHubUrl)
+  );
+  const manager = useMemo12(() => createIdentityManager(), []);
+  useEffect22(() => {
+    let cancelled = false;
+    manager.preflight().catch(() => {
+    });
+    detectPasskeySupport().then((support) => {
+      if (isTestBypassEnabled()) {
+        return;
+      }
+      if (!cancelled && (!support.webauthn || !support.platform)) {
+        dispatch({ type: "BROWSER_UNSUPPORTED" });
+      }
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [manager]);
+  useEffect22(() => {
+    if (state === "complete" && context.identity && context.keyBundle && onComplete) {
+      onComplete(context.identity, context.keyBundle);
+    }
+  }, [state, context.identity, context.keyBundle, onComplete]);
+  const authInFlight = useRef19(false);
+  const send = useCallback20(
+    (event) => {
+      if ((event.type === "AUTHENTICATE" || event.type === "CREATE_NEW") && state === "welcome" || event.type === "RETRY_AUTH" && state === "auth-error") {
+        if (authInFlight.current) return;
+        authInFlight.current = true;
+        manager.create().then((keyBundle) => {
+          dispatch({
+            type: "PASSKEY_SUCCESS",
+            identity: keyBundle.identity,
+            keyBundle
+          });
+        }).catch((err) => {
+          dispatch({
+            type: "PASSKEY_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }).finally(() => {
+          authInFlight.current = false;
+        });
+      }
+      dispatch(event);
+    },
+    [state, manager]
+  );
+  return /* @__PURE__ */ jsx8(OnboardingCtx.Provider, { value: { state, context, send }, children });
+}
+function useOnboarding() {
+  const ctx = useContext8(OnboardingCtx);
+  if (!ctx) {
+    throw new Error("useOnboarding must be used within <OnboardingProvider>");
+  }
+  return ctx;
+}
+
+// src/onboarding/helpers.ts
+function getPlatformAuthName() {
+  if (typeof navigator === "undefined") return "Biometric authentication";
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("mac") || ua.includes("iphone") || ua.includes("ipad")) {
+    return "Touch ID";
+  }
+  if (ua.includes("windows")) {
+    return "Windows Hello";
+  }
+  if (ua.includes("android")) {
+    return "Fingerprint";
+  }
+  return "Biometric authentication";
+}
+function truncateDid(did, headLen = 16, tailLen = 4) {
+  if (did.length <= headLen + tailLen + 3) return did;
+  return `${did.slice(0, headLen)}...${did.slice(-tailLen)}`;
+}
+async function copyToClipboard(text) {
+  if (typeof navigator === "undefined" || !navigator.clipboard) {
+    return false;
+  }
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/onboarding/screens/AuthenticatingScreen.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function AuthenticatingScreen() {
+  return /* @__PURE__ */ jsxs7("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx9("div", { className: "w-12 h-12 mb-6 border-4 border-primary border-t-transparent rounded-full animate-spin" }),
+    /* @__PURE__ */ jsxs7("h1", { className: "text-2xl font-semibold mb-2", children: [
+      "Waiting for ",
+      getPlatformAuthName()
+    ] }),
+    /* @__PURE__ */ jsx9("p", { className: "text-muted-foreground text-center", children: "Complete the biometric prompt to continue..." })
+  ] });
+}
+
+// src/onboarding/screens/AuthErrorScreen.tsx
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function AuthErrorScreen() {
+  const { send, context } = useOnboarding();
+  return /* @__PURE__ */ jsxs8("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx10("div", { className: "text-5xl mb-4", children: "!" }),
+    /* @__PURE__ */ jsx10("h1", { className: "text-2xl font-semibold mb-2", children: "Authentication failed" }),
+    /* @__PURE__ */ jsxs8("p", { className: "text-muted-foreground mb-2", children: [
+      "Could not set up ",
+      getPlatformAuthName(),
+      "."
+    ] }),
+    context.error && /* @__PURE__ */ jsx10("p", { className: "text-destructive text-sm mb-4 max-w-md text-center", children: context.error.message }),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-3",
+        onClick: () => send({ type: "RETRY_AUTH" }),
+        children: "Try again"
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-6",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back to welcome"
+      }
+    ),
+    /* @__PURE__ */ jsx10("p", { className: "text-xs text-muted-foreground max-w-sm text-center", children: "Make sure your browser supports passkeys (Chrome 116+, Safari 18+, Edge 116+)." })
+  ] });
+}
+
+// src/onboarding/screens/HubConnectScreen.tsx
+import { useEffect as useEffect23 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function HubConnectScreen({ connectToHub }) {
+  const { send, context } = useOnboarding();
+  useEffect23(() => {
+    let cancelled = false;
+    if (connectToHub) {
+      connectToHub().then(() => {
+        if (!cancelled) send({ type: "HUB_CONNECTED" });
+      }).catch((err) => {
+        if (!cancelled) {
+          send({
+            type: "HUB_FAILED",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }
+      });
+    } else {
+      send({ type: "HUB_CONNECTED" });
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs9("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx11("div", { className: "w-12 h-12 mb-6 border-4 border-primary border-t-transparent rounded-full animate-spin" }),
+    /* @__PURE__ */ jsx11("h1", { className: "text-2xl font-semibold mb-2", children: "Connecting to sync server" }),
+    /* @__PURE__ */ jsx11("p", { className: "text-muted-foreground mb-4", children: "Setting up secure connection..." }),
+    context.hubUrl && /* @__PURE__ */ jsx11("p", { className: "text-xs text-muted-foreground font-mono", children: context.hubUrl })
+  ] });
+}
+
+// src/onboarding/screens/ImportIdentityScreen.tsx
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function ImportIdentityScreen() {
+  const { send } = useOnboarding();
+  return /* @__PURE__ */ jsxs10("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx12("h1", { className: "text-2xl font-semibold mb-2", children: "Import your identity" }),
+    /* @__PURE__ */ jsx12("p", { className: "text-muted-foreground text-center mb-8 max-w-md", children: "Bring your existing xNet identity to this device." }),
+    /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-3 w-64",
+        onClick: () => send({ type: "SCAN_QR" }),
+        children: "Scan from another device"
+      }
+    ),
+    /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors mb-6",
+        onClick: () => send({ type: "ENTER_PHRASE" }),
+        children: "Enter recovery phrase"
+      }
+    ),
+    /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors",
+        onClick: () => send({ type: "BACK_TO_WELCOME" }),
+        children: "Back"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/ReadyScreen.tsx
+import { useState as useState28, useEffect as useEffect24, useRef as useRef20 } from "react";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function ReadyScreen() {
+  const { send, context } = useOnboarding();
+  const [copied, setCopied] = useState28(false);
+  const timerRef = useRef20(null);
+  useEffect24(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  const handleCopy = async () => {
+    if (context.identity?.did) {
+      const ok = await copyToClipboard(context.identity.did);
+      if (ok) {
+        setCopied(true);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => setCopied(false), 2e3);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs11("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx13("div", { className: "text-5xl mb-4", children: "\u2713" }),
+    /* @__PURE__ */ jsx13("h1", { className: "text-2xl font-semibold mb-6", children: "You're all set!" }),
+    context.identity && /* @__PURE__ */ jsxs11("div", { className: "flex flex-col items-center mb-4", children: [
+      /* @__PURE__ */ jsx13("label", { className: "text-xs text-muted-foreground mb-1", children: "Your identity" }),
+      /* @__PURE__ */ jsxs11("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx13("code", { className: "text-sm font-mono bg-muted px-3 py-1 rounded", children: truncateDid(context.identity.did) }),
+        /* @__PURE__ */ jsx13(
+          "button",
+          {
+            className: "text-xs text-primary hover:text-primary/80 transition-colors",
+            onClick: handleCopy,
+            title: "Copy full DID",
+            children: copied ? "Copied!" : "Copy"
+          }
+        )
+      ] })
+    ] }),
+    context.hubUrl && /* @__PURE__ */ jsxs11("div", { className: "flex flex-col items-center mb-4", children: [
+      /* @__PURE__ */ jsx13("label", { className: "text-xs text-muted-foreground mb-1", children: "Connected to" }),
+      /* @__PURE__ */ jsx13("span", { className: "text-sm font-mono", children: context.hubUrl })
+    ] }),
+    context.isDemo && /* @__PURE__ */ jsx13("div", { className: "px-4 py-2 bg-amber-100 dark:bg-amber-900/30 text-amber-900 dark:text-amber-100 rounded-lg text-sm mb-6", children: "Demo mode \u2014 data is saved locally; encrypted backups expire after 24h of inactivity." }),
+    /* @__PURE__ */ jsx13(
+      "button",
+      {
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors",
+        onClick: () => send({ type: "CREATE_FIRST_PAGE" }),
+        children: "Create your first page"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/screens/UnsupportedBrowserScreen.tsx
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function UnsupportedBrowserScreen() {
+  return /* @__PURE__ */ jsxs12("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+    /* @__PURE__ */ jsx14("div", { className: "text-5xl mb-4", children: ":(" }),
+    /* @__PURE__ */ jsx14("h1", { className: "text-2xl font-semibold mb-2", children: "Browser not supported" }),
+    /* @__PURE__ */ jsxs12("p", { className: "text-muted-foreground text-center mb-6 max-w-md", children: [
+      "xNet requires ",
+      getPlatformAuthName(),
+      " which isn't available in this browser."
+    ] }),
+    /* @__PURE__ */ jsx14(
+      "a",
+      {
+        href: "/download",
+        className: "px-6 py-3 bg-primary text-primary-foreground rounded-lg font-medium hover:bg-primary/90 transition-colors mb-6 no-underline",
+        children: "Download Desktop App"
+      }
+    ),
+    /* @__PURE__ */ jsx14("p", { className: "text-xs text-muted-foreground", children: "Supported browsers: Chrome 116+, Safari 18+, Edge 116+" })
+  ] });
+}
+
+// src/onboarding/screens/WelcomeScreen.tsx
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function WelcomeScreen() {
+  const { send } = useOnboarding();
+  return /* @__PURE__ */ jsxs13("div", { className: "flex flex-col items-center justify-center min-h-screen bg-gradient-to-b from-background to-muted/30 text-foreground p-6", children: [
+    /* @__PURE__ */ jsx15("div", { className: "w-16 h-16 mb-8 rounded-2xl bg-primary/10 flex items-center justify-center", children: /* @__PURE__ */ jsxs13(
+      "svg",
+      {
+        className: "w-8 h-8 text-primary",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        children: [
+          /* @__PURE__ */ jsx15("path", { d: "M12 2L2 7l10 5 10-5-10-5z" }),
+          /* @__PURE__ */ jsx15("path", { d: "M2 17l10 5 10-5" }),
+          /* @__PURE__ */ jsx15("path", { d: "M2 12l10 5 10-5" })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx15("h1", { className: "text-4xl font-bold mb-3 tracking-tight", children: "Welcome to xNet" }),
+    /* @__PURE__ */ jsx15("p", { className: "text-muted-foreground text-center mb-10 max-w-sm text-lg leading-relaxed", children: "Your private workspace that syncs everywhere and belongs to you." }),
+    /* @__PURE__ */ jsx15(
+      "button",
+      {
+        className: "group px-8 py-4 bg-primary text-primary-foreground rounded-xl font-semibold text-lg shadow-lg shadow-primary/25 hover:shadow-xl hover:shadow-primary/30 hover:scale-[1.02] active:scale-[0.98] transition-all duration-200 mb-4",
+        onClick: () => send({ type: "AUTHENTICATE" }),
+        children: /* @__PURE__ */ jsxs13("span", { className: "flex items-center gap-2", children: [
+          getPlatformAuthName() === "Touch ID" && /* @__PURE__ */ jsx15("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx15("path", { d: "M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.48.38z" }) }),
+          getPlatformAuthName() === "Face ID" && /* @__PURE__ */ jsx15("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx15("path", { d: "M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z" }) }),
+          getPlatformAuthName() === "Windows Hello" && /* @__PURE__ */ jsx15("svg", { className: "w-5 h-5", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx15("path", { d: "M3 5v14h18V5H3zm16 12H5V7h14v10z" }) }),
+          !["Touch ID", "Face ID", "Windows Hello"].includes(getPlatformAuthName()) && /* @__PURE__ */ jsxs13(
+            "svg",
+            {
+              className: "w-5 h-5",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              children: [
+                /* @__PURE__ */ jsx15("rect", { x: "3", y: "11", width: "18", height: "11", rx: "2", ry: "2" }),
+                /* @__PURE__ */ jsx15("path", { d: "M7 11V7a5 5 0 0 1 10 0v4" })
+              ]
+            }
+          ),
+          "Get started with ",
+          getPlatformAuthName()
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx15("p", { className: "text-xs text-muted-foreground/70 text-center max-w-xs mt-2 mb-8", children: "Creates a secure passkey on your device. No passwords needed." }),
+    /* @__PURE__ */ jsx15(
+      "button",
+      {
+        className: "text-sm text-muted-foreground hover:text-foreground transition-colors underline-offset-4 hover:underline",
+        onClick: () => send({ type: "IMPORT_EXISTING" }),
+        children: "I already have an identity"
+      }
+    )
+  ] });
+}
+
+// src/onboarding/OnboardingFlow.tsx
+import { Fragment, jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+function OnboardingFlow({ connectToHub, children }) {
+  const { state } = useOnboarding();
+  switch (state) {
+    case "welcome":
+      return /* @__PURE__ */ jsx16(WelcomeScreen, {});
+    case "authenticating":
+      return /* @__PURE__ */ jsx16(AuthenticatingScreen, {});
+    case "auth-error":
+      return /* @__PURE__ */ jsx16(AuthErrorScreen, {});
+    case "unsupported-browser":
+      return /* @__PURE__ */ jsx16(UnsupportedBrowserScreen, {});
+    case "import-identity":
+      return /* @__PURE__ */ jsx16(ImportIdentityScreen, {});
+    case "qr-scan":
+      return /* @__PURE__ */ jsxs14("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+        /* @__PURE__ */ jsx16("h1", { className: "text-2xl font-semibold mb-2", children: "QR Scan" }),
+        /* @__PURE__ */ jsx16("p", { className: "text-muted-foreground", children: "Coming soon \u2014 scan a QR code from another device." })
+      ] });
+    case "recovery-phrase":
+      return /* @__PURE__ */ jsxs14("div", { className: "flex flex-col items-center justify-center min-h-screen bg-background text-foreground p-6", children: [
+        /* @__PURE__ */ jsx16("h1", { className: "text-2xl font-semibold mb-2", children: "Recovery Phrase" }),
+        /* @__PURE__ */ jsx16("p", { className: "text-muted-foreground", children: "Coming soon \u2014 enter your recovery phrase." })
+      ] });
+    case "connecting-hub":
+      return /* @__PURE__ */ jsx16(HubConnectScreen, { connectToHub });
+    case "ready":
+      return /* @__PURE__ */ jsx16(ReadyScreen, {});
+    case "complete":
+      return /* @__PURE__ */ jsx16(Fragment, { children });
+    default:
+      return /* @__PURE__ */ jsx16(WelcomeScreen, {});
+  }
+}
+
+// src/onboarding/screens/SmartWelcome.tsx
+import { discoverExistingPasskey } from "@xnetjs/identity";
+import { useEffect as useEffect25, useState as useState29 } from "react";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+function SmartWelcome() {
+  const { send } = useOnboarding();
+  const [checking, setChecking] = useState29(true);
+  const [hasExisting, setHasExisting] = useState29(false);
+  useEffect25(() => {
+    let cancelled = false;
+    discoverExistingPasskey().then((passkey) => {
+      if (!cancelled) {
+        setHasExisting(passkey !== null);
+        setChecking(false);
+      }
+    }).catch(() => {
+      if (!cancelled) {
+        setChecking(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  if (checking) {
+    return /* @__PURE__ */ jsx17("div", { className: "onboarding-screen", children: /* @__PURE__ */ jsx17("p", { className: "spinner-text", children: "Checking for existing identity..." }) });
+  }
+  if (hasExisting) {
+    const authName = getPlatformAuthName();
+    return /* @__PURE__ */ jsxs15("div", { className: "onboarding-screen welcome-back", children: [
+      /* @__PURE__ */ jsx17("h1", { children: "Welcome back!" }),
+      /* @__PURE__ */ jsxs15("p", { className: "subtitle", children: [
+        "We found your xNet identity. Use ",
+        authName,
+        " to sign in."
+      ] }),
+      /* @__PURE__ */ jsxs15("button", { className: "primary-button", onClick: () => send({ type: "AUTHENTICATE" }), children: [
+        "Sign in with ",
+        authName
+      ] }),
+      /* @__PURE__ */ jsx17("button", { className: "text-button", onClick: () => send({ type: "CREATE_NEW" }), children: "Create a new identity instead" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx17(WelcomeScreen, {});
+}
+
+// src/onboarding/screens/SyncProgressOverlay.tsx
+import { useEffect as useEffect26 } from "react";
+import { Fragment as Fragment2, jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function SyncProgressOverlay({
+  progress,
+  onComplete
+}) {
+  useEffect26(() => {
+    if (progress.phase === "complete") {
+      const timer = setTimeout(onComplete, 1500);
+      return () => clearTimeout(timer);
+    }
+  }, [progress.phase, onComplete]);
+  return /* @__PURE__ */ jsx18("div", { className: "sync-progress-overlay", children: /* @__PURE__ */ jsxs16("div", { className: "sync-card", children: [
+    progress.phase === "connecting" && /* @__PURE__ */ jsxs16(Fragment2, { children: [
+      /* @__PURE__ */ jsx18("h2", { children: "Connecting to server..." }),
+      /* @__PURE__ */ jsx18("p", { className: "spinner-text", children: "Please wait" })
+    ] }),
+    progress.phase === "syncing" && /* @__PURE__ */ jsxs16(Fragment2, { children: [
+      /* @__PURE__ */ jsx18("h2", { children: "Syncing your data" }),
+      /* @__PURE__ */ jsx18("div", { className: "progress-bar", children: /* @__PURE__ */ jsx18(
+        "div",
+        {
+          className: "progress-fill",
+          style: {
+            width: `${progress.roomsSynced / Math.max(progress.roomsTotal, 1) * 100}%`
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsxs16("p", { className: "progress-text", children: [
+        progress.roomsSynced,
+        " of ",
+        progress.roomsTotal,
+        " items"
+      ] }),
+      /* @__PURE__ */ jsxs16("p", { className: "bytes-text", children: [
+        formatBytes2(progress.bytesReceived),
+        " received"
+      ] })
+    ] }),
+    progress.phase === "complete" && /* @__PURE__ */ jsxs16(Fragment2, { children: [
+      /* @__PURE__ */ jsx18("h2", { children: "All synced!" }),
+      /* @__PURE__ */ jsxs16("p", { children: [
+        progress.roomsTotal,
+        " items synchronized"
+      ] })
+    ] }),
+    progress.phase === "error" && /* @__PURE__ */ jsxs16(Fragment2, { children: [
+      /* @__PURE__ */ jsx18("h2", { children: "Sync issue" }),
+      /* @__PURE__ */ jsx18("p", { children: "Some data may not be up to date." }),
+      progress.error && /* @__PURE__ */ jsx18("p", { className: "error-detail", children: progress.error.message }),
+      /* @__PURE__ */ jsx18("button", { className: "primary-button", onClick: onComplete, children: "Continue anyway" })
+    ] })
+  ] }) });
+}
+
+// src/onboarding/templates.ts
+var QUICK_START_TEMPLATES = [
+  {
+    id: "blank-page",
+    name: "Blank Page",
+    description: "Start from scratch",
+    icon: "file"
+  },
+  {
+    id: "meeting-notes",
+    name: "Meeting Notes",
+    description: "Template for taking meeting notes",
+    icon: "users"
+  },
+  {
+    id: "project-tracker",
+    name: "Project Tracker",
+    description: "Database for tracking tasks",
+    icon: "kanban"
+  },
+  {
+    id: "canvas",
+    name: "Whiteboard",
+    description: "Infinite canvas for visual thinking",
+    icon: "pen-tool"
+  }
+];
+
+// src/sync/InitialSyncManager.ts
+function createInitialSyncManager() {
+  let progress = {
+    phase: "connecting",
+    roomsTotal: 0,
+    roomsSynced: 0,
+    bytesReceived: 0
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let syncedRoomIds = /* @__PURE__ */ new Set();
+  function notify() {
+    const snapshot = { ...progress };
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  }
+  return {
+    onProgress(listener) {
+      listeners.add(listener);
+      listener({ ...progress });
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    handleMessage(msg) {
+      switch (msg.type) {
+        case "initial-sync":
+          progress.phase = "syncing";
+          if (msg.update) {
+            progress.bytesReceived += msg.update.byteLength;
+          }
+          if (msg.room) {
+            syncedRoomIds.add(msg.room);
+            progress.roomsSynced = syncedRoomIds.size;
+          }
+          if (msg.roomCount != null) {
+            progress.roomsTotal = msg.roomCount;
+          }
+          notify();
+          break;
+        case "node-changes":
+          if (msg.changes) {
+            progress.bytesReceived += JSON.stringify(msg.changes).length;
+          }
+          notify();
+          break;
+        case "initial-sync-complete":
+          progress.phase = "complete";
+          progress.roomsTotal = msg.roomCount ?? syncedRoomIds.size;
+          progress.roomsSynced = syncedRoomIds.size;
+          notify();
+          break;
+      }
+    },
+    getProgress() {
+      return { ...progress };
+    },
+    start() {
+      syncedRoomIds = /* @__PURE__ */ new Set();
+      progress = {
+        phase: "connecting",
+        roomsTotal: 0,
+        roomsSynced: 0,
+        bytesReceived: 0
+      };
+      notify();
+    },
+    setError(error) {
+      progress.phase = "error";
+      progress.error = error;
+      notify();
+    },
+    reset() {
+      syncedRoomIds = /* @__PURE__ */ new Set();
+      progress = {
+        phase: "connecting",
+        roomsTotal: 0,
+        roomsSynced: 0,
+        bytesReceived: 0
+      };
+      listeners.clear();
+    }
+  };
+}
+
+// src/hooks/useSecurity.ts
+import {
+  hybridSign,
+  hybridVerify
+} from "@xnetjs/crypto";
+import { parseDID } from "@xnetjs/identity";
+import { useCallback as useCallback21, useMemo as useMemo13 } from "react";
+function useSecurity(options = {}) {
+  const context = useSecurityContext();
+  const effectiveLevel = options.level ?? context.level;
+  const hasPQKeys = useMemo13(
+    () => context.keyBundle?.pqSigningKey !== void 0,
+    [context.keyBundle]
+  );
+  const hasKeyBundle = useMemo13(() => context.keyBundle !== void 0, [context.keyBundle]);
+  const maxLevel = useMemo13(() => hasPQKeys ? 2 : 0, [hasPQKeys]);
+  const canSignAt = useCallback21(
+    (level) => {
+      if (!context.keyBundle) return false;
+      if (level === 0) return true;
+      return hasPQKeys;
+    },
+    [context.keyBundle, hasPQKeys]
+  );
+  const sign = useCallback21(
+    (data) => {
+      if (!context.keyBundle) {
+        throw new Error(
+          "No key bundle available. Ensure keyBundle is provided to SecurityProvider."
+        );
+      }
+      if (!canSignAt(effectiveLevel)) {
+        throw new Error(
+          `Cannot sign at Level ${effectiveLevel}: PQ keys required. Current key bundle only supports Level 0.`
+        );
+      }
+      return hybridSign(
+        data,
+        {
+          ed25519: context.keyBundle.signingKey,
+          mlDsa: context.keyBundle.pqSigningKey
+        },
+        effectiveLevel
+      );
+    },
+    [context.keyBundle, effectiveLevel, canSignAt]
+  );
+  const verify = useCallback21(
+    async (data, signature, did) => {
+      const ed25519PublicKey = parseDID(did);
+      const pqPublicKey = await context.registry.lookup(did);
+      return hybridVerify(
+        data,
+        signature,
+        {
+          ed25519: ed25519PublicKey,
+          mlDsa: pqPublicKey ?? void 0
+        },
+        {
+          minLevel: context.minVerificationLevel,
+          policy: context.verificationPolicy
+        }
+      );
+    },
+    [context.registry, context.minVerificationLevel, context.verificationPolicy]
+  );
+  return {
+    level: effectiveLevel,
+    hasPQKeys,
+    maxLevel,
+    sign,
+    verify,
+    setLevel: context.setLevel,
+    canSignAt,
+    hasKeyBundle
+  };
+}
+export {
+  AuthErrorScreen,
+  AuthenticatingScreen,
+  DemoBanner,
+  DemoDataExpiredScreen,
+  DemoQuotaIndicator,
+  ErrorBoundary,
+  HubConnectScreen,
+  HubStatusIndicator,
+  ImportIdentityScreen,
+  InstrumentationContext,
+  METABRIDGE_ORIGIN,
+  METABRIDGE_SEED_ORIGIN,
+  NodeStoreSyncProvider,
+  OfflineIndicator,
+  OnboardingFlow,
+  OnboardingProvider,
+  PluginRegistryContext,
+  QUICK_START_TEMPLATES,
+  ReadyScreen,
+  SecurityProvider,
+  Skeleton,
+  SmartWelcome,
+  SyncProgressOverlay,
+  TelemetryContext,
+  UnsupportedBrowserScreen,
+  WebSocketSyncProvider,
+  WelcomeScreen,
+  XNetProvider,
+  copyToClipboard,
+  createConnectionManager,
+  createInitialState,
+  createInitialSyncManager,
+  createMetaBridge,
+  createNodePool,
+  createOfflineQueue,
+  createRegistry,
+  createSyncManager,
+  flattenNode,
+  flattenNodes,
+  flattenNodesWithSchemaCheck,
+  flattenUnknownSchemaNode,
+  getPlatformAuthName,
+  injectSkeletonStyles,
+  onboardingReducer,
+  truncateDid,
+  useAudit,
+  useBackup,
+  useBlame,
+  useCan,
+  useCanEdit,
+  useCell,
+  useCommand,
+  useCommands,
+  useCommentCount,
+  useCommentCounts,
+  useComments,
+  useContributions,
+  useDatabase,
+  useDatabaseDoc,
+  useDatabaseRow,
+  useDatabaseSchema,
+  useDemoMode,
+  useDiff,
+  useEditorExtensions,
+  useEditorExtensionsSafe,
+  useFileUpload,
+  useGrants,
+  useHistory,
+  useHubSearch,
+  useHubStatus,
+  useIdentity,
+  useInstrumentation,
+  useIsOffline,
+  useMutate,
+  useNode,
+  useOnboarding,
+  usePeerDiscovery,
+  usePluginRegistry,
+  usePluginRegistryOptional,
+  usePlugins,
+  useQuery,
+  useRelatedRows,
+  useRemoteSchema,
+  useReverseRelations,
+  useSecurity,
+  useSecurityContext,
+  useSecurityContextOptional,
+  useSidebarItems,
+  useSlashCommands,
+  useSyncManager,
+  useTelemetryReporter,
+  useUndo,
+  useVerification,
+  useView,
+  useViews,
+  useXNet
+};