@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.1.0

package/dist/platform.cjs

@@ -1,13 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,714 +15,25 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/platform/shared/crypto-utils.ts
-function processWalletPublicKey(publicKey) {
-  const publicKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-  const publicKeyBytes = Buffer.from(publicKeyHex, "hex");
-  return publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
-}
-function processWalletPrivateKey(privateKey) {
-  const privateKeyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  return Buffer.from(privateKeyHex, "hex");
-}
-function parseEncryptedDataBuffer(encryptedBuffer) {
-  return {
-    iv: encryptedBuffer.slice(0, 16),
-    ephemPublicKey: encryptedBuffer.slice(16, 81),
-    // 65 bytes for uncompressed public key
-    ciphertext: encryptedBuffer.slice(81, -32),
-    mac: encryptedBuffer.slice(-32)
-  };
-}
-var init_crypto_utils = __esm({
-  "src/platform/shared/crypto-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/platform/shared/pgp-utils.ts
-function processPGPKeyOptions(options) {
-  return {
-    name: options?.name || "Vana User",
-    email: options?.email || "user@vana.org",
-    passphrase: options?.passphrase
-  };
-}
-function getPGPKeyGenParams(options) {
-  const { name, email, passphrase } = processPGPKeyOptions(options);
-  return {
-    type: "rsa",
-    rsaBits: 2048,
-    userIDs: [{ name, email }],
-    passphrase,
-    config: STANDARD_PGP_CONFIG
-  };
-}
-var STANDARD_PGP_CONFIG;
-var init_pgp_utils = __esm({
-  "src/platform/shared/pgp-utils.ts"() {
-    "use strict";
-    STANDARD_PGP_CONFIG = {
-      preferredCompressionAlgorithm: 2,
-      // zlib (openpgp.enums.compression.zlib)
-      preferredSymmetricAlgorithm: 7
-      // aes256 (openpgp.enums.symmetric.aes256)
-    };
-  }
-});
-
-// src/platform/shared/error-utils.ts
-function wrapCryptoError(operation, error) {
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return new Error(`${operation} failed: ${message}`);
-}
-var init_error_utils = __esm({
-  "src/platform/shared/error-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/lazy-import.ts
-function lazyImport(importFn) {
-  let cached = null;
-  return () => {
-    if (!cached) {
-      cached = importFn().catch((err) => {
-        cached = null;
-        throw new Error("Failed to load module", { cause: err });
-      });
-    }
-    return cached;
-  };
-}
-var init_lazy_import = __esm({
-  "src/utils/lazy-import.ts"() {
-    "use strict";
-  }
-});
-
-// src/platform/browser.ts
-var browser_exports = {};
-__export(browser_exports, {
-  BrowserPlatformAdapter: () => BrowserPlatformAdapter,
-  browserPlatformAdapter: () => browserPlatformAdapter
-});
-var getOpenPGP, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
-var init_browser = __esm({
-  "src/platform/browser.ts"() {
-    "use strict";
-    init_crypto_utils();
-    init_pgp_utils();
-    init_error_utils();
-    init_lazy_import();
-    getOpenPGP = lazyImport(() => import("openpgp"));
-    BrowserCryptoAdapter = class {
-      async encryptWithPublicKey(data, publicKeyHex) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
-          const encrypted = await eccrypto.encrypt(
-            publicKeyBuffer,
-            Buffer.from(data, "utf8")
-          );
-          const result = Buffer.concat([
-            encrypted.iv,
-            encrypted.ephemPublicKey,
-            encrypted.ciphertext,
-            encrypted.mac
-          ]);
-          return result.toString("hex");
-        } catch (error) {
-          throw new Error(`Encryption failed: ${error}`);
-        }
-      }
-      async decryptWithPrivateKey(encryptedData, privateKeyHex) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
-          const encryptedBuffer = Buffer.from(encryptedData, "hex");
-          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-          const decryptedBuffer = await eccrypto.decrypt(
-            privateKeyBuffer,
-            encryptedObj
-          );
-          return decryptedBuffer.toString("utf8");
-        } catch (error) {
-          throw new Error(`Decryption failed: ${error}`);
-        }
-      }
-      async generateKeyPair() {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBytes = new Uint8Array(32);
-          crypto.getRandomValues(privateKeyBytes);
-          const privateKey = Buffer.from(privateKeyBytes);
-          const publicKey = eccrypto.getPublicCompressed(privateKey);
-          return {
-            privateKey: privateKey.toString("hex"),
-            publicKey: publicKey.toString("hex")
-          };
-        } catch (error) {
-          throw wrapCryptoError("key generation", error);
-        }
-      }
-      async encryptWithWalletPublicKey(data, publicKey) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const uncompressedKey = processWalletPublicKey(publicKey);
-          const encryptedBuffer = await eccrypto.encrypt(
-            uncompressedKey,
-            Buffer.from(data)
-          );
-          const result = Buffer.concat([
-            encryptedBuffer.iv,
-            encryptedBuffer.ephemPublicKey,
-            encryptedBuffer.ciphertext,
-            encryptedBuffer.mac
-          ]);
-          return result.toString("hex");
-        } catch (error) {
-          throw wrapCryptoError("encrypt with wallet public key", error);
-        }
-      }
-      async decryptWithWalletPrivateKey(encryptedData, privateKey) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBuffer = processWalletPrivateKey(privateKey);
-          const encryptedBuffer = Buffer.from(encryptedData, "hex");
-          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-          const decryptedBuffer = await eccrypto.decrypt(
-            privateKeyBuffer,
-            encryptedObj
-          );
-          return decryptedBuffer.toString("utf8");
-        } catch (error) {
-          throw wrapCryptoError("decrypt with wallet private key", error);
-        }
-      }
-      async encryptWithPassword(data, password) {
-        try {
-          const openpgp = await getOpenPGP();
-          const message = await openpgp.createMessage({
-            binary: data
-          });
-          const encrypted = await openpgp.encrypt({
-            message,
-            passwords: [password],
-            format: "binary"
-          });
-          const response = new Response(encrypted);
-          const arrayBuffer = await response.arrayBuffer();
-          return new Uint8Array(arrayBuffer);
-        } catch (error) {
-          throw new Error(`Failed to encrypt with password: ${error}`);
-        }
-      }
-      async decryptWithPassword(encryptedData, password) {
-        try {
-          const openpgp = await getOpenPGP();
-          const message = await openpgp.readMessage({
-            binaryMessage: encryptedData
-          });
-          const { data: decrypted } = await openpgp.decrypt({
-            message,
-            passwords: [password],
-            format: "binary"
-          });
-          return new Uint8Array(decrypted);
-        } catch (error) {
-          throw new Error(`Failed to decrypt with password: ${error}`);
-        }
-      }
-    };
-    BrowserPGPAdapter = class {
-      async encrypt(data, publicKeyArmored) {
-        try {
-          const openpgp = await getOpenPGP();
-          const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
-          const encrypted = await openpgp.encrypt({
-            message: await openpgp.createMessage({ text: data }),
-            encryptionKeys: publicKey,
-            config: {
-              preferredCompressionAlgorithm: openpgp.enums.compression.zlib
-            }
-          });
-          return encrypted;
-        } catch (error) {
-          throw new Error(`PGP encryption failed: ${error}`);
-        }
-      }
-      async decrypt(encryptedData, privateKeyArmored) {
-        try {
-          const openpgp = await getOpenPGP();
-          const privateKey = await openpgp.readPrivateKey({
-            armoredKey: privateKeyArmored
-          });
-          const message = await openpgp.readMessage({
-            armoredMessage: encryptedData
-          });
-          const { data: decrypted } = await openpgp.decrypt({
-            message,
-            decryptionKeys: privateKey
-          });
-          return decrypted;
-        } catch (error) {
-          throw new Error(`PGP decryption failed: ${error}`);
-        }
-      }
-      async generateKeyPair(options) {
-        try {
-          const openpgp = await getOpenPGP();
-          const keyGenParams = getPGPKeyGenParams(options);
-          const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
-          return { publicKey, privateKey };
-        } catch (error) {
-          throw wrapCryptoError("PGP key generation", error);
-        }
-      }
-    };
-    BrowserHttpAdapter = class {
-      async fetch(url, options) {
-        if (typeof fetch === "undefined") {
-          throw new Error("Fetch API not available in this browser environment");
-        }
-        return fetch(url, options);
-      }
-    };
-    BrowserCacheAdapter = class {
-      prefix = "vana_cache_";
-      get(key) {
-        try {
-          if (typeof sessionStorage === "undefined") {
-            return null;
-          }
-          return sessionStorage.getItem(this.prefix + key);
-        } catch {
-          return null;
-        }
-      }
-      set(key, value) {
-        try {
-          if (typeof sessionStorage !== "undefined") {
-            sessionStorage.setItem(this.prefix + key, value);
-          }
-        } catch {
-        }
-      }
-      delete(key) {
-        try {
-          if (typeof sessionStorage !== "undefined") {
-            sessionStorage.removeItem(this.prefix + key);
-          }
-        } catch {
-        }
-      }
-      clear() {
-        try {
-          if (typeof sessionStorage === "undefined") {
-            return;
-          }
-          const keys = Object.keys(sessionStorage);
-          for (const key of keys) {
-            if (key.startsWith(this.prefix)) {
-              sessionStorage.removeItem(key);
-            }
-          }
-        } catch {
-        }
-      }
-    };
-    BrowserPlatformAdapter = class {
-      crypto;
-      pgp;
-      http;
-      cache;
-      platform = "browser";
-      constructor() {
-        this.crypto = new BrowserCryptoAdapter();
-        this.pgp = new BrowserPGPAdapter();
-        this.http = new BrowserHttpAdapter();
-        this.cache = new BrowserCacheAdapter();
-      }
-    };
-    browserPlatformAdapter = new BrowserPlatformAdapter();
-  }
-});
-
-// src/platform.ts
 var platform_exports = {};
 __export(platform_exports, {
-  BrowserPlatformAdapter: () => BrowserPlatformAdapter,
-  NodePlatformAdapter: () => NodePlatformAdapter,
-  createBrowserPlatformAdapter: () => createBrowserPlatformAdapter,
-  createNodePlatformAdapter: () => createNodePlatformAdapter,
-  createPlatformAdapter: () => createPlatformAdapter,
-  createPlatformAdapterFor: () => createPlatformAdapterFor,
-  createPlatformAdapterSafe: () => createPlatformAdapterSafe,
-  detectPlatform: () => detectPlatform,
-  getPlatformCapabilities: () => getPlatformCapabilities,
-  isPlatformSupported: () => isPlatformSupported
+  BrowserPlatformAdapter: () => import_browser.BrowserPlatformAdapter,
+  NodePlatformAdapter: () => import_node.NodePlatformAdapter,
+  createBrowserPlatformAdapter: () => import_browser_safe.createBrowserPlatformAdapter,
+  createNodePlatformAdapter: () => import_browser_safe.createNodePlatformAdapter,
+  createPlatformAdapter: () => import_utils.createPlatformAdapter,
+  createPlatformAdapterFor: () => import_utils.createPlatformAdapterFor,
+  createPlatformAdapterSafe: () => import_browser_safe.createPlatformAdapterSafe,
+  detectPlatform: () => import_utils.detectPlatform,
+  getPlatformCapabilities: () => import_utils.getPlatformCapabilities,
+  isPlatformSupported: () => import_utils.isPlatformSupported
 });
 module.exports = __toCommonJS(platform_exports);
