@sybil-studio-devs/sdk 0.1.0 → 0.2.0

package/dist/react/index.js

@@ -0,0 +1,2354 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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);
+
+// src/react/SybilPages.tsx
+var import_react = require("react");
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://app.sybil.studio/api/sdk/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var SybilSDK = class {
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = DEFAULT_BASE_URL;
+      this.timeout = DEFAULT_TIMEOUT;
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+      this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    }
+    if (!this.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!this.apiKey.startsWith("sk_live_") && !this.apiKey.startsWith("sk_test_")) {
+      throw new Error("Invalid API key format. Must start with sk_live_ or sk_test_");
+    }
+    this.pages = new PagesAPI(this);
+    this.documents = new DocumentsAPI(this);
+    this.youtube = new YouTubeAPI(this);
+    this.chat = new ChatAPI(this);
+    this.analyze = new AnalyzeAPI(this);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "x-api-key": this.apiKey,
+      ...options.headers
+    };
+    if (options.body && typeof options.body === "string") {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const message = errorData.error?.message || `Request failed with status ${response.status}`;
+        throw new SybilError(message, response.status, errorData.error?.code);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SybilError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SybilError("Request timeout", 408, "TIMEOUT");
+      }
+      throw new SybilError(
+        error instanceof Error ? error.message : "Unknown error",
+        500,
+        "UNKNOWN"
+      );
+    }
+  }
+};
+var SybilError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "SybilError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var PagesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.parent_id) searchParams.set("parent_id", params.parent_id);
+    if (params.is_published !== void 0) searchParams.set("is_published", params.is_published.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/pages${query ? `?${query}` : ""}`);
+  }
+  async get(pageId) {
+    return this.client.request(`/pages/${pageId}`);
+  }
+  async create(params = {}) {
+    return this.client.request("/pages", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async update(pageId, params) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  async delete(pageId) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "DELETE"
+    });
+  }
+  async upload(file, fileName) {
+    const formData = new FormData();
+    formData.append("file", file, fileName);
+    return this.client.request("/pages/upload", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async deleteFile(filePath) {
+    return this.client.request("/pages/upload", {
+      method: "DELETE",
+      body: JSON.stringify({ filePath })
+    });
+  }
+};
+var DocumentsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.status) searchParams.set("status", params.status);
+    if (params.fileType) searchParams.set("fileType", params.fileType);
+    if (params.search) searchParams.set("search", params.search);
+    const query = searchParams.toString();
+    return this.client.request(`/documents${query ? `?${query}` : ""}`);
+  }
+  async get(documentId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeContent) searchParams.set("includeContent", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    if (params.includeMetadata === false) searchParams.set("includeMetadata", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/documents/${documentId}${query ? `?${query}` : ""}`);
+  }
+  async process(file, options = {}) {
+    const formData = new FormData();
+    formData.append("file", file, options.fileName);
+    if (options.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    if (options.collectionId) {
+      formData.append("collectionId", options.collectionId);
+    }
+    return this.client.request("/documents", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async status(documentId) {
+    return this.client.request(`/documents/${documentId}/status`);
+  }
+  async insights(documentId, type) {
+    const query = type ? `?type=${type}` : "";
+    return this.client.request(`/documents/${documentId}/insights${query}`);
+  }
+  async delete(documentId) {
+    return this.client.request(`/documents/${documentId}`, {
+      method: "DELETE"
+    });
+  }
+  async waitForProcessing(documentId, options = {}) {
+    const maxAttempts = options.maxAttempts || 60;
+    const interval = options.interval || 3e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.status(documentId);
+      if (status.status === "processed" || status.status === "completed") {
+        const { document: document2 } = await this.get(documentId);
+        return document2;
+      }
+      if (status.status === "failed") {
+        throw new SybilError(status.error?.message || "Processing failed", 500, "PROCESSING_FAILED");
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new SybilError("Processing timeout", 408, "TIMEOUT");
+  }
+};
+var YouTubeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/youtube${query ? `?${query}` : ""}`);
+  }
+  async process(url, options) {
+    return this.client.request("/youtube", {
+      method: "POST",
+      body: JSON.stringify({
+        url,
+        collectionId: options?.collectionId,
+        force: options?.force
+      })
+    });
+  }
+  async get(videoId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeTranscript) searchParams.set("includeTranscript", "true");
+    if (params.includeChunks) searchParams.set("includeChunks", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/youtube/${videoId}${query ? `?${query}` : ""}`);
+  }
+  async delete(videoId) {
+    return this.client.request(`/youtube/${videoId}`, {
+      method: "DELETE"
+    });
+  }
+};
+var ChatAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async send(paramsOrDocId, query) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, query } : paramsOrDocId;
+    return this.client.request("/chat", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async history(documentId, limit) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("documentId", documentId);
+    if (limit) searchParams.set("limit", limit.toString());
+    return this.client.request(`/chat?${searchParams.toString()}`);
+  }
+};
+var AnalyzeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async run(paramsOrDocId, forceRefresh) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, forceRefresh } : paramsOrDocId;
+    return this.client.request("/analyze", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async get(documentId) {
+    return this.client.request(`/analyze?documentId=${documentId}`);
+  }
+};
+function embedPage(options) {
+  const {
+    pageId,
+    apiKey,
+    container,
+    baseUrl = "https://app.sybil.studio",
+    theme = "dark",
+    readOnly = false,
+    toolbar = true,
+    minHeight = "400px",
+    maxHeight,
+    onReady,
+    onChange,
+    onSave,
+    onError
+  } = options;
+  const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+  if (!containerEl) {
+    throw new Error("Container element not found");
+  }
+  const params = new URLSearchParams({
+    apiKey,
+    readOnly: readOnly.toString(),
+    toolbar: toolbar.toString(),
+    minHeight
+  });
+  if (typeof theme === "string") {
+    params.set("theme", theme);
+  } else {
+    if (theme.background) params.set("bg", theme.background);
+    if (theme.backgroundSecondary) params.set("bgSecondary", theme.backgroundSecondary);
+    if (theme.text) params.set("textColor", theme.text);
+    if (theme.textSecondary) params.set("textSecondary", theme.textSecondary);
+    if (theme.border) params.set("borderColor", theme.border);
+    if (theme.accent) params.set("accent", theme.accent);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.src = `${baseUrl}/embed/pages/${pageId}?${params.toString()}`;
+  iframe.style.width = "100%";
+  iframe.style.minHeight = minHeight;
+  if (maxHeight) iframe.style.maxHeight = maxHeight;
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "8px";
+  iframe.allow = "clipboard-write";
+  const handleMessage = (event) => {
+    if (event.origin !== new URL(baseUrl).origin) return;
+    switch (event.data?.type) {
+      case "sybil:page:ready":
+        onReady?.();
+        break;
+      case "sybil:page:changed":
+        onChange?.(event.data.blocks);
+        break;
+      case "sybil:page:saved":
+        onSave?.();
+        break;
+      case "sybil:page:error":
+        onError?.(new Error(event.data.error));
+        break;
+      case "sybil:content":
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  containerEl.appendChild(iframe);
+  return {
+    getContent: () => {
+      return new Promise((resolve) => {
+        const handler = (event) => {
+          if (event.data?.type === "sybil:content") {
+            window.removeEventListener("message", handler);
+            resolve(event.data.blocks);
+          }
+        };
+        window.addEventListener("message", handler);
+        iframe.contentWindow?.postMessage({ type: "sybil:getContent" }, baseUrl);
+      });
+    },
+    setContent: (blocks) => {
+      iframe.contentWindow?.postMessage({ type: "sybil:setContent", blocks }, baseUrl);
+    },
+    destroy: () => {
+      window.removeEventListener("message", handleMessage);
+      iframe.remove();
+    }
+  };
+}
+
+// src/react/SybilPages.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SybilPages = (0, import_react.forwardRef)(function SybilPages2({
+  apiKey,
+  pageId,
+  baseUrl,
+  theme = "dark",
+  readOnly = false,
+  toolbar = true,
+  minHeight = "400px",
+  maxHeight,
+  className,
+  style,
+  onReady,
+  onChange,
+  onSave,
+  onError
+}, ref) {
+  const containerRef = (0, import_react.useRef)(null);
+  const instanceRef = (0, import_react.useRef)(null);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    getContent: async () => {
+      if (!instanceRef.current) return [];
+      return instanceRef.current.getContent();
+    },
+    setContent: (blocks) => {
+      instanceRef.current?.setContent(blocks);
+    }
+  }));
+  (0, import_react.useEffect)(() => {
+    if (!containerRef.current || !pageId || !apiKey) return;
+    instanceRef.current?.destroy();
+    instanceRef.current = embedPage({
+      pageId,
+      apiKey,
+      container: containerRef.current,
+      baseUrl,
+      theme,
+      readOnly,
+      toolbar,
+      minHeight,
+      maxHeight,
+      onReady,
+      onChange,
+      onSave,
+      onError
+    });
+    return () => {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+    };
+  }, [pageId, apiKey, baseUrl, theme, readOnly, toolbar, minHeight, maxHeight]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        minHeight,
+        maxHeight,
+        ...style
+      }
+    }
+  );
+});
+
+// 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_react4 = require("react");
+function useSybilPages(options) {
+  const { apiKey, baseUrl } = options;
+  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_react4.useCallback)(async (pageId) => {
+    if (!sdkRef.current) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: fetchedPage } = await sdkRef.current.pages.get(pageId);
+      setPage(fetchedPage);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch page"));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const createPage = (0, import_react4.useCallback)(async (params = {}) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: newPage } = await sdkRef.current.pages.create(params);
+      setPage(newPage);
+      return newPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const updatePage = (0, import_react4.useCallback)(async (pageId, params) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      const { page: updatedPage } = await sdkRef.current.pages.update(pageId, params);
+      setPage(updatedPage);
+      return updatedPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+  const deletePage = (0, import_react4.useCallback)(async (pageId) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      await sdkRef.current.pages.delete(pageId);
+      setPage(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const setBlocks = (0, import_react4.useCallback)((blocks) => {
+    pendingBlocksRef.current = blocks;
+    setPage((prev) => prev ? { ...prev, blocks } : null);
+  }, []);
+  const save = (0, import_react4.useCallback)(async () => {
+    if (!page || !sdkRef.current || !pendingBlocksRef.current) return;
+    await updatePage(page.id, { blocks: pendingBlocksRef.current });
+    pendingBlocksRef.current = null;
+  }, [page, updatePage]);
+  return {
+    page,
+    loading,
+    saving,
+    error,
+    fetchPage,
+    createPage,
+    updatePage,
+    deletePage,
+    setBlocks,
+    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
+});