@sybil-studio-devs/sdk 0.1.1 → 0.2.0

package/dist/react/index.js

@@ -20,7 +20,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/react/index.ts
 var react_exports = {};
 __export(react_exports, {
+  SybilAtlas: () => SybilAtlas,
+  SybilNexus: () => SybilNexus,
   SybilPages: () => SybilPages,
+  useAtlas: () => useAtlas,
+  useNexus: () => useNexus,
   useSybilPages: () => useSybilPages
 });
 module.exports = __toCommonJS(react_exports);
@@ -437,23 +441,1454 @@ var SybilPages = (0, import_react.forwardRef)(function SybilPages2({
   );
 });
 
+// src/react/SybilAtlas.tsx
+var import_react2 = require("react");
+
+// src/atlas/client.ts
+var DEFAULT_BASE_URL2 = "https://app.sybil.studio";
+var AtlasLogger = class {
+  constructor(config) {
+    this.logs = [];
+    this.config = config;
+  }
+  log(level, category, message, data, duration) {
+    if (!this.config?.enabled) return;
+    const levels = ["debug", "info", "warn", "error"];
+    const configLevel = this.config.level || "info";
+    if (levels.indexOf(level) < levels.indexOf(configLevel)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      category,
+      message,
+      data,
+      duration
+    };
+    this.logs.push(entry);
+    this.config.onLog?.(entry);
+    if (typeof console !== "undefined") {
+      const prefix = `[Atlas SDK] [${category}]`;
+      switch (level) {
+        case "debug":
+          console.debug(prefix, message, data || "");
+          break;
+        case "info":
+          console.info(prefix, message, data || "");
+          break;
+        case "warn":
+          console.warn(prefix, message, data || "");
+          break;
+        case "error":
+          console.error(prefix, message, data || "");
+          break;
+      }
+    }
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+};
+function embedAtlas(config) {
+  const {
+    apiKey,
+    workspaceId,
+    container,
+    baseUrl = DEFAULT_BASE_URL2,
+    theme = "dark",
+    showSidebar = true,
+    sidebarWidth = 260,
+    sidebarCollapsible = true,
+    readOnly = false,
+    defaultPageId,
+    allowCreate = true,
+    allowDelete = true,
+    allowExport = true,
+    features = {},
+    logging,
+    onReady,
+    onPageChange,
+    onPageCreate,
+    onPageDelete,
+    onPageUpdate,
+    onError,
+    onNavigate
+  } = config;
+  const logger = new AtlasLogger(logging);
+  const startTime = Date.now();
+  logger.log("info", "render", "Initializing Atlas embed", {
+    workspaceId,
+    showSidebar,
+    readOnly,
+    features
+  });
+  const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+  if (!containerEl) {
+    const error = {
+      code: "CONTAINER_NOT_FOUND",
+      message: "Container element not found",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onError?.(error);
+    throw new Error(error.message);
+  }
+  const params = new URLSearchParams({
+    apiKey,
+    workspaceId,
+    readOnly: readOnly.toString(),
+    showSidebar: showSidebar.toString(),
+    sidebarWidth: sidebarWidth.toString(),
+    sidebarCollapsible: sidebarCollapsible.toString(),
+    allowCreate: allowCreate.toString(),
+    allowDelete: allowDelete.toString(),
+    allowExport: allowExport.toString()
+  });
+  if (defaultPageId) params.set("defaultPageId", defaultPageId);
+  if (typeof theme === "string") {
+    params.set("theme", theme);
+  } else {
+    Object.entries(theme).forEach(([key, value]) => {
+      if (value) params.set(`theme_${key}`, value);
+    });
+  }
+  Object.entries(features).forEach(([key, value]) => {
+    if (typeof value === "boolean") {
+      params.set(`feature_${key}`, value.toString());
+    }
+  });
+  const iframe = document.createElement("iframe");
+  iframe.src = `${baseUrl}/embed/atlas?${params.toString()}`;
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "8px";
+  iframe.allow = "clipboard-write";
+  let currentPage = null;
+  let isReady = false;
+  const createError = (code, message, status) => ({
+    code,
+    message,
+    status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  });
+  const apiRequest = async (endpoint, options = {}) => {
+    const requestStart = Date.now();
+    const url = `${baseUrl}/api/sdk/v1${endpoint}`;
+    logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`, {
+      url,
+      method: options.method || "GET"
+    });
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+      const duration = Date.now() - requestStart;
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = createError(
+          errorData.error?.code || "API_ERROR",
+          errorData.error?.message || `Request failed with status ${response.status}`,
+          response.status
+        );
+        logger.log("error", "api", `Request failed: ${endpoint}`, {
+          status: response.status,
+          error: errorData
+        }, duration);
+        onError?.(error);
+        throw error;
+      }
+      const data = await response.json();
+      logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+      return data;
+    } catch (err) {
+      if (err.code) throw err;
+      const error = createError("NETWORK_ERROR", err.message);
+      logger.log("error", "api", "Network error", { error: err.message });
+      onError?.(error);
+      throw error;
+    }
+  };
+  const postMessage = (type, payload) => {
+    iframe.contentWindow?.postMessage({ type, ...payload }, baseUrl);
+  };
+  const handleMessage = (event) => {
+    if (event.origin !== new URL(baseUrl).origin) return;
+    const { type, ...data } = event.data || {};
+    logger.log("debug", "render", `Message received: ${type}`, data);
+    switch (type) {
+      case "sybil:atlas:ready":
+        isReady = true;
+        logger.log("info", "render", "Atlas embed ready", {}, Date.now() - startTime);
+        onReady?.(instance);
+        break;
+      case "sybil:atlas:page:changed":
+        currentPage = data.page;
+        logger.log("info", "navigation", "Page changed", { pageId: data.page?.id });
+        onPageChange?.(data.page);
+        break;
+      case "sybil:atlas:page:created":
+        logger.log("info", "editor", "Page created", { pageId: data.page?.id });
+        onPageCreate?.(data.page);
+        break;
+      case "sybil:atlas:page:deleted":
+        logger.log("info", "editor", "Page deleted", { pageId: data.pageId });
+        onPageDelete?.(data.pageId);
+        break;
+      case "sybil:atlas:page:updated":
+        currentPage = data.page;
+        logger.log("debug", "sync", "Page updated", { pageId: data.page?.id });
+        onPageUpdate?.(data.page);
+        break;
+      case "sybil:atlas:navigate":
+        logger.log("info", "navigation", "Navigation requested", { pageId: data.pageId });
+        onNavigate?.(data.pageId);
+        break;
+      case "sybil:atlas:error":
+        const error = createError(data.code || "EMBED_ERROR", data.message);
+        logger.log("error", "render", "Embed error", data);
+        onError?.(error);
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  containerEl.appendChild(iframe);
+  const instance = {
+    getPages: async () => {
+      logger.log("info", "api", "Fetching pages");
+      const response = await apiRequest(
+        `/atlas/workspaces/${workspaceId}/sidebar`
+      );
+      return response.sidebar;
+    },
+    getPage: async (pageId) => {
+      logger.log("info", "api", "Fetching page", { pageId });
+      const response = await apiRequest(
+        `/atlas/pages/${pageId}`
+      );
+      return response.page;
+    },
+    createPage: async (params2) => {
+      logger.log("info", "api", "Creating page", params2);
+      const response = await apiRequest(
+        `/atlas/workspaces/${workspaceId}/pages`,
+        {
+          method: "POST",
+          body: JSON.stringify(params2)
+        }
+      );
+      postMessage("sybil:atlas:refresh");
+      return response.page;
+    },
+    updatePage: async (pageId, params2) => {
+      logger.log("info", "api", "Updating page", { pageId, ...params2 });
+      const response = await apiRequest(
+        `/atlas/pages/${pageId}`,
+        {
+          method: "PUT",
+          body: JSON.stringify(params2)
+        }
+      );
+      postMessage("sybil:atlas:refresh");
+      return response.page;
+    },
+    deletePage: async (pageId) => {
+      logger.log("info", "api", "Deleting page", { pageId });
+      await apiRequest(`/atlas/pages/${pageId}`, { method: "DELETE" });
+      postMessage("sybil:atlas:refresh");
+    },
+    navigateTo: (pageId) => {
+      logger.log("info", "navigation", "Navigating to page", { pageId });
+      postMessage("sybil:atlas:navigate", { pageId });
+    },
+    getCurrentPage: () => currentPage,
+    exportPage: async (pageId, format) => {
+      logger.log("info", "api", "Exporting page", { pageId, format });
+      const response = await fetch(
+        `${baseUrl}/api/sdk/v1/atlas/pages/${pageId}/export?format=${format}`,
+        {
+          headers: { "x-api-key": apiKey }
+        }
+      );
+      if (!response.ok) {
+        const error = createError("EXPORT_FAILED", "Failed to export page");
+        onError?.(error);
+        throw error;
+      }
+      return response.blob();
+    },
+    toggleSidebar: () => {
+      logger.log("debug", "render", "Toggling sidebar");
+      postMessage("sybil:atlas:toggleSidebar");
+    },
+    setSidebarWidth: (width) => {
+      logger.log("debug", "render", "Setting sidebar width", { width });
+      postMessage("sybil:atlas:setSidebarWidth", { width });
+    },
+    setTheme: (newTheme) => {
+      logger.log("debug", "render", "Setting theme", { theme: newTheme });
+      postMessage("sybil:atlas:setTheme", { theme: newTheme });
+    },
+    refresh: async () => {
+      logger.log("info", "sync", "Refreshing");
+      postMessage("sybil:atlas:refresh");
+    },
+    destroy: () => {
+      logger.log("info", "render", "Destroying Atlas embed");
+      window.removeEventListener("message", handleMessage);
+      iframe.remove();
+    },
+    getLogs: () => logger.getLogs(),
+    clearLogs: () => logger.clearLogs()
+  };
+  return instance;
+}
+var AtlasClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.workspaceId = config.workspaceId;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL2;
+    this.logger = new AtlasLogger(config.logging);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}/api/sdk/v1${endpoint}`;
+    const startTime = Date.now();
+    this.logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`);
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    const duration = Date.now() - startTime;
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      this.logger.log("error", "api", `Request failed: ${endpoint}`, {
+        status: response.status,
+        error: errorData
+      }, duration);
+      throw new Error(errorData.error?.message || `Request failed with status ${response.status}`);
+    }
+    this.logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+    return response.json();
+  }
+  async getSidebar() {
+    const response = await this.request(
+      `/atlas/workspaces/${this.workspaceId}/sidebar`
+    );
+    return response.sidebar;
+  }
+  async getPage(pageId) {
+    const response = await this.request(`/atlas/pages/${pageId}`);
+    return response.page;
+  }
+  async createPage(params = {}) {
+    const response = await this.request(
+      `/atlas/workspaces/${this.workspaceId}/pages`,
+      { method: "POST", body: JSON.stringify(params) }
+    );
+    return response.page;
+  }
+  async updatePage(pageId, params) {
+    const response = await this.request(
+      `/atlas/pages/${pageId}`,
+      { method: "PUT", body: JSON.stringify(params) }
+    );
+    return response.page;
+  }
+  async deletePage(pageId) {
+    await this.request(`/atlas/pages/${pageId}`, { method: "DELETE" });
+  }
+  async exportPage(pageId, format) {
+    const response = await fetch(
+      `${this.baseUrl}/api/sdk/v1/atlas/pages/${pageId}/export?format=${format}`,
+      { headers: { "x-api-key": this.apiKey } }
+    );
+    if (!response.ok) throw new Error("Failed to export page");
+    return response.blob();
+  }
+  async toggleFavorite(pageId) {
+    const response = await this.request(
+      `/atlas/pages/${pageId}/favorite`,
+      { method: "POST" }
+    );
+    return response.page;
+  }
+  getLogs() {
+    return this.logger.getLogs();
+  }
+  clearLogs() {
+    this.logger.clearLogs();
+  }
+};
+
+// src/react/SybilAtlas.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var SybilAtlas = (0, import_react2.forwardRef)(function SybilAtlas2({
+  apiKey,
+  workspaceId,
+  baseUrl,
+  theme = "dark",
+  showSidebar = true,
+  sidebarWidth = 260,
+  sidebarCollapsible = true,
+  readOnly = false,
+  defaultPageId,
+  allowCreate = true,
+  allowDelete = true,
+  allowExport = true,
+  features,
+  logging,
+  className,
+  style,
+  onReady,
+  onPageChange,
+  onPageCreate,
+  onPageDelete,
+  onPageUpdate,
+  onError,
+  onNavigate
+}, ref) {
+  const containerRef = (0, import_react2.useRef)(null);
+  const instanceRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useImperativeHandle)(ref, () => ({
+    getPages: async () => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.getPages();
+    },
+    getPage: async (pageId) => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.getPage(pageId);
+    },
+    createPage: async (params) => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.createPage(params || {});
+    },
+    updatePage: async (pageId, params) => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.updatePage(pageId, params);
+    },
+    deletePage: async (pageId) => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.deletePage(pageId);
+    },
+    navigateTo: (pageId) => {
+      instanceRef.current?.navigateTo(pageId);
+    },
+    getCurrentPage: () => {
+      return instanceRef.current?.getCurrentPage() || null;
+    },
+    exportPage: async (pageId, format) => {
+      if (!instanceRef.current) throw new Error("Atlas not initialized");
+      return instanceRef.current.exportPage(pageId, format);
+    },
+    toggleSidebar: () => {
+      instanceRef.current?.toggleSidebar();
+    },
+    setSidebarWidth: (width) => {
+      instanceRef.current?.setSidebarWidth(width);
+    },
+    setTheme: (newTheme) => {
+      instanceRef.current?.setTheme(newTheme);
+    },
+    refresh: async () => {
+      return instanceRef.current?.refresh();
+    },
+    getLogs: () => {
+      return instanceRef.current?.getLogs() || [];
+    },
+    clearLogs: () => {
+      instanceRef.current?.clearLogs();
+    }
+  }));
+  (0, import_react2.useEffect)(() => {
+    if (!containerRef.current || !apiKey || !workspaceId) return;
+    instanceRef.current?.destroy();
+    const config = {
+      apiKey,
+      workspaceId,
+      container: containerRef.current,
+      baseUrl,
+      theme,
+      showSidebar,
+      sidebarWidth,
+      sidebarCollapsible,
+      readOnly,
+      defaultPageId,
+      allowCreate,
+      allowDelete,
+      allowExport,
+      features,
+      logging,
+      onReady,
+      onPageChange,
+      onPageCreate,
+      onPageDelete,
+      onPageUpdate,
+      onError,
+      onNavigate
+    };
+    instanceRef.current = embedAtlas(config);
+    return () => {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+    };
+  }, [apiKey, workspaceId, baseUrl]);
+  (0, import_react2.useEffect)(() => {
+    instanceRef.current?.setTheme(theme);
+  }, [theme]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        width: "100%",
+        height: "100%",
+        minHeight: "500px",
+        ...style
+      }
+    }
+  );
+});
+
+// src/react/SybilNexus.tsx
+var import_react3 = require("react");
+
+// src/nexus/client.ts
+var DEFAULT_BASE_URL3 = "https://app.sybil.studio";
+var NexusLogger = class {
+  constructor(config) {
+    this.logs = [];
+    this.config = config;
+  }
+  log(level, category, message, data, duration) {
+    if (!this.config?.enabled) return;
+    const levels = ["debug", "info", "warn", "error"];
+    const configLevel = this.config.level || "info";
+    if (levels.indexOf(level) < levels.indexOf(configLevel)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      category,
+      message,
+      data,
+      duration,
+      fileId: data?.fileId,
+      folderId: data?.folderId
+    };
+    this.logs.push(entry);
+    this.config.onLog?.(entry);
+    if (typeof console !== "undefined") {
+      const prefix = `[Nexus SDK] [${category}]`;
+      switch (level) {
+        case "debug":
+          console.debug(prefix, message, data || "");
+          break;
+        case "info":
+          console.info(prefix, message, data || "");
+          break;
+        case "warn":
+          console.warn(prefix, message, data || "");
+          break;
+        case "error":
+          console.error(prefix, message, data || "");
+          break;
+      }
+    }
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+};
+function embedNexus(config) {
+  const {
+    apiKey,
+    workspaceId,
+    container,
+    baseUrl = DEFAULT_BASE_URL3,
+    theme = "dark",
+    initialFolderId = null,
+    viewMode = "list",
+    showSidebar = true,
+    showActivityFeed = true,
+    showBreadcrumbs = true,
+    showSearch = true,
+    allowUpload = true,
+    allowDownload = true,
+    allowDelete = true,
+    allowMove = true,
+    allowRename = true,
+    allowCreateFolder = true,
+    allowMultiSelect = true,
+    maxUploadSize,
+    acceptedFileTypes,
+    features = {},
+    logging,
+    onReady,
+    onNavigate,
+    onFileSelect,
+    onFileOpen,
+    onFileUpload,
+    onFileDelete,
+    onFolderCreate,
+    onFolderDelete,
+    onSelectionChange,
+    onError
+  } = config;
+  const logger = new NexusLogger(logging);
+  const startTime = Date.now();
+  logger.log("info", "ui", "Initializing Nexus embed", {
+    workspaceId,
+    initialFolderId,
+    viewMode,
+    features
+  });
+  const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+  if (!containerEl) {
+    const error = {
+      code: "CONTAINER_NOT_FOUND",
+      message: "Container element not found",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onError?.(error);
+    throw new Error(error.message);
+  }
+  const params = new URLSearchParams({
+    apiKey,
+    workspaceId,
+    viewMode,
+    showSidebar: showSidebar.toString(),
+    showActivityFeed: showActivityFeed.toString(),
+    showBreadcrumbs: showBreadcrumbs.toString(),
+    showSearch: showSearch.toString(),
+    allowUpload: allowUpload.toString(),
+    allowDownload: allowDownload.toString(),
+    allowDelete: allowDelete.toString(),
+    allowMove: allowMove.toString(),
+    allowRename: allowRename.toString(),
+    allowCreateFolder: allowCreateFolder.toString(),
+    allowMultiSelect: allowMultiSelect.toString()
+  });
+  if (initialFolderId) params.set("folderId", initialFolderId);
+  if (maxUploadSize) params.set("maxUploadSize", maxUploadSize.toString());
+  if (acceptedFileTypes?.length) params.set("acceptedFileTypes", acceptedFileTypes.join(","));
+  if (typeof theme === "string") {
+    params.set("theme", theme);
+  } else {
+    Object.entries(theme).forEach(([key, value]) => {
+      if (value) params.set(`theme_${key}`, value);
+    });
+  }
+  Object.entries(features).forEach(([key, value]) => {
+    if (typeof value === "boolean") {
+      params.set(`feature_${key}`, value.toString());
+    }
+  });
+  const iframe = document.createElement("iframe");
+  iframe.src = `${baseUrl}/embed/nexus?${params.toString()}`;
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "8px";
+  iframe.allow = "clipboard-write";
+  let currentFolderId = initialFolderId;
+  let selectedItems = [];
+  let isReady = false;
+  const createError = (code, message, status) => ({
+    code,
+    message,
+    status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  });
+  const apiRequest = async (endpoint, options = {}) => {
+    const requestStart = Date.now();
+    const url = `${baseUrl}/api/sdk/v1${endpoint}`;
+    logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`, {
+      url,
+      method: options.method || "GET"
+    });
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "x-api-key": apiKey,
+          ...options.body instanceof FormData ? {} : { "Content-Type": "application/json" },
+          ...options.headers
+        }
+      });
+      const duration = Date.now() - requestStart;
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = createError(
+          errorData.error?.code || "API_ERROR",
+          errorData.error?.message || `Request failed with status ${response.status}`,
+          response.status
+        );
+        logger.log("error", "api", `Request failed: ${endpoint}`, {
+          status: response.status,
+          error: errorData
+        }, duration);
+        onError?.(error);
+        throw error;
+      }
+      const data = await response.json();
+      logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+      return data;
+    } catch (err) {
+      if (err.code) throw err;
+      const error = createError("NETWORK_ERROR", err.message);
+      logger.log("error", "api", "Network error", { error: err.message });
+      onError?.(error);
+      throw error;
+    }
+  };
+  const postMessage = (type, payload) => {
+    iframe.contentWindow?.postMessage({ type, ...payload }, baseUrl);
+  };
+  const handleMessage = (event) => {
+    if (event.origin !== new URL(baseUrl).origin) return;
+    const { type, ...data } = event.data || {};
+    logger.log("debug", "ui", `Message received: ${type}`, data);
+    switch (type) {
+      case "sybil:nexus:ready":
+        isReady = true;
+        logger.log("info", "ui", "Nexus embed ready", {}, Date.now() - startTime);
+        onReady?.(instance);
+        break;
+      case "sybil:nexus:navigate":
+        currentFolderId = data.folderId;
+        logger.log("info", "navigation", "Navigated to folder", { folderId: data.folderId });
+        onNavigate?.(data.folderId);
+        break;
+      case "sybil:nexus:file:select":
+        logger.log("debug", "selection", "File selected", { fileId: data.file?.id });
+        onFileSelect?.(data.file);
+        break;
+      case "sybil:nexus:file:open":
+        logger.log("info", "ui", "File opened", { fileId: data.file?.id });
+        onFileOpen?.(data.file);
+        break;
+      case "sybil:nexus:file:upload":
+        logger.log("info", "upload", "File uploaded", { fileId: data.file?.id });
+        onFileUpload?.(data.file);
+        break;
+      case "sybil:nexus:file:delete":
+        logger.log("info", "api", "File deleted", { fileId: data.fileId });
+        onFileDelete?.(data.fileId);
+        break;
+      case "sybil:nexus:folder:create":
+        logger.log("info", "api", "Folder created", { folderId: data.folder?.id });
+        onFolderCreate?.(data.folder);
+        break;
+      case "sybil:nexus:folder:delete":
+        logger.log("info", "api", "Folder deleted", { folderId: data.folderId });
+        onFolderDelete?.(data.folderId);
+        break;
+      case "sybil:nexus:selection:change":
+        selectedItems = data.items || [];
+        logger.log("debug", "selection", "Selection changed", { count: selectedItems.length });
+        onSelectionChange?.(selectedItems);
+        break;
+      case "sybil:nexus:error":
+        const error = createError(data.code || "EMBED_ERROR", data.message);
+        logger.log("error", "ui", "Embed error", data);
+        onError?.(error);
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  containerEl.appendChild(iframe);
+  const instance = {
+    getFiles: async (folderId) => {
+      logger.log("info", "api", "Fetching files", { folderId });
+      const params2 = new URLSearchParams({ workspaceId });
+      if (folderId !== void 0) params2.set("folderId", folderId || "null");
+      const response = await apiRequest(
+        `/nexus/files?${params2.toString()}`
+      );
+      return response.files.map((f) => ({
+        ...f,
+        itemType: "file"
+      }));
+    },
+    getFolders: async (parentId) => {
+      logger.log("info", "api", "Fetching folders", { parentId });
+      const params2 = new URLSearchParams({ workspaceId });
+      if (parentId !== void 0) params2.set("parentId", parentId || "null");
+      const response = await apiRequest(
+        `/nexus/folders?${params2.toString()}`
+      );
+      return response.folders;
+    },
+    getFolderContents: async (folderId) => {
+      logger.log("info", "api", "Fetching folder contents", { folderId });
+      const params2 = new URLSearchParams({ workspaceId });
+      if (folderId) params2.set("folderId", folderId);
+      const response = await apiRequest(
+        `/nexus/folders/contents?${params2.toString()}`
+      );
+      return response;
+    },
+    getFolderTree: async () => {
+      logger.log("info", "api", "Fetching folder tree");
+      const response = await apiRequest(
+        `/nexus/folders/tree?workspaceId=${workspaceId}`
+      );
+      return response.tree;
+    },
+    getFile: async (fileId) => {
+      logger.log("info", "api", "Fetching file", { fileId });
+      const response = await apiRequest(`/nexus/files/${fileId}`);
+      return response.file;
+    },
+    getFolder: async (folderId) => {
+      logger.log("info", "api", "Fetching folder", { folderId });
+      const response = await apiRequest(
+        `/nexus/folders/${folderId}`
+      );
+      return response.folder;
+    },
+    uploadFile: async (file, folderId, onProgress) => {
+      logger.log("info", "upload", "Uploading file", { fileName: file.name, size: file.size, folderId });
+      const formData = new FormData();
+      formData.append("file", file);
+      formData.append("workspaceId", workspaceId);
+      if (folderId) formData.append("folderId", folderId);
+      const xhr = new XMLHttpRequest();
+      return new Promise((resolve, reject) => {
+        xhr.upload.addEventListener("progress", (e) => {
+          if (e.lengthComputable) {
+            const progress = Math.round(e.loaded / e.total * 100);
+            logger.log("debug", "upload", "Upload progress", { progress, fileName: file.name });
+            onProgress?.(progress);
+          }
+        });
+        xhr.addEventListener("load", () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            const response = JSON.parse(xhr.responseText);
+            logger.log("info", "upload", "Upload complete", { fileId: response.file?.id });
+            postMessage("sybil:nexus:refresh");
+            resolve(response.file);
+          } else {
+            const error = createError("UPLOAD_FAILED", "Failed to upload file", xhr.status);
+            logger.log("error", "upload", "Upload failed", { status: xhr.status });
+            onError?.(error);
+            reject(error);
+          }
+        });
+        xhr.addEventListener("error", () => {
+          const error = createError("UPLOAD_ERROR", "Network error during upload");
+          logger.log("error", "upload", "Upload network error");
+          onError?.(error);
+          reject(error);
+        });
+        xhr.open("POST", `${baseUrl}/api/sdk/v1/nexus/upload`);
+        xhr.setRequestHeader("x-api-key", apiKey);
+        xhr.send(formData);
+      });
+    },
+    uploadFiles: async (files, folderId, onProgress) => {
+      logger.log("info", "upload", "Uploading multiple files", { count: files.length, folderId });
+      const results = [];
+      for (let i = 0; i < files.length; i++) {
+        const file = await instance.uploadFile(files[i], folderId, (progress) => {
+          onProgress?.(i, progress);
+        });
+        results.push(file);
+      }
+      return results;
+    },
+    downloadFile: async (fileId) => {
+      logger.log("info", "download", "Downloading file", { fileId });
+      const response = await fetch(`${baseUrl}/api/sdk/v1/nexus/files/${fileId}/content`, {
+        headers: { "x-api-key": apiKey }
+      });
+      if (!response.ok) {
+        const error = createError("DOWNLOAD_FAILED", "Failed to download file", response.status);
+        onError?.(error);
+        throw error;
+      }
+      return response.blob();
+    },
+    getDownloadUrl: async (fileId) => {
+      logger.log("info", "download", "Getting download URL", { fileId });
+      const response = await apiRequest(`/nexus/files/${fileId}/url`);
+      return response.signedUrl;
+    },
+    deleteFile: async (fileId) => {
+      logger.log("info", "api", "Deleting file", { fileId });
+      await apiRequest(`/nexus/files/${fileId}`, { method: "DELETE" });
+      postMessage("sybil:nexus:refresh");
+    },
+    deleteFiles: async (fileIds) => {
+      logger.log("info", "api", "Deleting multiple files", { count: fileIds.length });
+      await apiRequest("/nexus/files/bulk", {
+        method: "DELETE",
+        body: JSON.stringify({ fileIds })
+      });
+      postMessage("sybil:nexus:refresh");
+    },
+    moveFile: async (fileId, targetFolderId) => {
+      logger.log("info", "api", "Moving file", { fileId, targetFolderId });
+      const response = await apiRequest(`/nexus/files/${fileId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ folderId: targetFolderId })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.file;
+    },
+    moveFiles: async (fileIds, targetFolderId) => {
+      logger.log("info", "api", "Moving multiple files", { count: fileIds.length, targetFolderId });
+      const response = await apiRequest("/nexus/files/bulk", {
+        method: "PATCH",
+        body: JSON.stringify({ fileIds, folderId: targetFolderId })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.files;
+    },
+    renameFile: async (fileId, newName) => {
+      logger.log("info", "api", "Renaming file", { fileId, newName });
+      const response = await apiRequest(`/nexus/files/${fileId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ name: newName })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.file;
+    },
+    starFile: async (fileId, starred) => {
+      logger.log("info", "api", "Starring file", { fileId, starred });
+      const response = await apiRequest(`/nexus/files/${fileId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ isStarred: starred })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.file;
+    },
+    starFiles: async (fileIds, starred) => {
+      logger.log("info", "api", "Starring multiple files", { count: fileIds.length, starred });
+      await apiRequest("/nexus/files/bulk", {
+        method: "PATCH",
+        body: JSON.stringify({ fileIds, isStarred: starred })
+      });
+      postMessage("sybil:nexus:refresh");
+    },
+    trashFile: async (fileId) => {
+      logger.log("info", "api", "Trashing file", { fileId });
+      await apiRequest(`/nexus/files/${fileId}`, { method: "DELETE" });
+      postMessage("sybil:nexus:refresh");
+    },
+    restoreFile: async (fileId, folderId) => {
+      logger.log("info", "api", "Restoring file", { fileId, folderId });
+      const response = await apiRequest(`/nexus/files/${fileId}/restore`, {
+        method: "POST",
+        body: JSON.stringify({ folderId })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.file;
+    },
+    createFolder: async (name, parentId, options) => {
+      logger.log("info", "api", "Creating folder", { name, parentId, options });
+      const response = await apiRequest("/nexus/folders", {
+        method: "POST",
+        body: JSON.stringify({ workspaceId, name, parentId, ...options })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.folder;
+    },
+    deleteFolder: async (folderId) => {
+      logger.log("info", "api", "Deleting folder", { folderId });
+      await apiRequest(`/nexus/folders/${folderId}`, { method: "DELETE" });
+      postMessage("sybil:nexus:refresh");
+    },
+    moveFolder: async (folderId, targetParentId) => {
+      logger.log("info", "api", "Moving folder", { folderId, targetParentId });
+      const response = await apiRequest(`/nexus/folders/${folderId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ parentId: targetParentId })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.folder;
+    },
+    renameFolder: async (folderId, newName) => {
+      logger.log("info", "api", "Renaming folder", { folderId, newName });
+      const response = await apiRequest(`/nexus/folders/${folderId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ name: newName })
+      });
+      postMessage("sybil:nexus:refresh");
+      return response.folder;
+    },
+    navigateTo: (folderId) => {
+      currentFolderId = folderId;
+      logger.log("info", "navigation", "Navigating to folder", { folderId });
+      postMessage("sybil:nexus:navigate", { folderId });
+    },
+    getCurrentFolder: () => currentFolderId,
+    getSelection: () => [...selectedItems],
+    setSelection: (itemIds) => {
+      logger.log("debug", "selection", "Setting selection", { count: itemIds.length });
+      postMessage("sybil:nexus:setSelection", { itemIds });
+    },
+    clearSelection: () => {
+      logger.log("debug", "selection", "Clearing selection");
+      postMessage("sybil:nexus:clearSelection");
+    },
+    selectAll: () => {
+      logger.log("debug", "selection", "Selecting all");
+      postMessage("sybil:nexus:selectAll");
+    },
+    setViewMode: (mode) => {
+      logger.log("debug", "ui", "Setting view mode", { mode });
+      postMessage("sybil:nexus:setViewMode", { mode });
+    },
+    toggleActivityFeed: () => {
+      logger.log("debug", "ui", "Toggling activity feed");
+      postMessage("sybil:nexus:toggleActivity");
+    },
+    toggleSidebar: () => {
+      logger.log("debug", "ui", "Toggling sidebar");
+      postMessage("sybil:nexus:toggleSidebar");
+    },
+    refresh: async () => {
+      logger.log("info", "ui", "Refreshing");
+      postMessage("sybil:nexus:refresh");
+    },
+    search: async (query) => {
+      logger.log("info", "api", "Searching", { query });
+      const params2 = new URLSearchParams({ workspaceId, search: query });
+      const response = await apiRequest(
+        `/nexus/files?${params2.toString()}`
+      );
+      return response.files.map((f) => ({
+        ...f,
+        itemType: "file"
+      }));
+    },
+    getStats: async () => {
+      logger.log("info", "api", "Fetching stats");
+      const response = await apiRequest(
+        `/nexus/stats?workspaceId=${workspaceId}`
+      );
+      return response.stats;
+    },
+    getActivity: async (limit = 50) => {
+      logger.log("info", "api", "Fetching activity", { limit });
+      const response = await apiRequest(
+        `/nexus/activity?workspaceId=${workspaceId}&limit=${limit}`
+      );
+      return response.activities;
+    },
+    getLabels: async () => {
+      logger.log("info", "api", "Fetching labels");
+      const response = await apiRequest(
+        `/nexus/labels?workspaceId=${workspaceId}`
+      );
+      return response.labels;
+    },
+    applyLabel: async (itemIds, labelId) => {
+      logger.log("info", "api", "Applying label", { count: itemIds.length, labelId });
+      await apiRequest("/nexus/labels/apply", {
+        method: "POST",
+        body: JSON.stringify({ itemIds, labelId })
+      });
+      postMessage("sybil:nexus:refresh");
+    },
+    removeLabel: async (itemIds, labelId) => {
+      logger.log("info", "api", "Removing label", { count: itemIds.length, labelId });
+      await apiRequest("/nexus/labels/apply", {
+        method: "DELETE",
+        body: JSON.stringify({ itemIds, labelId })
+      });
+      postMessage("sybil:nexus:refresh");
+    },
+    setTheme: (newTheme) => {
+      logger.log("debug", "ui", "Setting theme", { theme: newTheme });
+      postMessage("sybil:nexus:setTheme", { theme: newTheme });
+    },
+    destroy: () => {
+      logger.log("info", "ui", "Destroying Nexus embed");
+      window.removeEventListener("message", handleMessage);
+      iframe.remove();
+    },
+    getLogs: () => logger.getLogs(),
+    clearLogs: () => logger.clearLogs()
+  };
+  return instance;
+}
+var NexusClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.workspaceId = config.workspaceId;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL3;
+    this.logger = new NexusLogger(config.logging);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}/api/sdk/v1${endpoint}`;
+    const startTime = Date.now();
+    this.logger.log("debug", "api", `Request: ${options.method || "GET"} ${endpoint}`);
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "x-api-key": this.apiKey,
+        ...options.body instanceof FormData ? {} : { "Content-Type": "application/json" },
+        ...options.headers
+      }
+    });
+    const duration = Date.now() - startTime;
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      this.logger.log("error", "api", `Request failed: ${endpoint}`, {
+        status: response.status,
+        error: errorData
+      }, duration);
+      throw new Error(errorData.error?.message || `Request failed with status ${response.status}`);
+    }
+    this.logger.log("debug", "api", `Response: ${endpoint}`, { status: response.status }, duration);
+    return response.json();
+  }
+  async listFiles(folderId) {
+    const params = new URLSearchParams({ workspaceId: this.workspaceId });
+    if (folderId !== void 0) params.set("folderId", folderId || "null");
+    const response = await this.request(`/nexus/files?${params.toString()}`);
+    return response.files;
+  }
+  async listFolders(parentId) {
+    const params = new URLSearchParams({ workspaceId: this.workspaceId });
+    if (parentId !== void 0) params.set("parentId", parentId || "null");
+    const response = await this.request(`/nexus/folders?${params.toString()}`);
+    return response.folders;
+  }
+  async getFolderContents(folderId) {
+    const params = new URLSearchParams({ workspaceId: this.workspaceId });
+    if (folderId) params.set("folderId", folderId);
+    return this.request(`/nexus/folders/contents?${params.toString()}`);
+  }
+  async getFile(fileId) {
+    const response = await this.request(`/nexus/files/${fileId}`);
+    return response.file;
+  }
+  async uploadFile(file, folderId) {
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("workspaceId", this.workspaceId);
+    if (folderId) formData.append("folderId", folderId);
+    const response = await fetch(`${this.baseUrl}/api/sdk/v1/nexus/upload`, {
+      method: "POST",
+      headers: { "x-api-key": this.apiKey },
+      body: formData
+    });
+    if (!response.ok) throw new Error("Failed to upload file");
+    const data = await response.json();
+    return data.file;
+  }
+  async deleteFile(fileId) {
+    await this.request(`/nexus/files/${fileId}`, { method: "DELETE" });
+  }
+  async createFolder(name, parentId) {
+    const response = await this.request("/nexus/folders", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId: this.workspaceId, name, parentId })
+    });
+    return response.folder;
+  }
+  async deleteFolder(folderId) {
+    await this.request(`/nexus/folders/${folderId}`, { method: "DELETE" });
+  }
+  async getStats() {
+    const response = await this.request(
+      `/nexus/stats?workspaceId=${this.workspaceId}`
+    );
+    return response.stats;
+  }
+  async getActivity(limit = 50) {
+    const response = await this.request(
+      `/nexus/activity?workspaceId=${this.workspaceId}&limit=${limit}`
+    );
+    return response.activities;
+  }
+  getLogs() {
+    return this.logger.getLogs();
+  }
+  clearLogs() {
+    this.logger.clearLogs();
+  }
+};
+
+// src/react/SybilNexus.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var SybilNexus = (0, import_react3.forwardRef)(function SybilNexus2({
+  apiKey,
+  workspaceId,
+  baseUrl,
+  theme = "dark",
+  initialFolderId = null,
+  viewMode = "list",
+  showSidebar = true,
+  showActivityFeed = true,
+  showBreadcrumbs = true,
+  showSearch = true,
+  allowUpload = true,
+  allowDownload = true,
+  allowDelete = true,
+  allowMove = true,
+  allowRename = true,
+  allowCreateFolder = true,
+  allowMultiSelect = true,
+  maxUploadSize,
+  acceptedFileTypes,
+  features,
+  logging,
+  className,
+  style,
+  onReady,
+  onNavigate,
+  onFileSelect,
+  onFileOpen,
+  onFileUpload,
+  onFileDelete,
+  onFolderCreate,
+  onFolderDelete,
+  onSelectionChange,
+  onError
+}, ref) {
+  const containerRef = (0, import_react3.useRef)(null);
+  const instanceRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useImperativeHandle)(ref, () => ({
+    getFiles: async (folderId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFiles(folderId);
+    },
+    getFolders: async (parentId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFolders(parentId);
+    },
+    getFolderContents: async (folderId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFolderContents(folderId);
+    },
+    getFolderTree: async () => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFolderTree();
+    },
+    getFile: async (fileId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFile(fileId);
+    },
+    getFolder: async (folderId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getFolder(folderId);
+    },
+    uploadFile: async (file, folderId, onProgress) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.uploadFile(file, folderId, onProgress);
+    },
+    uploadFiles: async (files, folderId, onProgress) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.uploadFiles(files, folderId, onProgress);
+    },
+    downloadFile: async (fileId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.downloadFile(fileId);
+    },
+    getDownloadUrl: async (fileId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getDownloadUrl(fileId);
+    },
+    deleteFile: async (fileId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.deleteFile(fileId);
+    },
+    deleteFiles: async (fileIds) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.deleteFiles(fileIds);
+    },
+    moveFile: async (fileId, targetFolderId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.moveFile(fileId, targetFolderId);
+    },
+    renameFile: async (fileId, newName) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.renameFile(fileId, newName);
+    },
+    starFile: async (fileId, starred) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.starFile(fileId, starred);
+    },
+    createFolder: async (name, parentId, options) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.createFolder(name, parentId, options);
+    },
+    deleteFolder: async (folderId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.deleteFolder(folderId);
+    },
+    moveFolder: async (folderId, targetParentId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.moveFolder(folderId, targetParentId);
+    },
+    renameFolder: async (folderId, newName) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.renameFolder(folderId, newName);
+    },
+    navigateTo: (folderId) => {
+      instanceRef.current?.navigateTo(folderId);
+    },
+    getCurrentFolder: () => {
+      return instanceRef.current?.getCurrentFolder() || null;
+    },
+    getSelection: () => {
+      return instanceRef.current?.getSelection() || [];
+    },
+    setSelection: (itemIds) => {
+      instanceRef.current?.setSelection(itemIds);
+    },
+    clearSelection: () => {
+      instanceRef.current?.clearSelection();
+    },
+    selectAll: () => {
+      instanceRef.current?.selectAll();
+    },
+    setViewMode: (mode) => {
+      instanceRef.current?.setViewMode(mode);
+    },
+    toggleActivityFeed: () => {
+      instanceRef.current?.toggleActivityFeed();
+    },
+    toggleSidebar: () => {
+      instanceRef.current?.toggleSidebar();
+    },
+    refresh: async () => {
+      return instanceRef.current?.refresh();
+    },
+    search: async (query) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.search(query);
+    },
+    getStats: async () => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getStats();
+    },
+    getActivity: async (limit) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getActivity(limit);
+    },
+    getLabels: async () => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.getLabels();
+    },
+    applyLabel: async (itemIds, labelId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.applyLabel(itemIds, labelId);
+    },
+    removeLabel: async (itemIds, labelId) => {
+      if (!instanceRef.current) throw new Error("Nexus not initialized");
+      return instanceRef.current.removeLabel(itemIds, labelId);
+    },
+    setTheme: (newTheme) => {
+      instanceRef.current?.setTheme(newTheme);
+    },
+    getLogs: () => {
+      return instanceRef.current?.getLogs() || [];
+    },
+    clearLogs: () => {
+      instanceRef.current?.clearLogs();
+    }
+  }));
+  (0, import_react3.useEffect)(() => {
+    if (!containerRef.current || !apiKey || !workspaceId) return;
+    instanceRef.current?.destroy();
+    const config = {
+      apiKey,
+      workspaceId,
+      container: containerRef.current,
+      baseUrl,
+      theme,
+      initialFolderId,
+      viewMode,
+      showSidebar,
+      showActivityFeed,
+      showBreadcrumbs,
+      showSearch,
+      allowUpload,
+      allowDownload,
+      allowDelete,
+      allowMove,
+      allowRename,
+      allowCreateFolder,
+      allowMultiSelect,
+      maxUploadSize,
+      acceptedFileTypes,
+      features,
+      logging,
+      onReady,
+      onNavigate,
+      onFileSelect,
+      onFileOpen,
+      onFileUpload,
+      onFileDelete,
+      onFolderCreate,
+      onFolderDelete,
+      onSelectionChange,
+      onError
+    };
+    instanceRef.current = embedNexus(config);
+    return () => {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+    };
+  }, [apiKey, workspaceId, baseUrl]);
+  (0, import_react3.useEffect)(() => {
+    instanceRef.current?.setTheme(theme);
+  }, [theme]);
+  (0, import_react3.useEffect)(() => {
+    instanceRef.current?.setViewMode(viewMode);
+  }, [viewMode]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        width: "100%",
+        height: "100%",
+        minHeight: "500px",
+        ...style
+      }
+    }
+  );
+});
+
 // src/react/hooks.ts
