@nibgate/sdk 0.2.10 → 0.2.11

package/dist/nibgate.js

@@ -20,317 +20,21 @@ var Nibgate = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/browser/json.js
-  function jsonReplacer(_key, value) {
-    if (typeof value === "bigint") return value.toString();
-    return value;
-  }
-  function stringifyJson(value) {
-    return JSON.stringify(value, jsonReplacer);
-  }
-  var init_json = __esm({
-    "src/browser/json.js"() {
-    }
-  });
-
-  // src/browser/schemes/batch-scheme.js
-  function supportsBatching(requirements) {
-    const extra = requirements.extra;
-    if (!extra) return false;
-    return extra.name === CIRCLE_BATCHING_NAME && extra.version === CIRCLE_BATCHING_VERSION;
-  }
-  function getVerifyingContract(requirements) {
-    if (!supportsBatching(requirements)) return void 0;
-    return requirements.extra?.verifyingContract;
-  }
-  function createNonce() {
-    const bytes = new Uint8Array(32);
-    crypto.getRandomValues(bytes);
-    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  function getAddress(value) {
-    return value && typeof value === "string" && value.startsWith("0x") ? value.toLowerCase() : value;
-  }
-  var CIRCLE_BATCHING_NAME, CIRCLE_BATCHING_VERSION, GATEWAY_MIN_AUTH_VALIDITY_SECONDS, GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS, authorizationTypes, BatchEvmScheme;
-  var init_batch_scheme = __esm({
-    "src/browser/schemes/batch-scheme.js"() {
-      CIRCLE_BATCHING_NAME = "GatewayWalletBatched";
-      CIRCLE_BATCHING_VERSION = "1";
-      GATEWAY_MIN_AUTH_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
-      GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS = GATEWAY_MIN_AUTH_VALIDITY_SECONDS + 100;
-      authorizationTypes = {
-        TransferWithAuthorization: [
-          { name: "from", type: "address" },
-          { name: "to", type: "address" },
-          { name: "value", type: "uint256" },
-          { name: "validAfter", type: "uint256" },
-          { name: "validBefore", type: "uint256" },
-          { name: "nonce", type: "bytes32" }
-        ]
-      };
-      BatchEvmScheme = class {
-        constructor(signer) {
-          this.signer = signer;
-          this.scheme = CIRCLE_BATCHING_NAME;
-          this._beforeHooks = [];
-          this._afterHooks = [];
-          this._failureHooks = [];
-        }
-        onBeforePaymentCreation(hook) {
-          this._beforeHooks.push(hook);
-          return this;
-        }
-        onAfterPaymentCreation(hook) {
-          this._afterHooks.push(hook);
-          return this;
-        }
-        onPaymentCreationFailure(hook) {
-          this._failureHooks.push(hook);
-          return this;
-        }
-        async createPaymentPayload(x402Version, paymentRequirements) {
-          const context = {
-            paymentRequired: { x402Version, accepts: [paymentRequirements] },
-            selectedRequirements: paymentRequirements
-          };
-          for (const hook of this._beforeHooks) {
-            const result = await hook(context);
-            if (result && result.abort) {
-              throw new Error("Payment creation aborted: " + result.reason);
-            }
-          }
-          try {
-            if (!supportsBatching(paymentRequirements)) {
-              throw new Error(
-                'BatchEvmScheme can only handle Circle batching options. Expected extra.name="' + CIRCLE_BATCHING_NAME + '" and extra.version="' + CIRCLE_BATCHING_VERSION + '"'
-              );
-            }
-            const verifyingContract = getVerifyingContract(paymentRequirements);
-            if (!verifyingContract) {
-              throw new Error(
-                "Circle batching option missing extra.verifyingContract (GatewayWallet address)"
-              );
-            }
-            const nonce = createNonce();
-            const now = Math.floor(Date.now() / 1e3);
-            const validityWindowSeconds = Math.max(
-              paymentRequirements.maxTimeoutSeconds || 0,
-              GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS
-            );
-            const authorization = {
-              from: getAddress(this.signer.address),
-              to: getAddress(paymentRequirements.payTo),
-              value: paymentRequirements.amount,
-              validAfter: String(now - 600),
-              validBefore: String(now + validityWindowSeconds),
-              nonce
-            };
-            const signature = await this.signAuthorization(authorization, paymentRequirements, verifyingContract);
-            const payload = { authorization, signature };
-            const result = { x402Version, payload };
-            const createdContext = { ...context, paymentPayload: result };
-            for (const hook of this._afterHooks) {
-              try {
-                await hook(createdContext);
-              } catch {
-              }
-            }
-            return result;
-          } catch (error) {
-            const failureContext = { ...context, error };
-            for (const hook of this._failureHooks) {
-              const result = await hook(failureContext);
-              if (result && result.recovered) {
-                return { x402Version: result.payload.x402Version, payload: result.payload.payload };
-              }
-            }
-            throw error;
-          }
-        }
-        async signAuthorization(authorization, requirements, verifyingContract) {
-          if (!requirements.network.startsWith("eip155:")) {
-            throw new Error('BatchEvmScheme: unsupported network format "' + requirements.network + '". Expected "eip155:<chainId>"');
-          }
-          const chainId = parseInt(requirements.network.split(":")[1], 10);
-          const domain = {
-            name: CIRCLE_BATCHING_NAME,
-            version: CIRCLE_BATCHING_VERSION,
-            chainId,
-            verifyingContract: getAddress(verifyingContract)
-          };
-          const message = {
-            from: getAddress(authorization.from),
-            to: getAddress(authorization.to),
-            value: BigInt(authorization.value),
-            validAfter: BigInt(authorization.validAfter),
-            validBefore: BigInt(authorization.validBefore),
-            nonce: authorization.nonce
-          };
-          const typedData = {
-            domain,
-            types: authorizationTypes,
-            primaryType: "TransferWithAuthorization",
-            message
-          };
-          return this.signer.signTypedData(typedData);
-        }
-      };
-    }
-  });
-
-  // src/browser/gateway.js
-  var gateway_exports = {};
-  __export(gateway_exports, {
-    createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter
-  });
-  function encodeBase64(value) {
-    const text = typeof value === "string" ? value : stringifyJson(value);
-    if (typeof Buffer !== "undefined") return Buffer.from(text).toString("base64");
-    return btoa(unescape(encodeURIComponent(text)));
-  }
-  function decodeBase64(value) {
-    if (typeof Buffer !== "undefined") return Buffer.from(value, "base64").toString("utf8");
-    return decodeURIComponent(escape(atob(value)));
-  }
-  async function createCircleGatewayBrowserAdapter(options = {}) {
-    const signer = options.signer || await options.getSigner?.();
-    if (!signer?.address || typeof signer.signTypedData !== "function") {
-      throw new Error("Circle Gateway browser adapter requires an EVM signer with address and signTypedData.");
-    }
-    const scheme = options.clientModule?.BatchEvmScheme ? new options.clientModule.BatchEvmScheme(signer) : new BatchEvmScheme(signer);
-    const network = options.network || options.chainId && `eip155:${options.chainId}` || "eip155:5042002";
-    function parsePaymentRequired(input) {
-      if (input && typeof input === "object") return input;
-      if (!input || typeof input !== "string") throw new Error("Missing PAYMENT-REQUIRED header.");
-      return JSON.parse(decodeBase64(input));
-    }
-    function selectGatewayRequirement(paymentRequired) {
-      const accepts = Array.isArray(paymentRequired?.accepts) ? paymentRequired.accepts : [];
-      const selected = accepts.find((option) => {
-        const extra = option.extra || {};
-        return option.network === network && extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
-      }) || accepts.find((option) => {
-        const extra = option.extra || {};
-        return extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
-      });
-      if (!selected) {
-        const networks = accepts.map((option) => option.network).filter(Boolean).join(", ") || "none";
-        const hasGatewayExtra = accepts.some((option) => {
-          const extra = option.extra || {};
-          return extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
-        });
-        throw new Error(
-          hasGatewayExtra ? `No Circle Gateway batching payment option found for ${network}. Server returned networks: ${networks}.` : `The payment challenge is not a Circle Gateway batching challenge. Configure the creator access route with createCircleGatewayServer(...) or createNibgateServer({ paymentMode: 'circle-gateway', network: '${network}' }).`
-        );
-      }
-      return selected;
-    }
-    return {
-      signer,
-      network,
-      async pay({ paymentRequiredHeader, challenge }) {
-        const paymentRequired = parsePaymentRequired(paymentRequiredHeader || challenge);
-        const accepted = selectGatewayRequirement(paymentRequired);
-        const x402Version = paymentRequired.x402Version ?? 2;
-        const paymentPayload = await scheme.createPaymentPayload(x402Version, accepted);
-        const paymentSignature = encodeBase64({
-          ...paymentPayload,
-          resource: paymentRequired.resource,
-          accepted
-        });
-        return {
-          paymentSignature,
-          signature: paymentSignature,
-          metadata: {
-            paymentProvider: "circle-gateway",
-            network: accepted.network,
-            payer: signer.address,
-            recipient: accepted.payTo || accepted.recipient,
-            amount: accepted.amount,
-            currency: accepted.asset
-          }
-        };
-      }
-    };
-  }
-  var init_gateway = __esm({
-    "src/browser/gateway.js"() {
-      init_batch_scheme();
-      init_json();
-    }
-  });
-
-  // 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,
-    reviewTextHash: () => reviewTextHash,
-    settingsToAccessPolicy: () => settingsToAccessPolicy,
-    settingsToUnlockPolicy: () => settingsToUnlockPolicy,
-    setupResourcePage: () => setupResourcePage,
-    trackResourcePage: () => trackResourcePage,
-    validateResourceMetadata: () => validateResourceMetadata
-  });
-
   // src/core/payment.js
