@opendatalabs/vana-sdk 0.1.0-alpha.7e4db82 → 0.1.0-alpha.7ee7635

package/dist/node.cjs

@@ -0,0 +1,29 @@
+"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);
+var node_exports = {};
+__export(node_exports, {
+  NodePlatformAdapter: () => import_node.NodePlatformAdapter
+});
+module.exports = __toCommonJS(node_exports);
+var import_node = require("./platform/node");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodePlatformAdapter
+});
+//# sourceMappingURL=node.cjs.map

package/dist/node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node.ts"],"sourcesContent":["/**\n * Re-export Node.js platform adapter for dynamic imports\n */\nexport { NodePlatformAdapter } from \"./platform/node\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,kBAAoC;","names":[]}

package/dist/node.d.cts

@@ -0,0 +1,2 @@
+export { NodePlatformAdapter } from './platform/node.cjs';
+import './platform/interface.cjs';

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+export { NodePlatformAdapter } from './platform/node.js';
+import './platform/interface.js';

package/dist/node.js

@@ -0,0 +1,5 @@
+import { NodePlatformAdapter } from "./platform/node";
+export {
+  NodePlatformAdapter
+};
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node.ts"],"sourcesContent":["/**\n * Re-export Node.js platform adapter for dynamic imports\n */\nexport { NodePlatformAdapter } from \"./platform/node\";\n"],"mappings":"AAGA,SAAS,2BAA2B;","names":[]}

package/dist/platform/browser-only.cjs

@@ -0,0 +1,37 @@
+"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);
+var browser_only_exports = {};
+__export(browser_only_exports, {
+  createBrowserPlatformAdapter: () => createBrowserPlatformAdapter,
+  createPlatformAdapterSafe: () => createPlatformAdapterSafe
+});
+module.exports = __toCommonJS(browser_only_exports);
+var import_browser = require("./browser");
+function createBrowserPlatformAdapter() {
+  return new import_browser.BrowserPlatformAdapter();
+}
+function createPlatformAdapterSafe() {
+  return createBrowserPlatformAdapter();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowserPlatformAdapter,
+  createPlatformAdapterSafe
+});
+//# sourceMappingURL=browser-only.cjs.map