-var import_react2 = require("react");
+var import_react4 = require("react");
 function useSybilPages(options) {
   const { apiKey, baseUrl } = options;
-  const [page, setPage] = (0, import_react2.useState)(null);
-  const [loading, setLoading] = (0, import_react2.useState)(false);
-  const [saving, setSaving] = (0, import_react2.useState)(false);
-  const [error, setError] = (0, import_react2.useState)(null);
-  const sdkRef = (0, import_react2.useRef)(null);
-  const pendingBlocksRef = (0, import_react2.useRef)(null);
-  (0, import_react2.useEffect)(() => {
+  const [page, setPage] = (0, import_react4.useState)(null);
+  const [loading, setLoading] = (0, import_react4.useState)(false);
+  const [saving, setSaving] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const sdkRef = (0, import_react4.useRef)(null);
+  const pendingBlocksRef = (0, import_react4.useRef)(null);
+  (0, import_react4.useEffect)(() => {
     sdkRef.current = new SybilSDK({
       apiKey,
       baseUrl: baseUrl ? `${baseUrl}/api/sdk/v1` : void 0
     });
   }, [apiKey, baseUrl]);
-  const fetchPage = (0, import_react2.useCallback)(async (pageId) => {
+  const fetchPage = (0, import_react4.useCallback)(async (pageId) => {
     if (!sdkRef.current) return;
     setLoading(true);
     setError(null);
@@ -466,7 +1901,7 @@ function useSybilPages(options) {
       setLoading(false);
     }
   }, []);
-  const createPage = (0, import_react2.useCallback)(async (params = {}) => {
+  const createPage = (0, import_react4.useCallback)(async (params = {}) => {
     if (!sdkRef.current) throw new Error("SDK not initialized");
     setLoading(true);
     setError(null);
@@ -482,7 +1917,7 @@ function useSybilPages(options) {
       setLoading(false);
     }
   }, []);
-  const updatePage = (0, import_react2.useCallback)(async (pageId, params) => {
+  const updatePage = (0, import_react4.useCallback)(async (pageId, params) => {
     if (!sdkRef.current) throw new Error("SDK not initialized");
     setSaving(true);
     setError(null);
@@ -498,7 +1933,7 @@ function useSybilPages(options) {
       setSaving(false);
     }
   }, []);
-  const deletePage = (0, import_react2.useCallback)(async (pageId) => {
+  const deletePage = (0, import_react4.useCallback)(async (pageId) => {
     if (!sdkRef.current) throw new Error("SDK not initialized");
     setLoading(true);
     setError(null);
@@ -513,11 +1948,11 @@ function useSybilPages(options) {
       setLoading(false);
     }
   }, []);
-  const setBlocks = (0, import_react2.useCallback)((blocks) => {
+  const setBlocks = (0, import_react4.useCallback)((blocks) => {
     pendingBlocksRef.current = blocks;
     setPage((prev) => prev ? { ...prev, blocks } : null);
   }, []);
-  const save = (0, import_react2.useCallback)(async () => {
+  const save = (0, import_react4.useCallback)(async () => {
     if (!page || !sdkRef.current || !pendingBlocksRef.current) return;
     await updatePage(page.id, { blocks: pendingBlocksRef.current });
     pendingBlocksRef.current = null;
@@ -535,8 +1970,385 @@ function useSybilPages(options) {
     save
   };
 }
+
+// src/react/hooks/useAtlas.ts
+var import_react5 = require("react");
+function useAtlas(options) {
+  const { apiKey, workspaceId, baseUrl, logging } = options;
+  const [sidebar, setSidebar] = (0, import_react5.useState)(null);
+  const [currentPage, setCurrentPage] = (0, import_react5.useState)(null);
+  const [loading, setLoading] = (0, import_react5.useState)(false);
+  const [saving, setSaving] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const clientRef = (0, import_react5.useRef)(null);
+  (0, import_react5.useEffect)(() => {
+    clientRef.current = new AtlasClient({
+      apiKey,
+      workspaceId,
+      baseUrl,
+      logging
+    });
+  }, [apiKey, workspaceId, baseUrl, logging]);
+  const fetchSidebar = (0, import_react5.useCallback)(async () => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await clientRef.current.getSidebar();
+      setSidebar(data);
+      return data;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch sidebar");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const fetchPage = (0, import_react5.useCallback)(async (pageId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const page = await clientRef.current.getPage(pageId);
+      setCurrentPage(page);
+      return page;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const createPage = (0, import_react5.useCallback)(async (params = {}) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      const page = await clientRef.current.createPage(params);
+      await fetchSidebar();
+      return page;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, [fetchSidebar]);
+  const updatePage = (0, import_react5.useCallback)(async (pageId, params) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      const page = await clientRef.current.updatePage(pageId, params);
+      setCurrentPage(page);
+      await fetchSidebar();
+      return page;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, [fetchSidebar]);
+  const deletePage = (0, import_react5.useCallback)(async (pageId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      await clientRef.current.deletePage(pageId);
+      if (currentPage?.id === pageId) {
+        setCurrentPage(null);
+      }
+      await fetchSidebar();
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, [currentPage, fetchSidebar]);
+  const toggleFavorite = (0, import_react5.useCallback)(async (pageId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    try {
+      const page = await clientRef.current.toggleFavorite(pageId);
+      if (currentPage?.id === pageId) {
+        setCurrentPage(page);
+      }
+      await fetchSidebar();
+      return page;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to toggle favorite");
+      setError(error2);
+      throw error2;
+    }
+  }, [currentPage, fetchSidebar]);
+  const exportPage = (0, import_react5.useCallback)(async (pageId, format) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    try {
+      return await clientRef.current.exportPage(pageId, format);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to export page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const getLogs = (0, import_react5.useCallback)(() => {
+    return clientRef.current?.getLogs() || [];
+  }, []);
+  const clearLogs = (0, import_react5.useCallback)(() => {
+    clientRef.current?.clearLogs();
+  }, []);
+  return {
+    sidebar,
+    currentPage,
+    loading,
+    saving,
+    error,
+    fetchSidebar,
+    fetchPage,
+    createPage,
+    updatePage,
+    deletePage,
+    toggleFavorite,
+    exportPage,
+    setCurrentPage,
+    getLogs,
+    clearLogs
+  };
+}
+
+// src/react/hooks/useNexus.ts
+var import_react6 = require("react");
+function useNexus(options) {
+  const { apiKey, workspaceId, baseUrl, logging } = options;
+  const [files, setFiles] = (0, import_react6.useState)([]);
+  const [folders, setFolders] = (0, import_react6.useState)([]);
+  const [currentFolder, setCurrentFolder] = (0, import_react6.useState)(null);
+  const [breadcrumb, setBreadcrumb] = (0, import_react6.useState)([]);
+  const [loading, setLoading] = (0, import_react6.useState)(false);
+  const [uploading, setUploading] = (0, import_react6.useState)(false);
+  const [uploadProgress, setUploadProgress] = (0, import_react6.useState)(0);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const clientRef = (0, import_react6.useRef)(null);
+  (0, import_react6.useEffect)(() => {
+    clientRef.current = new NexusClient({
+      apiKey,
+      workspaceId,
+      baseUrl,
+      logging
+    });
+  }, [apiKey, workspaceId, baseUrl, logging]);
+  const fetchFiles = (0, import_react6.useCallback)(async (folderId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await clientRef.current.listFiles(folderId);
+      setFiles(data);
+      return data;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch files");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const fetchFolders = (0, import_react6.useCallback)(async (parentId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await clientRef.current.listFolders(parentId);
+      setFolders(data);
+      return data;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch folders");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const fetchFolderContents = (0, import_react6.useCallback)(async (folderId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await clientRef.current.getFolderContents(folderId);
+      setBreadcrumb(data.breadcrumb);
+      setCurrentFolder(folderId || null);
+      return data;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch folder contents");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const getFile = (0, import_react6.useCallback)(async (fileId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      return await clientRef.current.getFile(fileId);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to get file");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const uploadFile = (0, import_react6.useCallback)(async (file, folderId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    try {
+      const result = await clientRef.current.uploadFile(file, folderId);
+      await fetchFiles(folderId);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload file");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+      setUploadProgress(0);
+    }
+  }, [fetchFiles]);
+  const uploadFiles = (0, import_react6.useCallback)(async (filesToUpload, folderId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    const results = [];
+    try {
+      for (let i = 0; i < filesToUpload.length; i++) {
+        const result = await clientRef.current.uploadFile(filesToUpload[i], folderId);
+        results.push(result);
+        setUploadProgress((i + 1) / filesToUpload.length * 100);
+      }
+      await fetchFiles(folderId);
+      return results;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload files");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+      setUploadProgress(0);
+    }
+  }, [fetchFiles]);
+  const deleteFile = (0, import_react6.useCallback)(async (fileId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      await clientRef.current.deleteFile(fileId);
+      await fetchFiles(currentFolder);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete file");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [currentFolder, fetchFiles]);
+  const createFolder = (0, import_react6.useCallback)(async (name, parentId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await clientRef.current.createFolder(name, parentId);
+      await fetchFolders(parentId);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create folder");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchFolders]);
+  const deleteFolder = (0, import_react6.useCallback)(async (folderId) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      await clientRef.current.deleteFolder(folderId);
+      await fetchFolders(currentFolder);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete folder");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [currentFolder, fetchFolders]);
+  const navigateTo = (0, import_react6.useCallback)((folderId) => {
+    setCurrentFolder(folderId);
+    fetchFolderContents(folderId);
+  }, [fetchFolderContents]);
+  const getStats = (0, import_react6.useCallback)(async () => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    return clientRef.current.getStats();
+  }, []);
+  const getActivity = (0, import_react6.useCallback)(async (limit) => {
+    if (!clientRef.current) throw new Error("Client not initialized");
+    return clientRef.current.getActivity(limit);
+  }, []);
+  const refresh = (0, import_react6.useCallback)(async () => {
+    await fetchFolderContents(currentFolder);
+  }, [currentFolder, fetchFolderContents]);
+  const getLogs = (0, import_react6.useCallback)(() => {
+    return clientRef.current?.getLogs() || [];
+  }, []);
+  const clearLogs = (0, import_react6.useCallback)(() => {
+    clientRef.current?.clearLogs();
+  }, []);
+  return {
+    files,
+    folders,
+    currentFolder,
+    breadcrumb,
+    loading,
+    uploading,
+    uploadProgress,
+    error,
+    fetchFiles,
+    fetchFolders,
+    fetchFolderContents,
+    getFile,
+    uploadFile,
+    uploadFiles,
+    deleteFile,
+    createFolder,
+    deleteFolder,
+    navigateTo,
+    getStats,
+    getActivity,
+    refresh,
+    getLogs,
+    clearLogs
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SybilAtlas,
+  SybilNexus,
   SybilPages,
+  useAtlas,
+  useNexus,
   useSybilPages
 });