-  var PAYMENT_RAILS = ["gateway", "transfer"];
   function normalizePaymentRail(value, fallback = "gateway") {
     const rail = String(value || "").trim().toLowerCase().replace(/[-\s]+/g, "_");
     if (rail === "circle_gateway" || rail === "x402") return "gateway";
     if (rail === "direct_transfer" || rail === "wallet_transfer") return "transfer";
     return PAYMENT_RAILS.includes(rail) ? rail : fallback;
   }
+  var PAYMENT_RAILS;
+  var init_payment = __esm({
+    "src/core/payment.js"() {
+      PAYMENT_RAILS = ["gateway", "transfer"];
+    }
+  });
 
   // src/core/resource.js
-  var CONTENT_TYPES = ["music", "video", "article", "image"];
-  var TYPE_ALIASES = {
-    audio: "music",
-    song: "music",
-    track: "music",
-    album: "music",
-    playlist: "music",
-    photo: "image",
-    picture: "image",
-    illustration: "image",
-    art: "image",
-    movie: "video",
-    clip: "video"
-  };
-  var ACCESS_MODES = ["free", "paid", "blocked"];
-  var UNLOCK_MODES = ["one_time", "metered_stream", "metered_read", "time_pass", "agent_quota"];
   function normalizeContentType(value) {
     const type = String(value || "").trim().toLowerCase();
     if (CONTENT_TYPES.includes(type)) return type;
@@ -484,11 +188,37 @@ var Nibgate = (() => {
       resource: normalized
     };
   }
+  var CONTENT_TYPES, TYPE_ALIASES, ACCESS_MODES, UNLOCK_MODES;
+  var init_resource = __esm({
+    "src/core/resource.js"() {
+      init_payment();
+      CONTENT_TYPES = ["music", "video", "article", "image"];
+      TYPE_ALIASES = {
+        audio: "music",
+        song: "music",
+        track: "music",
+        album: "music",
+        playlist: "music",
+        photo: "image",
+        picture: "image",
+        illustration: "image",
+        art: "image",
+        movie: "video",
+        clip: "video"
+      };
+      ACCESS_MODES = ["free", "paid", "blocked"];
+      UNLOCK_MODES = ["one_time", "metered_stream", "metered_read", "time_pass", "agent_quota"];
+    }
+  });
 
   // src/browser/env.js
   function browserWindow() {
     return typeof window === "undefined" ? null : window;
   }
+  var init_env = __esm({
+    "src/browser/env.js"() {
+    }
+  });
 
   // src/browser/events.js
   function queueEvent(eventName, payload) {
@@ -539,6 +269,12 @@ var Nibgate = (() => {
       resource: normalizeResource(resource)
     };
   }
+  var init_events = __esm({
+    "src/browser/events.js"() {
+      init_env();
+      init_resource();
+    }
+  });
 
   // src/browser/storage.js
   function unlockStorageKey(resource) {
@@ -601,9 +337,14 @@ var Nibgate = (() => {
       return false;
     }
   }
+  var init_storage = __esm({
+    "src/browser/storage.js"() {
+      init_env();
+      init_resource();
+    }
+  });
 
   // src/browser/gate.js
-  var defaultClient = null;
   function setDefaultClient(client) {
     defaultClient = client;
   }
@@ -653,708 +394,1057 @@ var Nibgate = (() => {
       }
     };
   }
-
-  // src/browser/access.js
-  init_json();
-
-  // 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);
+  var defaultClient;
+  var init_gate = __esm({
+    "src/browser/gate.js"() {
+      init_resource();
+      init_events();
+      init_storage();
+      defaultClient = null;
+    }
+  });
+
+  // src/browser/json.js
+  function jsonReplacer(_key, value) {
+    if (typeof value === "bigint") return value.toString();
+    return value;
+  }
+  function stringifyJson(value) {
+    return JSON.stringify(value, jsonReplacer);
+  }
+  var init_json = __esm({
+    "src/browser/json.js"() {
+    }
+  });
+
+  // src/core/rating.js
+  function normalizeRating(input = {}) {
+    const value = typeof input === "number" ? input : input.rating ?? input.stars ?? input.ratingValue ?? input.score;
+    const numeric = Number.parseFloat(value);
+    const ratingValue = Number.isFinite(numeric) ? Math.max(1, Math.min(50, numeric <= 5 ? Math.round(numeric * 10) : Math.round(numeric))) : null;
+    return {
+      ...input,
+      rating: ratingValue ? ratingValue / 10 : void 0,
+      ratingValue: ratingValue || void 0
+    };
+  }
+  function ratingMessage(resource, rating = {}, options = {}) {
+    const normalized = normalizeResource(resource);
+    const normalizedRating = normalizeRating(rating);
+    const value = normalizedRating.ratingValue || 0;
+    return [
+      "Nibgate content rating",
+      `site:${options.siteDomain || options.domain || normalized.siteDomain || normalized.domain || ""}`,
+      `content:${normalized.externalId || normalized.id}`,
+      `url:${normalized.url || options.url || ""}`,
+      `rating:${value}`,
+      "I confirm this rating is tied to my unlock/payment proof."
+    ].join("\n");
+  }
+  var init_rating = __esm({
+    "src/core/rating.js"() {
+      init_resource();
+    }
+  });
+
+  // src/browser/schemes/batch-scheme.js
+  function supportsBatching(requirements) {
+    const extra = requirements.extra;
+    if (!extra) return false;
+    return extra.name === CIRCLE_BATCHING_NAME && extra.version === CIRCLE_BATCHING_VERSION;
+  }
+  function getVerifyingContract(requirements) {
+    if (!supportsBatching(requirements)) return void 0;
+    return requirements.extra?.verifyingContract;
+  }
+  function createNonce() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  function getAddress(value) {
+    return value && typeof value === "string" && value.startsWith("0x") ? value.toLowerCase() : value;
+  }
+  var CIRCLE_BATCHING_NAME, CIRCLE_BATCHING_VERSION, GATEWAY_MIN_AUTH_VALIDITY_SECONDS, GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS, authorizationTypes, BatchEvmScheme;
+  var init_batch_scheme = __esm({
+    "src/browser/schemes/batch-scheme.js"() {
+      CIRCLE_BATCHING_NAME = "GatewayWalletBatched";
+      CIRCLE_BATCHING_VERSION = "1";
+      GATEWAY_MIN_AUTH_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+      GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS = GATEWAY_MIN_AUTH_VALIDITY_SECONDS + 100;
+      authorizationTypes = {
+        TransferWithAuthorization: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "validAfter", type: "uint256" },
+          { name: "validBefore", type: "uint256" },
+          { name: "nonce", type: "bytes32" }
+        ]
+      };
+      BatchEvmScheme = class {
+        constructor(signer) {
+          this.signer = signer;
+          this.scheme = CIRCLE_BATCHING_NAME;
+          this._beforeHooks = [];
+          this._afterHooks = [];
+          this._failureHooks = [];
+        }
+        onBeforePaymentCreation(hook) {
+          this._beforeHooks.push(hook);
+          return this;
+        }
+        onAfterPaymentCreation(hook) {
+          this._afterHooks.push(hook);
+          return this;
+        }
+        onPaymentCreationFailure(hook) {
+          this._failureHooks.push(hook);
+          return this;
+        }
+        async createPaymentPayload(x402Version, paymentRequirements) {
+          const context = {
+            paymentRequired: { x402Version, accepts: [paymentRequirements] },
+            selectedRequirements: paymentRequirements
+          };
+          for (const hook of this._beforeHooks) {
+            const result = await hook(context);
+            if (result && result.abort) {
+              throw new Error("Payment creation aborted: " + result.reason);
+            }
+          }
+          try {
+            if (!supportsBatching(paymentRequirements)) {
+              throw new Error(
+                'BatchEvmScheme can only handle Circle batching options. Expected extra.name="' + CIRCLE_BATCHING_NAME + '" and extra.version="' + CIRCLE_BATCHING_VERSION + '"'
+              );
+            }
+            const verifyingContract = getVerifyingContract(paymentRequirements);
+            if (!verifyingContract) {
+              throw new Error(
+                "Circle batching option missing extra.verifyingContract (GatewayWallet address)"
+              );
+            }
+            const nonce = createNonce();
+            const now = Math.floor(Date.now() / 1e3);
+            const validityWindowSeconds = Math.max(
+              paymentRequirements.maxTimeoutSeconds || 0,
+              GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS
+            );
+            const authorization = {
+              from: getAddress(this.signer.address),
+              to: getAddress(paymentRequirements.payTo),
+              value: paymentRequirements.amount,
+              validAfter: String(now - 600),
+              validBefore: String(now + validityWindowSeconds),
+              nonce
+            };
+            const signature = await this.signAuthorization(authorization, paymentRequirements, verifyingContract);
+            const payload = { authorization, signature };
+            const result = { x402Version, payload };
+            const createdContext = { ...context, paymentPayload: result };
+            for (const hook of this._afterHooks) {
+              try {
+                await hook(createdContext);
+              } catch {
+              }
+            }
+            return result;
+          } catch (error) {
+            const failureContext = { ...context, error };
+            for (const hook of this._failureHooks) {
+              const result = await hook(failureContext);
+              if (result && result.recovered) {
+                return { x402Version: result.payload.x402Version, payload: result.payload.payload };
+              }
+            }
+            throw error;
+          }
+        }
+        async signAuthorization(authorization, requirements, verifyingContract) {
+          if (!requirements.network.startsWith("eip155:")) {
+            throw new Error('BatchEvmScheme: unsupported network format "' + requirements.network + '". Expected "eip155:<chainId>"');
+          }
+          const chainId = parseInt(requirements.network.split(":")[1], 10);
+          const domain = {
+            name: CIRCLE_BATCHING_NAME,
+            version: CIRCLE_BATCHING_VERSION,
+            chainId,
+            verifyingContract: getAddress(verifyingContract)
+          };
+          const message = {
+            from: getAddress(authorization.from),
+            to: getAddress(authorization.to),
+            value: BigInt(authorization.value),
+            validAfter: BigInt(authorization.validAfter),
+            validBefore: BigInt(authorization.validBefore),
+            nonce: authorization.nonce
+          };
+          const typedData = {
+            domain,
+            types: authorizationTypes,
+            primaryType: "TransferWithAuthorization",
+            message
+          };
+          return this.signer.signTypedData(typedData);
+        }
+      };
+    }
+  });
+
+  // src/browser/gateway.js
+  var gateway_exports = {};
+  __export(gateway_exports, {
+    createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter
+  });
+  function encodeBase64(value) {
+    const text = typeof value === "string" ? value : stringifyJson(value);
+    if (typeof Buffer !== "undefined") return Buffer.from(text).toString("base64");
+    return btoa(unescape(encodeURIComponent(text)));
+  }
+  function decodeBase64(value) {
+    if (typeof Buffer !== "undefined") return Buffer.from(value, "base64").toString("utf8");
+    return decodeURIComponent(escape(atob(value)));
+  }
+  async function createCircleGatewayBrowserAdapter(options = {}) {
+    const signer = options.signer || await options.getSigner?.();
+    if (!signer?.address || typeof signer.signTypedData !== "function") {
+      throw new Error("Circle Gateway browser adapter requires an EVM signer with address and signTypedData.");
+    }
+    const scheme = options.clientModule?.BatchEvmScheme ? new options.clientModule.BatchEvmScheme(signer) : new BatchEvmScheme(signer);
+    const network = options.network || options.chainId && `eip155:${options.chainId}` || "eip155:5042002";
+    function parsePaymentRequired(input) {
+      if (input && typeof input === "object") return input;
+      if (!input || typeof input !== "string") throw new Error("Missing PAYMENT-REQUIRED header.");
+      return JSON.parse(decodeBase64(input));
+    }
+    function selectGatewayRequirement(paymentRequired) {
+      const accepts = Array.isArray(paymentRequired?.accepts) ? paymentRequired.accepts : [];
+      const selected = accepts.find((option) => {
+        const extra = option.extra || {};
+        return option.network === network && extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
+      }) || accepts.find((option) => {
+        const extra = option.extra || {};
+        return extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
+      });
+      if (!selected) {
+        const networks = accepts.map((option) => option.network).filter(Boolean).join(", ") || "none";
+        const hasGatewayExtra = accepts.some((option) => {
+          const extra = option.extra || {};
+          return extra.name === "GatewayWalletBatched" && extra.version === "1" && typeof extra.verifyingContract === "string";
+        });
+        throw new Error(
+          hasGatewayExtra ? `No Circle Gateway batching payment option found for ${network}. Server returned networks: ${networks}.` : `The payment challenge is not a Circle Gateway batching challenge. Configure the creator access route with createCircleGatewayServer(...) or createNibgateServer({ paymentMode: 'circle-gateway', network: '${network}' }).`
+        );
+      }
+      return selected;
+    }
+    return {
+      signer,
+      network,
+      async pay({ paymentRequiredHeader, challenge }) {
+        const paymentRequired = parsePaymentRequired(paymentRequiredHeader || challenge);
+        const accepted = selectGatewayRequirement(paymentRequired);
+        const x402Version = paymentRequired.x402Version ?? 2;
+        const paymentPayload = await scheme.createPaymentPayload(x402Version, accepted);
+        const paymentSignature = encodeBase64({
+          ...paymentPayload,
+          resource: paymentRequired.resource,
+          accepted
+        });
+        return {
+          paymentSignature,
+          signature: paymentSignature,
+          metadata: {
+            paymentProvider: "circle-gateway",
+            network: accepted.network,
+            payer: signer.address,
+            recipient: accepted.payTo || accepted.recipient,
+            amount: accepted.amount,
+            currency: accepted.asset
+          }
+        };
+      }
+    };
+  }
+  var init_gateway = __esm({
+    "src/browser/gateway.js"() {
+      init_batch_scheme();
+      init_json();
     }
-    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;
+  });
+
+  // src/browser/reputation.js
+  function stripHex(value = "") {
+    return String(value || "").replace(/^0x/i, "").replace(/[^0-9a-fA-F]/g, "").toLowerCase();
   }
-  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;
-        }
-      });
+  function wordRight(hex = "") {
+    const clean = stripHex(hex);
+    if (clean.length > 64) throw new Error("ABI word is too long.");
+    return clean.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 encodeString(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) + encodeString(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 item;
+    return contentId;
   }
-
-  // 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 status = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status(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
+  function reviewTextHash(review = "") {
+    if (!review) return ZERO_HASH;
+    throw new Error("Text review hashing is not available in direct-browser mode. Pass reviewHash from your app/backend.");
+  }
+  async function prepareOnchainRating(resource, options = {}) {
+    if (options.contentId || options.contentHash) return { contentId: options.contentId || options.contentHash };
+    const prepareUrl = options.prepareUrl || options.indexUrl?.replace(/\/index$/, "/prepare");
+    if (!prepareUrl) throw new Error("contentId/contentHash or prepareUrl is required for onchain rating.");
+    const response = await fetch(prepareUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...options.indexHeaders || {} },
+      body: JSON.stringify({
+        siteId: options.siteId,
+        token: options.token,
+        resource,
+        url: resource.url,
+        path: resource.path
+      })
     });
     const payload = await response.json().catch(() => ({}));
-    if (response.status === 402) {
-      item.track("payment_challenge_returned", { source: options.source, challenge: payload, resource: item.resource });
-      status(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) {
-      status(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);
-    }
-    status(options.successMessage || "Access allowed and Nibgate events emitted.");
-    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
+    if (!response.ok || !payload.contentHash) throw new Error(payload.error || "Could not prepare Nibgate onchain rating.");
+    return payload;
   }
-  async function payWithPaymentSignature(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
-    const status = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status(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 challenge = options.challenge || null;
-      const checkout = options.createPaymentSignature || options.checkout;
-      const result = await checkout({
-        resource: item.resource,
-        challenge,
-        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 });
-      status(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 || {}
-      }
+  async function rateContentOnchain(resource, options = {}) {
+    const normalized = normalizeResource(resource);
+    const rating = normalizeRating(options.rating ?? options.stars ?? options);
+    if (!rating.ratingValue) throw new Error("Rating must be between 0.1 and 5 stars.");
+    const provider = options.provider || globalThis?.ethereum;
+    if (!provider?.request) throw new Error("Connect an EVM wallet to rate this content onchain.");
+    const contractAddress = options.contractAddress || options.reputationContract || NIBGATE_REPUTATION_CONTRACT;
+    if (!contractAddress) throw new Error("Nibgate reputation contract address is not configured.");
+    const accounts = await provider.request({ method: "eth_requestAccounts" });
+    const walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
+    if (!walletAddress) throw new Error("No wallet account selected.");
+    const prepared = await prepareOnchainRating(normalized, options);
+    const contentId = prepared.contentHash || prepared.contentId || contentRatingHash(normalized, options);
+    const reviewHash = options.reviewHash || ZERO_HASH;
+    const unlockRef = String(options.unlockRef || options.paymentId || options.txHash || "");
+    const data = encodeRateContent({ contentId, ratingValue: rating.ratingValue, reviewHash, unlockRef });
+    const txHash = await provider.request({
+      method: "eth_sendTransaction",
+      params: [{
+        from: walletAddress,
+        to: contractAddress,
+        data
+      }]
     });
-    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 });
-      status(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);
-    status(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 status = typeof options.onStatus === "function" ? options.onStatus : () => {
-    };
-    status(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 = payloadWithResource(normalized, {
+      rating: rating.rating,
+      ratingValue: rating.ratingValue,
+      walletAddress,
+      txHash,
+      contentHash: contentId,
+      reviewHash,
+      proofType: "onchain_pending",
+      proof: unlockRef,
+      paymentId: options.paymentId,
+      actor: options.actor || "human"
     });
-    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 || "" });
-      status(payload.detail || payload.error || options.paymentErrorMessage || "Payment failed.");
-      return { ok: false, status: response.status, payload, resource: item.resource, response };
+    emit("content_rating", payload);
+    if (options.indexUrl) {
+      await fetch(options.indexUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...options.indexHeaders || {} },
+        body: JSON.stringify({
+          siteId: options.siteId,
+          token: options.token,
+          txHash,
+          resource: normalized,
+          url: normalized.url,
+          path: normalized.path,
+          actor: options.actor || "human"
+        })
+      }).catch(() => null);
     }
-    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);
-    status(options.paymentSuccessMessage || "Payment verified. Content unlocked.");
-    return { ok: true, status: response.status, payload, payment, resource: item.resource, response };
+    return { txHash, walletAddress, contentId, ratingValue: rating.ratingValue, reviewHash };
   }