package/dist/platform/browser-only.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-only.ts"],"sourcesContent":["/**\n * Browser-only exports for platform adapters\n *\n * This file provides browser-only exports that completely avoid Node.js imports\n * when bundling for browser environments. This is used by the browser entry point.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-only platform adapter factory\n * This version does not include Node.js imports at all\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createPlatformAdapterSafe(): VanaPlatformAdapter {\n  // Always return browser adapter in browser environments\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,qBAAuC;AAOhC,SAAS,+BAAoD;AAClE,SAAO,IAAI,sCAAuB;AACpC;AAQO,SAAS,4BAAiD;AAE/D,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-only.d.cts

@@ -0,0 +1,25 @@
+import { VanaPlatformAdapter } from './interface.cjs';
+export { BrowserPlatformAdapter } from './browser.cjs';
+
+/**
+ * Browser-only exports for platform adapters
+ *
+ * This file provides browser-only exports that completely avoid Node.js imports
+ * when bundling for browser environments. This is used by the browser entry point.
+ */
+
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-only platform adapter factory
+ * This version does not include Node.js imports at all
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createPlatformAdapterSafe(): VanaPlatformAdapter;
+
+export { VanaPlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser-only.d.ts

@@ -0,0 +1,25 @@
+import { VanaPlatformAdapter } from './interface.js';
+export { BrowserPlatformAdapter } from './browser.js';
+
+/**
+ * Browser-only exports for platform adapters
+ *
+ * This file provides browser-only exports that completely avoid Node.js imports
+ * when bundling for browser environments. This is used by the browser entry point.
+ */
+
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-only platform adapter factory
+ * This version does not include Node.js imports at all
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createPlatformAdapterSafe(): VanaPlatformAdapter;
+
+export { VanaPlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser-only.js

@@ -0,0 +1,12 @@
+import { BrowserPlatformAdapter } from "./browser";
+function createBrowserPlatformAdapter() {
+  return new BrowserPlatformAdapter();
+}
+function createPlatformAdapterSafe() {
+  return createBrowserPlatformAdapter();
+}
+export {
+  createBrowserPlatformAdapter,
+  createPlatformAdapterSafe
+};
+//# sourceMappingURL=browser-only.js.map

package/dist/platform/browser-only.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-only.ts"],"sourcesContent":["/**\n * Browser-only exports for platform adapters\n *\n * This file provides browser-only exports that completely avoid Node.js imports\n * when bundling for browser environments. This is used by the browser entry point.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-only platform adapter factory\n * This version does not include Node.js imports at all\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createPlatformAdapterSafe(): VanaPlatformAdapter {\n  // Always return browser adapter in browser environments\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n"],"mappings":"AAQA,SAAS,8BAA8B;AAOhC,SAAS,+BAAoD;AAClE,SAAO,IAAI,uBAAuB;AACpC;AAQO,SAAS,4BAAiD;AAE/D,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-safe.cjs

@@ -0,0 +1,57 @@
+"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);
+var browser_safe_exports = {};
+__export(browser_safe_exports, {
+  createBrowserPlatformAdapter: () => createBrowserPlatformAdapter,
+  createNodePlatformAdapter: () => createNodePlatformAdapter,
+  createPlatformAdapterSafe: () => createPlatformAdapterSafe
+});
+module.exports = __toCommonJS(browser_safe_exports);
+var import_browser = require("./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 } = await import(moduleName);
+  return new NodePlatformAdapter();
+}
+function createBrowserPlatformAdapter() {
+  return new import_browser.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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowserPlatformAdapter,
+  createNodePlatformAdapter,
+  createPlatformAdapterSafe
+});
+//# sourceMappingURL=browser-safe.cjs.map

package/dist/platform/browser-safe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-safe.ts"],"sourcesContent":["/**\n * Browser-safe exports for platform adapters\n *\n * This file provides browser-safe exports that avoid importing Node.js dependencies\n * when bundling for browser environments.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Dynamically imports the NodePlatformAdapter only when needed\n * This prevents Node.js modules from being bundled in browser builds\n *\n * @returns Promise resolving to a NodePlatformAdapter instance\n * @throws {Error} If running in a browser environment\n */\nexport async function createNodePlatformAdapter(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    throw new Error(\n      \"NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead.\",\n    );\n  }\n\n  // Use string concatenation to avoid static analysis during bundling\n  const moduleName = \"./node\";\n  const { NodePlatformAdapter } = await import(moduleName);\n  return new NodePlatformAdapter();\n}\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-safe platform adapter factory\n *\n * @returns Promise resolving to the appropriate platform adapter\n */\nexport async function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    return createBrowserPlatformAdapter();\n  }\n\n  // Check for Node.js environment\n  if (\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node\n  ) {\n    // Only attempt Node.js import if we're not in a browser environment\n    if (typeof window === \"undefined\") {\n      return await createNodePlatformAdapter();\n    }\n  }\n\n  // Default to browser if we can't determine\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n// NodePlatformAdapter type is available through dynamic import to avoid bundling Node.js dependencies\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,qBAAuC;AASvC,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,QAAM,aAAa;AACnB,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO;AAC7C,SAAO,IAAI,oBAAoB;AACjC;AAOO,SAAS,+BAAoD;AAClE,SAAO,IAAI,sCAAuB;AACpC;AAOA,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,6BAA6B;AAAA,EACtC;AAGA,MACE,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,MACjB;AAEA,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO,MAAM,0BAA0B;AAAA,IACzC;AAAA,EACF;AAGA,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-safe.d.cts

@@ -0,0 +1,32 @@
+import { VanaPlatformAdapter } from './interface.cjs';
+export { BrowserPlatformAdapter } from './browser.cjs';
+
+/**
+ * Browser-safe exports for platform adapters
+ *
+ * This file provides browser-safe exports that avoid importing Node.js dependencies
+ * when bundling for browser environments.
+ */
+
+/**
+ * Dynamically imports the NodePlatformAdapter only when needed
+ * This prevents Node.js modules from being bundled in browser builds
+ *
+ * @returns Promise resolving to a NodePlatformAdapter instance
+ * @throws {Error} If running in a browser environment
+ */
+declare function createNodePlatformAdapter(): Promise<VanaPlatformAdapter>;
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-safe platform adapter factory
+ *
+ * @returns Promise resolving to the appropriate platform adapter
+ */
+declare function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter>;
+
+export { VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser-safe.d.ts

@@ -0,0 +1,32 @@
+import { VanaPlatformAdapter } from './interface.js';
+export { BrowserPlatformAdapter } from './browser.js';
+
+/**
+ * Browser-safe exports for platform adapters
+ *
+ * This file provides browser-safe exports that avoid importing Node.js dependencies
+ * when bundling for browser environments.
+ */
+
+/**
+ * Dynamically imports the NodePlatformAdapter only when needed
+ * This prevents Node.js modules from being bundled in browser builds
+ *
+ * @returns Promise resolving to a NodePlatformAdapter instance
+ * @throws {Error} If running in a browser environment
+ */
+declare function createNodePlatformAdapter(): Promise<VanaPlatformAdapter>;
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-safe platform adapter factory
+ *
+ * @returns Promise resolving to the appropriate platform adapter
+ */
+declare function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter>;
+
+export { VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser-safe.js

@@ -0,0 +1,31 @@
+import { BrowserPlatformAdapter } from "./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 } = await import(moduleName);
+  return new NodePlatformAdapter();
+}
+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();
+}
+export {
+  createBrowserPlatformAdapter,
+  createNodePlatformAdapter,
+  createPlatformAdapterSafe
+};
+//# sourceMappingURL=browser-safe.js.map

package/dist/platform/browser-safe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-safe.ts"],"sourcesContent":["/**\n * Browser-safe exports for platform adapters\n *\n * This file provides browser-safe exports that avoid importing Node.js dependencies\n * when bundling for browser environments.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Dynamically imports the NodePlatformAdapter only when needed\n * This prevents Node.js modules from being bundled in browser builds\n *\n * @returns Promise resolving to a NodePlatformAdapter instance\n * @throws {Error} If running in a browser environment\n */\nexport async function createNodePlatformAdapter(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    throw new Error(\n      \"NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead.\",\n    );\n  }\n\n  // Use string concatenation to avoid static analysis during bundling\n  const moduleName = \"./node\";\n  const { NodePlatformAdapter } = await import(moduleName);\n  return new NodePlatformAdapter();\n}\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-safe platform adapter factory\n *\n * @returns Promise resolving to the appropriate platform adapter\n */\nexport async function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    return createBrowserPlatformAdapter();\n  }\n\n  // Check for Node.js environment\n  if (\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node\n  ) {\n    // Only attempt Node.js import if we're not in a browser environment\n    if (typeof window === \"undefined\") {\n      return await createNodePlatformAdapter();\n    }\n  }\n\n  // Default to browser if we can't determine\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n// NodePlatformAdapter type is available through dynamic import to avoid bundling Node.js dependencies\n"],"mappings":"AAQA,SAAS,8BAA8B;AASvC,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,QAAM,aAAa;AACnB,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO;AAC7C,SAAO,IAAI,oBAAoB;AACjC;AAOO,SAAS,+BAAoD;AAClE,SAAO,IAAI,uBAAuB;AACpC;AAOA,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,6BAA6B;AAAA,EACtC;AAGA,MACE,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,MACjB;AAEA,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO,MAAM,0BAA0B;AAAA,IACzC;AAAA,EACF;AAGA,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser.cjs

@@ -0,0 +1,329 @@
+"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 __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 __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);
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserPlatformAdapter: () => BrowserPlatformAdapter
+});
+module.exports = __toCommonJS(browser_exports);
+var import_pgp_utils = require("./shared/pgp-utils");
+var import_error_utils = require("./shared/error-utils");
+var import_lazy_import = require("../utils/lazy-import");
+var import_WalletKeyEncryptionService = require("../crypto/services/WalletKeyEncryptionService");
+var import_crypto_utils = require("../utils/crypto-utils");
+var import_viem = require("viem");
+var import_utils = require("../crypto/ecies/utils");
+var secp256k1 = __toESM(require("@noble/secp256k1"), 1);
+var import_features = require("../config/features");
+var import_browser = require("../crypto/ecies/browser");
+const getOpenPGP = (0, import_lazy_import.lazyImport)(() => import("openpgp"));
+const getEccryptoJS = (0, import_lazy_import.lazyImport)(() => import("eccrypto-js"));
+class BrowserCryptoAdapter {
+  // Initialize both providers - only one will be used based on feature flag
+  customEciesProvider = new import_browser.BrowserECIESUint8Provider();
+  customWalletService = new import_WalletKeyEncryptionService.WalletKeyEncryptionService({
+    eciesProvider: this.customEciesProvider
+  });
+  async encryptWithPublicKey(data, publicKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const prefixedHex = publicKeyHex.startsWith("0x") ? publicKeyHex : `0x${publicKeyHex}`;
+        const publicKeyBytes = (0, import_viem.fromHex)(prefixedHex, "bytes");
+        const encrypted = await this.customEciesProvider.encrypt(
+          publicKeyBytes,
+          (0, import_viem.stringToBytes)(data)
+        );
+        const result = (0, import_utils.concatBytes)(
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        );
+        return (0, import_viem.toHex)(result).slice(2);
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const cleanKey = publicKeyHex.startsWith("0x") ? publicKeyHex.slice(2) : publicKeyHex;
+        const publicKeyBytes = Buffer.from(cleanKey, "hex");
+        const publicKeyBuffer = publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithPublicKey", error);
+    }
+  }
+  async decryptWithPrivateKey(encryptedData, privateKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const encryptedHex = encryptedData.startsWith("0x") ? encryptedData : `0x${encryptedData}`;
+        const privateHex = privateKeyHex.startsWith("0x") ? privateKeyHex : `0x${privateKeyHex}`;
+        const encryptedBytes = (0, import_viem.fromHex)(encryptedHex, "bytes");
+        const privateKeyBytes = (0, import_viem.fromHex)(privateHex, "bytes");
+        const encrypted = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBytes);
+        const decrypted = await this.customEciesProvider.decrypt(
+          privateKeyBytes,
+          encrypted
+        );
+        return (0, import_viem.bytesToString)(decrypted);
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKey = Buffer.from(privateKeyHex, "hex");
+        const encryptedBuffer = Buffer.from(encryptedData, "hex");
+        const { iv, ephemPublicKey, ciphertext, mac } = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBuffer);
+        const decrypted = await eccryptojs.decrypt(privateKey, {
+          iv: Buffer.from(iv),
+          ephemPublicKey: Buffer.from(ephemPublicKey),
+          ciphertext: Buffer.from(ciphertext),
+          mac: Buffer.from(mac)
+        });
+        return decrypted.toString("utf8");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithPrivateKey", error);
+    }
+  }
+  async encryptWithWalletPublicKey(data, publicKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.encryptWithWalletPublicKey(
+          data,
+          publicKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+        const publicKeyBytes = Buffer.from(cleanKey, "hex");
+        const publicKeyBuffer = publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithWalletPublicKey", error);
+    }
+  }
+  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.decryptWithWalletPrivateKey(
+          encryptedData,
+          privateKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKeyBuffer = Buffer.from(privateKey, "hex");
+        const encryptedBuffer = Buffer.from(encryptedData, "hex");
+        const { iv, ephemPublicKey, ciphertext, mac } = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBuffer);
+        const decrypted = await eccryptojs.decrypt(privateKeyBuffer, {
+          iv: Buffer.from(iv),
+          ephemPublicKey: Buffer.from(ephemPublicKey),
+          ciphertext: Buffer.from(ciphertext),
+          mac: Buffer.from(mac)
+        });
+        return decrypted.toString("utf8");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithWalletPrivateKey", error);
+    }
+  }
+  async generateKeyPair() {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const privateKeyBytes = secp256k1.utils.randomPrivateKey();
+        const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
+        return {
+          privateKey: (0, import_viem.toHex)(privateKeyBytes).slice(2),
+          publicKey: (0, import_viem.toHex)(publicKeyBytes).slice(2)
+        };
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKey = eccryptojs.generatePrivate();
+        const publicKey = eccryptojs.getPublic(privateKey);
+        return {
+          privateKey: privateKey.toString("hex"),
+          publicKey: publicKey.toString("hex")
+        };
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("generateKeyPair", 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"
+      });
+      return new Uint8Array(encrypted);
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithPassword", error);
+    }
+  }
+  async decryptWithPassword(encryptedData, password) {
+    try {
+      const openpgp = await getOpenPGP();
+      const message = await openpgp.readMessage({
+        binaryMessage: encryptedData
+      });
+      const { data } = await openpgp.decrypt({
+        message,
+        passwords: [password],
+        format: "binary"
+      });
+      return new Uint8Array(data);
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithPassword", error);
+    }
+  }
+}
+class BrowserPGPAdapter {
+  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 = (0, import_pgp_utils.getPGPKeyGenParams)(options);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
+      return { publicKey, privateKey };
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("PGP key generation", error);
+    }
+  }
+}
+class BrowserHttpAdapter {
+  async fetch(url, options) {
+    return fetch(url, options);
+  }
+}
+class BrowserCacheAdapter {
+  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") {
+        return;
+      }
+      sessionStorage.setItem(this.prefix + key, value);
+    } catch {
+    }
+  }
+  delete(key) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      sessionStorage.removeItem(this.prefix + key);
+    } catch {
+    }
+  }
+  clear() {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      const keysToRemove = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => sessionStorage.removeItem(key));
+    } catch {
+    }
+  }
+}
+class BrowserPlatformAdapter {
+  crypto = new BrowserCryptoAdapter();
+  pgp = new BrowserPGPAdapter();
+  http = new BrowserHttpAdapter();
+  cache = new BrowserCacheAdapter();
+  platform = "browser";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserPlatformAdapter
+});
+//# sourceMappingURL=browser.cjs.map