@nibgate/sdk 0.2.22 → 0.2.24

package/dist/nibgate.js

@@ -423,211 +423,6 @@ var Nibgate = (() => {
     }
   });
 
-  // src/browser/track.js
-  function trackResourcePage(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const validation = validateResourceMetadata(item.resource, options.validation || {});
-    if ((validation.warnings.length || validation.errors.length) && options.warn !== false && browserWindow()?.console?.warn) {
-      browserWindow().console.warn("Nibgate content metadata needs attention", validation);
-    }
-    item.content({ source: options.source, metadataQuality: { score: validation.score, warnings: validation.warnings, errors: validation.errors }, ...options.content || {} });
-    item.view({
-      source: options.source,
-      path: options.path || browserWindow()?.location?.pathname || item.resource.path,
-      referrer: options.referrer ?? browserWindow()?.document?.referrer ?? "",
-      ...options.view || {}
-    });
-    return item;
-  }
-  function setupResourcePage(resource, options = {}) {
-    const item = trackResourcePage(resource, options);
-    const win = browserWindow();
-    if (!win) return item;
-    const button = typeof options.button === "string" ? win.document.querySelector(options.button) : options.button;
-    const statusElement = typeof options.status === "string" ? win.document.querySelector(options.status) : options.status;
-    const setStatus = options.onStatus || ((message) => {
-      if (statusElement) statusElement.textContent = message || "";
-    });
-    if (button) {
-      button.addEventListener("click", async () => {
-        button.disabled = true;
-        try {
-          await checkResourceAccess(resource, { ...options, onStatus: setStatus });
-        } finally {
-          button.disabled = false;
-        }
-      });
-    }
-    return item;
-  }
-  var init_track = __esm({
-    "src/browser/track.js"() {
-      init_resource();
-      init_env();
-      init_gate();
-      init_access();
-    }
-  });
-
-  // src/browser/access.js
-  async function checkResourceAccess(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
-    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status2(options.checkingMessage || "Checking access route...");
-    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "nibgate-access-route" });
-    const response = await fetch(accessPath, {
-      method: options.method || "GET",
-      headers: {
-        accept: "application/json",
-        ...getPaymentProof(item.resource) ? { "x-nibgate-payment-proof": getPaymentProof(item.resource) } : {},
-        ...options.headers || {}
-      },
-      body: options.body
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (response.status === 402) {
-      item.track("payment_challenge_returned", { source: options.source, challenge: payload, resource: item.resource });
-      status2(options.challengeMessage || "Payment challenge returned. Continue with checkout.");
-      if (typeof options.createPaymentSignature === "function" || typeof options.checkout === "function") {
-        return payWithPaymentSignature(resource, {
-          ...options,
-          challenge: payload,
-          paymentRequiredHeader: response.headers.get("PAYMENT-REQUIRED") || response.headers.get("payment-required") || ""
-        });
-      }
-      if (options.autoPay && options.payPath) {
-        const paymentResult = await payAndUnlockResource(resource, options);
-        if (paymentResult.ok && options.retryAfterPay !== false) {
-          return checkResourceAccess(resource, { ...options, autoPay: false });
-        }
-        return paymentResult;
-      }
-      return { ok: false, status: response.status, challenge: payload, resource: item.resource, response };
-    }
-    if (!response.ok) {
-      status2(payload.error || options.errorMessage || "Access check failed");
-      return { ok: false, status: response.status, error: payload.error || "Access check failed", payload, resource: item.resource, response };
-    }
-    const payment = options.payment || payload.payment || null;
-    if (payment) {
-      item.unlockCompleted(payment);
-      item.paymentCompleted(payment);
-    }
-    status2(options.successMessage || "Access allowed and Nibgate events emitted.");
-    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
-  }
-  async function payWithPaymentSignature(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
-    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status2(options.paymentMessage || "Waiting for wallet payment approval...");
-    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "wallet-gateway" });
-    let paymentSignature = options.paymentSignature || "";
-    let paymentMemo = options.memo || "";
-    let paymentMetadata = options.payment || {};
-    if (!paymentSignature) {
-      const paymentRequiredHeader = options.paymentRequiredHeader || "";
-      const challenge2 = options.challenge || null;
-      const checkout = options.createPaymentSignature || options.checkout;
-      const result = await checkout({
-        resource: item.resource,
-        challenge: challenge2,
-        paymentRequiredHeader,
-        accessPath
-      });
-      paymentSignature = result?.paymentSignature || result?.signature || result?.payment || "";
-      paymentMemo = result?.memo || result?.paymentMemo || "";
-      paymentMetadata = result?.metadata || result?.paymentMetadata || result || {};
-    }
-    if (!paymentSignature) {
-      const error = "Wallet did not return a payment signature.";
-      item.track("payment_failed", { source: options.source, error });
-      status2(error);
-      return { ok: false, status: 400, error, resource: item.resource };
-    }
-    const response = await fetch(accessPath, {
-      method: options.method || "GET",
-      headers: {
-        accept: "application/json",
-        "payment-signature": paymentSignature,
-        ...paymentMemo ? { "payment-memo": paymentMemo } : {},
-        ...options.headers || {}
-      }
-    });
-    const responseText = await response.text();
-    let payload = {};
-    try {
-      payload = responseText ? JSON.parse(responseText) : {};
-    } catch (_error) {
-      payload = { error: responseText || "Payment verification failed" };
-    }
-    if (!response.ok) {
-      const detail = payload.detail || payload.reason || payload.invalidReason || payload.error || responseText || "Payment verification failed";
-      const error = typeof detail === "string" ? detail : stringifyJson(detail);
-      item.track("payment_failed", { source: options.source, status: response.status, error, ...paymentMetadata });
-      status2(options.paymentErrorMessage || error);
-      return { ok: false, status: response.status, error, payload, resource: item.resource, response };
-    }
-    const payment = payload.payment || {
-      paymentProvider: options.paymentProvider || "wallet-gateway",
-      paymentId: paymentSignature,
-      memo: paymentMemo,
-      amount: Number(item.resource.price || 0),
-      revenue: Number(item.resource.price || 0),
-      currency: item.resource.currency || "USDC",
-      ...paymentMetadata
-    };
-    storePaymentProof(item.resource, payload.unlockProof);
-    item.markUnlocked(payment);
-    status2(options.paymentSuccessMessage || "Payment verified. Content unlocked.");
-    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
-  }
-  async function payAndUnlockResource(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const payPath = options.payPath || item.resource.payPath || "/api/nibgate/pay";
-    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status2(options.paymentMessage || "Starting payment...");
-    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "circle-gateway" });
-    const response = await fetch(payPath, {
-      method: options.payMethod || "POST",
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-        ...options.payHeaders || {}
-      },
-      body: JSON.stringify({ resource: item.resource, ...options.payPayload || {} })
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || !payload.ok) {
-      item.track("payment_failed", { source: options.source, status: response.status, error: payload.error || "Payment failed", detail: payload.detail || "" });
-      status2(payload.detail || payload.error || options.paymentErrorMessage || "Payment failed.");
-      return { ok: false, status: response.status, payload, resource: item.resource, response };
-    }
-    const payment = payload.payment || {
-      paymentProvider: options.paymentProvider || "circle-gateway",
-      paymentId: payload.paymentId || `nibgate_payment_${Date.now()}`,
-      amount: Number(item.resource.price || 0),
-      revenue: Number(item.resource.price || 0),
-      currency: item.resource.currency || "USDC"
-    };
-    storePaymentProof(item.resource, payload.unlockProof);
-    item.markUnlocked(payment);
-    status2(options.paymentSuccessMessage || "Payment verified. Content unlocked.");
-    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
-  }
-  var init_access = __esm({
-    "src/browser/access.js"() {
-      init_events();
-      init_storage();
-      init_json();
-      init_gate();
-    }
-  });
-
   // src/core/rating.js
   function normalizeRating(input = {}) {
     const value = typeof input === "number" ? input : input.rating ?? input.stars ?? input.ratingValue ?? input.score;
@@ -26806,232 +26601,34 @@ ${prettyStateOverride(stateOverride)}`;
     }
   });
 
-  // src/browser/evm-gateway.js
-  async function createCircleGatewayBrowserAdapter2(options = {}) {
-    const gateway = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
-    return gateway.createCircleGatewayBrowserAdapter(options);
+  // src/browser/reputation.js
+  function stripHex(value = "") {
+    return String(value || "").replace(/^0x/i, "").replace(/[^0-9a-fA-F]/g, "").toLowerCase();
   }
-  function resolveAccessPath(resource, options) {
-    if (options.hosted || options.accessPath === "hosted") return HOSTED_PAY_URL;
-    return options.accessPath || resource.accessPath || "/api/nibgate/access";
+  function wordRight(hex = "") {
+    const clean2 = stripHex(hex);
+    if (clean2.length > 64) throw new Error("ABI word is too long.");
+    return clean2.padEnd(64, "0");
   }
-  function createEvmGatewayUnlock(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const win = browserWindow();
-    const accessPath = resolveAccessPath(item.resource, options);
-    const source = options.source || "nibgate-evm-gateway";
-    const network = options.network || "eip155:5042002";
-    const statusTarget = typeof options.status === "string" ? win?.document.querySelector(options.status) : options.status;
-    const connectButton = typeof options.connectButton === "string" ? win?.document.querySelector(options.connectButton) : options.connectButton;
-    const disconnectButton = typeof options.disconnectButton === "string" ? win?.document.querySelector(options.disconnectButton) : options.disconnectButton;
-    const unlockButton = typeof options.unlockButton === "string" ? win?.document.querySelector(options.unlockButton) : options.unlockButton;
-    const clearButton = typeof options.clearButton === "string" ? win?.document.querySelector(options.clearButton) : options.clearButton;
-    const walletLabel = typeof options.walletLabel === "string" ? win?.document.querySelector(options.walletLabel) : options.walletLabel;
-    const unlockedTarget = typeof options.unlockedTarget === "string" ? win?.document.querySelector(options.unlockedTarget) : options.unlockedTarget;
-    let walletAddress = "";
-    let busy = false;
-    function setStatus(message) {
-      if (typeof options.onStatus === "function") options.onStatus(message);
-      if (statusTarget) statusTarget.textContent = message || "";
-    }
-    function shortAddress(address) {
-      return address ? `${address.slice(0, 6)}...${address.slice(-4)}` : "";
-    }
-    function provider() {
-      return win?.ethereum || options.provider || null;
-    }
-    function setBusy(value) {
-      busy = Boolean(value);
-      [connectButton, disconnectButton, unlockButton, clearButton].forEach((button) => {
-        if (button && "disabled" in button) {
-          button.disabled = busy || button === connectButton && !provider() || button === disconnectButton && !walletAddress;
-        }
-      });
-    }
-    function renderWallet() {
-      const hasProvider = Boolean(provider());
-      if (walletLabel) walletLabel.textContent = walletAddress ? shortAddress(walletAddress) : hasProvider ? "Ready to connect" : "No wallet detected";
-      if (connectButton) connectButton.textContent = walletAddress ? "Connected" : "Connect wallet";
-      if (disconnectButton) disconnectButton.textContent = "Disconnect";
-      if (connectButton && "disabled" in connectButton) connectButton.disabled = busy || !hasProvider;
-      if (disconnectButton && "disabled" in disconnectButton) disconnectButton.disabled = busy || !walletAddress;
-    }
-    function setUnlocked(isUnlocked, payment = {}) {
-      if (unlockButton) unlockButton.textContent = isUnlocked ? "Unlocked" : `Unlock for ${item.resource.price} ${item.resource.currency || "USDC"}`;
-      if (unlockedTarget) {
-        if ("hidden" in unlockedTarget) unlockedTarget.hidden = !isUnlocked;
-        unlockedTarget.setAttribute("aria-hidden", isUnlocked ? "false" : "true");
-      }
-      if (isUnlocked) item.markUnlocked(payment);
-    }
-    async function connect() {
-      setBusy(true);
-      setStatus("Opening wallet connection...");
-      try {
-        const evm = provider();
-        if (!evm) throw new Error(options.noWalletMessage || "Install or open an EVM wallet to continue.");
-        const accounts = await evm.request({ method: "eth_requestAccounts" });
-        walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
-        if (!walletAddress) throw new Error("No wallet account selected.");
-        renderWallet();
-        setStatus("Wallet connected. You can unlock now.");
-        return walletAddress;
-      } finally {
-        setBusy(false);
-      }
-    }
-    async function disconnect() {
-      setBusy(true);
-      try {
-        const evm = provider();
-        if (evm?.request && walletAddress) {
-          try {
-            await evm.request({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
-          } catch (_error) {
-          }
-        }
-        walletAddress = "";
-        renderWallet();
-        setStatus(options.disconnectMessage || "Wallet disconnected for this page.");
-        return true;
-      } finally {
-        setBusy(false);
-      }
-    }
-    async function checkout(input) {
-      const evm = provider();
-      if (!evm) throw new Error(options.noWalletMessage || "Install or open an EVM wallet to continue.");
-      const currentAccounts = await evm.request({ method: "eth_accounts" }).catch(() => walletAddress ? [walletAddress] : []);
-      const currentAddress = Array.isArray(currentAccounts) && currentAccounts[0] ? currentAccounts[0] : walletAddress || await connect();
-      if (currentAddress !== walletAddress) walletAddress = currentAddress;
-      const gatewayWallet = await createCircleGatewayBrowserAdapter2({
-        network,
-        signer: {
-          address: currentAddress,
-          signTypedData: async (typedData) => {
-            const { createWalletClient: createWalletClient2, custom: custom2 } = await Promise.resolve().then(() => (init_esm(), esm_exports));
-            const wc = createWalletClient2({ transport: custom2(evm) });
-            return wc.signTypedData({
-              account: currentAddress,
-              domain: typedData.domain,
-              types: typedData.types,
-              primaryType: typedData.primaryType,
-              message: typedData.message
-            });
-          }
-        },
-        clientModule: options.circleClientModule
-      });
-      return gatewayWallet.pay(input);
-    }
-    async function unlock() {
-      setBusy(true);
-      try {
-        if (!walletAddress) await connect();
-        setBusy(true);
-        setStatus("Requesting Gateway unlock...");
-        const result = await checkResourceAccess(item.resource, {
-          accessPath,
-          source,
-          paymentProvider: options.paymentProvider || "circle-gateway-browser",
-          challengeMessage: options.challengeMessage || "Gateway payment required. Connect your wallet to continue...",
-          paymentMessage: options.paymentMessage || "Approve the Gateway payment proof in your wallet...",
-          successMessage: options.successMessage || `Unlocked ${item.resource.title || "content"}.`,
-          method: options.method,
-          headers: options.headers,
-          body: options.body,
-          checkout,
-          onStatus: setStatus
-        });
-        if (result.ok) {
-          setUnlocked(true, result.payment || {});
-          if (typeof options.onUnlock === "function") options.onUnlock(result);
-        }
-        return result;
-      } catch (error) {
-        const message = error?.message || "Unlock failed. Please try again.";
-        setStatus(message);
-        return { ok: false, status: 0, error: message, resource: item.resource };
-      } finally {
-        setBusy(false);
-        renderWallet();
-      }
-    }
-    function clear() {
-      clearPaymentProof(item.resource);
-      setUnlocked(false);
-      setStatus("Local payment proof cleared. The next unlock will require Gateway payment again.");
-    }
-    async function hydrate() {
-      const evm = provider();
-      try {
-        const accounts = evm ? await evm.request({ method: "eth_accounts" }) : [];
-        walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
-      } catch {
-      }
-      renderWallet();
-      setUnlocked(false);
-    }
-    function mount() {
-      connectButton?.addEventListener?.("click", () => connect().catch((error) => setStatus(error?.message || "Could not connect wallet.")));
-      disconnectButton?.addEventListener?.("click", () => disconnect().catch((error) => setStatus(error?.message || "Could not disconnect wallet.")));
-      unlockButton?.addEventListener?.("click", () => unlock());
-      clearButton?.addEventListener?.("click", clear);
-      hydrate();
-      trackResourcePage(item.resource, { source });
-      return controller;
-    }
-    const controller = { resource: item.resource, connect, disconnect, unlock, clear, hydrate, mount, getWalletAddress: () => walletAddress };
-    if (options.autoMount !== false) mount();
-    return controller;
-  }
-  function createHostedUnlock(resource, options = {}) {
-    return createEvmGatewayUnlock(resource, {
-      ...options,
-      hosted: true,
-      noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
-    });
-  }
-  var HOSTED_PAY_URL;
-  var init_evm_gateway = __esm({
-    "src/browser/evm-gateway.js"() {
-      init_env();
-      init_storage();
-      init_gate();
-      init_access();
-      init_track();
-      HOSTED_PAY_URL = "https://api.nibgate.xyz/api/hub/pay";
-    }
-  });
-
-  // src/browser/reputation.js
-  function stripHex(value = "") {
-    return String(value || "").replace(/^0x/i, "").replace(/[^0-9a-fA-F]/g, "").toLowerCase();
-  }
-  function wordRight(hex = "") {
-    const clean2 = stripHex(hex);
-    if (clean2.length > 64) throw new Error("ABI word is too long.");
-    return clean2.padEnd(64, "0");
-  }
-  function numberWord(value = 0) {
-    return Number(value || 0).toString(16).padStart(64, "0");
-  }
-  function utf8Hex(value = "") {
-    return Array.from(new TextEncoder().encode(String(value || ""))).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  }
-  function encodeString3(value = "") {
-    const hex = utf8Hex(value);
-    const byteLength = hex.length / 2;
-    const paddedLength = Math.ceil(byteLength / 32) * 64;
-    return numberWord(byteLength) + hex.padEnd(paddedLength, "0");
-  }
-  function encodeRateContent({ contentId, ratingValue, reviewHash, unlockRef }) {
-    return RATE_CONTENT_SELECTOR + wordRight(contentId) + numberWord(ratingValue) + wordRight(reviewHash || ZERO_HASH) + numberWord(128) + encodeString3(unlockRef || "");
-  }
-  function contentRatingHash(_resource, options = {}) {
-    const contentId = options.contentId || options.contentHash;
-    if (!contentId) {
-      throw new Error("contentId/contentHash is required. Use the Nibgate backend prepare endpoint or pass a known content hash.");
+  function numberWord(value = 0) {
+    return Number(value || 0).toString(16).padStart(64, "0");
+  }
+  function utf8Hex(value = "") {
+    return Array.from(new TextEncoder().encode(String(value || ""))).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  function encodeString3(value = "") {
+    const hex = utf8Hex(value);
+    const byteLength = hex.length / 2;
+    const paddedLength = Math.ceil(byteLength / 32) * 64;
+    return numberWord(byteLength) + hex.padEnd(paddedLength, "0");
+  }
+  function encodeRateContent({ contentId, ratingValue, reviewHash, unlockRef }) {
+    return RATE_CONTENT_SELECTOR + wordRight(contentId) + numberWord(ratingValue) + wordRight(reviewHash || ZERO_HASH) + numberWord(128) + encodeString3(unlockRef || "");
+  }
+  function contentRatingHash(_resource, options = {}) {
+    const contentId = options.contentId || options.contentHash;
+    if (!contentId) {
+      throw new Error("contentId/contentHash is required. Use the Nibgate backend prepare endpoint or pass a known content hash.");
     }
     return contentId;
   }
@@ -27287,13 +26884,654 @@ ${prettyStateOverride(stateOverride)}`;
     }
   });
 