-init_browser();
-
-// src/platform/node.ts
-init_crypto_utils();
-init_pgp_utils();
-init_error_utils();
-
-// src/platform/shared/stream-utils.ts
-async function streamToUint8Array(stream) {
-  const reader = stream.getReader();
-  const chunks = [];
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
-}
-
-// src/platform/node.ts
-init_lazy_import();
-var getOpenPGP2 = lazyImport(() => import("openpgp"));
-var getEccrypto = lazyImport(() => import("eccrypto"));
-var NodeCryptoAdapter = class {
-  async encryptWithPublicKey(data, publicKeyHex) {
-    try {
-      const eccrypto = await getEccrypto();
-      const publicKey = Buffer.from(publicKeyHex, "hex");
-      const message = Buffer.from(data, "utf8");
-      const encrypted = await eccrypto.encrypt(publicKey, message);
-      const result = Buffer.concat([
-        encrypted.iv,
-        encrypted.ephemPublicKey,
-        encrypted.ciphertext,
-        encrypted.mac
-      ]);
-      return result.toString("hex");
-    } catch (error) {
-      throw new Error(`Encryption failed: ${error}`);
-    }
-  }
-  async decryptWithPrivateKey(encryptedData, privateKeyHex) {
-    try {
-      const eccrypto = await getEccrypto();
-      const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
-      const encryptedBuffer = Buffer.from(encryptedData, "hex");
-      const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-      const decrypted = await eccrypto.decrypt(privateKeyBuffer, encryptedObj);
-      return decrypted.toString("utf8");
-    } catch (error) {
-      throw new Error(`Decryption failed: ${error}`);
-    }
-  }
-  async generateKeyPair() {
-    try {
-      const eccrypto = await getEccrypto();
-      const privateKey = eccrypto.generatePrivate();
-      const publicKey = eccrypto.getPublicCompressed(privateKey);
-      return {
-        privateKey: privateKey.toString("hex"),
-        publicKey: publicKey.toString("hex")
-      };
-    } catch (error) {
-      throw wrapCryptoError("key generation", error);
-    }
-  }
-  async encryptWithWalletPublicKey(data, publicKey) {
-    try {
-      const eccrypto = await getEccrypto();
-      const uncompressedKey = processWalletPublicKey(publicKey);
-      const encrypted = await eccrypto.encrypt(
-        uncompressedKey,
-        Buffer.from(data)
-      );
-      const result = Buffer.concat([
-        encrypted.iv,
-        encrypted.ephemPublicKey,
-        encrypted.ciphertext,
-        encrypted.mac
-      ]);
-      return result.toString("hex");
-    } catch (error) {
-      throw wrapCryptoError("encrypt with wallet public key", error);
-    }
-  }
-  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
-    try {
-      const eccrypto = await getEccrypto();
-      const privateKeyBuffer = processWalletPrivateKey(privateKey);
-      const encryptedBuffer = Buffer.from(encryptedData, "hex");
-      const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-      const decryptedBuffer = await eccrypto.decrypt(
-        privateKeyBuffer,
-        encryptedObj
-      );
-      return decryptedBuffer.toString("utf8");
-    } catch (error) {
-      throw wrapCryptoError("decrypt with wallet private key", error);
-    }
-  }
-  async encryptWithPassword(data, password) {
-    try {
-      const openpgp = await getOpenPGP2();
-      const message = await openpgp.createMessage({
-        binary: data
-      });
-      const encrypted = await openpgp.encrypt({
-        message,
-        passwords: [password],
-        format: "binary"
-      });
-      if (encrypted instanceof Uint8Array) {
-        return encrypted;
-      }
-      if (encrypted && typeof encrypted === "object" && "getReader" in encrypted) {
-        return await streamToUint8Array(
-          encrypted
-        );
-      }
-      throw new Error("Unexpected encrypted data format");
-    } catch (error) {
-      throw wrapCryptoError("encrypt with password", error);
-    }
-  }
-  async decryptWithPassword(encryptedData, password) {
-    try {
-      const openpgp = await getOpenPGP2();
-      const message = await openpgp.readMessage({
-        binaryMessage: encryptedData
-      });
-      const { data: decrypted } = await openpgp.decrypt({
-        message,
-        passwords: [password],
-        format: "binary"
-      });
-      return new Uint8Array(decrypted);
-    } catch (error) {
-      throw wrapCryptoError("decrypt with password", error);
-    }
-  }
-};
-var NodePGPAdapter = class {
-  async encrypt(data, publicKeyArmored) {
-    try {
-      const openpgp = await getOpenPGP2();
-      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
-      const encrypted = await openpgp.encrypt({
-        message: await openpgp.createMessage({ text: data }),
-        encryptionKeys: publicKey,
-        config: {
-          preferredCompressionAlgorithm: openpgp.enums.compression.zlib
-        }
-      });
-      return encrypted;
-    } catch (error) {
-      throw wrapCryptoError("PGP encryption", error);
-    }
-  }
-  async decrypt(encryptedData, privateKeyArmored) {
-    try {
-      const openpgp = await getOpenPGP2();
-      const privateKey = await openpgp.readPrivateKey({
-        armoredKey: privateKeyArmored
-      });
-      const message = await openpgp.readMessage({
-        armoredMessage: encryptedData
-      });
-      const { data: decrypted } = await openpgp.decrypt({
-        message,
-        decryptionKeys: privateKey
-      });
-      return decrypted;
-    } catch (error) {
-      throw wrapCryptoError("PGP decryption", error);
-    }
-  }
-  async generateKeyPair(options) {
-    try {
-      const openpgp = await getOpenPGP2();
-      const keyGenParams = getPGPKeyGenParams(options);
-      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
-      return { publicKey, privateKey };
-    } catch (error) {
-      throw wrapCryptoError("PGP key generation", error);
-    }
-  }
-};
-var NodeHttpAdapter = class {
-  async fetch(url, options) {
-    if (typeof globalThis.fetch !== "undefined") {
-      return globalThis.fetch(url, options);
-    }
-    throw new Error("No fetch implementation available in Node.js environment");
-  }
-};
-var NodeCacheAdapter = class {
-  cache = /* @__PURE__ */ new Map();
-  defaultTtl = 2 * 60 * 60 * 1e3;
-  // 2 hours in milliseconds
-  get(key) {
-    const entry = this.cache.get(key);
-    if (!entry) {
-      return null;
-    }
-    if (Date.now() > entry.expires) {
-      this.cache.delete(key);
-      return null;
-    }
-    return entry.value;
-  }
-  set(key, value) {
-    this.cache.set(key, {
-      value,
-      expires: Date.now() + this.defaultTtl
-    });
-  }
-  delete(key) {
-    this.cache.delete(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-};
-var NodePlatformAdapter = class {
-  crypto;
-  pgp;
-  http;
-  cache;
-  platform = "node";
-  constructor() {
-    this.crypto = new NodeCryptoAdapter();
-    this.pgp = new NodePGPAdapter();
-    this.http = new NodeHttpAdapter();
-    this.cache = new NodeCacheAdapter();
-  }
-};
-var nodePlatformAdapter = new NodePlatformAdapter();
-
-// src/platform/utils.ts
-function detectPlatform() {
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "browser";
-  }
-  return "node";
-}
-async function createPlatformAdapter() {
-  const platform = detectPlatform();
-  try {
-    if (platform === "node") {
-      if (typeof window !== "undefined") {
-        throw new Error(
-          "NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead."
-        );
-      }
-      const moduleName = "./node";
-      const { NodePlatformAdapter: NodePlatformAdapter2 } = await import(moduleName);
-      return new NodePlatformAdapter2();
-    } else {
-      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
-      return new BrowserPlatformAdapter2();
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to create platform adapter for ${platform}: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-async function createPlatformAdapterFor(platformType) {
-  try {
-    if (platformType === "node") {
-      if (typeof window !== "undefined") {
-        throw new Error(
-          "NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead."
-        );
-      }
-      const moduleName = "./node";
-      const { NodePlatformAdapter: NodePlatformAdapter2 } = await import(moduleName);
-      return new NodePlatformAdapter2();
-    } else {
-      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
-      return new BrowserPlatformAdapter2();
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to create platform adapter for ${platformType}: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-function isPlatformSupported(platformType) {
-  const currentPlatform = detectPlatform();
-  return currentPlatform === platformType;
-}
-function getPlatformCapabilities() {
-  const platform = detectPlatform();
-  return {
-    platform,
-    crypto: {
-      webCrypto: typeof crypto !== "undefined" && crypto.subtle,
-      nodeCrypto: typeof process !== "undefined" && process.versions && process.versions.node
-    },
-    fetch: typeof fetch !== "undefined" || typeof globalThis.fetch !== "undefined",
-    streams: typeof ReadableStream !== "undefined"
-  };
-}
-
-// src/platform/browser-safe.ts
-init_browser();
-async function createNodePlatformAdapter() {
-  if (typeof window !== "undefined") {
-    throw new Error(
-      "NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead."
-    );
-  }
-  const moduleName = "./node";
-  const { NodePlatformAdapter: NodePlatformAdapter2 } = await import(moduleName);
-  return new NodePlatformAdapter2();
-}
-function createBrowserPlatformAdapter() {
-  return new BrowserPlatformAdapter();
-}
-async function createPlatformAdapterSafe() {
-  if (typeof window !== "undefined") {
-    return createBrowserPlatformAdapter();
-  }
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    if (typeof window === "undefined") {
-      return await createNodePlatformAdapter();
-    }
-  }
-  return createBrowserPlatformAdapter();
-}
+var import_browser = require("./platform/browser");
+var import_node = require("./platform/node");
+var import_utils = require("./platform/utils");
+var import_browser_safe = require("./platform/browser-safe");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserPlatformAdapter,