@xnetjs/react 0.0.2 → 0.0.3

package/dist/chunk-IHTMVTTE.js

@@ -0,0 +1,1108 @@
+// src/context/security-context.tsx
+import { DEFAULT_SECURITY_LEVEL } from "@xnetjs/crypto";
+import { MemoryPQKeyRegistry } from "@xnetjs/identity";
+import { createContext, useContext, useState, useMemo, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+var SecurityContext = createContext(null);
+function SecurityProvider({
+  children,
+  level: initialLevel = DEFAULT_SECURITY_LEVEL,
+  minVerificationLevel: initialMinLevel = 0,
+  verificationPolicy: initialPolicy = "strict",
+  registry: providedRegistry,
+  keyBundle: initialBundle
+}) {
+  const [level, setLevel] = useState(initialLevel);
+  const [minVerificationLevel, setMinVerificationLevel] = useState(initialMinLevel);
+  const [verificationPolicy, setVerificationPolicy] = useState(
+    initialPolicy
+  );
+  const [keyBundle, setKeyBundle] = useState(initialBundle);
+  useEffect(() => {
+    setLevel(initialLevel);
+  }, [initialLevel]);
+  useEffect(() => {
+    setMinVerificationLevel(initialMinLevel);
+  }, [initialMinLevel]);
+  useEffect(() => {
+    setVerificationPolicy(initialPolicy);
+  }, [initialPolicy]);
+  useEffect(() => {
+    setKeyBundle(initialBundle);
+  }, [initialBundle]);
+  const registry = useMemo(() => providedRegistry ?? new MemoryPQKeyRegistry(), [providedRegistry]);
+  const value = useMemo(
+    () => ({
+      level,
+      minVerificationLevel,
+      verificationPolicy,
+      registry,
+      keyBundle,
+      setLevel,
+      setMinVerificationLevel,
+      setVerificationPolicy,
+      setKeyBundle
+    }),
+    [level, minVerificationLevel, verificationPolicy, registry, keyBundle]
+  );
+  return /* @__PURE__ */ jsx(SecurityContext.Provider, { value, children });
+}
+function useSecurityContext() {
+  const context = useContext(SecurityContext);
+  if (!context) {
+    throw new Error("useSecurityContext must be used within SecurityProvider");
+  }
+  return context;
+}
+function useSecurityContextOptional() {
+  return useContext(SecurityContext);
+}
+
+// src/context/telemetry-context.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var TelemetryContext = createContext2(null);
+function useTelemetryReporter() {
+  return useContext2(TelemetryContext);
+}
+
+// src/context/tracing-context.ts
+import { createContext as createContext3, useContext as useContext3 } from "react";
+var TRACE_STAGES = {
+  queryDescriptor: "data.query.descriptor",
+  queryBridge: "data.query.bridge",
+  queryFlatten: "data.query.flatten",
+  queryCommit: "data.query.commit",
+  mutateBridge: "data.mutate.bridge"
+};
+var TracingContext = createContext3(null);
+function useTracingReporter() {
+  return useContext3(TracingContext);
+}
+
+// src/hooks/usePlugins.ts
+import { createContext as createContext4, useContext as useContext4, useState as useState2, useEffect as useEffect2 } from "react";
+var PluginRegistryContext = createContext4(null);
+function usePluginRegistry() {
+  const registry = useContext4(PluginRegistryContext);
+  if (!registry) {
+    throw new Error(
+      "usePluginRegistry must be used within XNetProvider with plugins enabled. Ensure XNetProvider has platform: 'electron' or platform: 'web' in its config."
+    );
+  }
+  return registry;
+}
+function usePluginRegistryOptional() {
+  return useContext4(PluginRegistryContext);
+}
+function usePlugins() {
+  const registry = usePluginRegistry();
+  const [plugins, setPlugins] = useState2(() => registry.getAll());
+  useEffect2(() => {
+    setPlugins(registry.getAll());
+    const disposable = registry.onChange(() => {
+      setPlugins(registry.getAll());
+    });
+    return () => disposable.dispose();
+  }, [registry]);
+  return plugins;
+}
+function getTypedRegistry(contributions, type) {
+  switch (type) {
+    case "views":
+      return contributions.views;
+    case "commands":
+      return contributions.commands;
+    case "slashCommands":
+      return contributions.slashCommands;
+    case "sidebar":
+      return contributions.sidebar;
+    case "editor":
+      return contributions.editor;
+    case "propertyHandlers":
+      return contributions.propertyHandlers;
+    case "blocks":
+      return contributions.blocks;
+    case "settings":
+      return contributions.settings;
+    case "importers":
+      return contributions.importers;
+    default:
+      throw new Error(`Unknown contribution type: ${type}`);
+  }
+}
+function useContributions(type) {
+  const registry = usePluginRegistry();
+  const contributions = registry.getContributions();
+  const typedRegistry = getTypedRegistry(contributions, type);
+  const [items, setItems] = useState2(() => typedRegistry.getAll());
+  useEffect2(() => {
+    setItems(typedRegistry.getAll());
+    const unsubscribe = typedRegistry.onChange(() => {
+      setItems(typedRegistry.getAll());
+    });
+    return unsubscribe;
+  }, [typedRegistry]);
+  return items;
+}
+function useViews() {
+  return useContributions("views");
+}
+function useCommands() {
+  return useContributions("commands");
+}
+function useSlashCommands() {
+  return useContributions("slashCommands");
+}
+function useSidebarItems() {
+  return useContributions("sidebar");
+}
+function useImporters() {
+  return useContributions("importers");
+}
+function useEditorExtensions() {
+  return useContributions("editor");
+}
+function useEditorExtensionsSafe() {
+  const registry = usePluginRegistryOptional();
+  const [items, setItems] = useState2([]);
+  useEffect2(() => {
+    if (!registry) {
+      setItems([]);
+      return;
+    }
+    const contributions = registry.getContributions();
+    const typedRegistry = contributions.editor;
+    setItems(typedRegistry.getAll());
+    const unsubscribe = typedRegistry.onChange(() => {
+      setItems(typedRegistry.getAll());
+    });
+    return unsubscribe;
+  }, [registry]);
+  return items;
+}
+function useView(type) {
+  const views = useViews();
+  return views.find((v) => v.type === type);
+}
+function useCommand(id) {
+  const commands = useCommands();
+  return commands.find((c) => c.id === id);
+}
+
+// src/runtime.ts
+var DEFAULT_RUNTIME_BY_PLATFORM = {
+  web: {
+    mode: "worker",
+    fallback: "main-thread",
+    diagnostics: false
+  },
+  electron: {
+    mode: "ipc",
+    fallback: "error",
+    diagnostics: false
+  },
+  mobile: {
+    mode: "main-thread",
+    fallback: "main-thread",
+    diagnostics: false
+  }
+};
+function resolveRuntimeConfig(runtime, platform) {
+  const base = DEFAULT_RUNTIME_BY_PLATFORM[platform];
+  return {
+    ...base,
+    ...runtime,
+    worker: runtime?.worker ? { ...runtime.worker } : void 0
+  };
+}
+function createRuntimeStatus(runtime, overrides = {}) {
+  return {
+    requestedMode: overrides.requestedMode ?? runtime.mode,
+    activeMode: overrides.activeMode ?? null,
+    fallbackMode: overrides.fallbackMode ?? null,
+    usedFallback: overrides.usedFallback ?? false,
+    phase: overrides.phase ?? "initializing",
+    reason: overrides.reason ?? null
+  };
+}
+
+// src/context.ts
+import { MemoryNodeStorageAdapter, NodeStore } from "@xnetjs/data";
+import {
+  createDataBridge,
+  createMainThreadBridge,
+  MainThreadBridge,
+  WorkerBridge
+} from "@xnetjs/data-bridge";
+import { UndoManager } from "@xnetjs/history";
+import { createUCAN } from "@xnetjs/identity";
+import { PluginRegistry } from "@xnetjs/plugins";
+import React, {
+  createContext as createContext5,
+  useCallback,
+  useContext as useContext5,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState3
+} from "react";
+
+// src/hub/auto-backup.ts
+import * as Y from "yjs";
+var AutoBackup = class {
+  constructor(upload, options) {
+    this.upload = upload;
+    this.debounceMs = options?.debounceMs ?? 5e3;
+    this.isEnabled = options?.isEnabled ?? (() => true);
+  }
+  timers = /* @__PURE__ */ new Map();
+  debounceMs;
+  isEnabled;
+  handleDocUpdate(docId, doc) {
+    this.scheduleBackup(docId, doc, this.debounceMs);
+  }
+  handleDocEvict(docId, doc) {
+    this.scheduleBackup(docId, doc, 0);
+  }
+  scheduleBackup(docId, doc, delay) {
+    const existing = this.timers.get(docId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const run = async () => {
+      this.timers.delete(docId);
+      if (!this.isEnabled()) return;
+      try {
+        const state = Y.encodeStateAsUpdate(doc);
+        await this.upload(docId, state);
+      } catch (err) {
+        console.warn(`[auto-backup] Failed for ${docId}:`, err);
+      }
+    };
+    if (delay <= 0) {
+      void run();
+      return;
+    }
+    this.timers.set(
+      docId,
+      setTimeout(() => void run(), delay)
+    );
+  }
+  async flush() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+  }
+  destroy() {
+    void this.flush();
+  }
+};
+
+// src/hub/backup.ts
+import { concatBytes, decrypt, encrypt, NONCE_SIZE } from "@xnetjs/crypto";
+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;
+  }
+};
+var encodeEncrypted = (encrypted) => concatBytes(encrypted.nonce, encrypted.ciphertext);
+var decodeEncrypted = (payload) => {
+  const nonce = payload.slice(0, NONCE_SIZE);
+  const ciphertext = payload.slice(NONCE_SIZE);
+  return { nonce, ciphertext };
+};
+var resolveFetch = (fetchFn) => {
+  if (fetchFn) return fetchFn;
+  if (typeof fetch === "undefined") {
+    throw new Error("fetch is not available in this environment");
+  }
+  return fetch;
+};
+var buildAuthHeader = async (getAuthToken) => {
+  if (!getAuthToken) return null;
+  const token = await getAuthToken();
+  if (!token) return null;
+  return `Bearer ${token}`;
+};
+async function uploadBackup(config, docId, plaintext) {
+  const encrypted = encrypt(plaintext, config.encryptionKey);
+  const payload = encodeEncrypted(encrypted);
+  return uploadEncryptedBackup(config, docId, payload);
+}
+async function uploadEncryptedBackup(config, docId, payload) {
+  const httpUrl = toHttpUrl(config.hubUrl);
+  const fetcher = resolveFetch(config.fetchFn);
+  const authHeader = await buildAuthHeader(config.getAuthToken);
+  const res = await fetcher(`${httpUrl}/backup/${encodeURIComponent(docId)}`, {
+    method: "PUT",
+    headers: {
+      ...authHeader ? { Authorization: authHeader } : {},
+      "Content-Type": "application/octet-stream"
+    },
+    body: payload
+  });
+  if (!res.ok) {
+    throw new Error(`Backup upload failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function downloadBackup(config, docId) {
+  const payload = await downloadEncryptedBackup(config, docId);
+  if (!payload) return null;
+  const encrypted = decodeEncrypted(payload);
+  return decrypt(encrypted, config.encryptionKey);
+}
+async function downloadEncryptedBackup(config, docId) {
+  const httpUrl = toHttpUrl(config.hubUrl);
+  const fetcher = resolveFetch(config.fetchFn);
+  const authHeader = await buildAuthHeader(config.getAuthToken);
+  const res = await fetcher(`${httpUrl}/backup/${encodeURIComponent(docId)}`, {
+    headers: authHeader ? { Authorization: authHeader } : void 0
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    throw new Error(`Backup download failed: ${res.status} ${res.statusText}`);
+  }
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+// src/context.ts
+import { createSyncManager } from "@xnetjs/runtime";
+function log(...args) {
+  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
+    console.log("[XNetProvider]", ...args);
+  }
+}
+function scheduleIdle(fn) {
+  if (typeof window === "undefined") return;
+  const ric = window.requestIdleCallback;
+  if (typeof ric === "function") ric(fn);
+  else setTimeout(fn, 1e3);
+}
+function resolveConfiguredSignalingUrls(hubUrl, signalingServers) {
+  const seen = /* @__PURE__ */ new Set();
+  const configured = hubUrl ? [hubUrl, ...signalingServers ?? []] : signalingServers ?? [];
+  const urls = configured.map((url) => url.trim()).filter((url) => {
+    if (!url || seen.has(url)) return false;
+    seen.add(url);
+    return true;
+  });
+  return urls;
+}
+var HUB_CAPABILITIES = [
+  { with: "*", can: "hub/*" },
+  { with: "*", can: "backup/*" },
+  { with: "*", can: "files/*" },
+  { with: "*", can: "query/*" },
+  { with: "*", can: "index/*" }
+];
+var HUB_TOKEN_TTL_SECONDS = 60 * 60 * 24;
+var HUB_INDEX_DEBOUNCE_MS = 2e3;
+function getRuntimeErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function inferBridgeMode(bridge) {
+  if (bridge instanceof WorkerBridge) return "worker";
+  if (bridge instanceof MainThreadBridge) return "main-thread";
+  return null;
+}
+function reportRuntimeStatus(telemetry, status) {
+  telemetry?.reportUsage(`react.runtime.request.${status.requestedMode}`, 1);
+  if (status.activeMode) {
+    telemetry?.reportUsage(`react.runtime.active.${status.activeMode}`, 1);
+  }
+  if (status.usedFallback && status.fallbackMode) {
+    telemetry?.reportUsage(`react.runtime.fallback.${status.fallbackMode}`, 1);
+  }
+}
+function logRuntimeStatus(runtime, status) {
+  if (!runtime.diagnostics) return;
+  if (status.phase === "error") {
+    console.error("[XNetProvider] Runtime initialization failed:", status);
+    return;
+  }
+  if (status.usedFallback) {
+    console.warn("[XNetProvider] Runtime fallback activated:", status);
+    return;
+  }
+  console.info("[XNetProvider] Runtime ready:", status);
+}
+async function resolveTagSearchText(store, tagIds) {
+  const names = await Promise.all(
+    tagIds.map(async (id) => {
+      const tag = await store.get(id).catch(() => null);
+      const name = tag?.properties?.name;
+      return typeof name === "string" && name ? `#${name}` : null;
+    })
+  );
+  const present = names.filter((entry) => entry !== null);
+  return present.length > 0 ? present.join(" ") : void 0;
+}
+function resolveRuntimeFailure(runtime, nodeStore, reason, bridgeOptions) {
+  if (runtime.fallback === "main-thread") {
+    return {
+      bridge: createMainThreadBridge(nodeStore, bridgeOptions),
+      createdInternally: true,
+      status: createRuntimeStatus(runtime, {
+        activeMode: "main-thread",
+        fallbackMode: "main-thread",
+        usedFallback: true,
+        phase: "ready",
+        reason
+      })
+    };
+  }
+  return {
+    bridge: null,
+    createdInternally: false,
+    status: createRuntimeStatus(runtime, {
+      phase: "error",
+      reason
+    })
+  };
+}
+async function resolveRuntimeBridge(input) {
+  const {
+    runtime,
+    nodeStore,
+    authorDID,
+    signingKey,
+    signalingUrl,
+    dataBridge,
+    remoteNodeQueryClient,
+    remoteNodeQueryRouting,
+    syncManager
+  } = input;
+  if (runtime.mode === "ipc") {
+    if (!syncManager) {
+      return resolveRuntimeFailure(
+        runtime,
+        nodeStore,
+        "IPC runtime requires config.syncManager to be provided explicitly.",
+        { remoteNodeQueryClient, remoteNodeQueryRouting }
+      );
+    }
+    return {
+      bridge: dataBridge ?? createMainThreadBridge(nodeStore, {
+        remoteNodeQueryClient,
+        remoteNodeQueryRouting
+      }),
+      createdInternally: !dataBridge,
+      status: createRuntimeStatus(runtime, {
+        activeMode: "ipc",
+        phase: "ready"
+      })
+    };
+  }
+  if (dataBridge) {
+    const activeMode = inferBridgeMode(dataBridge) ?? runtime.mode;
+    const usedFallback = activeMode !== runtime.mode;
+    return {
+      bridge: dataBridge,
+      createdInternally: false,
+      status: createRuntimeStatus(runtime, {
+        activeMode,
+        fallbackMode: usedFallback ? activeMode : null,
+        usedFallback,
+        phase: "ready",
+        reason: usedFallback ? `Configured runtime "${runtime.mode}" resolved to "${activeMode}" through the supplied dataBridge.` : null
+      })
+    };
+  }
+  if (runtime.mode === "worker") {
+    try {
+      const bridge2 = await createDataBridge({
+        nodeStore,
+        config: {
+          dbName: runtime.worker?.dbName,
+          authorDID,
+          signingKey,
+          signalingUrl: runtime.worker?.signalingUrl ?? signalingUrl,
+          storagePort: runtime.worker?.storagePort,
+          remoteNodeQueryClient,
+          remoteNodeQueryRouting
+        },
+        workerUrl: runtime.worker?.url,
+        mode: "worker"
+      });
+      return {
+        bridge: bridge2,
+        createdInternally: true,
+        status: createRuntimeStatus(runtime, {
+          activeMode: "worker",
+          phase: "ready"
+        })
+      };
+    } catch (err) {
+      return resolveRuntimeFailure(
+        runtime,
+        nodeStore,
+        `Worker runtime unavailable: ${getRuntimeErrorMessage(err)}`,
+        { remoteNodeQueryClient, remoteNodeQueryRouting }
+      );
+    }
+  }
+  const bridge = await createDataBridge({
+    nodeStore,
+    config: {
+      authorDID,
+      signingKey,
+      signalingUrl,
+      remoteNodeQueryClient,
+      remoteNodeQueryRouting
+    },
+    mode: "main-thread"
+  });
+  return {
+    bridge,
+    createdInternally: true,
+    status: createRuntimeStatus(runtime, {
+      activeMode: "main-thread",
+      phase: "ready"
+    })
+  };
+}
+var XNetContext = createContext5(null);
+var XNetInternalContext = createContext5({
+  authorDID: null,
+  signingKey: null,
+  sync: void 0
+});
+var DataBridgeContext = createContext5(null);
+function useDataBridge() {
+  return useContext5(DataBridgeContext);
+}
+function XNetProvider({ config, children }) {
+  const [nodeStore, setNodeStore] = useState3(null);
+  const [nodeStoreReady, setNodeStoreReady] = useState3(false);
+  const [undoManager, setUndoManager] = useState3(null);
+  const [dataBridge, setDataBridge] = useState3(null);
+  const [syncManager, setSyncManager] = useState3(null);
+  const [hubStatus, setHubStatus] = useState3("disconnected");
+  const [pluginRegistry, setPluginRegistry] = useState3(null);
+  const nodeStorageRef = useRef(null);
+  const platform = config.platform ?? "web";
+  const authorDID = config.authorDID ?? config.identity?.did;
+  const hubUrl = config.hubUrl ?? null;
+  const signalingServersKey = (config.signalingServers ?? []).join("\n");
+  const signalingServers = useMemo2(
+    () => signalingServersKey ? signalingServersKey.split("\n") : [],
+    [signalingServersKey]
+  );
+  const signalingUrls = useMemo2(
+    () => resolveConfiguredSignalingUrls(hubUrl, signalingServers),
+    [hubUrl, signalingServers]
+  );
+  const hubOptions = config.hubOptions;
+  const autoAuth = hubOptions?.autoAuth ?? true;
+  const staticHubAuthToken = hubOptions?.authToken?.trim() ?? "";
+  const autoBackup = hubOptions?.autoBackup ?? false;
+  const backupDebounceMs = hubOptions?.backupDebounceMs ?? 5e3;
+  const enableSearchIndex = hubOptions?.enableSearchIndex ?? false;
+  const nodeSyncRoom = hubOptions?.nodeSyncRoom ?? authorDID ?? "default";
+  const encryptionKey = config.encryptionKey ?? null;
+  const runtimeWorkerUrlKey = config.runtime?.worker?.url ? String(config.runtime.worker.url) : "";
+  const runtimeConfig = useMemo2(
+    () => resolveRuntimeConfig(config.runtime, platform),
+    [
+      config.runtime?.mode,
+      config.runtime?.fallback,
+      config.runtime?.diagnostics,
+      config.runtime?.worker?.dbName,
+      config.runtime?.worker?.signalingUrl,
+      runtimeWorkerUrlKey,
+      platform
+    ]
+  );
+  const [runtimeStatus, setRuntimeStatus] = useState3(
+    () => createRuntimeStatus(runtimeConfig)
+  );
+  const getHubAuthToken = useCallback(async () => {
+    if (staticHubAuthToken) return staticHubAuthToken;
+    if (!hubUrl || !autoAuth) return "";
+    if (!authorDID || !config.signingKey) {
+      throw new Error("Missing authorDID/signingKey for hub auth");
+    }
+    return createUCAN({
+      issuer: authorDID,
+      issuerKey: config.signingKey,
+      audience: hubUrl,
+      capabilities: HUB_CAPABILITIES,
+      expiration: Math.floor(Date.now() / 1e3) + HUB_TOKEN_TTL_SECONDS
+    });
+  }, [authorDID, autoAuth, config.signingKey, hubUrl, staticHubAuthToken]);
+  useEffect3(() => {
+    const nodeStorageAdapter = config.nodeStorage ?? new MemoryNodeStorageAdapter();
+    nodeStorageRef.current = nodeStorageAdapter;
+    const signingKey = config.signingKey;
+    setRuntimeStatus(createRuntimeStatus(runtimeConfig));
+    if (!authorDID || !signingKey) {
+      console.warn(
+        "XNetProvider: authorDID and signingKey not provided. NodeStore will not be initialized. Provide these via config.authorDID/config.signingKey or config.identity."
+      );
+      setRuntimeStatus(
+        createRuntimeStatus(runtimeConfig, {
+          phase: "error",
+          reason: "authorDID and signingKey are required to initialize the runtime."
+        })
+      );
+      return;
+    }
+    let cancelled = false;
+    const initializeNodeStore = async () => {
+      if ("open" in nodeStorageAdapter && typeof nodeStorageAdapter.open === "function") {
+        await nodeStorageAdapter.open();
+      }
+      if (cancelled) return;
+      const ns = new NodeStore({
+        storage: nodeStorageAdapter,
+        authorDID,
+        signingKey
+      });
+      await ns.initialize();
+      if (cancelled) return;
+      const resolvedRuntime = await resolveRuntimeBridge({
+        runtime: runtimeConfig,
+        nodeStore: ns,
+        authorDID,
+        signingKey,
+        signalingUrl: signalingUrls[0],
+        dataBridge: config.dataBridge,
+        remoteNodeQueryClient: config.remoteNodeQueryClient,
+        remoteNodeQueryRouting: config.remoteNodeQueryRouting,
+        syncManager: config.syncManager
+      });
+      if (cancelled) {
+        if (resolvedRuntime.createdInternally && resolvedRuntime.bridge) {
+          resolvedRuntime.bridge.destroy();
+        }
+        return;
+      }
+      setRuntimeStatus(resolvedRuntime.status);
+      reportRuntimeStatus(config.telemetry, resolvedRuntime.status);
+      logRuntimeStatus(runtimeConfig, resolvedRuntime.status);
+      if (resolvedRuntime.status.phase !== "ready" || !resolvedRuntime.bridge) {
+        config.telemetry?.reportCrash(
+          new Error(resolvedRuntime.status.reason ?? "Runtime failed"),
+          {
+            codeNamespace: "react.runtime.initialize",
+            requestedMode: resolvedRuntime.status.requestedMode
+          }
+        );
+        setNodeStore(null);
+        setNodeStoreReady(false);
+        setDataBridge(null);
+        bridgeRef = null;
+        return;
+      }
+      setNodeStore(ns);
+      setNodeStoreReady(true);
+      setDataBridge(resolvedRuntime.bridge);
+      bridgeRef = resolvedRuntime.createdInternally ? resolvedRuntime.bridge : null;
+      if (typeof window !== "undefined") {
+        const win = window;
+        win.__xnetNodeStore = ns;
+      }
+      scheduleIdle(() => {
+        if (!cancelled) void ns.optimize();
+      });
+    };
+    let bridgeRef = null;
+    initializeNodeStore();
+    return () => {
+      cancelled = true;
+      if (bridgeRef) {
+        bridgeRef.destroy();
+      }
+      setDataBridge(null);
+      setNodeStore(null);
+      setNodeStoreReady(false);
+      if (typeof window !== "undefined") {
+        delete window.__xnetNodeStore;
+      }
+      if ("close" in nodeStorageAdapter && typeof nodeStorageAdapter.close === "function") {
+        nodeStorageAdapter.close();
+      }
+    };
+  }, [
+    authorDID,
+    config.nodeStorage,
+    config.signingKey,
+    config.dataBridge,
+    signalingUrls,
+    config.syncManager,
+    config.remoteNodeQueryClient,
+    config.remoteNodeQueryRouting,
+    config.telemetry,
+    hubUrl,
+    runtimeConfig,
+    runtimeWorkerUrlKey
+  ]);
+  useEffect3(() => {
+    if (config.syncManager) {
+      setSyncManager(config.syncManager);
+      const sm2 = config.syncManager;
+      if (sm2.setIdentity && authorDID && config.signingKey) {
+        sm2.setIdentity(authorDID, config.signingKey);
+      }
+      if (sm2.configureReplication) {
+        sm2.configureReplication(config.sync);
+      }
+      config.syncManager.start().catch((err) => {
+        console.warn("[XNetProvider] External SyncManager failed to start:", err);
+      });
+      return () => {
+        config.syncManager.stop().catch((err) => {
+          console.warn("[XNetProvider] External SyncManager failed to stop:", err);
+        });
+        setSyncManager(null);
+      };
+    }
+    if (!nodeStore || !nodeStoreReady || config.disableSyncManager) {
+      log("SyncManager disabled or NodeStore not ready", {
+        nodeStore: !!nodeStore,
+        nodeStoreReady,
+        disableSyncManager: config.disableSyncManager
+      });
+      setSyncManager(null);
+      return;
+    }
+    const storage = nodeStorageRef.current;
+    if (!storage) {
+      log("No storage adapter available");
+      return;
+    }
+    const signalingUrl = signalingUrls[0] ?? "";
+    if (autoAuth && hubUrl && (!authorDID || !config.signingKey)) {
+      console.warn("[XNetProvider] Hub auth enabled but authorDID/signingKey missing");
+    }
+    if (autoBackup && (!hubUrl || !encryptionKey)) {
+      console.warn("[XNetProvider] Auto-backup requires hubUrl and encryptionKey");
+    }
+    console.log("[XNetProvider] Creating SyncManager with signalingUrls:", signalingUrls);
+    log("Creating SyncManager with signalingUrls:", signalingUrls);
+    let autoBackupManager = null;
+    const enableAutoBackup = Boolean(autoBackup && hubUrl && encryptionKey);
+    const sm = createSyncManager({
+      nodeStore,
+      storage,
+      signalingUrl,
+      signalingUrls,
+      authorDID,
+      signingKey: config.signingKey,
+      replication: config.sync,
+      blobStore: config.blobStore,
+      nodeSyncRoom: hubUrl ? nodeSyncRoom : void 0,
+      getUCANToken: hubUrl ? getHubAuthToken : void 0,
+      onDocUpdate: enableAutoBackup ? (nodeId, doc) => {
+        autoBackupManager?.handleDocUpdate(nodeId, doc);
+      } : void 0,
+      onDocEvict: enableAutoBackup ? (nodeId, doc) => {
+        autoBackupManager?.handleDocEvict(nodeId, doc);
+      } : void 0
+    });
+    if (enableAutoBackup && hubUrl && encryptionKey) {
+      autoBackupManager = new AutoBackup(
+        async (docId, plaintext) => {
+          await uploadBackup(
+            {
+              hubUrl,
+              encryptionKey,
+              getAuthToken: autoAuth ? getHubAuthToken : void 0
+            },
+            docId,
+            plaintext
+          );
+        },
+        {
+          debounceMs: backupDebounceMs,
+          isEnabled: () => sm.connection?.status === "connected"
+        }
+      );
+    }
+    setSyncManager(sm);
+    console.log("[XNetProvider] SyncManager created and set in context");
+    log("SyncManager created, starting...");
+    sm.start().then(() => {
+      log("SyncManager started successfully");
+    }).catch((err) => {
+      console.warn("[XNetProvider] SyncManager failed to start:", err);
+      log("SyncManager start failed:", err);
+    });
+    return () => {
+      sm.stop().catch((err) => {
+        console.warn("[XNetProvider] SyncManager failed to stop:", err);
+      });
+      autoBackupManager?.destroy();
+      setSyncManager(null);
+    };
+  }, [
+    nodeStore,
+    nodeStoreReady,
+    config.disableSyncManager,
+    config.syncManager,
+    signalingUrls,
+    config.blobStore,
+    config.sync,
+    authorDID,
+    autoAuth,
+    autoBackup,
+    backupDebounceMs,
+    encryptionKey,
+    getHubAuthToken,
+    hubUrl,
+    nodeSyncRoom
+  ]);
+  useEffect3(() => {
+    if (!dataBridge || !syncManager) return;
+    const bridge = dataBridge;
+    if (typeof bridge.setSyncManager === "function") {
+      bridge.setSyncManager(syncManager);
+      log("Connected SyncManager to DataBridge");
+    }
+    return () => {
+      if (typeof bridge.setSyncManager === "function") {
+        bridge.setSyncManager(null);
+      }
+    };
+  }, [dataBridge, syncManager]);
+  useEffect3(() => {
+    if (!syncManager) {
+      setHubStatus("disconnected");
+      return;
+    }
+    setHubStatus(syncManager.status);
+    return syncManager.on("status", (status) => {
+      setHubStatus(status);
+    });
+  }, [syncManager]);
+  useEffect3(() => {
+    if (!nodeStore || !syncManager || !hubUrl || !enableSearchIndex) return;
+    const connection = syncManager.connection;
+    if (!connection) return;
+    const timers = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Map();
+    const schedule = (docId, payload) => {
+      pending.set(docId, payload);
+      const existing = timers.get(docId);
+      if (existing) clearTimeout(existing);
+      timers.set(
+        docId,
+        setTimeout(() => {
+          timers.delete(docId);
+          const next = pending.get(docId);
+          pending.delete(docId);
+          if (!next) return;
+          if (connection.status !== "connected") return;
+          if (next.type === "remove") {
+            connection.sendRaw({ type: "index-remove", docId });
+            return;
+          }
+          connection.sendRaw({
+            type: "index-update",
+            docId,
+            meta: next.meta,
+            ...next.text !== void 0 ? { text: next.text } : {}
+          });
+        }, HUB_INDEX_DEBOUNCE_MS)
+      );
+    };
+    const handleChange = (event) => {
+      const node = event.node;
+      if (!node || node.deleted) {
+        schedule(event.change.payload.nodeId, { type: "remove" });
+        return;
+      }
+      if (!node.schemaId) return;
+      const title = typeof node.properties.title === "string" ? node.properties.title : typeof node.properties.name === "string" ? node.properties.name : "";
+      const meta = { schemaIri: node.schemaId, title, properties: node.properties };
+      const tagIds = Array.isArray(node.properties.tags) ? node.properties.tags.filter((id) => typeof id === "string") : [];
+      if (tagIds.length === 0) {
+        schedule(node.id, { type: "update", meta });
+        return;
+      }
+      void resolveTagSearchText(nodeStore, tagIds).then((text) => {
+        schedule(node.id, { type: "update", meta, ...text ? { text } : {} });
+      });
+    };
+    const unsubscribe = nodeStore.subscribe(handleChange);
+    return () => {
+      unsubscribe();
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      pending.clear();
+    };
+  }, [enableSearchIndex, hubUrl, nodeStore, syncManager]);
+  useEffect3(() => {
+    if (!nodeStore || !nodeStoreReady || config.disablePlugins) {
+      log("PluginRegistry disabled or NodeStore not ready");
+      setPluginRegistry(null);
+      return;
+    }
+    log("Creating PluginRegistry with platform:", platform);
+    const registry = new PluginRegistry(nodeStore, platform);
+    setPluginRegistry(registry);
+    registry.loadFromStore().catch((err) => {
+      console.warn("[XNetProvider] Failed to load plugins from store:", err);
+    });
+    return () => {
+      const plugins = registry.getAll();
+      for (const plugin of plugins) {
+        if (plugin.status === "active") {
+          registry.deactivate(plugin.manifest.id).catch((err) => {
+            console.warn(`[XNetProvider] Failed to deactivate plugin ${plugin.manifest.id}:`, err);
+          });
+        }
+      }
+      setPluginRegistry(null);
+    };
+  }, [nodeStore, nodeStoreReady, config.disablePlugins, config.platform]);
+  useEffect3(() => {
+    if (!nodeStore || !nodeStoreReady || !authorDID) {
+      setUndoManager(null);
+      return;
+    }
+    const manager = new UndoManager(
+      nodeStore,
+      authorDID,
+      { localOnly: true, maxStackSize: 200 },
+      config.telemetry
+    );
+    manager.start();
+    setUndoManager(manager);
+    return () => {
+      manager.stop();
+      setUndoManager(null);
+    };
+  }, [nodeStore, nodeStoreReady, authorDID, config.telemetry]);
+  const value = useMemo2(
+    () => ({
+      nodeStore,
+      nodeStoreReady,
+      identity: config.identity,
+      authorDID: authorDID ?? null,
+      syncManager,
+      hubUrl,
+      hubStatus,
+      hubConnection: syncManager?.connection ?? null,
+      getHubAuthToken: hubUrl ? getHubAuthToken : void 0,
+      billing: config.billing,
+      encryptionKey,
+      blobStore: config.blobStore ?? null,
+      pluginRegistry,
+      runtimeStatus,
+      undoManager
+    }),
+    [
+      nodeStore,
+      nodeStoreReady,
+      config.identity,
+      authorDID,
+      syncManager,
+      hubUrl,
+      hubStatus,
+      getHubAuthToken,
+      config.billing,
+      encryptionKey,
+      config.blobStore,
+      pluginRegistry,
+      runtimeStatus,
+      undoManager
+    ]
+  );
+  const internalValue = useMemo2(
+    () => ({
+      authorDID: authorDID ?? null,
+      signingKey: config.signingKey ?? null,
+      sync: config.sync
+    }),
+    [authorDID, config.signingKey, config.sync]
+  );
+  let content = React.createElement(
+    PluginRegistryContext.Provider,
+    { value: pluginRegistry },
+    children
+  );
+  content = React.createElement(DataBridgeContext.Provider, { value: dataBridge }, content);
+  content = React.createElement(
+    TelemetryContext.Provider,
+    { value: config.telemetry ?? null },
+    content
+  );
+  content = React.createElement(TracingContext.Provider, { value: config.tracing ?? null }, content);
+  content = React.createElement(SecurityProvider, {
+    level: config.security?.level,
+    minVerificationLevel: config.security?.minVerificationLevel,
+    verificationPolicy: config.security?.verificationPolicy,
+    registry: config.security?.registry,
+    keyBundle: config.keyBundle,
+    children: content
+  });
+  content = React.createElement(XNetInternalContext.Provider, { value: internalValue }, content);
+  return React.createElement(XNetContext.Provider, { value }, content);
+}
+function useXNet() {
+  const context = useContext5(XNetContext);
+  if (!context) {
+    throw new Error("useXNet must be used within an XNetProvider");
+  }
+  return context;
+}
+function useXNetInternal() {
+  return useContext5(XNetInternalContext);
+}
+
+// src/hooks/useNodeStore.ts
+import { useContext as useContext6 } from "react";
+function useNodeStore() {
+  const context = useContext6(XNetContext);
+  if (context) {
+    return {
+      store: context.nodeStore,
+      isReady: context.nodeStoreReady,
+      error: null
+    };
+  }
+  throw new Error("useNodeStore must be used within an XNetProvider");
+}
+
+export {
+  SecurityProvider,
+  useSecurityContext,
+  useSecurityContextOptional,
+  TelemetryContext,
+  useTelemetryReporter,
+  TRACE_STAGES,
+  TracingContext,
+  useTracingReporter,
+  PluginRegistryContext,
+  usePluginRegistry,
+  usePluginRegistryOptional,
+  usePlugins,
+  useContributions,
+  useViews,
+  useCommands,
+  useSlashCommands,
+  useSidebarItems,
+  useImporters,
+  useEditorExtensions,
+  useEditorExtensionsSafe,
+  useView,
+  useCommand,
+  uploadBackup,
+  downloadBackup,
+  XNetContext,
+  useDataBridge,
+  XNetProvider,
+  useXNet,
+  useXNetInternal,
+  useNodeStore
+};