-  // src/browser/default-ui.js
-  var default_ui_exports = {};
-  __export(default_ui_exports, {
+  // src/browser/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    ACCESS_MODES: () => ACCESS_MODES,
+    CONTENT_TYPES: () => CONTENT_TYPES,
+    NIBGATE_CONTENT_HASH_NAMESPACE: () => NIBGATE_CONTENT_HASH_NAMESPACE,
+    NIBGATE_CONTENT_SETTING_FIELDS: () => NIBGATE_CONTENT_SETTING_FIELDS,
+    NIBGATE_REPUTATION_ABI: () => NIBGATE_REPUTATION_ABI,
+    NIBGATE_REPUTATION_CHAIN_ID: () => NIBGATE_REPUTATION_CHAIN_ID,
+    NIBGATE_REPUTATION_CHAIN_NAME: () => NIBGATE_REPUTATION_CHAIN_NAME,
+    NIBGATE_REPUTATION_CONTRACT: () => NIBGATE_REPUTATION_CONTRACT,
+    NIBGATE_REPUTATION_RPC_URL: () => NIBGATE_REPUTATION_RPC_URL,
+    PAYMENT_RAILS: () => PAYMENT_RAILS,
+    UNLOCK_MODES: () => UNLOCK_MODES,
+    checkResourceAccess: () => checkResourceAccess,
+    contentRatingHash: () => contentRatingHash,
+    createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter2,
+    createEvmGatewayUnlock: () => createEvmGatewayUnlock,
+    createGate: () => createGate,
+    createHostedUnlock: () => createHostedUnlock,
+    createNibgate: () => createNibgate,
+    createNibgateContentSettings: () => createNibgateContentSettings,
+    createOnchainRating: () => createOnchainRating,
+    createTransferCheckout: () => createTransferCheckout,
+    createWalletCheckout: () => createWalletCheckout,
+    mountRatingUI: () => mountRatingUI,
+    nibgate: () => nibgate,
+    normalizeAccessPolicy: () => normalizeAccessPolicy,
+    normalizeContentType: () => normalizeContentType,
+    normalizePaymentRail: () => normalizePaymentRail,
+    normalizeResource: () => normalizeResource,
+    normalizeUnlockPolicy: () => normalizeUnlockPolicy,
+    payAndUnlockResource: () => payAndUnlockResource,
+    payWithPaymentSignature: () => payWithPaymentSignature,
+    payWithTransfer: () => payWithTransfer,
+    rateContentOnchain: () => rateContentOnchain,
+    rateResource: () => rateResource,
     renderDefaultGatewayWalletUI: () => renderDefaultGatewayWalletUI,
     renderDefaultRatingUI: () => renderDefaultRatingUI,
-    renderDefaultUnlockUI: () => renderDefaultUnlockUI
+    renderDefaultUnlockUI: () => renderDefaultUnlockUI,
+    reviewTextHash: () => reviewTextHash,
+    settingsToAccessPolicy: () => settingsToAccessPolicy,
+    settingsToUnlockPolicy: () => settingsToUnlockPolicy,
+    setupResourcePage: () => setupResourcePage,
+    trackResourcePage: () => trackResourcePage,
+    validateResourceMetadata: () => validateResourceMetadata
   });