+  var RATE_CONTENT_SELECTOR, ZERO_HASH, NIBGATE_CONTENT_HASH_NAMESPACE, NIBGATE_REPUTATION_CHAIN_ID, NIBGATE_REPUTATION_CHAIN_NAME, NIBGATE_REPUTATION_RPC_URL, NIBGATE_REPUTATION_CONTRACT, NIBGATE_REPUTATION_ABI;
+  var init_reputation = __esm({
+    "src/browser/reputation.js"() {
+      init_rating();
+      init_resource();
+      init_events();
+      RATE_CONTENT_SELECTOR = "0xc62fad09";
+      ZERO_HASH = `0x${"0".repeat(64)}`;
+      NIBGATE_CONTENT_HASH_NAMESPACE = "nibgate:content:v1";
+      NIBGATE_REPUTATION_CHAIN_ID = 5042002;
+      NIBGATE_REPUTATION_CHAIN_NAME = "Arc Testnet";
+      NIBGATE_REPUTATION_RPC_URL = "https://rpc.testnet.arc.io";
+      NIBGATE_REPUTATION_CONTRACT = "0x9f27fd62e75f86a3c7addfdba443aab1f930e281";
+      NIBGATE_REPUTATION_ABI = [
+        {
+          type: "function",
+          name: "rateContent",
+          stateMutability: "nonpayable",
+          inputs: [
+            { name: "contentId", type: "bytes32" },
+            { name: "rating", type: "uint8" },
+            { name: "reviewHash", type: "bytes32" },
+            { name: "unlockRef", type: "string" }
+          ],
+          outputs: []
+        }
+      ];
+    }
+  });
 
-  // src/browser/checkout.js
-  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 || "";
+  // src/browser/rating-ui.js
+  var rating_ui_exports = {};
+  __export(rating_ui_exports, {
+    createOnchainRating: () => createOnchainRating,
+    mountRatingUI: () => mountRatingUI,
+    rateResource: () => rateResource
+  });
+  function rateResource(resource, rating = {}, extra = {}) {
+    const normalized = normalizeResource(resource);
+    const normalizedRating = normalizeRating(rating);
+    const payload = {
+      ...extra,
+      ...normalizedRating,
+      ratingMessage: extra.ratingMessage || rating.message || rating.ratingMessage || ratingMessage(normalized, normalizedRating, extra),
+      ratingSignature: extra.ratingSignature || rating.signature || rating.ratingSignature || void 0,
+      resource: normalized
+    };
+    return emit("content_rating", payload);
   }
-  function setElementDisabled(target, disabled) {
+  function createOnchainRating(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
     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 status = 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.");
+    const statusTarget = typeof options.status === "string" ? win?.document.querySelector(options.status) : options.status;
+    const ratingTarget = typeof options.ratingTarget === "string" ? win?.document.querySelector(options.ratingTarget) : options.ratingTarget;
+    const buttonSelector = options.ratingButtons || options.buttons || "[data-nibgate-rating-value], [data-rating]";
+    const explicitButtons = Array.isArray(options.buttons) ? options.buttons : typeof options.buttons === "string" ? Array.from(win?.document.querySelectorAll(options.buttons) || []) : options.buttons ? [options.buttons] : null;
+    const buttons = explicitButtons || Array.from(win?.document.querySelectorAll(buttonSelector) || []);
+    const source = options.source || "nibgate-onchain-rating";
+    let busy = false;
+    let payment = options.payment || null;
+    function setStatus(message) {
+      if (typeof options.onStatus === "function") options.onStatus(message);
+      if (statusTarget) statusTarget.textContent = message || "";
     }
-    async function unlock(extra = {}) {
-      setElementDisabled(button, true);
+    function setBusy(value) {
+      busy = Boolean(value);
+      buttons.forEach((button) => {
+        if (button && "disabled" in button) button.disabled = busy;
+      });
+    }
+    function setPayment(nextPayment = null) {
+      payment = nextPayment || null;
+      return payment;
+    }
+    function setVisible(isVisible) {
+      if (!ratingTarget) return Boolean(isVisible);
+      if ("hidden" in ratingTarget) ratingTarget.hidden = !isVisible;
+      ratingTarget.setAttribute("aria-hidden", isVisible ? "false" : "true");
+      return Boolean(isVisible);
+    }
+    function valueFromButton(button) {
+      const raw = button?.dataset?.nibgateRatingValue || button?.dataset?.rating || button?.value || button?.textContent;
+      const numeric = Number.parseFloat(String(raw || "").replace(/[^\d.]/g, ""));
+      return Number.isFinite(numeric) ? numeric : Number(options.rating || options.stars || 0);
+    }
+    async function rate(input = {}) {
+      setBusy(true);
       try {
-        return await checkResourceAccess(normalized, {
-          ...options,
-          ...extra,
-          accessPath,
-          createPaymentSignature: checkout,
-          onStatus: status
-        });
+        const rating = Number.parseFloat(input.rating ?? input.stars ?? input.value ?? options.rating ?? options.stars);
+        if (!Number.isFinite(rating)) throw new Error("Choose a rating before sending.");
+        const paymentId = input.paymentId || options.paymentId || (typeof options.getPaymentId === "function" ? options.getPaymentId() : payment?.paymentId);
+        const unlockRef = input.unlockRef || options.unlockRef || (typeof options.getUnlockRef === "function" ? options.getUnlockRef() : null) || paymentId || payment?.txHash || payment?.transactionHash || "";
+        setStatus(options.pendingMessage || "Send the onchain rating transaction...");
+        const result = await rateContentOnchain(item.resource, { ...options, ...input, rating, paymentId, unlockRef, source });
+        setStatus(options.successMessage || "Rating sent to Nibgate reputation.");
+        if (typeof options.onRated === "function") options.onRated(result);
+        return result;
+      } catch (error) {
+        const message = error?.message || options.errorMessage || "Rating failed.";
+        setStatus(message);
+        if (typeof options.onError === "function") options.onError(error);
+        throw error;
       } finally {
-        setElementDisabled(button, false);
+        setBusy(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) => status(error.message || "Checkout failed.")));
-      return { unlock };
+      buttons.forEach((button) => {
+        button?.addEventListener?.("click", () => rate({ rating: valueFromButton(button) }).catch(() => null));
+      });
+      if (options.visible !== void 0) setVisible(Boolean(options.visible));
+      return controller;
     }
-    return { resource: normalized, unlock, mount };
-  }
-
-  // src/core/rating.js
-  function normalizeRating(input = {}) {
-    const value = typeof input === "number" ? input : input.rating ?? input.stars ?? input.ratingValue ?? input.score;
-    const numeric = Number.parseFloat(value);
-    const ratingValue = Number.isFinite(numeric) ? Math.max(1, Math.min(50, numeric <= 5 ? Math.round(numeric * 10) : Math.round(numeric))) : null;
-    return {
-      ...input,
-      rating: ratingValue ? ratingValue / 10 : void 0,
-      ratingValue: ratingValue || void 0
-    };
+    const controller = { resource: item.resource, rate, mount, setPayment, setVisible };
+    if (options.autoMount !== false) mount();
+    return controller;
   }
-  function ratingMessage(resource, rating = {}, options = {}) {
-    const normalized = normalizeResource(resource);
-    const normalizedRating = normalizeRating(rating);
-    const value = normalizedRating.ratingValue || 0;
-    return [
-      "Nibgate content rating",
-      `site:${options.siteDomain || options.domain || normalized.siteDomain || normalized.domain || ""}`,
-      `content:${normalized.externalId || normalized.id}`,
-      `url:${normalized.url || options.url || ""}`,
-      `rating:${value}`,
-      "I confirm this rating is tied to my unlock/payment proof."
-    ].join("\n");
+  function mountRatingUI(resource, options = {}) {
+    const item = createGate(resource, options.gateOptions || {});
+    const win = browserWindow();
+    if (!win) return null;
+    const target = typeof options.target === "string" ? win.document.querySelector(options.target) : options.target;
+    if (!target) return null;
+    const stars = [1, 2, 3, 4, 5];
+    let selectedRating = 0;
+    const container = win.document.createElement("div");
+    container.className = "nibgate-rating-ui";
+    container.style.cssText = "display:flex;align-items:center;gap:4px;padding:8px 0";
+    const starButtons = stars.map((value) => {
+      const btn = win.document.createElement("button");
+      btn.type = "button";
+      btn.dataset.nibgateRatingValue = String(value);
+      btn.setAttribute("aria-label", `${value} star${value > 1 ? "s" : ""}`);
+      btn.innerHTML = "\u2606";
+      btn.style.cssText = "background:none;border:none;font-size:24px;cursor:pointer;color:#ccc;transition:color 0.15s;padding:2px;line-height:1";
+      btn.addEventListener("mouseenter", () => {
+        starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
+      });
+      btn.addEventListener("mouseleave", () => {
+        starButtons.forEach((b, i) => b.style.color = i < selectedRating ? "#f5b342" : "#ccc");
+      });
+      btn.addEventListener("click", () => {
+        selectedRating = value;
+        starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
+        rateResource(item.resource, { rating: value }).catch(() => {
+        });
+      });
+      container.appendChild(btn);
+      return btn;
+    });
+    const statusEl = win.document.createElement("span");
+    statusEl.style.cssText = "font-size:13px;color:#888;margin-left:8px";
+    statusEl.textContent = options.label || "Rate this content";
+    container.appendChild(statusEl);
+    target.appendChild(container);
+    function rate(r, input = {}) {
+      return item.rate({ ...input, rating: r });
+    }
+    function setRating(value) {
+      selectedRating = value;
+      starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
+    }
+    return { resource: item.resource, container, setRating, rate };
   }
+  var init_rating_ui = __esm({
+    "src/browser/rating-ui.js"() {
+      init_resource();
+      init_rating();
+      init_events();
+      init_env();
+      init_reputation();
+      init_gate();
+    }
+  });
+
+  // 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();
 
-  // src/browser/evm-gateway.js
+  // src/browser/access.js
+  init_events();
+  init_storage();
   init_json();
-  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 = {}) {
+  init_gate();
+
+  // src/browser/track.js
+  init_resource();
+  init_env();
+  init_gate();
+  function trackResourcePage(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;
+    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);
     }
-    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;
+    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;
         }
       });
     }
-    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);
+    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") || ""
+        });
       }
-    }
-    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) {
-          }
+      if (options.autoPay && options.payPath) {
+        const paymentResult = await payAndUnlockResource(resource, options);
+        if (paymentResult.ok && options.retryAfterPay !== false) {
+          return checkResourceAccess(resource, { ...options, autoPay: false });
         }
-        walletAddress = "";
-        renderWallet();
-        setStatus(options.disconnectMessage || "Wallet disconnected for this page.");
-        return true;
-      } finally {
-        setBusy(false);
+        return paymentResult;
       }
+      return { ok: false, status: response.status, challenge: payload, resource: item.resource, response };
     }
-    async function checkout(input) {
-      const evm = provider();
-      if (!evm) throw new Error(options.noWalletMessage || "Install or open an EVM wallet to continue.");
-      if (!walletAddress) await connect();
-      const gatewayWallet = await createCircleGatewayBrowserAdapter2({
-        network,
-        signer: {
-          address: walletAddress,
-          signTypedData: (typedData) => evm.request({ method: "eth_signTypedData_v4", params: [walletAddress, stringifyJson(typedData)] })
-        },
-        clientModule: options.circleClientModule
-      });
-      return gatewayWallet.pay(input);
+    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 };
     }
-    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();
-      }
+    const payment = options.payment || payload.payment || null;
+    if (payment) {
+      item.unlockCompleted(payment);
+      item.paymentCompleted(payment);
     }
-    function clear() {
-      clearPaymentProof(item.resource);
-      setUnlocked(false);
-      setStatus("Local payment proof cleared. The next unlock will require Gateway payment again.");
+    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 challenge = options.challenge || null;
+      const checkout = options.createPaymentSignature || options.checkout;
+      const result = await checkout({
+        resource: item.resource,
+        challenge,
+        paymentRequiredHeader,
+        accessPath
+      });
+      paymentSignature = result?.paymentSignature || result?.signature || result?.payment || "";
+      paymentMemo = result?.memo || result?.paymentMemo || "";
+      paymentMetadata = result?.metadata || result?.paymentMetadata || result || {};
     }
-    async function hydrate() {
-      const evm = provider();
-      try {
-        const accounts = evm ? await evm.request({ method: "eth_accounts" }) : [];
-        walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
-      } catch {
+    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 || {}
       }
-      renderWallet();
-      setUnlocked(false);
+    });
+    const responseText = await response.text();
+    let payload = {};
+    try {
+      payload = responseText ? JSON.parse(responseText) : {};
+    } catch (_error) {
+      payload = { error: responseText || "Payment verification failed" };
     }
-    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;
+    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 controller = { resource: item.resource, connect, disconnect, unlock, clear, hydrate, mount, getWalletAddress: () => walletAddress };
-    if (options.autoMount !== false) mount();
-    return controller;
+    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 };
   }
-  function createHostedUnlock(resource, options = {}) {
-    return createEvmGatewayUnlock(resource, {
-      ...options,
-      hosted: true,
-      noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
+  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 || {} })
     });
-  }
-
-  // src/browser/reputation.js
-  var RATE_CONTENT_SELECTOR = "0xc62fad09";
-  var ZERO_HASH = `0x${"0".repeat(64)}`;
-  var NIBGATE_CONTENT_HASH_NAMESPACE = "nibgate:content:v1";
-  var NIBGATE_REPUTATION_CHAIN_ID = 5042002;
-  var NIBGATE_REPUTATION_CHAIN_NAME = "Arc Testnet";
-  var NIBGATE_REPUTATION_RPC_URL = "https://rpc.testnet.arc.network";
-  var NIBGATE_REPUTATION_CONTRACT = "0x9f27fd62e75f86a3c7addfdba443aab1f930e281";
-  var NIBGATE_REPUTATION_ABI = [
-    {
-      type: "function",
-      name: "rateContent",
-      stateMutability: "nonpayable",
-      inputs: [
-        { name: "contentId", type: "bytes32" },
-        { name: "rating", type: "uint8" },
-        { name: "reviewHash", type: "bytes32" },
-        { name: "unlockRef", type: "string" }
-      ],
-      outputs: []
-    }
-  ];
-  function stripHex(value = "") {
-    return String(value || "").replace(/^0x/i, "").toLowerCase();
-  }
-  function wordRight(hex = "") {
-    const clean = stripHex(hex);
-    if (clean.length > 64) throw new Error("ABI word is too long.");
-    return clean.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 encodeString(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) + encodeString(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.");
+    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 };
     }
-    return contentId;
+    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 };
   }
-  function reviewTextHash(review = "") {
-    if (!review) return ZERO_HASH;
-    throw new Error("Text review hashing is not available in direct-browser mode. Pass reviewHash from your app/backend.");
+
+  // 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 || "";
   }
-  async function prepareOnchainRating(resource, options = {}) {
-    if (options.contentId || options.contentHash) return { contentId: options.contentId || options.contentHash };
-    const prepareUrl = options.prepareUrl || options.indexUrl?.replace(/\/index$/, "/prepare");
-    if (!prepareUrl) throw new Error("contentId/contentHash or prepareUrl is required for onchain rating.");
-    const response = await fetch(prepareUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json", ...options.indexHeaders || {} },
-      body: JSON.stringify({
-        siteId: options.siteId,
-        token: options.token,
-        resource,
-        url: resource.url,
-        path: resource.path
-      })
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || !payload.contentHash) throw new Error(payload.error || "Could not prepare Nibgate onchain rating.");
-    return payload;
+  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);
   }
-  async function rateContentOnchain(resource, options = {}) {
+  function createWalletCheckout(resource, options = {}) {
     const normalized = normalizeResource(resource);
-    const rating = normalizeRating(options.rating ?? options.stars ?? options);
-    if (!rating.ratingValue) throw new Error("Rating must be between 0.1 and 5 stars.");
-    const provider = options.provider || globalThis?.ethereum;
-    if (!provider?.request) throw new Error("Connect an EVM wallet to rate this content onchain.");
-    const contractAddress = options.contractAddress || options.reputationContract || NIBGATE_REPUTATION_CONTRACT;
-    if (!contractAddress) throw new Error("Nibgate reputation contract address is not configured.");
-    const accounts = await provider.request({ method: "eth_requestAccounts" });
-    const walletAddress = Array.isArray(accounts) ? accounts[0] || "" : "";
-    if (!walletAddress) throw new Error("No wallet account selected.");
-    const prepared = await prepareOnchainRating(normalized, options);
-    const contentId = prepared.contentHash || prepared.contentId || contentRatingHash(normalized, options);
-    const reviewHash = options.reviewHash || ZERO_HASH;
-    const unlockRef = String(options.unlockRef || options.paymentId || options.txHash || "");
-    const data = encodeRateContent({ contentId, ratingValue: rating.ratingValue, reviewHash, unlockRef });
-    const txHash = await provider.request({
-      method: "eth_sendTransaction",
-      params: [{
-        from: walletAddress,
-        to: contractAddress,
-        data
-      }]
-    });
-    const payload = payloadWithResource(normalized, {
-      rating: rating.rating,
-      ratingValue: rating.ratingValue,
-      walletAddress,
-      txHash,
-      contentHash: contentId,
-      reviewHash,
-      proofType: "onchain_pending",
-      proof: unlockRef,
-      paymentId: options.paymentId,
-      actor: options.actor || "human"
-    });
-    emit("content_rating", payload);
-    if (options.indexUrl) {
-      await fetch(options.indexUrl, {
-        method: "POST",
-        headers: { "content-type": "application/json", ...options.indexHeaders || {} },
-        body: JSON.stringify({
-          siteId: options.siteId,
-          token: options.token,
-          txHash,
-          resource: normalized,
-          url: normalized.url,
-          path: normalized.path,
-          actor: options.actor || "human"
-        })
-      }).catch(() => null);
+    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.");
     }
-    return { txHash, walletAddress, contentId, ratingValue: rating.ratingValue, reviewHash };
+    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/rating-ui.js
-  function rateResource(resource, rating = {}, extra = {}) {
-    const normalized = normalizeResource(resource);
-    const normalizedRating = normalizeRating(rating);
-    const payload = {
-      ...extra,
-      ...normalizedRating,
-      ratingMessage: extra.ratingMessage || rating.message || rating.ratingMessage || ratingMessage(normalized, normalizedRating, extra),
-      ratingSignature: extra.ratingSignature || rating.signature || rating.ratingSignature || void 0,
-      resource: normalized
-    };
-    return emit("content_rating", payload);
+  // src/browser/client.js
+  init_resource();
+  init_rating();
+  init_events();
+  init_gate();
+  init_gate();
+
+  // src/browser/evm-gateway.js
+  init_env();
+  init_storage();
+  init_json();
+  init_gate();
+  async function createCircleGatewayBrowserAdapter2(options = {}) {
+    const gateway = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+    return gateway.createCircleGatewayBrowserAdapter(options);
   }
-  function createOnchainRating(resource, 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 ratingTarget = typeof options.ratingTarget === "string" ? win?.document.querySelector(options.ratingTarget) : options.ratingTarget;
-    const buttonSelector = options.ratingButtons || options.buttons || "[data-nibgate-rating-value], [data-rating]";
-    const explicitButtons = Array.isArray(options.buttons) ? options.buttons : typeof options.buttons === "string" ? Array.from(win?.document.querySelectorAll(options.buttons) || []) : options.buttons ? [options.buttons] : null;
-    const buttons = explicitButtons || Array.from(win?.document.querySelectorAll(buttonSelector) || []);
-    const source = options.source || "nibgate-onchain-rating";
+    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;
-    let payment = options.payment || null;
     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);
-      buttons.forEach((button) => {
-        if (button && "disabled" in button) button.disabled = busy;
+      busy = Boolean(value);
+      [connectButton, disconnectButton, unlockButton, clearButton].forEach((button) => {
+        if (button && "disabled" in button) {
+          button.disabled = busy || button === connectButton && !provider() || button === disconnectButton && !walletAddress;
+        }
       });
     }
-    function setPayment(nextPayment = null) {
-      payment = nextPayment || null;
-      return payment;
+    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 setVisible(isVisible) {
-      if (!ratingTarget) return Boolean(isVisible);
-      if ("hidden" in ratingTarget) ratingTarget.hidden = !isVisible;
-      ratingTarget.setAttribute("aria-hidden", isVisible ? "false" : "true");
-      return Boolean(isVisible);
+    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);
     }
-    function valueFromButton(button) {
-      const raw = button?.dataset?.nibgateRatingValue || button?.dataset?.rating || button?.value || button?.textContent;
-      const numeric = Number.parseFloat(String(raw || "").replace(/[^\d.]/g, ""));
-      return Number.isFinite(numeric) ? numeric : Number(options.rating || options.stars || 0);
+    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 rate(input = {}) {
+    async function disconnect() {
       setBusy(true);
       try {
-        const rating = Number.parseFloat(input.rating ?? input.stars ?? input.value ?? options.rating ?? options.stars);
-        if (!Number.isFinite(rating)) throw new Error("Choose a rating before sending.");
-        const paymentId = input.paymentId || options.paymentId || (typeof options.getPaymentId === "function" ? options.getPaymentId() : payment?.paymentId);
-        const unlockRef = input.unlockRef || options.unlockRef || (typeof options.getUnlockRef === "function" ? options.getUnlockRef() : null) || paymentId || payment?.txHash || payment?.transactionHash || "";
-        setStatus(options.pendingMessage || "Send the onchain rating transaction...");
-        const result = await rateContentOnchain(item.resource, { ...options, ...input, rating, paymentId, unlockRef, source });
-        setStatus(options.successMessage || "Rating sent to Nibgate reputation.");
-        if (typeof options.onRated === "function") options.onRated(result);
+        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.");
+      if (!walletAddress) await connect();
+      const gatewayWallet = await createCircleGatewayBrowserAdapter2({
+        network,
+        signer: {
+          address: walletAddress,
+          signTypedData: (typedData) => evm.request({ method: "eth_signTypedData_v4", params: [walletAddress, stringifyJson(typedData)] })
+        },
+        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 || options.errorMessage || "Rating failed.";
+        const message = error?.message || "Unlock failed. Please try again.";
         setStatus(message);
-        if (typeof options.onError === "function") options.onError(error);
-        throw error;
+        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() {
-      buttons.forEach((button) => {
-        button?.addEventListener?.("click", () => rate({ rating: valueFromButton(button) }).catch(() => null));
-      });
-      if (options.visible !== void 0) setVisible(Boolean(options.visible));
+      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, rate, mount, setPayment, setVisible };
+    const controller = { resource: item.resource, connect, disconnect, unlock, clear, hydrate, mount, getWalletAddress: () => walletAddress };
     if (options.autoMount !== false) mount();
     return controller;
   }
-  function mountRatingUI(resource, options = {}) {
-    const item = createGate(resource, options.gateOptions || {});
-    const win = browserWindow();
-    if (!win) return null;
-    const target = typeof options.target === "string" ? win.document.querySelector(options.target) : options.target;
-    if (!target) return null;
-    const stars = [1, 2, 3, 4, 5];
-    let selectedRating = 0;
-    const container = win.document.createElement("div");
-    container.className = "nibgate-rating-ui";
-    container.style.cssText = "display:flex;align-items:center;gap:4px;padding:8px 0";
-    const starButtons = stars.map((value) => {
-      const btn = win.document.createElement("button");
-      btn.type = "button";
-      btn.dataset.nibgateRatingValue = String(value);
-      btn.setAttribute("aria-label", `${value} star${value > 1 ? "s" : ""}`);
-      btn.innerHTML = "\u2606";
-      btn.style.cssText = "background:none;border:none;font-size:24px;cursor:pointer;color:#ccc;transition:color 0.15s;padding:2px;line-height:1";
-      btn.addEventListener("mouseenter", () => {
-        starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
-      });
-      btn.addEventListener("mouseleave", () => {
-        starButtons.forEach((b, i) => b.style.color = i < selectedRating ? "#f5b342" : "#ccc");
-      });
-      btn.addEventListener("click", () => {
-        selectedRating = value;
-        starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
-        rateResource(item.resource, { rating: value }).catch(() => {
-        });
-      });
-      container.appendChild(btn);
-      return btn;
+  function createHostedUnlock(resource, options = {}) {
+    return createEvmGatewayUnlock(resource, {
+      ...options,
+      hosted: true,
+      noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
     });
-    const statusEl = win.document.createElement("span");
-    statusEl.style.cssText = "font-size:13px;color:#888;margin-left:8px";
-    statusEl.textContent = options.label || "Rate this content";
-    container.appendChild(statusEl);
-    target.appendChild(container);
-    function rate(r, input = {}) {
-      return item.rate({ ...input, rating: r });
-    }
-    function setRating(value) {
-      selectedRating = value;
-      starButtons.forEach((b, i) => b.style.color = i < value ? "#f5b342" : "#ccc");
-    }
-    return { resource: item.resource, container, setRating, rate };
   }
 
+  // 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;
@@ -1488,7 +1578,449 @@ var Nibgate = (() => {
   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 || {})) {
+      if (k === "dataset") Object.assign(e.dataset, v);
+      else if (k.startsWith("on")) e.addEventListener(k.slice(2).toLowerCase(), v);
+      else if (k === "style" && typeof v === "object") e.style.cssText = css(v);
+      else if (k === "cls") e.className = v;
+      else e.setAttribute(k, String(v));
+    }
+    if (typeof children === "string") e.innerHTML = children;
+    else if (children) (Array.isArray(children) ? children : [children]).forEach((c) => {
+      if (c != null) e.appendChild(typeof c === "string" ? document.createTextNode(c) : c);
+    });
+    return e;
+  }
+  function inject() {
+    if (document.getElementById(SID)) return;
+    const s = h("style", { id: SID }, `
+@keyframes nfade { from { opacity:0;transform:translateY(6px) } to { opacity:1;transform:translateY(0) } }
+@keyframes nscale { from { opacity:0;transform:scale(0.96) } to { opacity:1;transform:scale(1) } }
+@keyframes nshimmer { 0% { transform:translateX(-100%) } 100% { transform:translateX(100%) } }
+
+.nui { font-family:var(--font-content,'Kumbh Sans','ABC Favorit',-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif);color:${theme.fg};line-height:1.5;-webkit-font-smoothing:antialiased;font-size:19px }
+.nui *,.nui *::before,.nui *::after { box-sizing:border-box }
+.nui-btn { display:flex;align-items:center;justify-content:center;gap:8px;font-size:18px;font-weight:600;padding:14px 28px;border-radius:12px;cursor:pointer;transition:all.12s;font-family:inherit;line-height:1;border:none }
+.nui-btn:disabled { opacity:0.35;cursor:default;pointer-events:none }
+.nui-btn:focus-visible { outline:2px solid ${theme.accent};outline-offset:2px }
+.nui-btn-primary { background:${theme.accent};color:${theme.bg} }
+.nui-btn-primary:hover:not(:disabled) { opacity:0.9 }
+.nui-btn-primary:active:not(:disabled) { transform:scale(.98) }
+.nui-btn-outline { background:transparent;border:1px solid ${theme.border};color:${theme.fg} }
+.nui-btn-outline:hover:not(:disabled) { border-color:${theme.accent};color:${theme.accent} }
+.nui-input { padding:14px 16px;font-size:18px;border-radius:12px;border:1px solid ${theme.border};background:transparent;color:${theme.fg};width:100%;font-family:inherit;outline:none;transition:border-color.12s }
+.nui-input:focus { border-color:${theme.accent} }
+.nui-input::placeholder { color:${theme.muted} }
+.nui-label { font-size:17px;font-weight:600;color:${theme.muted};margin-bottom:8px;display:block }
+.nui-mono { font-family:ui-monospace,SFMono-Regular,'SF Mono',Menlo,Consolas,monospace }
+.nui-stat { font-size:18px;color:${theme.muted};line-height:1.4;min-height:28px }
+.nui-stat-err { color:#dc2626 }
+.nui-stat-ok { color:#16a34a }
+`);
+    document.head.appendChild(s);
+  }
+  function el(tag, a, c) {
+    return h(tag, a, c);
+  }
+  function status(el2, msg) {
+    if (!el2) return;
+    el2.textContent = msg || "";
+  }
+  function esc(s) {
+    const d = document.createElement("div");
+    d.textContent = String(s ?? "");
+    return d.innerHTML;
+  }
+  function renderDefaultUnlockUI(container, resource, options = {}) {
+    inject();
+    const card = el("div", { cls: "nui", style: { animation: "nfade .2s ease-out" } });
+    const lockSVG = '<svg width="24" height="24" viewBox="0 0 32 32" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" style="vertical-align:middle"><path d="M6 16v8a3 3 0 0 0 3 3h14a3 3 0 0 0 3-3v-8"/><path d="M10 16v-5a6 6 0 0 1 12 0v5"/><circle cx="16" cy="21" r="2"/></svg>';
+    card.innerHTML = `
+    <div style="display:flex;flex-direction:column;align-items:center;text-align:center;max-width:580px;margin:0 auto;padding:40px 52px">
+      <div id="nibgate-lottie" style="width:165px;height:168px;margin-bottom:24px"></div>
+      <div style="font-size:50px;font-weight:700;letter-spacing:-.03em;color:${theme.fg};margin-bottom:12px">${esc(resource.price)} USDC</div>
+      <div style="font-size:21px;color:${theme.muted};margin-bottom:48px">Pay to unlock this content</div>
+      <div data-nibgate-wallet-label class="nui-mono" style="font-size:18px;color:${theme.muted};margin-bottom:40px;min-height:28px">Connect wallet</div>
+      <div data-nibgate-unlock-wrap style="width:100%;position:relative;border-radius:12px;overflow:hidden;cursor:pointer">
+        <div data-nibgate-unlock-progress style="position:absolute;inset:0;width:0%;background:linear-gradient(90deg,rgba(255,255,255,0.1),rgba(255,255,255,0.45));border-radius:12px;transition:width .05s linear;z-index:2"></div>
+        <div data-nibgate-shimmer style="position:absolute;inset:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,0.12),transparent);border-radius:12px;transform:translateX(-100%);z-index:3;pointer-events:none"></div>
+        <button type="button" data-nibgate-unlock disabled class="nui-btn nui-btn-primary" style="width:100%;padding:24px 32px;font-size:24px;position:relative;z-index:4;background:${theme.accent};transition:transform .1s,opacity .15s;display:flex">${lockSVG}Hold to pay ${esc(resource.price)} USDC</button></div>
+      <div class="nui-stat" style="text-align:center;margin-top:16px" data-nibgate-status></div>
+    </div>
+    <div data-nibgate-premium hidden style="margin-top:32px;border-top:1px solid ${theme.border};padding-top:32px"></div>
+  `;
+    (typeof container === "string" ? document.querySelector(container) : container)?.appendChild(card);
+    (function loadLottie() {
+      if (!document.getElementById("nibgate-lottie")) return;
+      function startAnim(data) {
+        var d = document.getElementById("nibgate-lottie");
+        if (d && window.lottie) {
+          window.lottie.loadAnimation({ container: d, animationData: data, loop: true, autoplay: true });
+        }
+      }
+      if (window.lottie) {
+        if (window._lottieData) {
+          startAnim(window._lottieData);
+        } else {
+          fetch("/nibgate-unlock-key.json?t=1").then(function(r) {
+            if (!r.ok) throw new Error();
+            return r.json();
+          }).then(function(d) {
+            window._lottieData = d;
+            startAnim(d);
+          }).catch(function() {
+          });
+        }
+        return;
+      }
+      if (window._lottieLoading) return;
+      window._lottieLoading = true;
+      var s = document.createElement("script");
+      s.src = "https://cdnjs.cloudflare.com/ajax/libs/lottie-web/5.12.2/lottie.min.js";
+      s.onload = function() {
+        fetch("/nibgate-unlock-key.json?t=1").then(function(r) {
+          if (!r.ok) throw new Error();
+          return r.json();
+        }).then(function(d) {
+          window._lottieData = d;
+          startAnim(d);
+        }).catch(function() {
+        });
+      };
+      document.head.appendChild(s);
+    })();
+    const st = card.querySelector("[data-nibgate-status]");
+    const label = card.querySelector("[data-nibgate-wallet-label]");
+    const wrap = card.querySelector("[data-nibgate-unlock-wrap]");
+    const prog = card.querySelector("[data-nibgate-unlock-progress]");
+    const shimmer = card.querySelector("[data-nibgate-shimmer]");
+    const btn = card.querySelector("[data-nibgate-unlock]");
+    const HOLD_MS = 1500;
+    let holdTimer = null, holdActive = false, holdComplete = false;
+    const ctrl = createEvmGatewayUnlock(resource, {
+      ...options,
+      connectButton: null,
+      unlockButton: null,
+      walletLabel: null,
+      status: "[data-nibgate-status]",
+      unlockedTarget: "[data-nibgate-premium]",
+      onStatus: (msg) => status(st, msg)
+    });
+    function shortAddress(a) {
+      return a ? a.slice(0, 6) + "..." + a.slice(-4) : "";
+    }
+    function updateLabel() {
+      const addr = ctrl.getWalletAddress();
+      if (addr) {
+        label.innerHTML = shortAddress(addr) + ' <span data-nibgate-disconnect style="cursor:pointer">\xB7 Disconnect</span>';
+        btn.disabled = false;
+        btn.style.cursor = "pointer";
+      } else {
+        label.textContent = "Connect wallet";
+        btn.disabled = true;
+        btn.style.cursor = "default";
+        btn.innerHTML = lockSVG + "Hold to pay " + esc(resource.price) + " USDC";
+      }
+    }
+    function setBtnText(t) {
+      btn.innerHTML = lockSVG + t;
+    }
+    function resetHold() {
+      holdActive = false;
+      holdComplete = false;
+      holdTimer = null;
+      btn.style.transform = "scale(1)";
+      prog.style.width = "0%";
+      shimmer.style.animation = "none";
+      shimmer.style.transform = "translateX(-100%)";
+      if (!btn.disabled) setBtnText("Hold to pay " + esc(resource.price) + " USDC");
+    }
+    function startHold(e) {
+      if (btn.disabled || holdActive) return;
+      e.preventDefault();
+      holdActive = true;
+      holdComplete = false;
+      btn.style.transform = "scale(.97)";
+      prog.style.transition = "none";
+      prog.style.width = "0%";
+      shimmer.style.animation = "nshimmer 1s ease-in-out infinite";
+      shimmer.style.transform = "none";
+      setBtnText("Hold\u2026");
+      requestAnimationFrame(() => {
+        prog.style.transition = "width " + HOLD_MS + "ms linear";
+        prog.style.width = "100%";
+      });
+      const t1 = setTimeout(() => {
+        if (holdActive && !holdComplete) setBtnText("Keep holding\u2026");
+      }, HOLD_MS * 0.4);
+      const t2 = setTimeout(() => {
+        if (holdActive && !holdComplete) setBtnText("Almost there\u2026");
+      }, HOLD_MS * 0.75);
+      holdTimer = setTimeout(() => {
+        holdComplete = true;
+        holdActive = false;
+        clearTimeout(t1);
+        clearTimeout(t2);
+        btn.style.transform = "scale(1)";
+        shimmer.style.animation = "none";
+        prog.style.transition = "width .05s linear";
+        setBtnText("Processing\u2026");
+        btn.disabled = true;
+        setTimeout(() => ctrl.unlock().then(updateLabel).catch(updateLabel), 300);
+      }, HOLD_MS);
+    }
+    function cancelHold() {
+      if (!holdActive || holdComplete) return;
+      clearTimeout(holdTimer);
+      resetHold();
+    }
+    label.addEventListener("click", (e) => {
+      if (e.target.dataset.nibgateDisconnect !== void 0) {
+        ctrl.disconnect().then(updateLabel);
+      } else if (!ctrl.getWalletAddress()) {
+        ctrl.connect().then(updateLabel).catch(() => updateLabel());
+      }
+    });
+    wrap.addEventListener("mousedown", startHold);
+    wrap.addEventListener("touchstart", startHold, { passive: false });
+    document.addEventListener("mouseup", cancelHold);
+    document.addEventListener("touchend", cancelHold);
+    wrap.addEventListener("mouseleave", cancelHold);
+    setTimeout(updateLabel, 200);
+    const cleanup = () => {
+      document.removeEventListener("mouseup", cancelHold);
+      document.removeEventListener("touchend", cancelHold);
+    };
+    card.addEventListener("remove", cleanup);
+    return { ...ctrl, element: card, destroy: () => {
+      cleanup();
+      card.remove();
+    } };
+  }
+  function renderDefaultRatingUI(container, resource, options = {}) {
+    inject();
+    let sel = 0, busy = false, ctrl = null, statusTimer = null;
+    const wrap = el("div", { cls: "nui", style: { animation: "nfade .2s ease-out", textAlign: "center", padding: "28px 0" } });
+    const starRow = el("div", { style: { display: "flex", justifyContent: "center", alignItems: "center", gap: "4px" } });
+    const stars = [];
+    for (let i = 1; i <= 5; i++) {
+      const b = el("button", {
+        type: "button",
+        "aria-label": `${i} star${i > 1 ? "s" : ""}`,
+        "data-star": i,
+        style: {
+          background: "none",
+          border: "none",
+          cursor: "pointer",
+          padding: "4px",
+          fontSize: "31px",
+          lineHeight: "1",
+          color: theme.border,
+          transition: "color .12s, transform .12s",
+          borderRadius: "4px",
+          fontFamily: "inherit"
+        }
+      }, "\u2606");
+      stars.push(b);
+      starRow.appendChild(b);
+    }
+    const avgEl = el("span", { style: { fontSize: "17px", color: theme.muted, marginLeft: "12px" } });
+    avgEl.textContent = "No ratings yet";
+    starRow.appendChild(avgEl);
+    const st = el("div", { style: { fontSize: "17px", color: theme.muted, marginTop: "8px", minHeight: "1.4em" } });
+    st.textContent = "Tap stars to rate";
+    wrap.append(starRow, st);
+    (typeof container === "string" ? document.querySelector(container) : container)?.appendChild(wrap);
+    function clearStatus() {
+      if (statusTimer) {
+        clearTimeout(statusTimer);
+        statusTimer = null;
+      }
+      st.textContent = sel > 0 ? "" : "Tap stars to rate";
+      st.style.color = theme.muted;
+    }
+    function setStatus(msg, color, autoClear) {
+      st.textContent = msg || "";
+      st.style.color = color || "";
+      if (autoClear) statusTimer = setTimeout(clearStatus, autoClear);
+    }
+    function fill(h2) {
+      stars.forEach((b, i) => {
+        const active = i < h2;
+        b.style.color = active ? theme.accent : theme.border;
+        b.textContent = active ? "\u2605" : "\u2606";
+        b.style.transform = active ? "scale(1.08)" : "scale(1)";
+      });
+    }
+    function setPrompt(v) {
+      const labels = ["", "Poor", "Below average", "Average", "Good", "Excellent"];
+      setStatus(labels[v]);
+    }
+    async function rate(v) {
+      if (busy || !ctrl) return;
+      busy = true;
+      stars.forEach((b) => {
+        b.disabled = true;
+        b.style.cursor = "default";
+      });
+      sel = v;
+      fill(v);
+      setStatus("Submitting\u2026");
+      try {
+        await ctrl.rate({ rating: v });
+        fill(v);
+        setStatus("You rated " + v + " \u2605".repeat(v), theme.accent, 3e3);
+        refresh();
+      } catch (e) {
+        setStatus(e?.message || "Could not save rating. Try again.", "#dc2626");
+        fill(sel);
+      } finally {
+        busy = false;
+        stars.forEach((b) => {
+          b.disabled = false;
+          b.style.cursor = "pointer";
+        });
+      }
+    }
+    function refresh() {
+      const u = options.statsUrl || (resource.id ? `${options.apiBase || "/api"}/rating/${resource.id}` : null);
+      if (!u) return;
+      fetch(u).then((r) => r.json()).then((d) => {
+        if (d.count > 0) {
+          avgEl.textContent = `${d.average.toFixed(1)} \u2014 ${d.count} rating${d.count !== 1 ? "s" : ""}`;
+        } else {
+          avgEl.textContent = "No ratings yet";
+        }
+      }).catch(() => {
+      });
+    }
+    stars.forEach((b) => {
+      const v = parseInt(b.dataset.star);
+      b.addEventListener("mouseenter", () => {
+        if (!busy) {
+          fill(v);
+          setPrompt(v);
+        }
+      });
+      b.addEventListener("mouseleave", () => {
+        if (!busy) {
+          fill(sel);
+          clearStatus();
+        }
+      });
+      b.addEventListener("click", () => rate(v));
+      b.addEventListener("keydown", (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          rate(v);
+        }
+      });
+    });
+    Promise.resolve().then(() => (init_rating_ui(), rating_ui_exports)).then((m) => {
+      ctrl = m.createOnchainRating(resource, {
+        autoMount: false,
+        contentId: options.contentId || "0x" + (resource.id || "").replace(/-/g, ""),
+        onRated: (r) => {
+          setStatus("Rating saved", theme.accent, 3e3);
+          refresh();
+          if (typeof options.onRated === "function") options.onRated(r);
+        },
+        onError: (e) => {
+          setStatus(e?.message || "Could not save rating. Try again.", "#dc2626");
+          if (typeof options.onError === "function") options.onError(e);
+        }
+      });
+      refresh();
+    }).catch(() => {
+      setStatus("Could not load rating", "#dc2626");
+    });
+    return { element: wrap, destroy: () => wrap.remove(), refresh, setRating: (v) => {
+      sel = v;
+      fill(v);
+    } };
+  }
+  function renderDefaultGatewayWalletUI(container, options = {}) {
+    inject();
+    let tab = "deposit";
+    const wrap = el("div", { cls: "nui", style: { animation: "nfade .2s ease-out", border: "1px solid " + theme.border, borderRadius: "16px", padding: "28px" } });
+    wrap.innerHTML = `
+    <div style="display:flex;gap:12px;margin-bottom:20px">
+      <div data-gw-wallet-card style="flex:1;background:${theme.bg};border:1px solid ${theme.border};border-radius:12px;padding:16px">
+        <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:4px">
+          <div style="font-size:12px;font-weight:600;color:${theme.muted};letter-spacing:.02em">Wallet</div>
+          <button data-gw-connect style="font-size:12px;font-weight:600;cursor:pointer;border:1px solid ${theme.accent};background:transparent;color:${theme.accent};border-radius:8px;padding:4px 12px;font-family:inherit">Connect</button>
+        </div>
+        <div data-gw-wallet-balance class="nui-mono" style="font-size:24px;font-weight:700;color:${theme.fg}">\u2014</div>
+      </div>
+      <div style="flex:1;background:${theme.bg};border:1px solid ${theme.border};border-radius:12px;padding:16px">
+        <div style="font-size:12px;font-weight:600;color:${theme.muted};margin-bottom:4px;letter-spacing:.02em">Gateway</div>
+        <div data-gw-balance class="nui-mono" style="font-size:24px;font-weight:700;color:${theme.fg}">\u2014</div>
+      </div>
+    </div>
+    <div style="display:flex;gap:0;margin-bottom:20px;border-bottom:1px solid ${theme.border}">
+      <button data-tab="deposit" style="flex:1;padding:10px 0;font-size:15px;font-weight:600;cursor:pointer;border:none;background:transparent;color:${theme.fg};border-bottom:2px solid ${theme.accent};font-family:inherit">Deposit</button>
+      <button data-tab="withdraw" style="flex:1;padding:10px 0;font-size:15px;font-weight:600;cursor:pointer;border:none;background:transparent;color:${theme.muted};border-bottom:2px solid transparent;font-family:inherit">Withdraw</button>
+    </div>
+    <div data-gw-form></div>
+  `;
+    (typeof container === "string" ? document.querySelector(container) : container)?.appendChild(wrap);
+    const formEl = wrap.querySelector("[data-gw-form]");
+    const tabs = wrap.querySelectorAll("[data-tab]");
+    function select(btns, t) {
+      btns.forEach((b) => {
+        const on = b.dataset.tab === t;
+        b.style.color = on ? theme.fg : theme.muted;
+        b.style.borderBottomColor = on ? theme.accent : "transparent";
+      });
+    }
+    function render(t) {
+      tab = t;
+      select(tabs, t);
+      if (t === "deposit") {
+        formEl.innerHTML = `
+        <label class="nui-label">Amount (USDC)</label>
+        <input type="number" step="0.01" min="0" placeholder="0.00" data-gw-deposit-amount class="nui-input" style="margin-bottom:16px">
+        <button type="button" data-gw-deposit class="nui-btn nui-btn-primary" style="width:100%;padding:16px 28px;font-size:20px">Deposit</button>
+        <div data-gw-tx class="nui-mono" style="font-size:12px;color:${theme.muted};word-break:break-all;margin-top:12px;display:none"></div>
+      `;
+      } else {
+        formEl.innerHTML = `
+        <label class="nui-label">Amount (USDC)</label>
+        <input type="number" step="0.01" min="0" placeholder="0.00" data-gw-withdraw-amount class="nui-input" style="margin-bottom:16px">
+        <button type="button" data-gw-withdraw class="nui-btn nui-btn-primary" style="width:100%;padding:16px 28px;font-size:20px">Withdraw to your wallet</button>
+        <div data-gw-tx class="nui-mono" style="font-size:12px;color:${theme.muted};word-break:break-all;margin-top:12px;display:none"></div>
+      `;
+      }
+    }
+    render("deposit");
+    tabs.forEach((b) => b.addEventListener("click", () => render(b.dataset.tab)));
+    return { element: wrap, destroy: () => wrap.remove(), switchTab: render };
+  }
+
+  // src/browser/index.js
+  init_resource();
+
   // src/core/settings.js
+  init_payment();
+  init_resource();
   var NIBGATE_CONTENT_SETTING_FIELDS = [
     { name: "publishToNibgate", label: "Publish to Nibgate discovery", type: "boolean", defaultValue: true },
     { name: "type", label: "Content type", type: "select", options: CONTENT_TYPES, defaultValue: "article" },
@@ -1531,6 +2063,9 @@ var Nibgate = (() => {
   function settingsToUnlockPolicy(settings = {}) {
     return normalizeUnlockPolicy(settings.unlockMode || settings.unlock || "one_time");
   }
+
+  // src/browser/index.js
+  init_payment();
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=nibgate.js.map