+  init_gate();
+
+  // src/browser/access.js
+  init_events();
+  init_storage();
+  init_json();
+  init_gate();
+
+  // src/browser/track.js
+  init_resource();
+  init_env();
+  init_gate();
+  function trackResourcePage(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const validation = validateResourceMetadata(item.resource, options.validation || {});
+    if ((validation.warnings.length || validation.errors.length) && options.warn !== false && browserWindow()?.console?.warn) {
+      browserWindow().console.warn("Nibgate content metadata needs attention", validation);
+    }
+    item.content({ source: options.source, metadataQuality: { score: validation.score, warnings: validation.warnings, errors: validation.errors }, ...options.content || {} });
+    item.view({
+      source: options.source,
+      path: options.path || browserWindow()?.location?.pathname || item.resource.path,
+      referrer: options.referrer ?? browserWindow()?.document?.referrer ?? "",
+      ...options.view || {}
+    });
+    return item;
+  }
+  function setupResourcePage(resource, options = {}) {
+    const item = trackResourcePage(resource, options);
+    const win = browserWindow();
+    if (!win) return item;
+    const button = typeof options.button === "string" ? win.document.querySelector(options.button) : options.button;
+    const statusElement = typeof options.status === "string" ? win.document.querySelector(options.status) : options.status;
+    const setStatus = options.onStatus || ((message) => {
+      if (statusElement) statusElement.textContent = message || "";
+    });
+    if (button) {
+      button.addEventListener("click", async () => {
+        button.disabled = true;
+        try {
+          await checkResourceAccess(resource, { ...options, onStatus: setStatus });
+        } finally {
+          button.disabled = false;
+        }
+      });
+    }
+    return item;
+  }
+
+  // src/browser/access.js
+  async function checkResourceAccess(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
+    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
+    };
+    status2(options.checkingMessage || "Checking access route...");
+    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "nibgate-access-route" });
+    const response = await fetch(accessPath, {
+      method: options.method || "GET",
+      headers: {
+        accept: "application/json",
+        ...getPaymentProof(item.resource) ? { "x-nibgate-payment-proof": getPaymentProof(item.resource) } : {},
+        ...options.headers || {}
+      },
+      body: options.body
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (response.status === 402) {
+      item.track("payment_challenge_returned", { source: options.source, challenge: payload, resource: item.resource });
+      status2(options.challengeMessage || "Payment challenge returned. Continue with checkout.");
+      if (typeof options.createPaymentSignature === "function" || typeof options.checkout === "function") {
+        return payWithPaymentSignature(resource, {
+          ...options,
+          challenge: payload,
+          paymentRequiredHeader: response.headers.get("PAYMENT-REQUIRED") || response.headers.get("payment-required") || ""
+        });
+      }
+      if (options.autoPay && options.payPath) {
+        const paymentResult = await payAndUnlockResource(resource, options);
+        if (paymentResult.ok && options.retryAfterPay !== false) {
+          return checkResourceAccess(resource, { ...options, autoPay: false });
+        }
+        return paymentResult;
+      }
+      return { ok: false, status: response.status, challenge: payload, resource: item.resource, response };
+    }
+    if (!response.ok) {
+      status2(payload.error || options.errorMessage || "Access check failed");
+      return { ok: false, status: response.status, error: payload.error || "Access check failed", payload, resource: item.resource, response };
+    }
+    const payment = options.payment || payload.payment || null;
+    if (payment) {
+      item.unlockCompleted(payment);
+      item.paymentCompleted(payment);
+    }
+    status2(options.successMessage || "Access allowed and Nibgate events emitted.");
+    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
+  }
+  async function payWithPaymentSignature(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
+    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
+    };
+    status2(options.paymentMessage || "Waiting for wallet payment approval...");
+    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "wallet-gateway" });
+    let paymentSignature = options.paymentSignature || "";
+    let paymentMemo = options.memo || "";
+    let paymentMetadata = options.payment || {};
+    if (!paymentSignature) {
+      const paymentRequiredHeader = options.paymentRequiredHeader || "";
+      const challenge2 = options.challenge || null;
+      const checkout = options.createPaymentSignature || options.checkout;
+      const result = await checkout({
+        resource: item.resource,
+        challenge: challenge2,
+        paymentRequiredHeader,
+        accessPath
+      });
+      paymentSignature = result?.paymentSignature || result?.signature || result?.payment || "";
+      paymentMemo = result?.memo || result?.paymentMemo || "";
+      paymentMetadata = result?.metadata || result?.paymentMetadata || result || {};
+    }
+    if (!paymentSignature) {
+      const error = "Wallet did not return a payment signature.";
+      item.track("payment_failed", { source: options.source, error });
+      status2(error);
+      return { ok: false, status: 400, error, resource: item.resource };
+    }
+    const response = await fetch(accessPath, {
+      method: options.method || "GET",
+      headers: {
+        accept: "application/json",
+        "payment-signature": paymentSignature,
+        ...paymentMemo ? { "payment-memo": paymentMemo } : {},
+        ...options.headers || {}
+      }
+    });
+    const responseText = await response.text();
+    let payload = {};
+    try {
+      payload = responseText ? JSON.parse(responseText) : {};
+    } catch (_error) {
+      payload = { error: responseText || "Payment verification failed" };
+    }
+    if (!response.ok) {
+      const detail = payload.detail || payload.reason || payload.invalidReason || payload.error || responseText || "Payment verification failed";
+      const error = typeof detail === "string" ? detail : stringifyJson(detail);
+      item.track("payment_failed", { source: options.source, status: response.status, error, ...paymentMetadata });
+      status2(options.paymentErrorMessage || error);
+      return { ok: false, status: response.status, error, payload, resource: item.resource, response };
+    }
+    const payment = payload.payment || {
+      paymentProvider: options.paymentProvider || "wallet-gateway",
+      paymentId: paymentSignature,
+      memo: paymentMemo,
+      amount: Number(item.resource.price || 0),
+      revenue: Number(item.resource.price || 0),
+      currency: item.resource.currency || "USDC",
+      ...paymentMetadata
+    };
+    storePaymentProof(item.resource, payload.unlockProof);
+    item.markUnlocked(payment);
+    status2(options.paymentSuccessMessage || "Payment verified. Content unlocked.");
+    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
+  }
+  async function payAndUnlockResource(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const payPath = options.payPath || item.resource.payPath || "/api/nibgate/pay";
+    const status2 = typeof options.onStatus === "function" ? options.onStatus : () => {
+    };
+    status2(options.paymentMessage || "Starting payment...");
+    item.unlockStarted({ source: options.source, paymentProvider: options.paymentProvider || "circle-gateway" });
+    const response = await fetch(payPath, {
+      method: options.payMethod || "POST",
+      headers: {
+        accept: "application/json",
+        "content-type": "application/json",
+        ...options.payHeaders || {}
+      },
+      body: JSON.stringify({ resource: item.resource, ...options.payPayload || {} })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || !payload.ok) {
+      item.track("payment_failed", { source: options.source, status: response.status, error: payload.error || "Payment failed", detail: payload.detail || "" });
+      status2(payload.detail || payload.error || options.paymentErrorMessage || "Payment failed.");
+      return { ok: false, status: response.status, payload, resource: item.resource, response };
+    }
+    const payment = payload.payment || {
+      paymentProvider: options.paymentProvider || "circle-gateway",
+      paymentId: payload.paymentId || `nibgate_payment_${Date.now()}`,
+      amount: Number(item.resource.price || 0),
+      revenue: Number(item.resource.price || 0),
+      currency: item.resource.currency || "USDC"
+    };
+    storePaymentProof(item.resource, payload.unlockProof);
+    item.markUnlocked(payment);
+    status2(options.paymentSuccessMessage || "Payment verified. Content unlocked.");
+    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
+  }
+
+  // src/browser/checkout.js
+  init_resource();
+  init_env();
+  function setElementText(target, message) {
+    const win = browserWindow();
+    if (!target || !win) return;
+    const element = typeof target === "string" ? win.document.querySelector(target) : target;
+    if (element) element.textContent = message || "";
+  }
+  function setElementDisabled(target, disabled) {
+    const win = browserWindow();
+    if (!target || !win) return;
+    const element = typeof target === "string" ? win.document.querySelector(target) : target;
+    if (element && "disabled" in element) element.disabled = Boolean(disabled);
+  }
+  function createWalletCheckout(resource, options = {}) {
+    const normalized = normalizeResource(resource);
+    const accessPath = options.accessPath || normalized.accessPath || "/api/nibgate/access";
+    const button = options.button || null;
+    const statusTarget = options.status || null;
+    const status2 = typeof options.onStatus === "function" ? options.onStatus : (message) => setElementText(statusTarget, message);
+    const checkout = options.checkout || options.createPaymentSignature || options.pay;
+    if (typeof checkout !== "function") {
+      throw new Error("createWalletCheckout requires checkout/createPaymentSignature/pay callback for the active wallet or Gateway adapter.");
+    }
+    async function unlock(extra = {}) {
+      setElementDisabled(button, true);
+      try {
+        return await checkResourceAccess(normalized, {
+          ...options,
+          ...extra,
+          accessPath,
+          createPaymentSignature: checkout,
+          onStatus: status2
+        });
+      } finally {
+        setElementDisabled(button, false);
+      }
+    }
+    function mount() {
+      const win = browserWindow();
+      if (!win || !button) return { unlock };
+      const element = typeof button === "string" ? win.document.querySelector(button) : button;
+      if (element) element.addEventListener("click", () => unlock().catch((error) => status2(error.message || "Checkout failed.")));
+      return { unlock };
+    }
+    return { resource: normalized, unlock, mount };
+  }
+
+  // src/browser/client.js
+  init_resource();
+  init_rating();
+  init_events();
+  init_gate();
+  init_gate();
+
+  // src/browser/evm-gateway.js
+  init_env();
+  init_storage();
+  init_gate();
+  async function createCircleGatewayBrowserAdapter2(options = {}) {
+    const gateway = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+    return gateway.createCircleGatewayBrowserAdapter(options);
+  }
+  var HOSTED_PAY_URL = "https://api.nibgate.xyz/api/hub/pay";
+  function resolveAccessPath(resource, options) {
+    if (options.hosted || options.accessPath === "hosted") return HOSTED_PAY_URL;
+    return options.accessPath || resource.accessPath || "/api/nibgate/access";
+  }
+  function createEvmGatewayUnlock(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const win = browserWindow();
+    const accessPath = resolveAccessPath(item.resource, options);
+    const source = options.source || "nibgate-evm-gateway";
+    const network = options.network || "eip155:5042002";
+    const statusTarget = typeof options.status === "string" ? win?.document.querySelector(options.status) : options.status;
+    const connectButton = typeof options.connectButton === "string" ? win?.document.querySelector(options.connectButton) : options.connectButton;
+    const disconnectButton = typeof options.disconnectButton === "string" ? win?.document.querySelector(options.disconnectButton) : options.disconnectButton;
+    const unlockButton = typeof options.unlockButton === "string" ? win?.document.querySelector(options.unlockButton) : options.unlockButton;
+    const clearButton = typeof options.clearButton === "string" ? win?.document.querySelector(options.clearButton) : options.clearButton;
+    const walletLabel = typeof options.walletLabel === "string" ? win?.document.querySelector(options.walletLabel) : options.walletLabel;
+    const unlockedTarget = typeof options.unlockedTarget === "string" ? win?.document.querySelector(options.unlockedTarget) : options.unlockedTarget;
+    let walletAddress = "";
+    let busy = false;
+    function setStatus(message) {
+      if (typeof options.onStatus === "function") options.onStatus(message);
+      if (statusTarget) statusTarget.textContent = message || "";
+    }
+    function shortAddress(address) {
+      return address ? `${address.slice(0, 6)}...${address.slice(-4)}` : "";
+    }
+    function provider() {
+      return win?.ethereum || options.provider || null;
+    }
+    function setBusy(value) {
+      busy = Boolean(value);
+      [connectButton, disconnectButton, unlockButton, clearButton].forEach((button) => {
+        if (button && "disabled" in button) {
+          button.disabled = busy || button === connectButton && !provider() || button === disconnectButton && !walletAddress;
+        }
+      });
+    }
+    function renderWallet() {
+      const hasProvider = Boolean(provider());
+      if (walletLabel) walletLabel.textContent = walletAddress ? shortAddress(walletAddress) : hasProvider ? "Ready to connect" : "No wallet detected";
+      if (connectButton) connectButton.textContent = walletAddress ? "Connected" : "Connect wallet";
+      if (disconnectButton) disconnectButton.textContent = "Disconnect";
+      if (connectButton && "disabled" in connectButton) connectButton.disabled = busy || !hasProvider;
+      if (disconnectButton && "disabled" in disconnectButton) disconnectButton.disabled = busy || !walletAddress;
+    }
+    function setUnlocked(isUnlocked, payment = {}) {
+      if (unlockButton) unlockButton.textContent = isUnlocked ? "Unlocked" : `Unlock for ${item.resource.price} ${item.resource.currency || "USDC"}`;
+      if (unlockedTarget) {
+        if ("hidden" in unlockedTarget) unlockedTarget.hidden = !isUnlocked;
+        unlockedTarget.setAttribute("aria-hidden", isUnlocked ? "false" : "true");
+      }
+      if (isUnlocked) item.markUnlocked(payment);
+    }
+    async function connect() {
+      setBusy(true);
+      setStatus("Opening wallet connection...");
+      try {
+        const evm = provider();
+        if (!evm) throw new Error(options.noWalletMessage || "Install or open an EVM wallet to continue.");
+        const accounts = await evm.request({ method: "eth_requestAccounts" });
+        walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
+        if (!walletAddress) throw new Error("No wallet account selected.");
+        renderWallet();
+        setStatus("Wallet connected. You can unlock now.");
+        return walletAddress;
+      } finally {
+        setBusy(false);
+      }
+    }
+    async function disconnect() {
+      setBusy(true);
+      try {
+        const evm = provider();
+        if (evm?.request && walletAddress) {
+          try {
+            await evm.request({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
+          } catch (_error) {
+          }
+        }
+        walletAddress = "";
+        renderWallet();
+        setStatus(options.disconnectMessage || "Wallet disconnected for this page.");
+        return true;
+      } finally {
+        setBusy(false);
+      }
+    }
+    async function checkout(input) {
+      const evm = provider();
+      if (!evm) throw new Error(options.noWalletMessage || "Install or open an EVM wallet to continue.");
+      const currentAccounts = await evm.request({ method: "eth_accounts" }).catch(() => walletAddress ? [walletAddress] : []);
+      const currentAddress = Array.isArray(currentAccounts) && currentAccounts[0] ? currentAccounts[0] : walletAddress || await connect();
+      if (currentAddress !== walletAddress) walletAddress = currentAddress;
+      const gatewayWallet = await createCircleGatewayBrowserAdapter2({
+        network,
+        signer: {
+          address: currentAddress,
+          signTypedData: async (typedData) => {
+            const { createWalletClient: createWalletClient2, custom: custom2 } = await Promise.resolve().then(() => (init_esm(), esm_exports));
+            const wc = createWalletClient2({ transport: custom2(evm) });
+            return wc.signTypedData({
+              account: currentAddress,
+              domain: typedData.domain,
+              types: typedData.types,
+              primaryType: typedData.primaryType,
+              message: typedData.message
+            });
+          }
+        },
+        clientModule: options.circleClientModule
+      });
+      return gatewayWallet.pay(input);
+    }
+    async function unlock() {
+      setBusy(true);
+      try {
+        if (!walletAddress) await connect();
+        setBusy(true);
+        setStatus("Requesting Gateway unlock...");
+        const result = await checkResourceAccess(item.resource, {
+          accessPath,
+          source,
+          paymentProvider: options.paymentProvider || "circle-gateway-browser",
+          challengeMessage: options.challengeMessage || "Gateway payment required. Connect your wallet to continue...",
+          paymentMessage: options.paymentMessage || "Approve the Gateway payment proof in your wallet...",
+          successMessage: options.successMessage || `Unlocked ${item.resource.title || "content"}.`,
+          method: options.method,
+          headers: options.headers,
+          body: options.body,
+          checkout,
+          onStatus: setStatus
+        });
+        if (result.ok) {
+          setUnlocked(true, result.payment || {});
+          if (typeof options.onUnlock === "function") options.onUnlock(result);
+        }
+        return result;
+      } catch (error) {
+        const message = error?.message || "Unlock failed. Please try again.";
+        setStatus(message);
+        return { ok: false, status: 0, error: message, resource: item.resource };
+      } finally {
+        setBusy(false);
+        renderWallet();
+      }
+    }
+    function clear() {
+      clearPaymentProof(item.resource);
+      setUnlocked(false);
+      setStatus("Local payment proof cleared. The next unlock will require Gateway payment again.");
+    }
+    async function hydrate() {
+      const evm = provider();
+      try {
+        const accounts = evm ? await evm.request({ method: "eth_accounts" }) : [];
+        walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
+      } catch {
+      }
+      renderWallet();
+      setUnlocked(false);
+    }
+    function mount() {
+      connectButton?.addEventListener?.("click", () => connect().catch((error) => setStatus(error?.message || "Could not connect wallet.")));
+      disconnectButton?.addEventListener?.("click", () => disconnect().catch((error) => setStatus(error?.message || "Could not disconnect wallet.")));
+      unlockButton?.addEventListener?.("click", () => unlock());
+      clearButton?.addEventListener?.("click", clear);
+      hydrate();
+      trackResourcePage(item.resource, { source });
+      return controller;
+    }
+    const controller = { resource: item.resource, connect, disconnect, unlock, clear, hydrate, mount, getWalletAddress: () => walletAddress };
+    if (options.autoMount !== false) mount();
+    return controller;
+  }
+  function createHostedUnlock(resource, options = {}) {
+    return createEvmGatewayUnlock(resource, {
+      ...options,
+      hosted: true,
+      noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
+    });
+  }
+
+  // src/browser/client.js
+  init_rating_ui();
+
+  // src/browser/transfer.js
+  init_resource();
+  function createTransferCheckout(resource, options = {}) {
+    const normalized = normalizeResource({ ...resource, paymentRail: "transfer" });
+    const sendTransfer = options.sendTransfer || options.transfer;
+    if (typeof sendTransfer !== "function") {
+      throw new Error("createTransferCheckout requires sendTransfer({ resource, recipient, amount, currency, network }) and a server verifyTransfer hook.");
+    }
+    return {
+      resource: normalized,
+      async pay(input = {}) {
+        const recipient = normalized.recipient || normalized.payTo;
+        const amount = String(normalized.price || normalized.amount || "0");
+        const currency = normalized.currency || "USDC";
+        const network = options.network || input.challenge?.accepts?.[0]?.network || "eip155:5042002";
+        const result = await sendTransfer({ resource: normalized, recipient, amount, currency, network, challenge: input.challenge });
+        const txHash = result?.txHash || result?.hash || result?.transactionHash || result?.paymentId || "";
+        if (!txHash) throw new Error("Transfer checkout did not return a txHash.");
+        return {
+          paymentSignature: txHash,
+          signature: txHash,
+          memo: result.memo || "",
+          metadata: {
+            paymentProvider: "direct-transfer",
+            paymentId: txHash,
+            txHash,
+            recipient,
+            amount: Number(amount),
+            currency,
+            network,
+            ...result.metadata || result
+          }
+        };
+      }
+    };
+  }
+  async function payWithTransfer(resource, options = {}) {
+    const checkout = options.checkout || createTransferCheckout(resource, options).pay;
+    const result = await checkout({ resource: normalizeResource(resource), challenge: options.challenge || null });
+    const txHash = result?.metadata?.txHash || result?.txHash || result?.paymentSignature || result?.signature || "";
+    if (!txHash) throw new Error("Transfer checkout did not return a txHash.");
+    return checkResourceAccess(resource, {
+      ...options,
+      headers: {
+        ...options.headers || {},
+        "x-nibgate-transfer-tx": txHash
+      },
+      payment: result.metadata || { paymentProvider: "direct-transfer", txHash, paymentId: txHash }
+    });
+  }
+
+  // src/browser/client.js
+  function createNibgate(defaults = {}) {
+    const defaultResource = defaults.resource ? normalizeResource(defaults.resource) : null;
+    function resourceWithDefaults(resource = {}) {
+      return normalizeResource({
+        ...defaultResource || {},
+        ...typeof resource === "string" ? { id: resource } : resource
+      });
+    }
+    return {
+      content(resource, extra = {}) {
+        return emit("content_registered", payloadWithResource(resourceWithDefaults(resource), extra));
+      },
+      registerContent(resource, extra = {}) {
+        return emit("content_registered", payloadWithResource(resourceWithDefaults(resource), extra));
+      },
+      view(resource, extra = {}) {
+        return emit("resource_view", payloadWithResource(resourceWithDefaults(resource), extra));
+      },
+      track(eventName, payload = {}) {
+        return emit(eventName || "custom", payload);
+      },
+      unlockStarted(resource, extra = {}) {
+        return emit("unlock_started", payloadWithResource(resourceWithDefaults(resource), extra));
+      },
+      unlockCompleted(resource, payment = {}) {
+        return emit("unlock_completed", payloadWithResource(resourceWithDefaults(resource), payment));
+      },
+      paymentCompleted(resource, payment = {}) {
+        return emit("payment_completed", payloadWithResource(resourceWithDefaults(resource), payment));
+      },
+      rateResource(resource, rating = {}, extra = {}) {
+        return rateResource(resourceWithDefaults(resource), rating, extra);
+      },
+      ratingMessage(resource, rating = {}, messageOptions = {}) {
+        return ratingMessage(resourceWithDefaults(resource), rating, messageOptions);
+      },
+      gate(resource, options = {}) {
+        return createGate(resourceWithDefaults(resource), { ...options, client: this });
+      },
+      trackResourcePage(resource, options = {}) {
+        return trackResourcePage(resourceWithDefaults(resource), options);
+      },
+      checkResourceAccess(resource, options = {}) {
+        return checkResourceAccess(resourceWithDefaults(resource), options);
+      },
+      payWithPaymentSignature(resource, options = {}) {
+        return payWithPaymentSignature(resourceWithDefaults(resource), options);
+      },
+      createWalletCheckout(resource, options = {}) {
+        return createWalletCheckout(resourceWithDefaults(resource), options);
+      },
+      createCircleGatewayBrowserAdapter(options = {}) {
+        return createCircleGatewayBrowserAdapter2(options);
+      },
+      createTransferCheckout(resource, options = {}) {
+        return createTransferCheckout(resourceWithDefaults(resource), options);
+      },
+      payWithTransfer(resource, options = {}) {
+        return payWithTransfer(resourceWithDefaults(resource), options);
+      },
+      createEvmGatewayUnlock(resource, options = {}) {
+        return createEvmGatewayUnlock(resourceWithDefaults(resource), options);
+      },
+      createOnchainRating(resource, options = {}) {
+        return createOnchainRating(resourceWithDefaults(resource), options);
+      },
+      mountRatingUI(resource, options = {}) {
+        return mountRatingUI(resourceWithDefaults(resource), options);
+      },
+      payAndUnlockResource(resource, options = {}) {
+        return payAndUnlockResource(resourceWithDefaults(resource), options);
+      },
+      setupResourcePage(resource, options = {}) {
+        return setupResourcePage(resourceWithDefaults(resource), options);
+      },
+      normalizeResource: resourceWithDefaults,
+      normalizeContentType,
+      flush: flushQueue
+    };
+  }
+  var nibgate = createNibgate();
+  setDefaultClient(nibgate);
+
+  // src/browser/index.js
+  init_rating_ui();
+  init_reputation();
+
+  // src/browser/default-ui.js
+  var SID = "nibgate-ui-styles";
+  var theme = {
+    bg: "var(--bg, #f4f4f0)",
+    fg: "var(--fg, #0a0a0a)",
+    muted: "var(--muted, #6b6862)",
+    border: "var(--border, #cecdc3)",
+    accent: "var(--accent, #7c9a6d)",
+    accentSoft: "var(--accent-soft, #d8e8d3)",
+    cardHover: "var(--card-hover, #e0ddd3)"
+  };
+  var css = (s) => Object.entries(s).map(([k, v]) => `${k.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase())}:${v}`).join(";");
   function h(tag, attrs, children) {
     const e = document.createElement(tag);
     for (const [k, v] of Object.entries(attrs || {})) {
@@ -27505,70 +27743,9 @@ ${prettyStateOverride(stateOverride)}`;
       document.removeEventListener("touchend", cancelHold);
     };
     card.addEventListener("remove", cleanup);
-    let gwOverlayEl = null;
-    let balTimer = null;
-    let balEl = null;
-    function depositIconHTML() {
-      return '<svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="display:inline;vertical-align:baseline"><path d="M12 17V3"/><path d="m6 11 6 6 6-6"/><path d="M19 21H5"/></svg>';
-    }
-    async function showGatewayWallet() {
-      if (gwOverlayEl) return;
-      gwOverlayEl = el("div", { style: "position:fixed;inset:0;z-index:9999;background:rgba(0,0,0,0.5);display:flex;align-items:center;justify-content:center;padding:20px;animation:nfade .15s ease-out" });
-      const modal = el("div", { style: "background:" + theme.bg + ";border-radius:16px;max-width:540px;width:100%;max-height:90vh;overflow:auto;position:relative;box-shadow:0 8px 32px rgba(0,0,0,0.12);animation:nscale .15s ease-out" });
-      const close = el("button", { style: "position:absolute;top:12px;right:16px;z-index:20;background:none;border:none;font-size:28px;cursor:pointer;color:" + theme.muted + ";font-family:inherit;line-height:1" }, "\xD7");
-      close.addEventListener("click", closeGatewayWallet);
-      modal.appendChild(close);
-      gwOverlayEl.appendChild(modal);
-      gwOverlayEl.addEventListener("click", (e) => {
-        if (e.target === gwOverlayEl) closeGatewayWallet();
-      });
-      document.body.appendChild(gwOverlayEl);
-      document.addEventListener("keydown", onGwKey);
-      const gw = await Promise.resolve().then(() => (init_default_ui(), default_ui_exports));
-      gw.renderDefaultGatewayWalletUI(modal, options.gatewayOptions || {});
-    }
-    function closeGatewayWallet() {
-      if (!gwOverlayEl) return;
-      gwOverlayEl.remove();
-      gwOverlayEl = null;
-      document.removeEventListener("keydown", onGwKey);
-    }
-    function onGwKey(e) {
-      if (e.key === "Escape") closeGatewayWallet();
-    }
-    function ensureBalEl() {
-      if (balEl && balEl.isConnected) return balEl;
-      balEl = el("span", { "data-nibgate-bal": "", style: "margin-left:6px;cursor:pointer;white-space:nowrap" }, depositIconHTML() + " <span data-nibgate-bal-text></span>");
-      balEl.addEventListener("click", showGatewayWallet);
-      if (label.parentNode) label.parentNode.insertBefore(balEl, label.nextSibling);
-      return balEl;
-    }
-    async function refreshBalance() {
-      if (stateRef?.destroyed) return;
-      const addr = ctrl.getWalletAddress();
-      if (!addr) return;
-      const txt = ensureBalEl().querySelector("[data-nibgate-bal-text]");
-      if (options.gatewayBalanceUrl) {
-        try {
-          const res = await fetch(options.gatewayBalanceUrl + "?address=" + encodeURIComponent(addr));
-          const data = await res.json();
-          if (txt) txt.textContent = data?.balance || data?.availableBalance || "\u2026";
-          return;
-        } catch {
-        }
-      }
-      if (txt) txt.textContent = "\u2026";
-    }
-    if (window.ethereum) {
-      balTimer = setInterval(refreshBalance, 3e3);
-      setTimeout(refreshBalance, 1e3);
-      window.ethereum.on("accountsChanged", refreshBalance);
-    }
     return { ...ctrl, element: card, destroy: () => {
       cleanup();
       card.remove();
-      if (balTimer) clearInterval(balTimer);
-      closeGatewayWallet();
     } };
   }
   function renderDefaultRatingUI(container, resource, options = {}) {
@@ -27770,276 +27947,8 @@ ${prettyStateOverride(stateOverride)}`;
     tabs.forEach((b) => b.addEventListener("click", () => render(b.dataset.tab)));
     return { element: wrap3, destroy: () => wrap3.remove(), switchTab: render };
   }
-  var SID, theme, css;
-  var init_default_ui = __esm({
-    "src/browser/default-ui.js"() {
-      init_evm_gateway();
-      SID = "nibgate-ui-styles";
-      theme = {
-        bg: "var(--bg, #f4f4f0)",
-        fg: "var(--fg, #0a0a0a)",
-        muted: "var(--muted, #6b6862)",
-        border: "var(--border, #cecdc3)",
-        accent: "var(--accent, #7c9a6d)",
-        accentSoft: "var(--accent-soft, #d8e8d3)",
-        cardHover: "var(--card-hover, #e0ddd3)"
-      };
-      css = (s) => Object.entries(s).map(([k, v]) => `${k.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase())}:${v}`).join(";");
-    }
-  });
-
-  // src/browser/index.js
-  var index_exports = {};
-  __export(index_exports, {
-    ACCESS_MODES: () => ACCESS_MODES,
-    CONTENT_TYPES: () => CONTENT_TYPES,
-    NIBGATE_CONTENT_HASH_NAMESPACE: () => NIBGATE_CONTENT_HASH_NAMESPACE,
-    NIBGATE_CONTENT_SETTING_FIELDS: () => NIBGATE_CONTENT_SETTING_FIELDS,
-    NIBGATE_REPUTATION_ABI: () => NIBGATE_REPUTATION_ABI,
-    NIBGATE_REPUTATION_CHAIN_ID: () => NIBGATE_REPUTATION_CHAIN_ID,
-    NIBGATE_REPUTATION_CHAIN_NAME: () => NIBGATE_REPUTATION_CHAIN_NAME,
-    NIBGATE_REPUTATION_CONTRACT: () => NIBGATE_REPUTATION_CONTRACT,
-    NIBGATE_REPUTATION_RPC_URL: () => NIBGATE_REPUTATION_RPC_URL,
-    PAYMENT_RAILS: () => PAYMENT_RAILS,
-    UNLOCK_MODES: () => UNLOCK_MODES,
-    checkResourceAccess: () => checkResourceAccess,
-    contentRatingHash: () => contentRatingHash,
-    createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter2,
-    createEvmGatewayUnlock: () => createEvmGatewayUnlock,
-    createGate: () => createGate,
-    createHostedUnlock: () => createHostedUnlock,
-    createNibgate: () => createNibgate,
-    createNibgateContentSettings: () => createNibgateContentSettings,
-    createOnchainRating: () => createOnchainRating,
-    createTransferCheckout: () => createTransferCheckout,
-    createWalletCheckout: () => createWalletCheckout,
-    mountRatingUI: () => mountRatingUI,
-    nibgate: () => nibgate,
-    normalizeAccessPolicy: () => normalizeAccessPolicy,
-    normalizeContentType: () => normalizeContentType,
-    normalizePaymentRail: () => normalizePaymentRail,
-    normalizeResource: () => normalizeResource,
-    normalizeUnlockPolicy: () => normalizeUnlockPolicy,
-    payAndUnlockResource: () => payAndUnlockResource,
-    payWithPaymentSignature: () => payWithPaymentSignature,
-    payWithTransfer: () => payWithTransfer,
-    rateContentOnchain: () => rateContentOnchain,
-    rateResource: () => rateResource,
-    renderDefaultGatewayWalletUI: () => renderDefaultGatewayWalletUI,
-    renderDefaultRatingUI: () => renderDefaultRatingUI,
-    renderDefaultUnlockUI: () => renderDefaultUnlockUI,
-    reviewTextHash: () => reviewTextHash,
-    settingsToAccessPolicy: () => settingsToAccessPolicy,
-    settingsToUnlockPolicy: () => settingsToUnlockPolicy,
-    setupResourcePage: () => setupResourcePage,
-    trackResourcePage: () => trackResourcePage,
-    validateResourceMetadata: () => validateResourceMetadata
-  });
-  init_gate();
-  init_access();
-
-  // src/browser/checkout.js
-  init_resource();
-  init_env();
-  init_access();
-  function setElementText(target, message) {
-    const win = browserWindow();
-    if (!target || !win) return;
-    const element = typeof target === "string" ? win.document.querySelector(target) : target;
-    if (element) element.textContent = message || "";
-  }
-  function setElementDisabled(target, disabled) {
-    const win = browserWindow();
-    if (!target || !win) return;
-    const element = typeof target === "string" ? win.document.querySelector(target) : target;
-    if (element && "disabled" in element) element.disabled = Boolean(disabled);
-  }
-  function createWalletCheckout(resource, options = {}) {
-    const normalized = normalizeResource(resource);
-    const accessPath = options.accessPath || normalized.accessPath || "/api/nibgate/access";
-    const button = options.button || null;
-    const statusTarget = options.status || null;
-    const status2 = typeof options.onStatus === "function" ? options.onStatus : (message) => setElementText(statusTarget, message);
-    const checkout = options.checkout || options.createPaymentSignature || options.pay;
-    if (typeof checkout !== "function") {
-      throw new Error("createWalletCheckout requires checkout/createPaymentSignature/pay callback for the active wallet or Gateway adapter.");
-    }
-    async function unlock(extra = {}) {
-      setElementDisabled(button, true);
-      try {
-        return await checkResourceAccess(normalized, {
-          ...options,
-          ...extra,
-          accessPath,
-          createPaymentSignature: checkout,
-          onStatus: status2
-        });
-      } finally {
-        setElementDisabled(button, false);
-      }
-    }
-    function mount() {
-      const win = browserWindow();
-      if (!win || !button) return { unlock };
-      const element = typeof button === "string" ? win.document.querySelector(button) : button;
-      if (element) element.addEventListener("click", () => unlock().catch((error) => status2(error.message || "Checkout failed.")));
-      return { unlock };
-    }
-    return { resource: normalized, unlock, mount };
-  }
-
-  // src/browser/client.js
-  init_resource();
-  init_rating();
-  init_events();
-  init_gate();
-  init_gate();
-  init_access();
-  init_evm_gateway();
-  init_rating_ui();
-  init_track();
-
-  // src/browser/transfer.js
-  init_resource();
-  function createTransferCheckout(resource, options = {}) {
-    const normalized = normalizeResource({ ...resource, paymentRail: "transfer" });
-    const sendTransfer = options.sendTransfer || options.transfer;
-    if (typeof sendTransfer !== "function") {
-      throw new Error("createTransferCheckout requires sendTransfer({ resource, recipient, amount, currency, network }) and a server verifyTransfer hook.");
-    }
-    return {
-      resource: normalized,
-      async pay(input = {}) {
-        const recipient = normalized.recipient || normalized.payTo;
-        const amount = String(normalized.price || normalized.amount || "0");
-        const currency = normalized.currency || "USDC";
-        const network = options.network || input.challenge?.accepts?.[0]?.network || "eip155:5042002";
-        const result = await sendTransfer({ resource: normalized, recipient, amount, currency, network, challenge: input.challenge });
-        const txHash = result?.txHash || result?.hash || result?.transactionHash || result?.paymentId || "";
-        if (!txHash) throw new Error("Transfer checkout did not return a txHash.");
-        return {
-          paymentSignature: txHash,
-          signature: txHash,
-          memo: result.memo || "",
-          metadata: {
-            paymentProvider: "direct-transfer",
-            paymentId: txHash,
-            txHash,
-            recipient,
-            amount: Number(amount),
-            currency,
-            network,
-            ...result.metadata || result
-          }
-        };
-      }
-    };
-  }
-  async function payWithTransfer(resource, options = {}) {
-    const checkout = options.checkout || createTransferCheckout(resource, options).pay;
-    const result = await checkout({ resource: normalizeResource(resource), challenge: options.challenge || null });
-    const txHash = result?.metadata?.txHash || result?.txHash || result?.paymentSignature || result?.signature || "";
-    if (!txHash) throw new Error("Transfer checkout did not return a txHash.");
-    return checkResourceAccess(resource, {
-      ...options,
-      headers: {
-        ...options.headers || {},
-        "x-nibgate-transfer-tx": txHash
-      },
-      payment: result.metadata || { paymentProvider: "direct-transfer", txHash, paymentId: txHash }
-    });
-  }
-
-  // src/browser/client.js
-  function createNibgate(defaults = {}) {
-    const defaultResource = defaults.resource ? normalizeResource(defaults.resource) : null;
-    function resourceWithDefaults(resource = {}) {
-      return normalizeResource({
-        ...defaultResource || {},
-        ...typeof resource === "string" ? { id: resource } : resource
-      });
-    }
-    return {
-      content(resource, extra = {}) {
-        return emit("content_registered", payloadWithResource(resourceWithDefaults(resource), extra));
-      },
-      registerContent(resource, extra = {}) {
-        return emit("content_registered", payloadWithResource(resourceWithDefaults(resource), extra));
-      },
-      view(resource, extra = {}) {
-        return emit("resource_view", payloadWithResource(resourceWithDefaults(resource), extra));
-      },
-      track(eventName, payload = {}) {
-        return emit(eventName || "custom", payload);
-      },
-      unlockStarted(resource, extra = {}) {
-        return emit("unlock_started", payloadWithResource(resourceWithDefaults(resource), extra));
-      },
-      unlockCompleted(resource, payment = {}) {
-        return emit("unlock_completed", payloadWithResource(resourceWithDefaults(resource), payment));
-      },
-      paymentCompleted(resource, payment = {}) {
-        return emit("payment_completed", payloadWithResource(resourceWithDefaults(resource), payment));
-      },
-      rateResource(resource, rating = {}, extra = {}) {
-        return rateResource(resourceWithDefaults(resource), rating, extra);
-      },
-      ratingMessage(resource, rating = {}, messageOptions = {}) {
-        return ratingMessage(resourceWithDefaults(resource), rating, messageOptions);
-      },
-      gate(resource, options = {}) {
-        return createGate(resourceWithDefaults(resource), { ...options, client: this });
-      },
-      trackResourcePage(resource, options = {}) {
-        return trackResourcePage(resourceWithDefaults(resource), options);
-      },
-      checkResourceAccess(resource, options = {}) {
-        return checkResourceAccess(resourceWithDefaults(resource), options);
-      },
-      payWithPaymentSignature(resource, options = {}) {
-        return payWithPaymentSignature(resourceWithDefaults(resource), options);
-      },
-      createWalletCheckout(resource, options = {}) {
-        return createWalletCheckout(resourceWithDefaults(resource), options);
-      },
-      createCircleGatewayBrowserAdapter(options = {}) {
-        return createCircleGatewayBrowserAdapter2(options);
-      },
-      createTransferCheckout(resource, options = {}) {
-        return createTransferCheckout(resourceWithDefaults(resource), options);
-      },
-      payWithTransfer(resource, options = {}) {
-        return payWithTransfer(resourceWithDefaults(resource), options);
-      },
-      createEvmGatewayUnlock(resource, options = {}) {
-        return createEvmGatewayUnlock(resourceWithDefaults(resource), options);
-      },
-      createOnchainRating(resource, options = {}) {
-        return createOnchainRating(resourceWithDefaults(resource), options);
-      },
-      mountRatingUI(resource, options = {}) {
-        return mountRatingUI(resourceWithDefaults(resource), options);
-      },
-      payAndUnlockResource(resource, options = {}) {
-        return payAndUnlockResource(resourceWithDefaults(resource), options);
-      },
-      setupResourcePage(resource, options = {}) {
-        return setupResourcePage(resourceWithDefaults(resource), options);
-      },
-      normalizeResource: resourceWithDefaults,
-      normalizeContentType,
-      flush: flushQueue
-    };
-  }
-  var nibgate = createNibgate();
-  setDefaultClient(nibgate);
 
   // src/browser/index.js
-  init_evm_gateway();
-  init_rating_ui();
-  init_track();
-  init_reputation();
-  init_default_ui();
   init_resource();
 
   // src/core/settings.js