@sagepilot-ai/web-events-addon 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2764 @@
+// ../sdk-installation-client/src/index.ts
+var SagepilotInstallationError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.code = code;
+    this.name = "SagepilotInstallationError";
+    this.status = options.status;
+    this.cause = options.cause;
+  }
+};
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var VISITOR_ID = /^[A-Za-z0-9_-]{1,128}$/;
+var TERMINAL = /* @__PURE__ */ new Set(["admitted", "duplicate", "disabled", "invalid", "retryable"]);
+function safeURL(value) {
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]", "10.0.2.2"].includes(url.hostname))) {
+    throw new Error("SDK endpoints require HTTPS and cannot contain credentials, queries or fragments.");
+  }
+  return url;
+}
+function validateSagepilotInstallationReceipt(value, requestedIDs) {
+  const results = value?.results;
+  if (!Array.isArray(results)) throw new Error("SDK admission receipt is missing.");
+  const requested = new Set(requestedIDs), seen = /* @__PURE__ */ new Set();
+  if (requested.size !== requestedIDs.length) throw new Error("SDK batch contains duplicate observation IDs.");
+  for (const item of results) {
+    if (!item || !requested.has(item.event_id) || seen.has(item.event_id) || !TERMINAL.has(item.status)) {
+      throw new Error("SDK admission receipt does not match the requested observations.");
+    }
+    seen.add(item.event_id);
+  }
+  return { results };
+}
+var SagepilotInstallationClient = class {
+  /** Validates the public installation binding without treating it as customer authentication. */
+  constructor(options) {
+    this.options = options;
+    this.current = null;
+    this.anonymousId = null;
+    this.pending = null;
+    this.startup = null;
+    this.generation = 0;
+    this.uploadRevision = 0;
+    this.transitioning = false;
+    this.owners = /* @__PURE__ */ new Map();
+    this.requests = /* @__PURE__ */ new Set();
+    const parts = options.key.split(":");
+    if (parts.length !== 2 || !parts.every((value) => UUID.test(value))) throw new Error("SDK key must be workspace_id:installation_id UUIDs.");
+    this.workspaceId = parts[0].toLowerCase();
+    this.installationId = parts[1].toLowerCase();
+    const host = safeURL(options.apiHost ?? "https://api.sagepilot.ai");
+    if (host.pathname !== "/") throw new Error("SDK apiHost must be a gateway origin.");
+    this.apiHost = host.origin;
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.storageKey = `sagepilot:sdk-session:${this.workspaceId}:${this.installationId}`;
+  }
+  /** Returns a copy of the active anonymous session without allowing mutation of capture ownership. */
+  session() {
+    return this.current ? { ...this.current } : null;
+  }
+  /** The merchant route owns the cookie path and forwards only the visitor cookie. */
+  get visitorCookiePath() {
+    return `/sagepilot/visitor/${this.workspaceId}/${this.installationId}`;
+  }
+  /** Resolves browser continuity on the storefront without sending an upload token or contact data. */
+  async syncVisitorCookie(anonymousId, analyticsAllowed, popupCompleted) {
+    if (this.options.platform !== "web" || typeof location === "undefined") throw new Error("Visitor cookies require a website.");
+    const endpoint = safeURL(location.origin + this.visitorCookiePath);
+    const value = await this.request(endpoint.href, {
+      method: "POST",
+      mode: "same-origin",
+      credentials: "same-origin",
+      body: JSON.stringify({ analytics_allowed: analyticsAllowed, anonymous_id: anonymousId, popup_completed: popupCompleted })
+    }, 2500);
+    if (!value || value.anonymous_id !== null && (typeof value.anonymous_id !== "string" || !VISITOR_ID.test(value.anonymous_id)) || typeof value.popup_completed !== "boolean" || typeof value.restored !== "boolean") {
+      throw new Error("Invalid SDK visitor cookie response.");
+    }
+    return value;
+  }
+  /** Reports whether this runtime still holds matching capture authority for a queued owner. */
+  hasCaptureOwner(owner) {
+    const session = this.owners.get(owner.session_id) ?? this.current;
+    return !!session && session.session_id === owner.session_id && session.customer_id === owner.customer_id;
+  }
+  /** Restores only the requested browser/device owner, then obtains a fresh server-authorized session. */
+  async start(anonymousId) {
+    if (!anonymousId.trim() || anonymousId.length > 128) throw new Error("SDK anonymous ID must contain 1\u2013128 characters.");
+    if (this.anonymousId && this.anonymousId !== anonymousId) throw new Error("Destroy this SDK client before changing its anonymous owner.");
+    this.anonymousId = anonymousId;
+    if (this.startup) return this.startup;
+    const generation = this.generation;
+    const startup = (async () => {
+      if (!this.current && this.options.storage) {
+        let restored = null;
+        try {
+          const raw = await this.options.storage.getItem(this.storageKey);
+          if (raw && raw.length <= 16384) restored = this.validateSession(JSON.parse(raw));
+          const previous = await this.options.storage.getItem(this.storageKey + ":owners");
+          if (previous && previous.length <= 65536) {
+            const entries = JSON.parse(previous);
+            if (Array.isArray(entries) && entries.length <= 4) for (const entry of entries) {
+              const owner = this.validateSession(entry);
+              this.owners.set(owner.session_id, owner);
+            }
+          }
+        } catch {
+        }
+        if (generation !== this.generation) throw new Error("SDK session restoration was cancelled.");
+        this.current = restored;
+      }
+      if (generation !== this.generation) throw new Error("SDK session startup was cancelled.");
+      return this.refresh(true);
+    })().finally(() => {
+      if (this.startup === startup) this.startup = null;
+    });
+    this.startup = startup;
+    return startup;
+  }
+  /** Renews the owner or, when allowed for web capture, starts fresh after an expired browser session. */
+  async refresh(recoverAnonymous = false) {
+    if (this.pending) return this.pending;
+    if (!this.anonymousId) throw new Error("Start the installation client before renewing it.");
+    const generation = this.generation, prior = this.current;
+    const pending = (async () => {
+      let renewing = prior;
+      let value;
+      try {
+        value = await this.requestSession(prior?.session_token);
+      } catch (error) {
+        if (!recoverAnonymous || !prior || this.options.platform !== "web" || generation !== this.generation || !(error instanceof SagepilotInstallationError) || error.status !== 401) throw error;
+        renewing = null;
+        value = await this.requestSession();
+      }
+      const next = this.validateSession(value);
+      if (generation !== this.generation) throw new Error("SDK session startup was cancelled.");
+      if (renewing && (next.session_id !== renewing.session_id || next.customer_id !== renewing.customer_id) || !renewing && (next.customer_id !== null || next.session_id === prior?.session_id)) {
+        throw new Error("SDK session renewal changed capture ownership.");
+      }
+      if (prior && !renewing) this.owners.delete(prior.session_id);
+      this.current = next;
+      this.remember(next);
+      try {
+        await this.options.storage?.setItem(this.storageKey, JSON.stringify(next));
+      } catch {
+      }
+      return { ...next };
+    })().finally(() => {
+      if (this.pending === pending) this.pending = null;
+    });
+    this.pending = pending;
+    return pending;
+  }
+  /** Requests policy for this browser or device with the original token when renewing. */
+  requestSession(token) {
+    return this.request(`${this.apiHost}/platform-api/v1/sdk/sessions`, {
+      method: "POST",
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+      body: JSON.stringify({
+        key: `${this.workspaceId}:${this.installationId}`,
+        anonymous_id: this.anonymousId,
+        platform: this.options.platform,
+        ...this.options.appId ? { app_id: this.options.appId } : {}
+      })
+    });
+  }
+  /** Supplies a short-lived native upload authorization only for the original capture owner. */
+  async authorize(owner) {
+    let session = this.owners.get(owner.session_id) ?? this.current;
+    if (!session || owner.customer_id !== session.customer_id || owner.session_id !== session.session_id) throw new Error("SDK capture ownership changed.");
+    if (Date.parse(session.expires_at) - Date.now() < 6e4) {
+      if (session.session_id === this.current?.session_id) session = await this.refresh();
+      else {
+        const original = session;
+        session = this.validateSession(await this.requestSession(session.session_token));
+        if (session.session_id !== original.session_id || session.customer_id !== original.customer_id) throw new Error("Historical capture ownership changed.");
+        this.remember(session);
+      }
+    }
+    if (!session.collection_enabled || owner.session_id !== session.session_id || owner.customer_id !== session.customer_id) throw new Error("SDK collection is disabled or its owner changed.");
+    return { url: session.ingestion_url, headers: {
+      Authorization: `Bearer ${session.session_token}`,
+      "Content-Type": "application/json",
+      "X-Sagepilot-Sdk-Name": this.options.sdk.name,
+      "X-Sagepilot-Sdk-Version": this.options.sdk.version
+    } };
+  }
+  /** Posts one bounded immutable batch; collectors own backoff and retain missing/retryable receipts. */
+  async upload(observations, owner) {
+    if (!observations.length || observations.length > 100) throw new Error("SDK batches require 1\u2013100 observations.");
+    for (const item of observations) {
+      if (item.owner.session_id !== owner.session_id || item.owner.customer_id !== owner.customer_id) throw new Error("SDK batch mixes capture ownership.");
+    }
+    const revision = this.uploadRevision;
+    const auth = await this.authorize(owner);
+    if (revision !== this.uploadRevision) throw new Error("SDK upload was cancelled.");
+    const body = JSON.stringify({ schema_version: 1, observations });
+    if (new TextEncoder().encode(body).byteLength > 128 * 1024) throw new Error("SDK batch exceeds the upload limit.");
+    return validateSagepilotInstallationReceipt(await this.request(auth.url, { method: "POST", headers: auth.headers, body }), observations.map((item) => item.event_id));
+  }
+  /** Submits explicit popup contacts independently from ordinary observation payloads. */
+  async submitContact(input) {
+    if (!UUID.test(input.submission_id) || !Number.isSafeInteger(input.popup_revision) || input.popup_revision < 1 || typeof input.marketing_consent !== "boolean") throw new Error("Invalid popup submission.");
+    const result = await this.authenticated("/contact", input);
+    if (!result || !["recorded", "verification_required"].includes(result.status) || result.status === "verification_required" && (!result.challenge_id || !UUID.test(result.challenge_id) || !Number.isFinite(Date.parse(result.expires_at ?? "")))) throw new Error("Invalid popup submission response.");
+    return result;
+  }
+  /** Adopts customer authority only from the server's completed verification operation. */
+  async verifyContact(challengeId, code) {
+    if (!UUID.test(challengeId) || !/^\d{6}$/.test(code)) throw new Error("Enter the six-digit verification code.");
+    return this.transition("/contact/verify", { challenge_id: challengeId, code }, true);
+  }
+  /** Revokes the current identified grant and establishes a fresh anonymous capture owner. */
+  async logout() {
+    return this.transition("/logout", {}, false);
+  }
+  /** Keeps a bounded credential cache separate from observations so old anonymous batches retain their owner. */
+  remember(session) {
+    this.owners.set(session.session_id, { ...session });
+    while (this.owners.size > 4) this.owners.delete(this.owners.keys().next().value);
+    try {
+      void Promise.resolve(this.options.storage?.setItem(this.storageKey + ":owners", JSON.stringify([...this.owners.values()]))).catch(() => {
+      });
+    } catch {
+    }
+  }
+  /** Uses the current scoped credential for identity operations without attaching it to event records. */
+  async authenticated(path, body) {
+    const prior = this.current;
+    if (!prior) throw new Error("Start the installation client first.");
+    if (Date.parse(prior.expires_at) - Date.now() < 6e4) await this.refresh();
+    if (this.current?.session_id !== prior.session_id) throw new Error("SDK identity session changed.");
+    return this.request(`${this.apiHost}/platform-api/v1/sdk${path}`, { method: "POST", headers: { Authorization: `Bearer ${this.current.session_token}` }, body: JSON.stringify(body) });
+  }
+  /** Serializes explicit ownership transitions and rejects unrelated or stale server responses. */
+  async transition(path, body, identified) {
+    if (this.transitioning) throw new Error("An SDK identity operation is already running.");
+    this.transitioning = true;
+    const generation = this.generation, prior = this.current;
+    try {
+      const next = this.validateSession(await this.authenticated(path, body));
+      if (generation !== this.generation || !prior || next.session_id === prior.session_id || (identified ? next.customer_id === null : next.customer_id !== null)) throw new Error("Invalid SDK identity transition.");
+      this.generation++;
+      this.cancelPending();
+      this.pending = null;
+      if (path === "/logout") this.owners.delete(prior.session_id);
+      else this.remember(prior);
+      this.current = next;
+      this.remember(next);
+      try {
+        await this.options.storage?.setItem(this.storageKey, JSON.stringify(next));
+      } catch {
+      }
+      return { ...next };
+    } finally {
+      this.transitioning = false;
+    }
+  }
+  /** Cancels requests on permission/ownership boundaries while preserving the current session for safe renewal. */
+  cancelPending() {
+    this.uploadRevision++;
+    for (const controller of this.requests) controller.abort();
+  }
+  /** Fences in-flight session adoption and stops all outstanding requests. */
+  destroy() {
+    this.generation++;
+    this.cancelPending();
+    this.current = null;
+    this.anonymousId = null;
+    this.pending = null;
+    this.startup = null;
+    this.owners.clear();
+  }
+  /** Rejects foreign, identified or malformed session responses before credentials are used. */
+  validateSession(value) {
+    const session = value;
+    if (!session || session.workspace_id !== this.workspaceId || session.installation_id !== this.installationId || session.platform !== this.options.platform || session.anonymous_id !== this.anonymousId || session.customer_id !== null && (typeof session.customer_id !== "string" || !UUID.test(session.customer_id)) || !UUID.test(session.session_id) || typeof session.session_token !== "string" || session.session_token.length > 16384 || !session.session_token || !Number.isFinite(Date.parse(session.expires_at)) || typeof session.collection_enabled !== "boolean" || session.visitor_cookie_enabled !== void 0 && typeof session.visitor_cookie_enabled !== "boolean" || !Number.isSafeInteger(session.revision)) {
+      throw new Error("SDK session response has invalid scope or ownership.");
+    }
+    const url = safeURL(session.ingestion_url);
+    if (url.pathname !== "/events/v1/sdk/observations") throw new Error("SDK ingestion route is invalid.");
+    return { ...session };
+  }
+  /** Performs bounded SDK HTTP requests without retrying mutations or following credential redirects. */
+  async request(url, init, timeoutMs = 15e3) {
+    const controller = new AbortController();
+    this.requests.add(controller);
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const headers = new Headers(init.headers);
+      headers.set("Content-Type", "application/json");
+      headers.set("X-Sagepilot-Sdk-Name", this.options.sdk.name);
+      headers.set("X-Sagepilot-Sdk-Version", this.options.sdk.version);
+      const response = await this.fetchImpl(url, { ...init, headers, signal: controller.signal, redirect: "error", credentials: init.credentials ?? "omit" });
+      if (!response.ok) {
+        void response.body?.cancel().catch(() => {
+        });
+        throw new SagepilotInstallationError("invalid_response", `SDK request failed with HTTP ${response.status}.`, { status: response.status });
+      }
+      if (Number(response.headers.get("content-length") ?? 0) > 65536) throw new Error("SDK response exceeds limit.");
+      let text2 = "";
+      if (response.body?.getReader) {
+        const reader = response.body.getReader(), decoder = new TextDecoder();
+        let bytes = 0;
+        try {
+          for (; ; ) {
+            const part = await reader.read();
+            if (part.done) break;
+            bytes += part.value.byteLength;
+            if (bytes > 65536) {
+              await reader.cancel();
+              throw new Error("SDK response exceeds limit.");
+            }
+            text2 += decoder.decode(part.value, { stream: true });
+          }
+          text2 += decoder.decode();
+        } finally {
+          reader.releaseLock();
+        }
+      } else {
+        text2 = await response.text();
+        if (text2.length > 65536) throw new Error("SDK response exceeds limit.");
+      }
+      return JSON.parse(text2);
+    } catch (error) {
+      if (controller.signal.aborted || error instanceof TypeError) {
+        throw new SagepilotInstallationError("network_error", "SDK request could not reach the server.", { cause: error });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+      this.requests.delete(controller);
+    }
+  }
+};
+function createSagepilotInstallationClient(options) {
+  return new SagepilotInstallationClient(options);
+}
+
+// package.json
+var name = "@sagepilot-ai/web-events-addon";
+var version = "0.2.0";
+
+// src/projection.ts
+var sensitive = /password|passwd|secret|token|authorization|cookie|session|email|phone|contact|address|card|payment|cvv|ssn|dob|birth|customer|user|account|person|profile|name|description|message|content|text|search|query/i;
+var compact = /^[A-Za-z0-9_.:-]{1,128}$/;
+var routes = /* @__PURE__ */ new Map();
+function project(value) {
+  const output = { fields: [], structure: [], limited: false };
+  let budget = 256;
+  function visit(input, path, depth) {
+    if (--budget < 0 || depth > 8 || output.fields.length >= 48) {
+      output.limited = true;
+      return;
+    }
+    if (input === null || typeof input === "boolean" || typeof input === "number") {
+      if (typeof input === "number" && (!Number.isFinite(input) || Math.abs(input) > Number.MAX_SAFE_INTEGER)) return;
+      output.fields.push({ path, type: input === null ? "null" : typeof input, value: input });
+      return;
+    }
+    if (typeof input === "string") {
+      const numericProductReference = /\.(?:product_id|variant_id|sku)$/.test(path) && /^\d{1,20}$/.test(input);
+      if (numericProductReference || compact.test(input) && !/^\+?\d{7,}$/.test(input) && !/^[A-Za-z0-9_-]{32,}$/.test(input)) output.fields.push({ path, type: "string", value: input });
+      else output.fields.push({ path, type: "string", omitted: "privacy_or_size" });
+      return;
+    }
+    if (Array.isArray(input)) {
+      output.structure.push({ path, type: "array" });
+      for (let index = 0; index < Math.min(input.length, 10); index++) visit(input[index], `${path}[${index}]`, depth + 1);
+      if (input.length > 10) output.limited = true;
+      return;
+    }
+    if (!input || typeof input !== "object" || Object.getPrototypeOf(input) !== Object.prototype) return;
+    output.structure.push({ path, type: "object" });
+    const keys = [];
+    for (const key in input) {
+      if (Object.prototype.hasOwnProperty.call(input, key)) keys.push(key);
+      if (keys.length > 32) break;
+    }
+    keys.sort();
+    if (keys.length > 32) output.limited = true;
+    for (const key of keys.slice(0, 32)) {
+      if (!/^[A-Za-z_][A-Za-z0-9_]{0,47}$/.test(key) || sensitive.test(key)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (descriptor && "value" in descriptor) visit(descriptor.value, `${path}.${key}`, depth + 1);
+    }
+  }
+  visit(value, "$", 0);
+  return output;
+}
+function projectText(value) {
+  if (typeof value !== "string" || value.length > 65536 || !/^\s*[\[{]/.test(value.slice(0, 64))) return null;
+  try {
+    return project(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+function routeFor(input) {
+  if (input.length > 2048) return Promise.resolve(null);
+  let url;
+  try {
+    url = new URL(input, globalThis.location?.href);
+  } catch {
+    return Promise.resolve(null);
+  }
+  if (!/^https?:$/.test(url.protocol) || url.username || url.password) return Promise.resolve(null);
+  const cacheKey = url.origin + url.pathname;
+  const existing = routes.get(cacheKey);
+  if (existing) return existing;
+  const fingerprint = (async () => {
+    if (!globalThis.crypto?.subtle) return null;
+    const segments = [];
+    for (const segment of url.pathname.split("/").filter(Boolean).slice(0, 12)) {
+      if (/^v\d{1,2}$/i.test(segment)) {
+        segments.push(segment.toLowerCase());
+        continue;
+      }
+      if (!/^[A-Za-z_-]{1,64}$/.test(segment)) {
+        segments.push(":id");
+        continue;
+      }
+      const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(segment));
+      segments.push(":op_" + Array.from(new Uint8Array(digest)).slice(0, 8).map((byte) => byte.toString(16).padStart(2, "0")).join(""));
+    }
+    return url.origin + "/" + segments.join("/");
+  })().catch(() => null);
+  if (routes.size >= 128) routes.delete(routes.keys().next().value);
+  routes.set(cacheKey, fingerprint);
+  return fingerprint;
+}
+
+// src/product.ts
+var privateKey = /pass|secret|token|auth|cookie|session|customer|buyer|user|account|profile|email|phone|mobile|contact|address|payment|credit|cvv|order|personal|customiz|monogram|option|review|message|comment|__proto__|constructor|prototype/i;
+var identifier = /^(?:@?id|schema_product(?:ID|SKU)|productGroup(?:ID|SKU)|(?:product[_-]?)?sku|(?:product|catalog(?:ue)?|variant|item|article|part|model)[_-]?(?:id|code|number|ref)|mpn|gtin(?:8|12|13|14)?|upc|ean|isbn|reference|code)$/i;
+var aliases = { product_id: /^(?:product[_-]?id|id)$/i, variant_id: /^(?:variant[_-]?id)$/i, sku: /^(?:product[_-]?)?sku$/i };
+var publicField = /^(?:@type|@id|name|title|product_name|slug|id|productGroupID|product[_-]?(?:id|sku|url)|variant[_-]?id|sku|mpn|gtin\d*|url|image|images|image_url|imageUrl|offers|variants|hasVariant|price|priceValue|sale_price|price[_-]?Currency|currency|currencyId|currencyFormat|brand|category|color|size|material|availability|stockRemaining|available|selected|selectedVariantId)$/i;
+function normalized(value) {
+  return typeof value === "string" ? value.normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ") : "";
+}
+function commerceAction(value) {
+  const label2 = value.normalize("NFKC").trim();
+  return label2.replace(/\s*[·|–—-]\s*(?:₹|\$|€|£|INR|USD|EUR|GBP)\s*(?:\d{1,8}|\d{1,3}(?:,\d{3}){1,2}|\d{1,2}(?:,\d{2}){1,2},\d{3})(?:\.\d{1,2})?\s*$/i, "").trim();
+}
+function sameVariant(left, right) {
+  return !!left && !!right && (left === right || left.replace(/^gid:\/\/shopify\/ProductVariant\/(\d+)$/, "$1") === right.replace(/^gid:\/\/shopify\/ProductVariant\/(\d+)$/, "$1"));
+}
+function nativeForms() {
+  const result = [], forms = [...document.querySelectorAll("form[action]")];
+  if (forms.length > 32) return null;
+  for (const form of forms) {
+    const action = publicURL(form.getAttribute("action"));
+    if (!action || new URL(action).origin !== location.origin || !/\/cart\/add\/?$/.test(new URL(action).pathname)) continue;
+    const inputs = [...form.querySelectorAll('input[type="hidden"][name="id"]')], products = [...form.querySelectorAll('input[type="hidden"][name="product-id"]')];
+    if (inputs.length !== 1 || products.length > 1) continue;
+    const variant = id(inputs[0].value ?? inputs[0].getAttribute("value"));
+    const product = id(products.length ? products[0].value ?? products[0].getAttribute("value") : form.closest("[data-product-id]")?.getAttribute("data-product-id"));
+    if (variant) result.push({ form, product, variant });
+  }
+  return result;
+}
+function labeledProductID() {
+  const labels = [...document.querySelectorAll("span,dt,th,label")], values = [];
+  if (labels.length > 1024) return;
+  for (const label2 of labels) {
+    const value = label2.nextElementSibling;
+    if (label2.childElementCount || normalized(label2.textContent) !== "product id:" || !value || value.childElementCount || [label2, value].some((node) => node.closest('header,footer,form,dialog,[role="dialog"],[hidden],[aria-hidden="true"],[data-sagepilot-popup],[itemprop="review"],[itemtype$="/Review"],[data-review-id]'))) continue;
+    const product = id(value.textContent?.trim());
+    if (product) values.push(product);
+  }
+  return values.length === 1 ? values[0] : void 0;
+}
+function publicURL(value, base = location.href, image = false) {
+  if (typeof value !== "string" || value.length > 1024) return;
+  try {
+    const url = new URL(value, base);
+    const keys = [...url.searchParams.keys()];
+    if (url.username || url.password || /[<>\x00-\x1f\x7f@]/.test(decodeURIComponent(url.href)) || new Set(keys).size !== keys.length || keys.some((key) => /token|signature|auth|credential|password|secret|policy|expires|x-amz|^sig$|^key$/i.test(key))) return;
+    if (image && /\/_next\/image$/.test(url.pathname) && keys.every((key) => key === "url" || key === "w" && /^\d{1,5}$/.test(url.searchParams.get(key)) || key === "q" && /^\d{1,3}$/.test(url.searchParams.get(key)) && Number(url.searchParams.get(key)) <= 100)) return publicURL(url.searchParams.get("url"), base, true);
+    if (image && keys.length) {
+      if (!/\.(?:jpe?g|png|webp|avif|gif|svg)$/i.test(url.pathname) || !keys.every((key) => {
+        const value2 = url.searchParams.get(key);
+        return /^(?:w|h|width|height)$/.test(key) ? /^\d{1,5}$/.test(value2) && Number(value2) > 0 : /^(?:q|quality)$/.test(key) ? /^\d{1,3}$/.test(value2) && Number(value2) > 0 && Number(value2) <= 100 : key === "v" ? /^\d{1,20}$/.test(value2) : key === "dpr" ? /^(?:[1-7](?:\.\d{1,2})?|0\.[1-9]\d?|8)$/.test(value2) : /^(?:f|format)$/.test(key) ? /^(?:jpe?g|png|webp|avif|gif|svg|xxs|xs|s|m|l|xl|xxl|u|xu)$/.test(value2) : key === "fit" ? /^(?:cover|contain|fill|inside|outside|max|crop)$/.test(value2) : key === "auto" ? /^(?:format|compress|format,compress|compress,format)$/.test(value2) : key === "crop" && /^(?:center|faces|top|bottom|left|right)$/.test(value2);
+      })) return;
+      url.search = "";
+    }
+    if (!image && keys.length && (keys.length > 1 || !keys.every((key) => /^(?:variant|variant_id)$/.test(key) && !!id(url.searchParams.get(key))))) return;
+    if (!image && /^(?:#content|#product|#variant)?$/.test(url.hash)) url.hash = "";
+    if ((url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)) && !url.username && !url.password && !url.hash && !/[<>\x00-\x1f\x7f@]/.test(decodeURIComponent(url.href))) return url.href;
+  } catch {
+  }
+}
+function documentURL() {
+  try {
+    const url = new URL(location.href);
+    for (const key of [...url.searchParams.keys()]) if (/^utm_(?:source|medium|campaign|term|content|id|source_platform|creative_format|marketing_tactic)$/.test(key)) url.searchParams.delete(key);
+    return publicURL(url.href);
+  } catch {
+    return;
+  }
+}
+function productSourceURL(value) {
+  const url = publicURL(value);
+  return url && !/(?:^|[/_.-])(?:customers?|buyers?|users?|accounts?|profiles?|orders?|checkout|auth|login|sessions?|private|tokens?|contacts?|addresses|payments?)(?=[/_.-]|$)/i.test(decodeURIComponent(new URL(url).pathname)) ? url : void 0;
+}
+function scalar(value) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER ? value : void 0;
+  if (typeof value !== "string" || value.length > 256 || /[<>\x00-\x1f\x7f]|@|https?:|\+?\d[\d\s().-]{5,}\d|[A-Za-z0-9_-]{32,}|\b(?:bearer|sk_live_|sk_test_|ghp_)|personalized|personalised|monogram|recommended for|your name/i.test(value.normalize("NFKC"))) return;
+  return value;
+}
+function id(value) {
+  if (typeof value === "number") return Number.isSafeInteger(value) ? String(value) : void 0;
+  return typeof value === "string" && /^[A-Za-z0-9_:/+=.-]{1,128}$/.test(value) && !/^(?:bearer|sk_live_|sk_test_|ghp_|eyJ[A-Za-z0-9_-]+\.)/i.test(value) ? value : void 0;
+}
+function links(facts, base) {
+  const image = facts.image_url ?? facts.imageUrl ?? facts.image ?? facts.images, offers = Array.isArray(facts.offers) ? facts.offers : [facts.offers];
+  const assets = Array.isArray(image) ? image : image === void 0 ? [] : [image], rawImages = [];
+  let complete = assets.length <= 16;
+  for (const value of assets.slice(0, 16)) {
+    const uri = value && typeof value === "object" ? value.url ?? value.contentUrl : value;
+    if (typeof uri === "string" && /^(?:https?:\/\/|\/)/i.test(uri) && publicURL(uri, base, true)) rawImages.push(new URL(uri, base).href);
+    else complete = false;
+  }
+  const urls = offers.map((value) => value && typeof value === "object" ? publicURL(value.url, base) : void 0).filter(Boolean);
+  return {
+    rawImages: complete ? rawImages : void 0,
+    url: publicURL(facts.url ?? facts.product_url ?? facts.productUrl ?? (typeof facts["@id"] === "string" && /[/?]/.test(facts["@id"]) ? facts["@id"] : void 0), base) ?? (urls.length === offers.length && new Set(urls).size === 1 ? urls[0] : void 0),
+    sku: id(facts.sku ?? facts.productSku ?? facts.product_sku),
+    images: (Array.isArray(image) ? image.slice(0, 8) : [image]).map((value) => {
+      const uri = value && typeof value === "object" ? value.url ?? value.contentUrl : value;
+      return typeof uri === "string" && /^(?:https?:\/\/|\/)/i.test(uri) ? publicURL(uri, base, true) : void 0;
+    }).filter((value) => !!value)
+  };
+}
+function parseProductJSON(value, limit = 262144) {
+  if (value.length > limit || new TextEncoder().encode(value).length > limit) return null;
+  try {
+    return JSON.parse(value, (key, item, context) => {
+      if (identifier.test(key) && typeof item === "number") return context?.source && /^-?\d+$/.test(context.source) ? context.source : id(item);
+      return item;
+    });
+  } catch {
+    return null;
+  }
+}
+function flightRows(value) {
+  const bytes = new TextEncoder().encode(value), decoder = new TextDecoder(), rows = [];
+  let offset = 0;
+  while (offset < bytes.length) {
+    if (bytes[offset] === 10) {
+      offset++;
+      continue;
+    }
+    const colon = bytes.indexOf(58, offset);
+    if (colon < offset || colon - offset > 16 || !/^[\da-f]*$/i.test(decoder.decode(bytes.subarray(offset, colon)))) return [];
+    const start = colon + 1, comma = bytes.indexOf(44, start), tag = String.fromCharCode(bytes[start]);
+    if (/^[A-Za-z]$/.test(tag) && comma > start + 1 && comma - start < 16 && /^[\da-f]+$/i.test(decoder.decode(bytes.subarray(start + 1, comma)))) {
+      const size = parseInt(decoder.decode(bytes.subarray(start + 1, comma)), 16);
+      if (comma + 1 + size > bytes.length) return [];
+      offset = comma + 1 + size;
+      continue;
+    }
+    const newline = bytes.indexOf(10, start), end = newline < 0 ? bytes.length : newline;
+    if (bytes[start] === 91 || bytes[start] === 123) {
+      const row = parseProductJSON(decoder.decode(bytes.subarray(start, end)));
+      if (row === null) return [];
+      rows.push(row);
+    }
+    offset = end + 1;
+  }
+  return rows;
+}
+function indexedProducts(graph, source, title, schemas) {
+  if (!Array.isArray(graph) || graph.length > 8192 || !Array.isArray(graph[0]) || graph[0][0] !== "ShallowReactive") return [];
+  const values = graph;
+  function ref(index) {
+    return typeof index === "number" && Number.isInteger(index) && index >= 0 && index < values.length ? values[index] : void 0;
+  }
+  const tail = new URL(source).pathname.split("/").filter(Boolean).pop(), result = [];
+  for (const row of graph) {
+    if (!row || typeof row !== "object" || Array.isArray(row) || !Object.prototype.hasOwnProperty.call(row, "productVariants") || normalized(ref(row.name)) !== title) continue;
+    const variants = ref(row.productVariants);
+    if (!Array.isArray(variants) || variants.length > 16) return [];
+    for (const index of variants) {
+      const value = ref(index);
+      if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+      const variant = value;
+      const product_id = id(ref(row.id)), variant_id = id(ref(variant.id)), sku = id(ref(variant.sku)), name2 = ref(variant.name);
+      if (!product_id || !variant_id || !sku || variant_id !== tail || normalized(name2) !== title) continue;
+      const matching = schemas.filter((value2) => {
+        const offers = Array.isArray(value2.offers) ? value2.offers : [value2.offers], declared = [value2.url, value2.product_url, value2.productUrl, value2["@id"], ...offers.map((row2) => row2 && typeof row2 === "object" ? row2.url : void 0)].filter((uri) => uri !== void 0);
+        return declared.every((uri) => publicURL(uri, source) === source) && normalized(value2.name) === title && [variant_id, sku].includes(String(value2.sku));
+      });
+      if (matching.length !== 1) return [];
+      result.push({ product_id, variant_id, sku, name: name2, url: source, image: links(matching[0], source).images[0], schema_productSKU: String(matching[0].sku) });
+    }
+  }
+  return result.length === 1 ? result : [];
+}
+function project2(row, source, source_ref, variant) {
+  if (Array.isArray(row.offers) && row.offers.length > 16 || Array.isArray(variant?.offers) && variant.offers.length > 16) return null;
+  const identifiers = {}, variant_identifiers = {}, attributes = {};
+  let limited = false;
+  for (const [record, ids] of [[row, identifiers], ...variant ? [[variant, variant_identifiers]] : []]) {
+    const keys = Object.keys(record);
+    if (keys.length > 48) limited = true;
+    for (const key of keys.slice(0, 48)) {
+      if (!/^[A-Za-z_@][A-Za-z0-9_@-]{0,63}$/.test(key) || privateKey.test(key) || ["variants", "offers", "@type", "@context"].includes(key) || source !== "catalog_response" && !identifier.test(key) && !publicField.test(key)) continue;
+      if (record === row && variant && /^(?:image|images|image_url|imageUrl)$/.test(key) && links(variant, source_ref).images.length) continue;
+      const value = record[key];
+      if (identifier.test(key)) {
+        const exact = id(value), target = record === row && /^variant[_-]?(?:id|code|number|ref)$/i.test(key) ? variant_identifiers : ids;
+        if (exact !== void 0 && Object.keys(target).length < 32) target[key] = exact;
+        else if (exact !== void 0) limited = true;
+        continue;
+      }
+      if (Object.keys(attributes).length >= 32) {
+        limited = true;
+        continue;
+      }
+      if (Array.isArray(value)) {
+        if (value.length > 16) {
+          limited = true;
+          continue;
+        }
+        const projected = value.map(scalar);
+        if (projected.every((item) => item !== void 0)) attributes[key] = projected;
+      } else {
+        const projected = scalar(value);
+        if (projected !== void 0) attributes[key] = projected;
+      }
+    }
+  }
+  const snapshot = { metadata: {
+    resolution: "resolved",
+    identifiers,
+    variant_identifiers,
+    attributes,
+    provenance: { source, source_ref, match: "unresolved" },
+    limited
+  } };
+  for (const [field, pattern] of Object.entries(aliases)) {
+    const variantSKU = Object.keys(variant_identifiers).some((key) => /^sku$/i.test(key));
+    if (field === "sku" && variant && !variantSKU && variant_identifiers.id !== void 0 && !Object.entries(identifiers).some(([key, value]) => aliases.sku.test(key) && value === variant_identifiers.id)) continue;
+    const pool = field === "product_id" ? identifiers : field === "sku" ? variantSKU ? variant_identifiers : identifiers : { ...identifiers, ...variant_identifiers };
+    const values = Object.keys(pool).filter((key) => pattern.test(key)).map((key) => pool[key]);
+    if (field === "variant_id" && !values.length && variant_identifiers.id !== void 0) values.push(variant_identifiers.id);
+    const unique = [...new Set(values)];
+    if (unique.length > 1) return null;
+    if (unique.length) snapshot[field] = unique[0];
+  }
+  const facts = { ...row, ...variant }, name2 = scalar(row.name ?? row.title ?? row.product_name ?? facts.name ?? facts.title), offer = facts.offers;
+  const offers = (Array.isArray(offer) ? offer : [offer]).filter((value) => value && typeof value === "object");
+  if (offers.some((value) => Array.isArray(value.priceSpecification) && value.priceSpecification.length > 16)) return null;
+  if (typeof name2 === "string" && name2.length <= 160) snapshot.name = name2;
+  const specifications = offers.map((value) => {
+    const specs = (Array.isArray(value.priceSpecification) ? value.priceSpecification : [value.priceSpecification]).filter((spec) => spec && typeof spec === "object");
+    return specs.filter((spec) => !spec.priceType || /(?:^|\/)SalePrice$/.test(String(spec.priceType)));
+  });
+  const prices = offers.map((value, n) => value.price ?? (value.lowPrice !== void 0 && value.lowPrice === value.highPrice ? value.lowPrice : void 0) ?? (specifications[n].length && specifications[n].every((spec) => spec.price === specifications[n][0].price) ? specifications[n][0].price : void 0));
+  const money = facts.price && typeof facts.price === "object" && !Array.isArray(facts.price) ? facts.price : void 0;
+  const amount = facts.sale_price ?? facts.priceValue ?? (money ? /^[A-Z]{3}$/.test(String(money.currencyCode)) ? money.amount : void 0 : facts.price) ?? (prices.length && prices.every((value) => value === prices[0]) ? prices[0] : void 0);
+  if ((typeof amount === "number" || typeof amount === "string" && /^\d{1,10}(?:\.\d{1,4})?$/.test(amount)) && Number.isFinite(Number(amount)) && Number(amount) >= 0 && Number(amount) <= Number.MAX_SAFE_INTEGER) snapshot.price = Number(amount);
+  const currencies = offers.map((value, n) => value.priceCurrency ?? (specifications[n].length && specifications[n].every((spec) => spec.priceCurrency === specifications[n][0].priceCurrency) ? specifications[n][0].priceCurrency : void 0)).filter(Boolean);
+  const currency = facts.currency ?? facts.currencyId ?? facts.price_currency ?? facts.priceCurrency ?? money?.currencyCode ?? (new Set(currencies).size === 1 ? currencies[0] : void 0);
+  if (typeof currency === "string" && /^[A-Z]{3}$/.test(currency)) snapshot.currency = currency;
+  if (money && [facts.currency, facts.currencyId, facts.price_currency, facts.priceCurrency, ...currencies].some((value) => value !== void 0 && value !== money.currencyCode)) {
+    delete snapshot.price;
+    delete snapshot.currency;
+  }
+  const { url, images, rawImages } = links(facts, source_ref);
+  if (url) snapshot.url = url;
+  if (images.length) snapshot.image_url = images[0];
+  if (!Object.keys(identifiers).length && !Object.keys(variant_identifiers).length || typeof name2 !== "string" || snapshot.price === void 0 && !images.length) return null;
+  if (new TextEncoder().encode(JSON.stringify(snapshot)).length > 8192) return null;
+  return { snapshot, ref: crypto.randomUUID(), images, rawImages, url, sku: snapshot.sku, variant: snapshot.variant_id, expires: Date.now() + 9e5 };
+}
+function entryKey(value) {
+  const identity = value.snapshot.metadata.provenance.source === "public_hydration" && value.snapshot.product_id ? [value.snapshot.product_id, value.snapshot.variant_id, value.snapshot.sku] : [Object.entries(value.snapshot.metadata.identifiers).sort(), Object.entries(value.snapshot.metadata.variant_identifiers).sort()];
+  return JSON.stringify([identity, value.snapshot.metadata.provenance.source_ref, value.blocked && !Object.keys(value.snapshot.metadata.identifiers).length ? [value.sku, value.url, value.images, value.ids] : null]);
+}
+function createProductIndex(options) {
+  let records = [], limited = false, pageLimited = false, stopped = false, active = null, jsonPage = "", jsonPageTime = 0;
+  const generations = /* @__PURE__ */ new WeakMap(), startup = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const timeout = setTimeout(() => {
+    if (startup.length || listeners.size) limited = true;
+    startup.length = 0;
+    for (const stop of [...listeners]) stop();
+    listeners.clear();
+  }, 1e4);
+  function pause() {
+    active = null;
+    startup.length = 0;
+    for (const stop of [...listeners]) stop();
+  }
+  function observe(value, source, kind = "catalog_response") {
+    const epoch = options.epoch(), source_ref = productSourceURL(source);
+    if (!epoch || stopped || !source_ref) return;
+    if (typeof value === "string") value = parseProductJSON(value);
+    const filename = new URL(source_ref).pathname.split("/").pop() ?? "";
+    const queue = [{ value, product: kind !== "json_ld" && /(?:^|[-_.])(?:products?|catalog)(?:[-_.]|$)/i.test(filename), depth: 0 }];
+    let visited = 0;
+    while (queue.length && visited++ < 512) {
+      const item = queue.shift();
+      if (item.depth > 5) {
+        limited = true;
+        continue;
+      }
+      if (Array.isArray(item.value)) {
+        for (const child of item.value.slice(0, 128)) queue.push({ value: child, product: item.product, depth: item.depth + 1 });
+        if (item.value.length > 128) limited = true;
+        continue;
+      }
+      if (!item.value || typeof item.value !== "object") continue;
+      const row = item.value, types = Array.isArray(row["@type"]) ? row["@type"] : [row["@type"]];
+      if (types.includes("ProductGroup") && Array.isArray(row.hasVariant)) {
+        if (row.hasVariant.length > 16) {
+          limited = true;
+          continue;
+        }
+        const { id: groupID, productID: groupProductID, hasVariant, ...group } = row;
+        const parent = Object.fromEntries(Object.entries(group).filter(([key]) => !aliases.product_id.test(key) && !aliases.sku.test(key) && !/^(?:url|@id|product[_-]?url)$/i.test(key)));
+        for (const child of hasVariant) if (child && typeof child === "object") queue.push({ value: { ...parent, ...child, url: links(child, source_ref).url, productGroupID: row.productGroupID ?? groupProductID ?? groupID, productGroupSKU: row.sku, "@type": "Product" }, product: true, depth: item.depth + 1, group: { url: links(row, source_ref).url, name: normalized(row.name) } });
+        continue;
+      }
+      const product = types.some((type) => ["Product", "IndividualProduct"].includes(String(type))) || item.product;
+      if (product && Object.keys(row).some((key) => identifier.test(key))) {
+        const variants = Array.isArray(row.variants) ? row.variants : [void 0];
+        if (variants.length > 16) {
+          limited = true;
+          continue;
+        }
+        if (variants.some((value2) => value2 !== void 0 && (!value2 || typeof value2 !== "object" || Array.isArray(value2)))) continue;
+        for (const variant of variants.slice(0, 16)) {
+          const selected = variant && typeof variant === "object" ? variant : void 0;
+          let entry = project2(row, kind, source_ref, selected);
+          if (!entry) {
+            const facts = { ...row, ...selected }, evidence = links(facts, source_ref);
+            const ids = Object.keys(facts).filter((key) => aliases.product_id.test(key)).map((key) => id(facts[key])).filter((value2) => value2 !== void 0);
+            if (!evidence.sku && !evidence.url && !evidence.images.length && !ids.length) continue;
+            entry = { ...evidence, ids, variant: id(selected?.variant_id ?? selected?.variantId ?? selected?.id ?? row.variant_id ?? row.variantId), ref: crypto.randomUUID(), blocked: true, expires: Date.now() + 9e5, snapshot: { metadata: { resolution: "ambiguous", identifiers: {}, variant_identifiers: {}, attributes: {}, provenance: { source: kind, source_ref, match: "unresolved" }, limited: false } } };
+          }
+          if (entry.snapshot.metadata.limited) limited = true;
+          entry.group = item.group;
+          const signature = entryKey(entry);
+          const previous = records.find((existing) => entryKey(existing) === signature);
+          if (["json_ld", "public_hydration"].includes(kind) && previous && !entry.blocked) {
+            const conflict = previous.blocked || ["price", "currency", "url"].some((key) => previous.snapshot[key] !== void 0 && entry.snapshot[key] !== void 0 && previous.snapshot[key] !== entry.snapshot[key]) || ["identifiers", "variant_identifiers"].some((key) => Object.entries(previous.snapshot.metadata[key]).some(([name2, value2]) => entry.snapshot.metadata[key][name2] !== void 0 && entry.snapshot.metadata[key][name2] !== value2));
+            const strong = previous.url ? previous : entry, weak = strong === entry ? previous : entry;
+            entry.snapshot = { ...weak.snapshot, ...strong.snapshot, metadata: { ...strong.snapshot.metadata, identifiers: { ...weak.snapshot.metadata.identifiers, ...strong.snapshot.metadata.identifiers }, variant_identifiers: { ...weak.snapshot.metadata.variant_identifiers, ...strong.snapshot.metadata.variant_identifiers }, attributes: { ...weak.snapshot.metadata.attributes, ...strong.snapshot.metadata.attributes } } };
+            entry.url = strong.url ?? weak.url;
+            entry.group = strong.group ?? weak.group;
+            entry.images = [.../* @__PURE__ */ new Set([...strong.images, ...weak.images])];
+            entry.rawImages = strong.rawImages && weak.rawImages ? [.../* @__PURE__ */ new Set([...strong.rawImages, ...weak.rawImages])] : void 0;
+            if (entry.images.length > 16 || (entry.rawImages?.length ?? 0) > 16 || Object.keys(entry.snapshot.metadata.attributes).length > 32 || Object.keys(entry.snapshot.metadata.identifiers).length > 32 || Object.keys(entry.snapshot.metadata.variant_identifiers).length > 32) limited = true;
+            if (conflict || limited) {
+              entry.blocked = true;
+              entry.snapshot.metadata.resolution = "ambiguous";
+            }
+          }
+          entry.ref = previous?.ref ?? entry.ref;
+          records = records.filter((existing) => entryKey(existing) !== signature && existing.expires > Date.now());
+          if (records.length >= 128) {
+            limited = true;
+            continue;
+          }
+          records.push(entry);
+        }
+      }
+      for (const key of ["products", "product", "catalog", "data", "@graph", "items", "itemListElement", "item", "mainEntity"]) if (row[key] !== void 0 && (key !== "items" || product)) queue.push({ value: row[key], product: product || ["products", "product", "catalog"].includes(key), depth: item.depth + 1 });
+    }
+    if (queue.length) limited = true;
+  }
+  function readPage() {
+    function incomplete() {
+      pageLimited = true;
+      jsonPage = "";
+    }
+    const currentDocument = documentURL(), source = currentDocument && productSourceURL(currentDocument), canonical = publicURL(document.querySelector('link[rel="canonical"]')?.getAttribute("href")) ?? source;
+    if (!source || !canonical) return;
+    const native = nativeForms();
+    if (!native) {
+      incomplete();
+      return;
+    }
+    const scripts = [];
+    let work = 0, hydrationWork = 0, schemaCount = 0, hydrationCount = 0, hydrationLimited = false, hash = 2166136261, second = 5381;
+    for (const script of document.scripts) {
+      if (script.src || script.type === "application/json" && privateKey.test(script.id)) continue;
+      const text2 = script.textContent ?? "";
+      if (script.type !== "application/ld+json" && script.type !== "application/json" && script.id !== "__NEXT_DATA__" && !text2.slice(0, 128).includes("self.__next_f")) continue;
+      if (script.type === "application/ld+json") {
+        if (++schemaCount > 256 || text2.length > 262144 || (work += new TextEncoder().encode(text2).length) > 1048576) {
+          incomplete();
+          return;
+        }
+      } else if (++hydrationCount > 256 || hydrationLimited || text2.length > 1048576 - hydrationWork || (hydrationWork += new TextEncoder().encode(text2).length) > 1048576) {
+        hydrationLimited = true;
+        continue;
+      }
+      scripts.push(script);
+      for (let n = 0; n < text2.length; n++) {
+        const code = text2.charCodeAt(n);
+        hash = Math.imul(hash ^ code, 16777619) >>> 0;
+        second = (Math.imul(second, 33) ^ code) >>> 0;
+      }
+    }
+    const signature = [source, canonical, document.querySelector("h1")?.textContent, document.readyState, scripts.length, hydrationLimited, hash, second, JSON.stringify(native.map(({ product, variant }) => [product, variant]))].join(":");
+    if (jsonPage === signature && Date.now() - jsonPageTime < 9e5) return;
+    pageLimited = false;
+    jsonPage = signature;
+    jsonPageTime = Date.now();
+    const previousRefs = new Map(records.filter((entry) => entry.expires > Date.now()).map((entry) => [entryKey(entry), entry.ref]));
+    records = records.filter((entry) => !["json_ld", "public_hydration"].includes(entry.snapshot.metadata.provenance.source) || entry.snapshot.metadata.provenance.source_ref !== source);
+    const schemas = [], roots = [], chunks = [], variantSources = [];
+    let bytes = 0, indexed, indexedCount = 0;
+    for (const script of scripts) {
+      const text2 = script.textContent ?? "";
+      if (script.type === "application/ld+json") {
+        if (new TextEncoder().encode(text2).length > 262144) {
+          incomplete();
+          return;
+        }
+        const pending2 = [parseProductJSON(text2)];
+        for (let n = 0; pending2.length && n < 256; n++) {
+          const value = pending2.shift();
+          if (Array.isArray(value)) {
+            if (value.length > 64) {
+              incomplete();
+              return;
+            }
+            pending2.push(...value);
+            continue;
+          }
+          if (!value || typeof value !== "object") continue;
+          const row = value, types = Array.isArray(row["@type"]) ? row["@type"] : [row["@type"]];
+          if (types.some((type) => ["Product", "ProductGroup", "IndividualProduct"].includes(String(type)))) schemas.push(row);
+          for (const key of ["@graph", "mainEntity", "itemListElement", "item"]) if (row[key]) pending2.push(row[key]);
+        }
+        if (pending2.length) {
+          incomplete();
+          return;
+        }
+      } else if (hydrationLimited) continue;
+      else if (script.type === "application/json" && script.id === "__NUXT_DATA__") {
+        bytes += new TextEncoder().encode(text2).length;
+        if (++indexedCount > 1) hydrationLimited = true;
+        try {
+          indexed = JSON.parse(text2);
+        } catch {
+          hydrationLimited = true;
+        }
+      } else if (script.type === "application/json" && script.id !== "__NEXT_DATA__") {
+        bytes += new TextEncoder().encode(text2).length;
+        const parsed = parseProductJSON(text2), variants = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" ? parsed.variants : void 0;
+        if (Array.isArray(variants) && variants.length <= 16 && variants.every((row) => row && typeof row === "object" && !Array.isArray(row) && id(row.id))) {
+          const root = parsed && !Array.isArray(parsed) && typeof parsed === "object" && parsed.handle === new URL(canonical).pathname.split("/").pop() ? parsed : void 0;
+          const declared = root ? [...new Set(Object.entries(root).filter(([key]) => aliases.product_id.test(key)).map(([, value]) => id(value)).filter((value) => value !== void 0))] : [];
+          if (declared.length > 1) {
+            pageLimited = true;
+            continue;
+          }
+          const parentIDs = variants.map((row) => id(row.featured_image?.product_id)), parent = root ? declared[0] : parentIDs.every((value) => value && value === parentIDs[0]) ? parentIDs[0] : void 0;
+          if (parent) variantSources.push({ rows: variants, parent });
+        }
+      } else if (script.id === "__NEXT_DATA__" && text2.length <= 1048576) {
+        bytes += new TextEncoder().encode(text2).length;
+        roots.push(parseProductJSON(text2, 1048576));
+      } else if (text2.includes("self.__next_f.push")) for (const match of text2.length <= 1048576 ? text2.matchAll(/self\.__next_f\.push\(\[1\s*,\s*("(?:[^"\\]|\\.)*")\s*\]\)/g) : []) {
+        try {
+          const chunk = JSON.parse(match[1]);
+          if (typeof chunk === "string") {
+            bytes += new TextEncoder().encode(chunk).length;
+            if (bytes <= 1048576) chunks.push(chunk);
+          }
+        } catch {
+        }
+      }
+    }
+    if (bytes > 1048576) hydrationLimited = true;
+    if (!hydrationLimited) roots.push(...flightRows(chunks.join("")));
+    else roots.length = 0;
+    const title = normalized(document.querySelector("h1")?.textContent), hydrated = [], typedVariants = /* @__PURE__ */ new Map();
+    const anchors = [...document.querySelectorAll("a[href]")].slice(0, 512).map((node) => publicURL(node.getAttribute("href"))).filter((value) => !!value);
+    const pending = roots.map((value) => ({ value, product: false, depth: 0 }));
+    let visited = 0;
+    while (pending.length && visited++ < 8192) {
+      const item = pending.shift();
+      if (Array.isArray(item.value)) {
+        if (item.value.length > 128) {
+          hydrationLimited = true;
+          continue;
+        }
+        for (const value of item.value) if (value && typeof value === "object") pending.push({ value, product: item.product, depth: item.depth + 1 });
+        continue;
+      }
+      if (!item.value || typeof item.value !== "object") continue;
+      const original = item.value, core = original.product;
+      const row = core && typeof core === "object" && !Array.isArray(core) && Array.isArray(original.variants) ? { ...core, variants: original.variants } : original, name2 = normalized(row.name ?? row.title ?? row.product_name);
+      const typedID = id(row.id);
+      if (typedID && /^gid:\/\/shopify\/ProductVariant\/\d+$/.test(typedID)) typedVariants.set(typedID, [...typedVariants.get(typedID) ?? [], row]);
+      const schema = schemas.filter((value) => normalized(value.name) === name2 && (links(value, source).url === canonical || name2 === title));
+      const segments = new URL(canonical).pathname.split("/").filter(Boolean).map(decodeURIComponent);
+      const slugValue = row.slug ?? row.handle ?? (schema.length === 1 && name2 === title ? row.url : void 0);
+      const slug = typeof slugValue === "string" && /^[a-z0-9-]{1,160}$/.test(slugValue) && segments[segments.length - 1] === slugValue;
+      const productLinks = typeof row.handle === "string" && /^[a-z0-9-]{1,160}$/.test(row.handle) && /^gid:\/\/shopify\/Product\/\d+$/.test(typedID ?? "") ? [...new Set(anchors.filter((value) => new URL(value).origin === location.origin && new URL(value).pathname.endsWith("/products/" + row.handle)))] : [];
+      const declaredID = Object.entries(row).some(([key, value]) => /^(?:id|product[_-]?id|sku)$/i.test(key) && id(value) !== void 0 && segments.includes(id(value)));
+      const publicFacts = [row.price, row.priceValue, row.sale_price, row.image, row.image_url].some((value) => value !== void 0) || Array.isArray(row.variants) && row.variants.length > 0;
+      if (name2 && publicFacts && (slug && (row.handle === void 0 || schema.length === 1) || productLinks.length === 1 || links(row, source).url === canonical || item.product && declaredID && schema.length === 1 && name2 === title) && (Object.keys(row).some((key) => identifier.test(key)) || Array.isArray(row.variants))) hydrated.push({ row, schema: schema.length === 1 ? schema[0] : void 0, url: productLinks.length === 1 ? productLinks[0] : void 0, structured: row !== original || /^gid:\/\/shopify\/Product\/\d+$/.test(typedID ?? "") });
+      for (const [key, value] of Object.entries(original)) if (!privateKey.test(key) && value && typeof value === "object") pending.push({ value, product: item.product || /product/i.test(key), depth: item.depth + 1 });
+    }
+    const consumed = /* @__PURE__ */ new Set();
+    const schemaVariants = schemas.flatMap((row) => Array.isArray(row.hasVariant) ? row.hasVariant : [row]).filter((row) => !!row && typeof row === "object" && !Array.isArray(row));
+    if (!pending.length && !hydrationLimited && bytes <= 1048576) for (const item of hydrated) {
+      const variantID = id(item.row.variantId), concrete = variantID && /^gid:\/\/shopify\/ProductVariant\/\d+$/.test(variantID) ? typedVariants.get(variantID) : void 0;
+      const concreteFacts = concrete?.map((row2) => JSON.stringify([row2.price, row2.image, row2.sku]));
+      if (concreteFacts && new Set(concreteFacts).size !== 1) {
+        pageLimited = true;
+        continue;
+      }
+      const row = concrete?.length ? { ...item.row, variants: [concrete[0]] } : item.row;
+      const safe = Object.fromEntries(Object.entries(row).filter(([key]) => (publicField.test(key) || identifier.test(key)) && !privateKey.test(key)));
+      if (typeof safe.price === "string" && /^\$[\da-f]+:/i.test(safe.price)) delete safe.price;
+      if (item.structured && (!safe.price || typeof safe.price !== "object")) delete safe.price;
+      if (![...links(safe, source).images].length) {
+        delete safe.image;
+        delete safe.images;
+        delete safe.image_url;
+        delete safe.imageUrl;
+      }
+      if (Array.isArray(safe.variants)) safe.variants = safe.variants.map((value) => {
+        if (!value || typeof value !== "object") return null;
+        const variant = Object.fromEntries(Object.entries(value).filter(([key]) => (publicField.test(key) || identifier.test(key)) && !privateKey.test(key))), money = variant.price;
+        const facts = schemaVariants.filter((row2) => sameVariant(id(variant.id ?? variant.variantId), links(row2, source).url && new URL(links(row2, source).url).searchParams.get("variant"))).map((row2) => project2(row2, "json_ld", source)?.snapshot).filter(Boolean);
+        if (item.structured && (!money || typeof money !== "object" || !/^[A-Z]{3}$/.test(String(money.currencyCode))) || money && typeof money === "object" && facts.some((fact) => fact.price !== void 0 && Number(money.amount) !== fact.price || fact.currency !== void 0 && money.currencyCode !== fact.currency)) for (const key of ["price", "currency", "priceCurrency", "price_currency", "offers"]) variant[key] = void 0;
+        return variant;
+      });
+      const schema = { ...item.schema };
+      if (item.row.special_price !== void 0) {
+        const declared = item.schema && project2(item.schema, "json_ld", source)?.snapshot;
+        delete safe.price;
+        if (declared?.price !== void 0 && declared.currency && Number(item.row.special_price) === declared.price) safe.sale_price = declared.price;
+        else for (const key of ["price", "offers", "currency", "currencyId", "priceCurrency", "price_currency"]) {
+          delete schema[key];
+          delete safe[key];
+        }
+      }
+      if (id(safe.id) && schema.productID !== void 0 && id(schema.productID) !== id(safe.id)) {
+        schema.schema_productID = schema.productID;
+        delete schema.productID;
+      }
+      const combined = { ...schema, ...safe, "@type": "Product", name: safe.name ?? safe.title ?? safe.product_name, url: links(safe, source).url ?? item.url ?? canonical };
+      observe({ products: [combined] }, source, "public_hydration");
+      if (item.schema) consumed.add(item.schema);
+    }
+    for (const row of schemas) if (!consumed.has(row)) observe(row, source, "json_ld");
+    if (!hydrationLimited && source === canonical) for (const row of indexedProducts(indexed, source, title, schemas)) {
+      observe({ products: [row] }, source, "public_hydration");
+      records = records.filter((entry) => entry.snapshot.metadata.provenance.source !== "json_ld" || entry.snapshot.metadata.provenance.source_ref !== source || entry.sku !== row.schema_productSKU || normalized(entry.snapshot.name) !== title || entry.url && entry.url !== source);
+    }
+    if (!pending.length && !hydrationLimited) for (const { rows: variants, parent: parentID } of variantSources) {
+      const bindings = native.filter((form) => form.product && variants.some((row) => sameVariant(id(row.id), form.variant)));
+      const parents = [...new Set(bindings.map((form) => form.product))];
+      if (!parents.length) continue;
+      if (parents.length !== 1 || parents[0] !== parentID) {
+        pageLimited = true;
+        continue;
+      }
+      for (const entry of records.filter((value) => ["json_ld", "public_hydration"].includes(value.snapshot.metadata.provenance.source) && value.snapshot.metadata.provenance.source_ref === source)) {
+        const selector = entry.url && new URL(entry.url).searchParams.get("variant"), matches = variants.filter((row2) => sameVariant(id(row2.id), selector));
+        if (!selector || matches.length !== 1 || !entry.url || new URL(entry.url).origin + new URL(entry.url).pathname !== new URL(canonical).origin + new URL(canonical).pathname) continue;
+        const row = matches[0], image = row.featured_image, parent = id(image?.product_id);
+        if (parent && parent !== parents[0] || row.sku !== void 0 && id(row.sku) !== entry.sku || entry.snapshot.product_id && entry.snapshot.product_id !== parents[0]) {
+          pageLimited = true;
+          continue;
+        }
+        entry.snapshot.product_id = parents[0];
+        entry.snapshot.variant_id = id(row.id);
+        entry.variant = id(row.id);
+        entry.snapshot.metadata.identifiers.product_id = parents[0];
+        entry.snapshot.metadata.variant_identifiers.variant_id = id(row.id);
+        entry.snapshot.metadata.provenance.source = "public_hydration";
+      }
+    }
+    for (const entry of records) entry.ref = previousRefs.get(entryKey(entry)) ?? entry.ref;
+  }
+  function consume(candidate) {
+    const xhr = candidate.ref.deref();
+    if (!xhr || stopped || !active || options.epoch() !== active || generations.get(xhr) !== candidate.generation) return;
+    if (xhr.readyState !== 4) return;
+    try {
+      if (xhr.status >= 200 && xhr.status < 300 && publicURL(xhr.responseURL) === candidate.url && /json/i.test(xhr.getResponseHeader("content-type") ?? "")) observe(xhr.responseType === "json" ? xhr.response : xhr.responseText, candidate.url);
+    } catch {
+    }
+  }
+  return {
+    observe,
+    /** Stores only safe request metadata and weak references before server authorization. */
+    track(xhr, input, method) {
+      const generation = (generations.get(xhr) ?? 0) + 1;
+      generations.set(xhr, generation);
+      const url = productSourceURL(input);
+      if (active || stopped || !url || method.toUpperCase() !== "GET" || !/\/(?:products?|catalog)\.json$/i.test(new URL(url).pathname) || typeof WeakRef === "undefined") return;
+      if (startup.length >= 32) {
+        limited = true;
+        return;
+      }
+      startup.push({ ref: new WeakRef(xhr), url, generation });
+    },
+    /** Activates after both gates, reading only still-live completed or subsequently completed XHRs. */
+    activate() {
+      const epoch = options.epoch();
+      if (!epoch || stopped || active) return;
+      active = epoch;
+      for (const candidate of startup.splice(0)) {
+        const xhr = candidate.ref.deref();
+        if (!xhr) {
+          limited = true;
+          continue;
+        }
+        consume(candidate);
+        if (xhr.readyState !== 4) {
+          const stop = () => {
+            candidate.ref.deref()?.removeEventListener("loadend", complete);
+            listeners.delete(stop);
+          };
+          const complete = () => {
+            consume(candidate);
+            stop();
+          };
+          listeners.add(stop);
+          xhr.addEventListener("loadend", complete, { once: true });
+        }
+      }
+    },
+    /** Resolves the actual target before considering current-page context; an off-page link never inherits its ancestor product. */
+    resolve(root, observedPrice, observedCurrency, observedLabel) {
+      const source_ref = location.origin + "/";
+      const empty = (resolution) => ({ product_ref: crypto.randomUUID(), snapshot: { metadata: { resolution, identifiers: {}, variant_identifiers: {}, attributes: {}, provenance: { source: "dom", source_ref, match: "unresolved" }, limited: limited || pageLimited } } });
+      if (stopped || !options.epoch() || root.closest("header,footer,[data-sagepilot-popup]")) return empty("unresolved");
+      readPage();
+      records = records.filter((entry) => entry.expires > Date.now());
+      if (limited || pageLimited) return empty("ambiguous");
+      const anchor = root.closest("a[href]"), targetURL = anchor ? publicURL(anchor.getAttribute("href")) : void 0;
+      if (anchor && !targetURL) return empty("unresolved");
+      const current = documentURL(), canonical = publicURL(document.querySelector('link[rel="canonical"]')?.getAttribute("href")) ?? current;
+      if (!current) return empty("unresolved");
+      const samePage = current && canonical && new URL(current).origin + new URL(current).pathname === new URL(canonical).origin + new URL(canonical).pathname;
+      const currentSelector = current ? new URL(current).searchParams.get("variant") ?? new URL(current).searchParams.get("variant_id") : void 0;
+      const clickedImage = /^img$/i.test(root.tagName) && root.getClientRects().length ? publicURL(root.currentSrc || root.getAttribute("src"), location.href, true) : void 0;
+      const literalImage = clickedImage ? new URL(root.currentSrc || root.getAttribute("src"), location.href).href : void 0;
+      const action = commerceAction(root.getAttribute("aria-label") ?? root.innerText ?? root.textContent ?? "");
+      const primary = /^h1$/i.test(root.tagName) || root.matches("button,[role='button']") && /^(?:add(?: to (?:cart|bag|basket))?|buy(?: now)?|rent(?: now)?)[.!]?$/i.test(action);
+      if (!anchor && primary && !samePage) return empty("unresolved");
+      const form = root.form ?? root.closest("form"), privateForm = form && [...form.querySelectorAll("input:not([type='hidden']),textarea,select")].some((node) => node.tagName === "TEXTAREA" || !/^(?:quantity|qty|variant(?:_id)?|option(?:\[.*\])?|attribute_[A-Za-z0-9_]+)$/i.test(node.getAttribute("name") ?? ""));
+      if (privateForm) return empty("unresolved");
+      let pageContext = !anchor && primary && samePage && !privateForm && !root.closest("dialog,[role='dialog']");
+      const images = /* @__PURE__ */ new Set(), urls = /* @__PURE__ */ new Set(), skus = /* @__PURE__ */ new Set(), variants = /* @__PURE__ */ new Set(), ids = /* @__PURE__ */ new Set();
+      const bound = records.filter((entry) => entry.snapshot.metadata.provenance.source_ref === current && entry.url && new URL(entry.url).origin + new URL(entry.url).pathname === new URL(canonical).origin + new URL(canonical).pathname);
+      const native = nativeForms(), owner = root.form ?? root.closest("form");
+      if (!native) return empty("ambiguous");
+      const own = native.find((value) => value.form === owner);
+      const ownerAction = owner && publicURL(owner.getAttribute("action"));
+      if (primary && ownerAction && new URL(ownerAction).origin === location.origin && /\/cart\/add\/?$/.test(new URL(ownerAction).pathname) && !own) return empty("ambiguous");
+      const forms = native.filter((form2) => bound.some((entry) => sameVariant(entry.variant, form2.variant) || sameVariant(entry.url && new URL(entry.url).searchParams.get("variant"), form2.variant)));
+      if (primary && own && !forms.includes(own)) return empty("unresolved");
+      const checked = [...document.querySelectorAll('input[type="radio"]:checked')];
+      if (checked.length > 32) return empty("ambiguous");
+      const controls = checked.map((node) => id(node.value)).filter((value) => value && bound.some((entry) => entry.variant === value));
+      const selections = [.../* @__PURE__ */ new Set([...(own ? forms.filter((value) => value === own) : forms).map((form2) => form2.variant), ...controls])];
+      const nativeConflict = selections.length && (selections.length !== 1 || currentSelector && !sameVariant(selections[0], currentSelector));
+      const nativeVariant = samePage && selections.length === 1 && (!currentSelector || sameVariant(selections[0], currentSelector)) ? selections[0] : void 0;
+      let exactVariant = id(root.getAttribute("data-variant-id") ?? root.getAttribute("data-variant_id") ?? anchor?.getAttribute("data-variant-id"));
+      const exactProduct = id(root.getAttribute("data-product-id") ?? root.getAttribute("data-product_id") ?? anchor?.getAttribute("data-product-id"));
+      const exactSKU = id(root.getAttribute("data-sku") ?? anchor?.getAttribute("data-sku"));
+      let card = root, direct = null;
+      for (let depth = 0; card && depth < 6 && card !== document.body; depth++, card = card.parentElement) {
+        const nodes2 = [card], walker = document.createTreeWalker(card, NodeFilter.SHOW_ELEMENT);
+        let next;
+        while ((next = walker.nextNode()) && nodes2.length <= 64) nodes2.push(next);
+        if (nodes2.length > 64) break;
+        if (!direct && card.matches("[data-product-id],[data-variant-id],[data-product_id],[data-variant_id]")) direct = card;
+        for (const node of nodes2) {
+          const image = publicURL(node.getAttribute("src") ?? void 0, location.href, true);
+          if (image) images.add(image);
+          for (const match of String(getComputedStyle(node).backgroundImage ?? "").matchAll(/url\(["']?([^"')]+)["']?\)/g)) {
+            const value = publicURL(match[1], location.href, true);
+            if (value) images.add(value);
+          }
+          const url = publicURL(node.getAttribute("href") ?? void 0);
+          if (url) urls.add(url);
+          const sku = id(node.getAttribute("data-sku") ?? (node.getAttribute("itemprop") === "sku" ? node.getAttribute("content") : null));
+          if (sku) skus.add(sku);
+          const variant = id(node.getAttribute("data-variant-id") ?? node.getAttribute("data-variant_id"));
+          if (variant) variants.add(variant);
+          const product = id(node.getAttribute("data-product-id") ?? node.getAttribute("data-product_id") ?? (node.getAttribute("itemprop") === "productID" ? node.getAttribute("content") : null));
+          if (product) ids.add(product);
+        }
+        if (targetURL || images.size && urls.size) break;
+      }
+      const desired = targetURL ?? (urls.size === 1 ? [...urls][0] : void 0);
+      if (primary && desired && new URL(desired).origin + new URL(desired).pathname !== new URL(canonical).origin + new URL(canonical).pathname) pageContext = false;
+      if (pageContext && nativeConflict) return empty("ambiguous");
+      exactVariant ?? (exactVariant = pageContext ? nativeVariant : void 0);
+      const labelCandidate = pageContext && current === canonical && records.some((entry) => entry.snapshot.product_id === void 0 && entry.snapshot.metadata.provenance.source === "json_ld" && entry.snapshot.metadata.provenance.source_ref === current && entry.url === current && entry.sku && new URL(current).pathname.split("/").map(decodeURIComponent).includes(entry.sku));
+      const labeled = labelCandidate ? labeledProductID() : void 0, productLabel = labeled && new URL(current).pathname.split("/").map(decodeURIComponent).includes(labeled) ? labeled : void 0;
+      if (exactVariant) {
+        variants.clear();
+        variants.add(exactVariant);
+      }
+      if (exactProduct) {
+        ids.clear();
+        ids.add(exactProduct);
+      }
+      if (exactSKU) {
+        skus.clear();
+        skus.add(exactSKU);
+      }
+      const sharedImages = new Set([...images].filter((value) => records.filter((entry) => entry.images.includes(value)).length > 1));
+      const pageSchema = records.filter((entry) => entry.snapshot.metadata.provenance.source === "json_ld" && entry.snapshot.metadata.provenance.source_ref === current);
+      const uniqueLiteral = literalImage && pageSchema.every((entry) => entry.rawImages !== void 0) && pageSchema.filter((entry) => entry.rawImages?.includes(literalImage)).length === 1;
+      const matches = [];
+      for (const entry of records) {
+        if (pageContext && ["json_ld", "public_hydration"].includes(entry.snapshot.metadata.provenance.source) && entry.snapshot.metadata.provenance.source_ref !== current) continue;
+        const declaredVariantURL = entry.url ? new URL(entry.url).searchParams.get("variant") ?? new URL(entry.url).searchParams.get("variant_id") : void 0;
+        const labelMatch = productLabel && entry.sku === productLabel && entry.url === current && entry.snapshot.metadata.provenance.source === "json_ld";
+        if (labelMatch && entry.snapshot.product_id !== void 0 && entry.snapshot.product_id !== productLabel) return empty("ambiguous");
+        if (exactVariant && !sameVariant(entry.variant ?? declaredVariantURL, exactVariant)) continue;
+        const query = desired ? new URL(desired).searchParams : current ? new URL(current).searchParams : null;
+        const selected = query?.get("variant") ?? query?.get("variant_id"), variantValues = Object.values(entry.snapshot.metadata.variant_identifiers);
+        if (pageContext && currentSelector && ![entry.variant, entry.sku, declaredVariantURL, ...variantValues].some((value) => sameVariant(value, currentSelector))) continue;
+        const exactURL = !!desired && (entry.url === desired || !!selected && entry.url?.split("?")[0] === desired.split("?")[0] && [entry.variant, entry.sku, ...variantValues].some((value) => sameVariant(value, selected)));
+        const image = entry.images.find((value) => images.has(value) && !sharedImages.has(value)), token = entry.sku && new RegExp(`(?:^|[^A-Za-z0-9])${entry.sku.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:$|[^A-Za-z0-9])`);
+        const skuImage = token ? [...images].find((value) => !sharedImages.has(value) && token.test(new URL(value).pathname)) : void 0;
+        const title = normalized(entry.snapshot.name), titleOnPage = [...document.querySelectorAll("h1")].slice(0, 8).some((node) => node.getClientRects().length && normalized(node.textContent) === title);
+        const groupOnPage = entry.group?.url === canonical && samePage && entry.snapshot.metadata.provenance.source_ref === current && [...document.querySelectorAll("h1")].slice(0, 8).some((node) => node.getClientRects().length && normalized(node.textContent) === entry.group?.name);
+        const directImage = uniqueLiteral && !targetURL && samePage && pageSchema.includes(entry) && entry.rawImages?.includes(literalImage) && !sharedImages.has(clickedImage) && (!entry.url || entry.url.split("?")[0] === canonical.split("?")[0]) && (!currentSelector || [entry.variant, entry.sku, declaredVariantURL, ...variantValues].includes(currentSelector));
+        const corroborated = title && title === normalized(observedLabel) && observedPrice !== void 0 && entry.snapshot.price === observedPrice;
+        let match = exactURL ? "exact_url" : !targetURL && (entry.variant && variants.has(entry.variant) || exactVariant && sameVariant(entry.variant ?? declaredVariantURL, exactVariant)) ? "exact_variant" : labelMatch || !targetURL && typeof entry.snapshot.product_id === "string" && ids.has(entry.snapshot.product_id) ? "direct_id" : !targetURL && entry.sku && skus.has(entry.sku) ? "exact_sku" : skuImage && (!targetURL || !entry.url) ? "exact_sku" : directImage || image && (corroborated || entry.blocked || entry.url === current && titleOnPage || groupOnPage) && (!targetURL || !entry.url) ? "exact_image" : null;
+        if (!match && pageContext && titleOnPage && (entry.snapshot.metadata.provenance.source === "catalog_response" || entry.snapshot.metadata.provenance.source_ref === current) && (entry.url === current || entry.url === canonical) && (!selected || [entry.variant, entry.sku, ...variantValues].some((value) => sameVariant(value, selected)))) match = "exact_url";
+        if (match) matches.push({ entry, match, rank: exactURL ? 3 : match === "exact_url" ? 1 : 2, image: skuImage ?? image });
+      }
+      const rank = Math.max(0, ...matches.map((value) => value.rank)), best = matches.filter((value) => value.rank === rank);
+      const directSelector = direct && id(direct.getAttribute("data-variant-id") ?? direct.getAttribute("data-variant_id") ?? direct.getAttribute("data-sku"));
+      if (!best.length && direct && (!anchor || direct === anchor) && !/^h1$/i.test(root.tagName) && (!primary || samePage && (!currentSelector || currentSelector === directSelector)) && !root.closest("dialog,[role='dialog']")) {
+        const identifiers = {}, variant_identifiers = {};
+        const product = id(direct.getAttribute("data-product-id") ?? direct.getAttribute("data-product_id")), variant = id(direct.getAttribute("data-variant-id") ?? direct.getAttribute("data-variant_id"));
+        if (product) identifiers.product_id = product;
+        if (variant) variant_identifiers.variant_id = variant;
+        if (product || variant) {
+          const snapshot = { ...product ? { product_id: product } : {}, ...variant ? { variant_id: variant } : {}, metadata: { resolution: "resolved", identifiers, variant_identifiers, attributes: {}, provenance: { source: "dom_attribute", source_ref, match: "direct_id" }, limited: false } };
+          const price2 = direct.getAttribute("data-price"), currency = direct.getAttribute("data-currency");
+          if (price2 && /^\d{1,8}(?:\.\d{1,4})?$/.test(price2)) snapshot.price = Number(price2);
+          if (currency && /^[A-Z]{3}$/.test(currency)) snapshot.currency = currency;
+          const old = records.find((value) => value.snapshot.product_id === product && value.snapshot.variant_id === variant && value.snapshot.metadata.provenance.source === "dom_attribute");
+          const entry = old ?? { snapshot, ref: crypto.randomUUID(), images: [], expires: Date.now() + 9e5 };
+          if (!old && records.length < 128) records.push(entry);
+          return { snapshot, product_ref: entry.ref };
+        }
+      }
+      if (best.length !== 1 || best[0]?.entry.blocked) return empty(best.length || sharedImages.size ? "ambiguous" : "unresolved");
+      const result = JSON.parse(JSON.stringify(best[0].entry.snapshot));
+      if (productLabel && best[0].entry.sku === productLabel && best[0].entry.url === current && best[0].entry.snapshot.metadata.provenance.source === "json_ld") {
+        result.product_id = productLabel;
+        result.metadata.identifiers.product_id = productLabel;
+        result.metadata.provenance.source = "dom";
+      }
+      if (exactVariant && !result.variant_id) {
+        result.variant_id = exactVariant;
+        result.metadata.variant_identifiers.variant_id = exactVariant;
+      }
+      const chosen = best[0].entry, groupID = chosen.snapshot.metadata.identifiers.productGroupID;
+      if (pageContext && groupID && chosen.group?.url === canonical && chosen.snapshot.metadata.provenance.source_ref === current) {
+        const selected = chosen.url && (new URL(chosen.url).searchParams.get("variant") ?? new URL(chosen.url).searchParams.get("variant_id")), parents = [...new Set(forms.filter((form2) => form2.product && sameVariant(form2.variant, selected)).map((form2) => form2.product))];
+        if (parents.length > 1 || parents[0] === groupID && result.product_id !== void 0 && result.product_id !== parents[0]) return empty("ambiguous");
+        if (parents[0] === groupID && result.product_id === void 0) {
+          result.product_id = parents[0];
+          result.metadata.identifiers.product_id = parents[0];
+          result.metadata.provenance.source = "dom";
+        }
+      }
+      if (typeof result.price === "number" && observedPrice !== void 0 && Math.abs(result.price - observedPrice) > 1e-9 || result.currency && observedCurrency && result.currency !== observedCurrency) return empty("unresolved");
+      if (!result.image_url && best[0].image) result.image_url = best[0].image;
+      result.metadata.provenance.match = best[0].match;
+      return new TextEncoder().encode(JSON.stringify(result)).length <= 8192 ? { snapshot: result, product_ref: best[0].entry.ref } : empty("unresolved");
+    },
+    /** Clears every startup weak reference, deferred listener and retained product fact. */
+    pause,
+    destroy() {
+      stopped = true;
+      clearTimeout(timeout);
+      pause();
+      records = [];
+    }
+  };
+}
+
+// src/dom.ts
+var imageSelector = "img[alt],div[alt],[role='img'][aria-label]";
+var privateRegion = "form,input,textarea,select,[contenteditable='true'],[data-sagepilot-popup],[hidden],[aria-hidden='true']";
+function nodes(root, limit) {
+  const result = [root], walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+  let next;
+  while (next = walker.nextNode()) {
+    if (result.length >= limit) return null;
+    result.push(next);
+  }
+  return result;
+}
+function text(root) {
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let result = "", next, count = 0;
+  while (next = walker.nextNode()) {
+    if (++count > 16 || (next.nodeValue?.length ?? 0) > 120) return null;
+    const parent = next.parentElement;
+    if (parent && (!parent.getClientRects().length || parent.closest("[aria-hidden='true']") || getComputedStyle(parent).visibility === "hidden")) continue;
+    result += next.nodeValue ?? "";
+    if (result.length > 120) return null;
+  }
+  return result.trim().replace(/\s+/g, " ");
+}
+function label(value) {
+  value = value?.normalize("NFKC") ?? null;
+  if (!value || value.length < 3 || value.length > 80 || /\d[\d\s().-]{5,}\d|@|https?:|\+\d|[A-Za-z0-9_-]{24,}|\b(?:your|my|account|profile|personalized|personalised|customized|customised|monogram|email|phone|address|password|token|customer|name)\b/i.test(value)) return null;
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function price(value) {
+  const match = value?.match(/^(?:rent at\s+)?(?:(USD|EUR|GBP|INR|CAD|AUD|JPY)\s*)?[$€£¥₹]?\s*(\d{1,8}(?:[.,]\d{1,2})?|(?:\d{1,3}(?:,\d{3})+|\d{1,3}(?:,\d{2})*,\d{3})(?:\.\d{1,2})?)\s*(USD|EUR|GBP|INR|CAD|AUD|JPY)?(?:\s*\/\s*(?:mo|month))?$/i);
+  if (!match || !/[$€£¥₹]|\b(?:USD|EUR|GBP|INR|CAD|AUD|JPY)\b/i.test(value)) return null;
+  if (match[1] && match[3] && match[1].toUpperCase() !== match[3].toUpperCase()) return null;
+  const amount = Number(/,\d{3}(?:\.|$)/.test(match[2]) ? match[2].replace(/,/g, "") : match[2].replace(",", ".")), currency = match[1] ?? match[3];
+  return Number.isFinite(amount) && amount <= Number.MAX_SAFE_INTEGER ? { price: amount, ...currency ? { currency: currency.toUpperCase() } : {} } : null;
+}
+function productAt(target) {
+  let candidate = target;
+  for (let depth = 0; candidate && depth < 6 && candidate !== document.body; depth++, candidate = candidate.parentElement) {
+    if (candidate.closest(privateRegion)) return null;
+    const children = nodes(candidate, 64);
+    if (!children) return null;
+    if (children.some((node) => node.matches("input,textarea,select,[contenteditable='true']"))) return null;
+    const images = children.filter((node) => node.matches(imageSelector));
+    if (images.length > 1) return null;
+    if (images.length !== 1) continue;
+    const name2 = label(images[0].getAttribute("alt") ?? images[0].getAttribute("aria-label"));
+    if (!name2 || !children.some((node) => node !== images[0] && !node.childElementCount && node.getClientRects().length && getComputedStyle(node).visibility !== "hidden" && label(text(node)) === name2)) continue;
+    const amounts = children.filter((node) => node.matches("p,span,[itemprop='price']") && !node.closest("del,s") && node.getClientRects().length && getComputedStyle(node).visibility !== "hidden").map((node) => price(text(node))).filter(Boolean);
+    if (!amounts.length || new Set(amounts.map((amount) => `${amount.price}:${amount.currency ?? ""}`)).size > 1) continue;
+    const siblings = candidate.parentElement?.children;
+    if (siblings && siblings.length > 64) return null;
+    for (const sibling of siblings ? [...siblings] : []) {
+      if (sibling === candidate) continue;
+      const entries = nodes(sibling, 64);
+      if (!entries) return null;
+      if (entries.some((node) => node.matches(imageSelector) && label(node.getAttribute("alt") ?? node.getAttribute("aria-label")) === name2)) return null;
+    }
+    return { node: candidate, label: name2, ...amounts[0] };
+  }
+  return null;
+}
+function quantity(product) {
+  const values = (nodes(product.node, 64) ?? []).filter((node) => (!node.childElementCount || node.matches("p")) && node.getClientRects().length && getComputedStyle(node).visibility !== "hidden").map((node) => text(node)?.match(/^(?:.*\s)?(?:quantity|qty)\s*:\s*(\d{1,6})$/i)?.[1]).filter((value) => value !== void 0);
+  const unique = [...new Set(values)];
+  return unique.length === 1 ? Number(unique[0]) : null;
+}
+function createDOMCart(options) {
+  const regions = /* @__PURE__ */ new WeakMap(), pending = /* @__PURE__ */ new Map();
+  let stopped = false;
+  function cart(wanted) {
+    const markers = [], possible = document.querySelectorAll("h1,h2,h3,h4,h5,h6,span,[aria-label],aside,[role='dialog']");
+    for (let index = 0; index < Math.min(possible.length, 128); index++) {
+      const node2 = possible[index];
+      if (!node2.childElementCount && /^(?:shopping )?(?:cart|bag)$/i.test(text(node2) ?? "")) markers.push(node2);
+    }
+    const candidates = /* @__PURE__ */ new Set();
+    for (const marker of markers.slice(0, 8)) {
+      let node2 = marker.parentElement;
+      for (let depth = 0; node2 && node2 !== document.body && depth < 6; depth++, node2 = node2.parentElement) {
+        const children = nodes(node2, 256);
+        if (!children) break;
+        if (children.some((child) => child.getClientRects().length && getComputedStyle(child).visibility !== "hidden" && (child.matches("[aria-busy='true'],[role='progressbar']") || !child.childElementCount && /^(?:loading|updating)[.\s…]*$/i.test(text(child) ?? "")))) break;
+        const buttons = children.filter((child) => child.matches("button,[role='button']"));
+        if (!buttons.some((button) => /^(?:proceed to )?checkout$/i.test(text(button) ?? ""))) continue;
+        if (buttons.some((button) => /\badd\b.*\bcart\b/i.test(text(button) ?? "")) || node2.closest("[hidden],[aria-hidden='true'],[aria-busy='true']")) break;
+        const style = getComputedStyle(node2);
+        if (style.display === "none" || style.visibility === "hidden") break;
+        candidates.add(node2);
+        break;
+      }
+    }
+    if (candidates.size !== 1) return null;
+    const node = [...candidates][0], images = (nodes(node, 256) ?? []).filter((child) => child.matches(imageSelector));
+    if (images.length > 16) return null;
+    if (!images.length && !(nodes(node, 256) ?? []).some((child) => /^(?:(?:your|the|shopping)\s+)?(?:cart|bag)\s+(?:is\s+)?empty[.!:]?$|^add some products (?:in|to) (?:the|your) (?:cart|bag)\b/i.test(text(child) ?? ""))) return null;
+    const seen = /* @__PURE__ */ new Set();
+    let count = 0;
+    for (const image of images) {
+      const product = productAt(image), amount = product ? quantity(product) : null;
+      if (!product || !node.contains(product.node) || amount === null || seen.has(product.label)) return null;
+      seen.add(product.label);
+      if (product.label === wanted) count = amount;
+    }
+    let ref = regions.get(node);
+    if (!ref) {
+      ref = crypto.randomUUID();
+      regions.set(node, ref);
+    }
+    return { node, ref, quantity: count };
+  }
+  function remove(key) {
+    const item = pending.get(key);
+    if (item) clearTimeout(item.timer);
+    pending.delete(key);
+    if (!pending.size) observer.disconnect();
+  }
+  function finish(key) {
+    const item = pending.get(key);
+    if (!item) return;
+    let after = null;
+    try {
+      after = cart(item.label);
+    } catch {
+    }
+    remove(key);
+    if (stopped || item.suppressed || !item.product.product_ref || options.epoch() !== item.epoch || options.networkVersion() !== item.network || performance.now() > item.deadline + 250 || performance.now() - item.changed < 300 || !after || after.node !== item.before.node || after.quantity <= item.before.quantity) return;
+    options.emit("interaction", {
+      action: "cart_change",
+      confirmation: "dom_cart_quantity_increase",
+      trigger_id: item.trigger,
+      cart_region_ref: after.ref,
+      before_quantity: item.before.quantity,
+      after_quantity: after.quantity,
+      product: { ...item.product, quantity: after.quantity - item.before.quantity }
+    }, item.epoch, Date.now());
+  }
+  const observer = new MutationObserver((records) => {
+    for (const item of pending.values()) if (records.some((record) => item.before.node.contains(record.target) || record.target.contains(item.before.node))) item.changed = performance.now();
+  });
+  return {
+    /** Resolves the actual clicked product independently from the stricter cart-outcome reader. */
+    click(target, epoch, trigger) {
+      if (stopped) return {};
+      const product = productAt(target), before = product ? cart(product.label) : null;
+      const match = options.productSnapshot?.(target, before?.node.contains(target) ? void 0 : product?.price, product?.currency, product?.label);
+      const resolved = match?.snapshot.metadata.resolution === "resolved";
+      if (!product && !resolved) return {};
+      const action = commerceAction((target.getAttribute("aria-label") ?? text(target) ?? "").slice(0, 256)).toLowerCase();
+      const excluded = /\b(?:wishlist|compare|address|tag|subscribe|contact)\b/i.test(action + " " + (target.getAttribute("title") ?? "").slice(0, 256));
+      const add = !excluded && /\badd\b.*\bcart\b/.test(action), increment = /^(?:\+|increase(?: quantity)?|increment(?: quantity)?)$/.test(action);
+      const intent = resolved && !excluded && target.matches("button,[role='button']") && !target.closest("dialog,[role='dialog']") && /^(?:add|add to (?:cart|bag|basket))$/.test(action);
+      const existing = product ? pending.get(product.label) : void 0;
+      if (existing) existing.suppressed = true;
+      const network = options.networkVersion();
+      let watching;
+      const sameProduct = !resolved || !product || typeof match?.snapshot.name !== "string" || label(match.snapshot.name) === product.label;
+      if (product && sameProduct && before && !existing && pending.size < 3 && (add || increment && before.node.contains(target))) {
+        watching = {
+          label: product.label,
+          epoch,
+          trigger,
+          before,
+          network,
+          changed: performance.now(),
+          deadline: performance.now() + 2e3,
+          suppressed: false,
+          product: {},
+          timer: setTimeout(() => finish(product.label), 2e3)
+        };
+        pending.set(product.label, watching);
+        observer.observe(document.body, { childList: true, characterData: true, subtree: true });
+      }
+      const context = (product_ref) => {
+        const snapshot = match?.snapshot, common = resolved ? snapshot : null;
+        const evidence = { product_ref, ...!resolved && product ? { price: product.price, ...product.currency ? { currency: product.currency } : {} } : {}, ...snapshot ? { snapshot } : {} };
+        for (const key of ["product_id", "variant_id", "sku", "price", "currency"]) if (common?.[key] !== void 0) evidence[key] = common[key];
+        const amount = add || intent ? target.closest("[data-quantity]")?.getAttribute("data-quantity") : null;
+        if (amount && /^\d{1,8}(?:\.\d{1,4})?$/.test(amount)) evidence.quantity = Number(amount);
+        if (watching && product && !stopped && options.epoch() === epoch && pending.get(product.label) === watching)
+          watching.product = { product_ref, ...add ? { price: product.price, ...product.currency ? { currency: product.currency } : {} } : {}, ...snapshot ? { snapshot } : {} };
+        return { product: evidence, ...intent ? { intent: "add_to_cart" } : {} };
+      };
+      if (resolved) return context(match.product_ref);
+      return crypto.subtle.digest("SHA-256", new TextEncoder().encode(location.origin + "\n" + product.label)).then((digest) => context("dom_" + [...new Uint8Array(digest)].slice(0, 16).map((byte) => byte.toString(16).padStart(2, "0")).join("")));
+    },
+    /** Fences delayed observations and clears all retained transient product context. */
+    destroy() {
+      stopped = true;
+      observer.disconnect();
+      for (const key of [...pending.keys()]) remove(key);
+    }
+  };
+}
+
+// src/collectors.ts
+function observePage(options) {
+  const originalPush = history.pushState, originalReplace = history.replaceState;
+  let stopped = false, previous = "", current = "", currentPage = null, pendingClicks = 0, pendingRoutes = 0;
+  const roles = /* @__PURE__ */ new Set(["button", "link", "checkbox", "radio", "textbox", "combobox", "menuitem", "tab", "option", "switch", "listbox", "slider"]);
+  const dom = createDOMCart({ epoch: options.epoch, emit: options.emit, networkVersion: options.networkVersion ?? (() => 0), productSnapshot: options.productSnapshot });
+  function navigation() {
+    const epoch = options.epoch(), url = location.href;
+    if (stopped || !epoch || url === current) return;
+    const old = current;
+    current = url;
+    currentPage = null;
+    if (pendingRoutes >= 128) {
+      options.dropped();
+      return;
+    }
+    pendingRoutes++;
+    const time = Date.now();
+    void Promise.all([routeFor(url), old ? routeFor(old) : Promise.resolve(null)]).then(([page, from]) => {
+      if (!page || stopped || options.epoch() !== epoch) return;
+      if (current === url) currentPage = page;
+      previous = from ?? "";
+      let match;
+      try {
+        const heading = current === url ? document.querySelector("main h1") ?? document.querySelector("h1") : null;
+        match = heading ? options.productSnapshot?.(heading) : void 0;
+      } catch {
+        options.dropped();
+      }
+      options.emit("navigation", {
+        action: "page_view",
+        page,
+        ...previous ? { previous_page: previous } : {},
+        ...match?.snapshot.metadata.resolution === "resolved" ? { product: { product_ref: match.product_ref, snapshot: match.snapshot } } : {}
+      }, epoch, time);
+    }).catch(options.dropped).finally(() => {
+      pendingRoutes--;
+    });
+  }
+  function push(...args) {
+    Reflect.apply(originalPush, this, args);
+    navigation();
+  }
+  function replace(...args) {
+    Reflect.apply(originalReplace, this, args);
+    navigation();
+  }
+  function click(event) {
+    const epoch = options.epoch();
+    if (stopped || !epoch || !(event.target instanceof Element) || event.composedPath().some((node) => node instanceof Element && node.hasAttribute("data-sagepilot-popup"))) return;
+    if (pendingClicks >= 128) {
+      options.dropped();
+      return;
+    }
+    try {
+      const target = event.target.closest("button,a,input,select,textarea,[role='button']") ?? event.target;
+      const path = [];
+      let node = target;
+      for (let depth = 0; node && depth < 6; depth++, node = node.parentElement) {
+        const role = node.getAttribute("role"), type = node.getAttribute("type"), parent = node.parentElement;
+        const sibling = parent && parent.children.length <= 64 ? Array.prototype.indexOf.call(parent.children, node) : -1;
+        path.push({
+          tag: node.tagName.toLowerCase(),
+          sibling_index: sibling,
+          ...role && roles.has(role) ? { role } : {},
+          ...type && /^(button|submit|reset|checkbox|radio)$/.test(type) ? { type } : {}
+        });
+      }
+      const time = Date.now(), targetTag = target.tagName.toLowerCase();
+      const evidence = semanticEvidence(target);
+      let product = {};
+      try {
+        product = dom.click(target, epoch, crypto.randomUUID());
+      } catch {
+        options.dropped();
+      }
+      const emit = (ordinary, page) => {
+        if (!stopped && options.epoch() === epoch) options.emit("interaction", { action: "click", target_tag: targetTag, target_path: path, ...evidence, ...ordinary, ...page ? { page } : {} }, epoch, time);
+      };
+      pendingClicks++;
+      if (typeof product.then !== "function") {
+        try {
+          emit(product, current === location.href ? currentPage : null);
+        } finally {
+          queueMicrotask(() => {
+            pendingClicks--;
+          });
+        }
+      } else void Promise.all([routeFor(location.href), Promise.resolve(product).catch(() => {
+        options.dropped();
+        return {};
+      })]).then(([page, ordinary]) => emit(ordinary, page)).catch(options.dropped).finally(() => {
+        pendingClicks--;
+      });
+    } catch {
+      options.dropped();
+    }
+  }
+  history.pushState = push;
+  history.replaceState = replace;
+  document.addEventListener("click", click, true);
+  window.addEventListener("popstate", navigation);
+  window.addEventListener("hashchange", navigation);
+  navigation();
+  return function stopPage() {
+    stopped = true;
+    dom.destroy();
+    document.removeEventListener("click", click, true);
+    window.removeEventListener("popstate", navigation);
+    window.removeEventListener("hashchange", navigation);
+    if (history.pushState === push) history.pushState = originalPush;
+    if (history.replaceState === replace) history.replaceState = originalReplace;
+  };
+}
+function semanticEvidence(target) {
+  const hints = /* @__PURE__ */ new Set(["add", "cart", "remove", "checkout", "buy", "purchase", "wishlist", "product", "search", "subscribe", "submit"]);
+  const label2 = (target.getAttribute("aria-label") ?? target.textContent ?? "").slice(0, 256).toLowerCase();
+  const semanticTokens = [...new Set(label2.split(/[^a-z]+/).filter((token) => hints.has(token)))].sort();
+  return { semantic_tokens: semanticTokens };
+}
+
+// src/network.ts
+function observeNetwork(options) {
+  const fetchOriginal = globalThis.fetch, proto = globalThis.Response?.prototype;
+  const textOriginal = proto?.text, jsonOriginal = proto?.json;
+  const xhr = globalThis.XMLHttpRequest?.prototype, openOriginal = xhr?.open, sendOriginal = xhr?.send;
+  const responses = /* @__PURE__ */ new WeakMap(), requests = /* @__PURE__ */ new WeakMap();
+  const active = /* @__PURE__ */ new Set(), xhrCleanups = /* @__PURE__ */ new Set();
+  let stopped = false, insideFetch = false, pendingEmits = 0;
+  function state(url, method, body) {
+    const epoch = options.epoch();
+    if (stopped || !epoch || active.size >= 128 || options.excluded(url)) return null;
+    if (!/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$/i.test(method)) return null;
+    if (!/^(GET|HEAD|OPTIONS)$/i.test(method)) {
+      try {
+        options.mutation?.();
+      } catch {
+        options.dropped();
+      }
+    }
+    const result = {
+      id: crypto.randomUUID(),
+      epoch,
+      method: method.toUpperCase(),
+      url,
+      route: routeFor(url),
+      start: performance.now(),
+      request: projectText(body),
+      status: 0,
+      bodySeen: false
+    };
+    active.add(result);
+    return result;
+  }
+  function emit(item, phase, outcome, response = null) {
+    if (stopped || options.epoch() !== item.epoch) return;
+    if (pendingEmits >= 128) {
+      item.request = null;
+      options.dropped();
+      return;
+    }
+    pendingEmits++;
+    const elapsed = Math.max(0, performance.now() - item.start), time = Date.now();
+    const request = phase === "headers" ? item.request : null;
+    if (phase === "headers") item.request = null;
+    void item.route.then((route) => {
+      if (!route || stopped || options.epoch() !== item.epoch) return;
+      options.emit("network", {
+        request_id: item.id,
+        method: item.method,
+        route,
+        route_version: 2,
+        status: item.status,
+        duration_ms: Math.round(elapsed),
+        outcome,
+        phase,
+        projection_version: 2,
+        ...request ? { request } : {},
+        ...response ? { response } : {}
+      }, item.epoch, time);
+    }).catch(options.dropped).finally(() => {
+      pendingEmits--;
+    });
+  }
+  function fetchObserved(...args) {
+    let item = null;
+    try {
+      const input = args[0], init = args[1];
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      item = state(url, init?.method ?? (input instanceof Request ? input.method : "GET"), init?.body);
+    } catch {
+      options.dropped();
+    }
+    let result;
+    const previous = insideFetch;
+    try {
+      insideFetch = true;
+      result = Reflect.apply(fetchOriginal, this, args);
+    } catch (error) {
+      if (item) {
+        emit(item, "headers", "error");
+        active.delete(item);
+      }
+      throw error;
+    } finally {
+      insideFetch = previous;
+    }
+    const captured = item;
+    if (captured) void result.then((response) => {
+      captured.status = response.status;
+      emit(captured, "headers", "completed");
+      if (!stopped && /(?:application|text)\/(?:[a-z0-9.+-]*\+)?json/i.test(response.headers.get("content-type") ?? "")) responses.set(response, captured);
+      active.delete(captured);
+    }, () => {
+      emit(captured, "headers", "error");
+      active.delete(captured);
+    }).catch(options.dropped);
+    return result;
+  }
+  function consume(response, original, isText) {
+    const result = Reflect.apply(original, response, []), item = responses.get(response);
+    if (item && !item.bodySeen) {
+      item.bodySeen = true;
+      responses.delete(response);
+      void result.then((value) => {
+        if (stopped || options.epoch() !== item.epoch) return;
+        try {
+          if (item.status >= 200 && item.status < 300) options.products?.observe(value, item.url);
+          const projected = isText ? projectText(value) : project(value);
+          emit(item, "body", "completed", projected);
+        } catch {
+          options.dropped();
+        }
+      }, () => {
+      }).catch(options.dropped);
+    }
+    return result;
+  }
+  function text2() {
+    return consume(this, textOriginal, true);
+  }
+  function json() {
+    return consume(this, jsonOriginal, false);
+  }
+  function open(...args) {
+    const prior = requests.get(this);
+    const result = Reflect.apply(openOriginal, this, args);
+    let url = null;
+    try {
+      url = String(args[1]);
+      options.products?.track(this, url, args[0]);
+    } catch {
+      options.dropped();
+    }
+    if (prior) {
+      prior.cleanup?.();
+      active.delete(prior);
+      requests.delete(this);
+    }
+    if (!insideFetch) {
+      try {
+        const item = url ? state(url, args[0], null) : null;
+        if (item) requests.set(this, item);
+      } catch {
+        options.dropped();
+      }
+    }
+    return result;
+  }
+  function send(body) {
+    const item = requests.get(this);
+    if (!item || item.cleanup || stopped || options.epoch() !== item.epoch) return Reflect.apply(sendOriginal, this, [body]);
+    item.request = projectText(body);
+    let outcome = "completed";
+    const failed = (event) => {
+      outcome = event.type;
+    };
+    const cleanup = () => {
+      this.removeEventListener("loadend", complete);
+      for (const type of ["error", "abort", "timeout"]) this.removeEventListener(type, failed);
+      active.delete(item);
+      requests.delete(this);
+      xhrCleanups.delete(cleanup);
+      item.cleanup = void 0;
+    };
+    const complete = () => {
+      try {
+        item.status = this.status;
+        emit(item, "headers", outcome);
+        if (outcome === "completed" && /(?:application|text)\/(?:[a-z0-9.+-]*\+)?json/i.test(this.getResponseHeader("content-type") ?? "")) {
+          if (item.status >= 200 && item.status < 300) options.products?.observe(this.responseType === "json" ? this.response : this.responseType === "" || this.responseType === "text" ? this.responseText : null, item.url);
+          const response = this.responseType === "json" ? project(this.response) : this.responseType === "" || this.responseType === "text" ? projectText(this.responseText) : null;
+          if (response) emit(item, "body", outcome, response);
+        }
+      } catch {
+        options.dropped();
+      } finally {
+        cleanup();
+      }
+    };
+    item.cleanup = cleanup;
+    xhrCleanups.add(cleanup);
+    this.addEventListener("loadend", complete);
+    for (const type of ["error", "abort", "timeout"]) this.addEventListener(type, failed);
+    try {
+      return Reflect.apply(sendOriginal, this, [body]);
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+  }
+  if (typeof fetchOriginal === "function") globalThis.fetch = fetchObserved;
+  if (proto) proto.text = text2;
+  if (proto) proto.json = json;
+  if (xhr) {
+    xhr.open = open;
+    xhr.send = send;
+  }
+  return function stopNetwork() {
+    stopped = true;
+    for (const cleanup of [...xhrCleanups]) cleanup();
+    active.clear();
+    if (globalThis.fetch === fetchObserved) globalThis.fetch = fetchOriginal;
+    if (proto?.text === text2) proto.text = textOriginal;
+    if (proto?.json === json) proto.json = jsonOriginal;
+    if (xhr?.open === open) xhr.open = openOriginal;
+    if (xhr?.send === send) xhr.send = sendOriginal;
+  };
+}
+
+// src/storage.ts
+var JOURNAL_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_RECORDS = 8192;
+var MAX_BYTES = 8 * 1024 * 1024;
+var BACKUP_RECORDS = 256;
+var BACKUP_BYTES = 512 * 1024;
+function createJournal(scope) {
+  const memory = /* @__PURE__ */ new Map();
+  const backupSizes = /* @__PURE__ */ new Map();
+  const prefix = `sagepilot:web-journal:${scope}:`, purgeKey = prefix + "purged";
+  let db = null, backup = null;
+  let pending = Promise.resolve(), opened = null;
+  let appends = null;
+  let pendingBytes = 0, backupBytes = 0;
+  let purge = null;
+  let quotaEvicted = 0, expiredRecords = 0, storageFailures = 0;
+  function valid2(record) {
+    return !!record && typeof record.id === "string" && record.id.length > 0 && record.id.length <= 128 && Number.isSafeInteger(record.bytes) && record.bytes > 0 && record.bytes <= 32768 && Number.isFinite(record.expires) && record.value?.event_id === record.id && typeof record.value.owner?.session_id === "string" && (record.value.owner.customer_id === null || typeof record.value.owner.customer_id === "string");
+  }
+  function backupKeys(store) {
+    const keys = [];
+    for (let index = 0; index < store.length; index++) {
+      const key = store.key(index);
+      if (key?.startsWith(prefix) && key !== purgeKey) keys.push(key);
+    }
+    return keys;
+  }
+  function readBackup() {
+    const records = [];
+    try {
+      backup = globalThis.localStorage ?? null;
+      if (!backup) return records;
+      purge = backup.getItem(purgeKey);
+      for (const key of backupKeys(backup)) {
+        const raw = backup.getItem(key), size = (key.length + (raw?.length ?? 0)) * 2;
+        let record;
+        if (raw && size <= BACKUP_BYTES) {
+          try {
+            record = JSON.parse(raw);
+          } catch {
+          }
+        }
+        if (!record || !valid2(record) || key !== prefix + record.id) {
+          backup.removeItem(key);
+          continue;
+        }
+        records.push(record);
+        backupSizes.set(record.id, size);
+        backupBytes += size;
+      }
+    } catch {
+      backup = null;
+      storageFailures++;
+    }
+    return records;
+  }
+  function saveBackup(records) {
+    if (!backup) return;
+    for (const record of records) {
+      if (backupSizes.size >= BACKUP_RECORDS || backupBytes >= BACKUP_BYTES) break;
+      if (backupSizes.has(record.id) || backupBytes + record.bytes > BACKUP_BYTES) continue;
+      const key = prefix + record.id, raw = JSON.stringify(record), size = (key.length + raw.length) * 2;
+      if (backupBytes + size > BACKUP_BYTES) continue;
+      try {
+        backup.setItem(key, raw);
+      } catch {
+        storageFailures++;
+        break;
+      }
+      backupSizes.set(record.id, size);
+      backupBytes += size;
+    }
+  }
+  function removeBackup(ids) {
+    if (!backup) return;
+    for (const id2 of ids) {
+      const size = backupSizes.get(id2);
+      if (size === void 0) continue;
+      try {
+        backup.removeItem(prefix + id2);
+      } catch {
+        storageFailures++;
+        continue;
+      }
+      backupSizes.delete(id2);
+      backupBytes -= size;
+    }
+  }
+  function fallback() {
+    db?.close();
+    db = null;
+    storageFailures++;
+    saveBackup(memory.values());
+  }
+  async function persist(puts, deletes, clear = false) {
+    removeBackup(deletes);
+    if (db) {
+      try {
+        await new Promise((resolve, reject) => {
+          const tx = db.transaction("events", "readwrite"), store = tx.objectStore("events");
+          if (clear) store.clear();
+          for (const id2 of deletes) store.delete(id2);
+          for (const record of puts) store.put(record);
+          tx.oncomplete = () => resolve();
+          tx.onabort = tx.onerror = () => reject(tx.error ?? new Error("Journal transaction failed"));
+        });
+        removeBackup(puts.map((record) => record.id));
+        return;
+      } catch {
+        fallback();
+      }
+    }
+    saveBackup(deletes.length ? memory.values() : puts);
+  }
+  function readIndexedDB() {
+    return new Promise((resolve, reject) => {
+      let settled = false, connection = null;
+      let timer = setTimeout(fail, 1500);
+      function fail() {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        connection?.close();
+        reject(new Error("IndexedDB journal is unavailable"));
+      }
+      try {
+        const request = indexedDB.open("sagepilot-web-events-" + scope, 1);
+        request.onupgradeneeded = () => {
+          if (!request.result.objectStoreNames.contains("events")) request.result.createObjectStore("events", { keyPath: "id" });
+        };
+        request.onerror = request.onblocked = fail;
+        request.onsuccess = () => {
+          if (settled) {
+            request.result.close();
+            return;
+          }
+          connection = request.result;
+          clearTimeout(timer);
+          timer = setTimeout(fail, 5e3);
+          try {
+            const tx = connection.transaction("events", "readonly");
+            const read = tx.objectStore("events").getAll(void 0, MAX_RECORDS + 1);
+            tx.onabort = tx.onerror = fail;
+            tx.oncomplete = () => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timer);
+              db = connection;
+              db.onversionchange = fallback;
+              resolve(read.result);
+            };
+          } catch {
+            fail();
+          }
+        };
+      } catch {
+        fail();
+      }
+    });
+  }
+  function remove(id2) {
+    const record = memory.get(id2);
+    if (record) {
+      memory.delete(id2);
+      pendingBytes -= record.bytes;
+    }
+  }
+  function prune() {
+    const deleted = [], now = Date.now();
+    for (const [id2, record] of memory) {
+      if (record.expires <= now) {
+        remove(id2);
+        deleted.push(id2);
+        expiredRecords++;
+      }
+    }
+    while (memory.size > MAX_RECORDS || pendingBytes > MAX_BYTES) {
+      const id2 = memory.keys().next().value;
+      remove(id2);
+      deleted.push(id2);
+      quotaEvicted++;
+    }
+    return deleted;
+  }
+  async function restore() {
+    const saved = readBackup();
+    const primary = await readIndexedDB().catch(() => {
+      storageFailures++;
+      return [];
+    });
+    const corrupt = [];
+    for (const record of [...saved, ...primary].filter((record2) => {
+      if (valid2(record2) && (!purge || record2.purge === purge)) return true;
+      if (typeof record2?.id === "string") corrupt.push(record2.id);
+      return false;
+    }).sort((a, b) => a.expires - b.expires)) {
+      remove(record.id);
+      memory.set(record.id, record);
+      pendingBytes += record.bytes;
+    }
+    const deleted = [...corrupt, ...prune()];
+    const existing = new Set(primary.filter(valid2).map((record) => record.id));
+    if (db) removeBackup(saved.filter((record) => existing.has(record.id)).map((record) => record.id));
+    const migrate = db ? saved.filter((record) => memory.has(record.id) && !existing.has(record.id)) : [];
+    if (deleted.length || migrate.length) await persist(migrate, deleted);
+  }
+  function serial(action) {
+    appends = null;
+    const next = pending.then(async () => {
+      await (opened ?? (opened = restore()));
+      return action();
+    });
+    pending = next.then(() => {
+    }, () => {
+      storageFailures++;
+    });
+    return next;
+  }
+  return {
+    /** Coalesces queued captures into one disk transaction while preserving the capture order. */
+    append(record) {
+      if (appends) {
+        appends.records.push(record);
+        return appends.committed;
+      }
+      const records = [record];
+      const committed = serial(async () => {
+        if (appends?.records === records) appends = null;
+        for (const item of records) {
+          if (purge) item.purge = purge;
+          remove(item.id);
+          memory.set(item.id, item);
+          pendingBytes += item.bytes;
+        }
+        const deleted = memory.size > MAX_RECORDS || pendingBytes > MAX_BYTES ? prune() : [];
+        await persist(records.filter((item) => memory.has(item.id)), deleted);
+      });
+      appends = { records, committed };
+      return committed;
+    },
+    /** Selects a bounded upload batch without removing unacknowledged records. */
+    batch() {
+      return serial(async () => {
+        const deleted = prune();
+        if (deleted.length) await persist([], deleted);
+        const selected = [];
+        let bytes = 0;
+        for (const record of memory.values()) {
+          if (selected.length >= 50 || bytes + record.bytes > 96 * 1024) break;
+          selected.push(record.value);
+          bytes += record.bytes;
+        }
+        return selected;
+      });
+    },
+    /** Deletes only terminal receipt IDs from memory and any writable journal. */
+    acknowledge(ids) {
+      return serial(async () => {
+        for (const id2 of ids) remove(id2);
+        await persist([], [...ids]);
+      });
+    },
+    /** Purges evidence and fences the old generation if an inaccessible IndexedDB returns later. */
+    clear() {
+      return serial(async () => {
+        memory.clear();
+        pendingBytes = 0;
+        purge = crypto.randomUUID();
+        if (backup) {
+          try {
+            for (const key of backupKeys(backup)) backup.removeItem(key);
+            backup.setItem(purgeKey, purge);
+          } catch {
+            storageFailures++;
+          }
+        }
+        backupSizes.clear();
+        backupBytes = 0;
+        await persist([], [], true);
+      });
+    },
+    /** Reports known storage limits without exposing evidence or credentials. */
+    diagnostics() {
+      let volatile = 0;
+      if (!db) {
+        for (const id2 of memory.keys()) if (!backupSizes.has(id2)) volatile++;
+      }
+      return {
+        storage: db ? "indexeddb" : backup ? "localStorage" : "memory",
+        pending_records: memory.size,
+        pending_bytes: pendingBytes,
+        memory_only_records: volatile,
+        quota_evicted: quotaEvicted,
+        expired_records: expiredRecords,
+        storage_failures: storageFailures
+      };
+    },
+    /** Closes browser handles after earlier writes settle. */
+    async close() {
+      await pending;
+      db?.close();
+      db = null;
+    }
+  };
+}
+
+// src/popup.ts
+function popupCompletionKey(workspaceId, installationId) {
+  return `sagepilot:sdk-popup:${workspaceId}:${installationId}:completed`;
+}
+function valid(value) {
+  if (!value || !Number.isSafeInteger(value.revision) || value.revision < 1 || typeof value.enabled !== "boolean" || !/^#[0-9a-f]{6}$/i.test(value.accent_color) || !["email", "none"].includes(value.verification) || ![value.title, value.body, value.button_text, value.success_text].every((item) => typeof item === "string" && item.length <= 2e3) || !value.fields || ![value.fields.name, value.fields.email, value.fields.phone].every((item) => typeof item === "boolean") || !Array.isArray(value.required_fields) || value.required_fields.some((field) => !["name", "email", "phone"].includes(field) || !value.fields[field]) || value.verification === "email" && !value.fields.email || !Number.isFinite(value.frequency_hours) || value.frequency_hours < 1 || value.frequency_hours > 8760 || !value.trigger || !Number.isFinite(value.trigger.delay_seconds) || value.trigger.delay_seconds < 0 || value.trigger.delay_seconds > 300 || !Number.isFinite(value.trigger.scroll_percent) || value.trigger.scroll_percent < 0 || value.trigger.scroll_percent > 100 || !Array.isArray(value.trigger.page_paths) || value.trigger.page_paths.length > 20 || value.trigger.page_paths.some((path) => typeof path !== "string" || !path.startsWith("/") || path.startsWith("//") || /[?#\\]/.test(path) || path.length > 300)) return false;
+  if (value.logo_url !== null) {
+    try {
+      const url = new URL(value.logo_url);
+      if (url.protocol !== "https:" || url.username || url.password) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function createPopup(options) {
+  let config = null, host = null;
+  let timer = null, entered = Date.now(), path = location.pathname, generation = 0;
+  let previousFocus = null, cleanup = null;
+  const scope = `sagepilot:sdk-popup:${options.client.workspaceId}:${options.client.installationId}`;
+  const shownKey = scope + ":shown";
+  const completedKey = popupCompletionKey(options.client.workspaceId, options.client.installationId);
+  function remove() {
+    generation++;
+    cleanup?.();
+    cleanup = null;
+    host?.remove();
+    host = null;
+    if (previousFocus instanceof HTMLElement && previousFocus.isConnected) previousFocus.focus();
+    previousFocus = null;
+  }
+  function eligible() {
+    const session = options.client.session();
+    if (!config?.enabled || host || !session || session.customer_id || options.storage.getItem(completedKey) === session.anonymous_id) return false;
+    if (path !== location.pathname) {
+      path = location.pathname;
+      entered = Date.now();
+    }
+    if (config.trigger.page_paths.length && !config.trigger.page_paths.includes(path)) return false;
+    if (Date.now() - entered < config.trigger.delay_seconds * 1e3) return false;
+    const height = Math.max(document.documentElement.scrollHeight - innerHeight, 1);
+    if (config.trigger.scroll_percent > 0 && scrollY / height * 100 < config.trigger.scroll_percent) return false;
+    const raw = options.storage.getItem(shownKey), last = Number(raw);
+    return !raw || !Number.isFinite(last) || Date.now() - last >= config.frequency_hours * 36e5;
+  }
+  function element(tag, text2) {
+    const node = document.createElement(tag);
+    if (text2 !== void 0) node.textContent = text2;
+    return node;
+  }
+  function show() {
+    if (!eligible() || !config) return;
+    const published = config, revision = ++generation;
+    previousFocus = document.activeElement;
+    host = element("div");
+    host.setAttribute("data-sagepilot-popup", "");
+    host.style.cssText = "position:fixed;inset:0;z-index:2147483000;display:grid;place-items:center;padding:20px;background:#10251d66";
+    const shadow = host.attachShadow({ mode: "open" });
+    const style = element("style");
+    style.textContent = `:host{font-family:system-ui,sans-serif;color:#172c23;color-scheme:light}*{box-sizing:border-box}.panel{background:white;width:min(420px,calc(100vw - 40px));max-height:90dvh;overflow:auto;border-radius:18px;padding:28px;box-shadow:0 16px 80px #0003;position:relative}h2{margin:4px 28px 10px 0;font-size:25px}p{line-height:1.5;color:#52645a}label{display:block;margin-top:14px;font-size:14px}input{display:block;width:100%;padding:11px;border:1px solid #b6c7bd;border-radius:7px;margin-top:6px;font:inherit;background:white;color:#172c23}button{cursor:pointer;font:inherit;color:inherit}button[type=submit]{display:block;width:100%;border:0;border-radius:8px;background:${published.accent_color};color:white;padding:13px;margin-top:20px;font-weight:600}button:disabled{opacity:.6;cursor:wait}.close{position:absolute;right:15px;top:12px;border:0;background:transparent;font-size:25px}.status{min-height:1.3em;font-size:14px}.logo{max-width:160px;max-height:60px;object-fit:contain}input:focus-visible,button:focus-visible{outline:3px solid #729e82;outline-offset:3px}@media(max-width:480px){.panel{padding:22px}h2{font-size:22px}}`;
+    shadow.append(style);
+    const panel = element("section");
+    panel.className = "panel";
+    panel.setAttribute("role", "dialog");
+    panel.setAttribute("aria-modal", "true");
+    panel.setAttribute("aria-labelledby", "sage-popup-title");
+    const close = element("button", "\xD7");
+    close.type = "button";
+    close.className = "close";
+    close.setAttribute("aria-label", "Close form");
+    function dismiss() {
+      options.emit("popup_dismissed");
+      remove();
+    }
+    close.addEventListener("click", dismiss);
+    panel.append(close);
+    if (published.logo_url) {
+      const logo = element("img");
+      logo.src = published.logo_url;
+      logo.alt = "";
+      logo.className = "logo";
+      logo.referrerPolicy = "no-referrer";
+      panel.append(logo);
+    }
+    const title = element("h2", published.title);
+    title.id = "sage-popup-title";
+    panel.append(title, element("p", published.body));
+    const form = element("form"), status = element("p");
+    status.className = "status";
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    const inputs = /* @__PURE__ */ new Map();
+    const contactLabels = [];
+    for (const field of ["name", "email", "phone"]) {
+      if (!published.fields[field]) continue;
+      const label2 = element("label", field === "phone" ? "Phone" : field === "email" ? "Email" : "Name");
+      const input = element("input");
+      input.name = field;
+      input.type = field === "email" ? "email" : field === "phone" ? "tel" : "text";
+      input.autocomplete = field === "phone" ? "tel" : field;
+      input.maxLength = field === "phone" ? 32 : field === "email" ? 254 : 100;
+      input.required = published.required_fields.includes(field) || field === "email" && published.verification === "email";
+      label2.append(input);
+      form.append(label2);
+      contactLabels.push(label2);
+      inputs.set(field, input);
+    }
+    const submit = element("button", published.button_text);
+    submit.type = "submit";
+    form.append(submit, status);
+    panel.append(form);
+    shadow.append(panel);
+    document.body.append(host);
+    options.storage.setItem(shownKey, String(Date.now()));
+    options.emit("popup_shown");
+    const contactInputs = new Map(inputs);
+    let submissionId = crypto.randomUUID(), challenge = null, busy = false;
+    async function submitForm(event) {
+      event.preventDefault();
+      if (busy || revision !== generation) return;
+      busy = true;
+      submit.disabled = true;
+      status.textContent = "";
+      try {
+        if (challenge) {
+          await options.identify(challenge, inputs.get("code").value);
+          if (revision !== generation) return;
+          form.replaceChildren(element("p", published.success_text), close);
+          close.className = "close";
+        } else {
+          const contact = { submission_id: submissionId, popup_revision: published.revision, marketing_consent: true };
+          for (const field of ["name", "email", "phone"]) {
+            const value = inputs.get(field)?.value.trim();
+            if (value) contact[field] = value;
+          }
+          const result = await options.submit(contact);
+          if (revision !== generation) return;
+          options.emit("popup_submitted");
+          for (const input of inputs.values()) input.value = "";
+          if (result.status === "verification_required") {
+            let restartForm2 = function() {
+              if (busy) return;
+              challenge = null;
+              submissionId = crypto.randomUUID();
+              inputs.clear();
+              for (const [key, value] of contactInputs) inputs.set(key, value);
+              submit.textContent = published.button_text;
+              status.textContent = "";
+              form.replaceChildren(...contactLabels, submit, status);
+              inputs.values().next().value?.focus();
+            };
+            var restartForm = restartForm2;
+            challenge = result.challenge_id;
+            inputs.clear();
+            const label2 = element("label", "Email verification code"), code = element("input");
+            code.name = "code";
+            code.inputMode = "numeric";
+            code.autocomplete = "one-time-code";
+            code.pattern = "[0-9]{6}";
+            code.maxLength = 6;
+            code.required = true;
+            inputs.set("code", code);
+            label2.append(code);
+            submit.textContent = "Verify email";
+            const restart = element("button", "Start again or use another email");
+            restart.type = "button";
+            restart.addEventListener("click", restartForm2);
+            form.replaceChildren(label2, submit, restart, status);
+            status.textContent = "Check your email for the six-digit code.";
+            code.focus();
+          } else form.replaceChildren(element("p", published.success_text));
+        }
+      } catch (error) {
+        if (revision === generation) status.textContent = challenge ? "Verification failed. Check the code and try again." : "We couldn't save the form. Please try again.";
+        options.report(error);
+      } finally {
+        busy = false;
+        submit.disabled = false;
+      }
+    }
+    form.addEventListener("submit", submitForm);
+    function keydown(event) {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        dismiss();
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const focusable = [...shadow.querySelectorAll("button:not(:disabled),input:not(:disabled)")];
+      const first = focusable[0], last = focusable[focusable.length - 1];
+      if (event.shiftKey && shadow.activeElement === first) {
+        event.preventDefault();
+        last?.focus();
+      } else if (!event.shiftKey && shadow.activeElement === last) {
+        event.preventDefault();
+        first?.focus();
+      }
+    }
+    shadow.addEventListener("keydown", keydown);
+    cleanup = () => {
+      form.removeEventListener("submit", submitForm);
+      shadow.removeEventListener("keydown", keydown);
+    };
+    (inputs.values().next().value ?? close).focus();
+  }
+  return {
+    /** Applies only a validated published revision; disabling immediately removes an open form. */
+    configure(value) {
+      if (value && !valid(value)) {
+        options.report(new Error("Invalid published popup configuration."));
+        value = null;
+      }
+      if (value?.revision === config?.revision && value?.enabled === config?.enabled) return;
+      remove();
+      config = value ?? null;
+      entered = Date.now();
+      path = location.pathname;
+      if (timer) clearInterval(timer);
+      timer = null;
+      if (config?.enabled) {
+        timer = setInterval(show, 1e3);
+        show();
+      }
+    },
+    /** Cancels rendering and listeners when the installation runtime is destroyed. */
+    destroy() {
+      if (timer) clearInterval(timer);
+      timer = null;
+      config = null;
+      remove();
+    }
+  };
+}
+
+// src/index.ts
+var instances = /* @__PURE__ */ new Map();
+var VISITOR_KEY = "sagepilot_anonymous_id";
+var VISITOR_ID2 = /^[A-Za-z0-9_-]{1,128}$/;
+function createSagepilotWebEvents(options) {
+  const scope = options.key.toLowerCase();
+  const existing = instances.get(scope);
+  if (existing) return existing;
+  let anonymousStorage = "memory";
+  let browserId = null;
+  let cookieRequests = Promise.resolve();
+  let cookieSynced = false;
+  const memory = /* @__PURE__ */ new Map();
+  const storage = {
+    getItem(key) {
+      try {
+        return localStorage.getItem(key) ?? memory.get(key) ?? null;
+      } catch {
+        return memory.get(key) ?? null;
+      }
+    },
+    setItem(key, value) {
+      memory.set(key, value);
+      try {
+        localStorage.setItem(key, value);
+      } catch {
+      }
+    },
+    removeItem(key) {
+      memory.delete(key);
+      try {
+        localStorage.removeItem(key);
+      } catch {
+      }
+    }
+  };
+  const client = createSagepilotInstallationClient({
+    key: options.key,
+    apiHost: options.apiHost,
+    platform: "web",
+    fetch: options.fetch,
+    storage,
+    sdk: { name, version }
+  });
+  const completedKey = popupCompletionKey(client.workspaceId, client.installationId);
+  const cookieKey = `sagepilot:sdk-visitor-cookie:${scope}`;
+  const journal = createJournal(scope.replace(/:/g, "_"));
+  let localPermission = options.collectionEnabled === true, started = false, destroyed = false, policyKnown = false;
+  let identityChanging = false;
+  let starting = null, draining = null;
+  let generation = 0, epoch = "", failures = 0, rejected = 0, dropped = 0, lastRefresh = 0, capturePending = 0, captureBytes = 0, networkMutations = 0;
+  let retryTimer = null;
+  let policyTimer = null;
+  let stopPage = null, stopNetwork = null;
+  let products = null;
+  function report(error) {
+    try {
+      options.onError?.(error);
+    } catch {
+    }
+  }
+  function canUseVisitorCookie() {
+    const session = client.session();
+    return !destroyed && localPermission && session?.collection_enabled === true && session.visitor_cookie_enabled === true;
+  }
+  function syncVisitorCookie(anonymousId, allowed) {
+    if (!allowed) cookieSynced = false;
+    const operation = cookieRequests.then(async () => {
+      if (allowed) {
+        if (!canUseVisitorCookie()) return null;
+        storage.setItem(cookieKey, "1");
+      } else if (!storage.getItem(cookieKey)) return null;
+      try {
+        const visitor = await client.syncVisitorCookie(
+          anonymousId,
+          allowed,
+          anonymousId !== null && storage.getItem(completedKey) === anonymousId
+        );
+        if (visitor.anonymous_id === null) {
+          cookieSynced = false;
+          storage.removeItem(cookieKey);
+        }
+        return visitor;
+      } catch (error) {
+        if (!destroyed) report(error);
+        return null;
+      }
+    });
+    cookieRequests = operation;
+    return operation;
+  }
+  function rememberBrowser(anonymousId, restored) {
+    memory.set(VISITOR_KEY, anonymousId);
+    try {
+      if (localStorage.getItem(VISITOR_KEY) !== anonymousId) localStorage.setItem(VISITOR_KEY, anonymousId);
+      anonymousStorage = "localStorage";
+    } catch {
+      anonymousStorage = "memory";
+    }
+    if (restored) anonymousStorage = "cookie";
+    browserId = anonymousId;
+  }
+  async function syncCookiePolicy(revision) {
+    if (destroyed || revision !== generation) return;
+    const session = client.session();
+    if (!session?.collection_enabled || session.visitor_cookie_enabled !== true) {
+      await syncVisitorCookie(null, false);
+      if (browserId && anonymousStorage === "cookie") rememberBrowser(browserId, false);
+      return;
+    }
+    if (cookieSynced || !localPermission) return;
+    const currentId = session.anonymous_id;
+    const cookie = await syncVisitorCookie(currentId, true);
+    const restoredId = cookie?.anonymous_id;
+    if (!restoredId || revision !== generation || !canUseVisitorCookie() || client.session()?.anonymous_id !== currentId) return;
+    if (cookie.popup_completed) {
+      storage.setItem(completedKey, restoredId);
+      popup.configure(null);
+    }
+    rememberBrowser(restoredId, cookie.restored);
+    if (restoredId !== currentId) {
+      policyKnown = false;
+      epoch = crypto.randomUUID();
+      detach(true);
+      popup.configure(null);
+      client.destroy();
+      await client.start(restoredId);
+    }
+    if (revision === generation && canUseVisitorCookie()) cookieSynced = true;
+  }
+  async function startVisitor(revision) {
+    const saved = browserId ?? storage.getItem(VISITOR_KEY);
+    const anonymousId = saved && VISITOR_ID2.test(saved) ? saved : crypto.randomUUID();
+    rememberBrowser(anonymousId, false);
+    await client.start(anonymousId);
+    await syncCookiePolicy(revision);
+  }
+  async function completeVisitor(anonymousId) {
+    if (!anonymousId || destroyed || client.session()?.anonymous_id !== anonymousId) return;
+    storage.setItem(completedKey, anonymousId);
+    if (canUseVisitorCookie()) await syncVisitorCookie(anonymousId, true);
+  }
+  async function clearCollection() {
+    await Promise.all([journal.clear(), syncVisitorCookie(null, false)]);
+  }
+  function enabled() {
+    if (destroyed || identityChanging || !started || !localPermission || !policyKnown) return false;
+    const session = client.session();
+    return session?.collection_enabled === true && Date.parse(session.expires_at) > Date.now();
+  }
+  function captureEpoch() {
+    return enabled() ? epoch : null;
+  }
+  function excluded(input) {
+    try {
+      const url = new URL(input, location.href), session = client.session();
+      return url.origin === client.apiHost && url.pathname.startsWith("/platform-api/v1/sdk/") || url.origin === location.origin && url.pathname === client.visitorCookiePath || !!session && url.origin + url.pathname === session.ingestion_url;
+    } catch {
+      return true;
+    }
+  }
+  const capture = (kind, data, capturedEpoch, time) => {
+    const session = client.session();
+    if (!session || !enabled() || epoch !== capturedEpoch) {
+      dropped++;
+      return;
+    }
+    const observation = {
+      event_id: crypto.randomUUID(),
+      kind,
+      occurred_at: new Date(time).toISOString(),
+      owner: { session_id: session.session_id, customer_id: session.customer_id, identity_epoch: capturedEpoch },
+      workspace_id: session.workspace_id,
+      installation_id: session.installation_id,
+      platform: "web",
+      sdk_name: name,
+      sdk_version: version,
+      clock_quality: "unverified",
+      clock_source: "device_wall",
+      data
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(observation)).byteLength;
+    if (bytes > 32768) {
+      rejected++;
+      return;
+    }
+    if (capturePending >= 128 || captureBytes + bytes > 512 * 1024) {
+      dropped++;
+      return;
+    }
+    capturePending++;
+    captureBytes += bytes;
+    void journal.append({ id: observation.event_id, value: observation, bytes, expires: Date.now() + JOURNAL_TTL_MS }).catch(report).finally(() => {
+      capturePending--;
+      captureBytes -= bytes;
+    });
+  };
+  const popup = createPopup({
+    client,
+    storage,
+    report,
+    emit(action) {
+      if (enabled()) capture("lifecycle", { action }, epoch, Date.now());
+    },
+    submit(input) {
+      return addon.submitContact(input);
+    },
+    identify(challenge, code) {
+      return addon.verifyContact(challenge, code);
+    }
+  });
+  async function changeIdentity(operation) {
+    if (!started || destroyed) throw new Error("Start the web-events installation first.");
+    if (identityChanging) throw new Error("An SDK identity operation is already running.");
+    identityChanging = true;
+    generation++;
+    epoch = crypto.randomUUID();
+    detach(true);
+    client.cancelPending();
+    try {
+      await operation();
+    } finally {
+      identityChanging = false;
+      if (!destroyed) {
+        epoch = crypto.randomUUID();
+        if (enabled()) attach();
+        else detach();
+        schedule();
+      }
+    }
+  }
+  async function refreshConfig() {
+    if (identityChanging) return;
+    const revision = generation;
+    const previous = client.session();
+    try {
+      await client.refresh(true);
+      await syncCookiePolicy(revision);
+    } catch (error) {
+      if (revision === generation && !destroyed) {
+        popup.configure(null);
+        const status = error instanceof SagepilotInstallationError ? error.status ?? 0 : 0;
+        const temporary = error instanceof SagepilotInstallationError && (error.code === "network_error" || status === 408 || status === 425 || status === 429 || status >= 500);
+        if (!temporary) suspendCapture();
+      }
+      throw error;
+    }
+    if (revision !== generation || destroyed) return;
+    if (previous?.session_id !== client.session()?.session_id || Date.parse(previous?.expires_at ?? "") <= Date.now()) {
+      epoch = crypto.randomUUID();
+    }
+    lastRefresh = Date.now();
+    policyKnown = true;
+    popup.configure(client.session()?.popup);
+    if (!client.session()?.collection_enabled) {
+      detach();
+      await journal.clear();
+    } else {
+      attach();
+      schedule();
+    }
+  }
+  function suspendCapture() {
+    policyKnown = false;
+    lastRefresh = 0;
+    epoch = crypto.randomUUID();
+    detach();
+    schedule();
+  }
+  function detach(preserveProducts = false) {
+    stopPage?.();
+    stopPage = null;
+    stopNetwork?.();
+    stopNetwork = null;
+    if (preserveProducts) products?.pause();
+    else {
+      products?.destroy();
+      products = null;
+    }
+    if (retryTimer) clearTimeout(retryTimer);
+    retryTimer = null;
+  }
+  function attach() {
+    if (!enabled()) return;
+    armNetwork();
+    products?.activate();
+    if (!stopPage) stopPage = observePage({
+      epoch: captureEpoch,
+      emit: capture,
+      dropped: () => {
+        dropped++;
+      },
+      networkVersion: () => networkMutations,
+      productSnapshot: (root, price2, currency, label2) => products?.resolve(root, price2, currency, label2)
+    });
+  }
+  function armNetwork() {
+    if (destroyed || !localPermission || stopNetwork) return;
+    products ?? (products = createProductIndex({ epoch: captureEpoch }));
+    stopNetwork = observeNetwork({
+      epoch: captureEpoch,
+      excluded,
+      emit: capture,
+      dropped: () => {
+        dropped++;
+      },
+      mutation: () => {
+        networkMutations++;
+      },
+      products
+    });
+  }
+  function schedule() {
+    if (!started || destroyed || !localPermission || identityChanging || retryTimer) return;
+    const delay = failures ? Math.min(6e4, 2e3 * 2 ** Math.min(failures, 5)) * (0.8 + Math.random() * 0.4) : 2e3;
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      void flush().catch(report).finally(schedule);
+    }, delay);
+  }
+  async function flush() {
+    if (draining) return draining;
+    if (!started || destroyed || !localPermission || identityChanging) return;
+    const revision = generation;
+    draining = (async () => {
+      try {
+        if (!policyKnown || Date.now() - lastRefresh > 6e4) await refreshConfig();
+        if (revision !== generation || !enabled()) return;
+        for (let pass = 0; pass < 4; pass++) {
+          const queued = await journal.batch();
+          const first = queued[0]?.owner;
+          const batch = queued.filter((item) => item.owner.session_id === first?.session_id && item.owner.customer_id === first?.customer_id);
+          if (revision !== generation || !enabled()) return;
+          if (!batch.length) {
+            failures = 0;
+            return;
+          }
+          if (!client.hasCaptureOwner(first)) {
+            dropped += batch.length;
+            await journal.acknowledge(new Set(batch.map((item) => item.event_id)));
+            continue;
+          }
+          const receipt = await client.upload(batch, first);
+          if (revision !== generation || !enabled()) return;
+          const terminal = new Set(receipt.results.filter((item) => item.status !== "retryable").map((item) => item.event_id));
+          dropped += receipt.results.filter((item) => item.status === "disabled" || item.status === "invalid").length;
+          await journal.acknowledge(terminal);
+          if (terminal.size !== batch.length) {
+            failures = Math.min(failures + 1, 6);
+            return;
+          }
+          failures = 0;
+        }
+      } catch (error) {
+        if (revision === generation && !destroyed) {
+          failures = Math.min(failures + 1, 6);
+          if (client.session()?.collection_enabled === false) {
+            detach();
+            await journal.clear();
+          } else if (policyKnown && error instanceof SagepilotInstallationError && [401, 403, 404, 410].includes(error.status ?? 0)) suspendCapture();
+        }
+        throw error;
+      }
+    })().finally(() => {
+      draining = null;
+    });
+    return draining;
+  }
+  function online() {
+    void flush().catch(report);
+  }
+  const addon = {
+    /** Bootstraps this browser owner without loading chat, showing a popup or collecting before consent. */
+    async start() {
+      if (destroyed) throw new Error("This web-events collector was destroyed.");
+      if (starting) return starting;
+      if (started) return;
+      if (typeof window === "undefined" || !globalThis.crypto?.randomUUID) throw new Error("Web events require a browser on HTTPS or loopback.");
+      const revision = generation;
+      starting = (async () => {
+        armNetwork();
+        await startVisitor(revision);
+        if (destroyed || revision !== generation) return;
+        started = true;
+        policyKnown = true;
+        epoch = crypto.randomUUID();
+        lastRefresh = Date.now();
+        popup.configure(client.session()?.popup);
+        window.addEventListener("online", online);
+        policyTimer = setInterval(() => {
+          void refreshConfig().catch(report);
+        }, 6e4);
+        if (!localPermission || !client.session()?.collection_enabled) detach();
+        if (!client.session()?.collection_enabled) await journal.clear();
+        attach();
+        schedule();
+      })().catch((error) => {
+        if (revision !== generation || destroyed) return;
+        detach();
+        throw error;
+      }).finally(() => {
+        starting = null;
+      });
+      return starting;
+    },
+    /** Fences immediately; disabling aborts SDK requests and purges unuploaded evidence. */
+    async setCollectionEnabled(next) {
+      if (destroyed) throw new Error("This web-events collector was destroyed.");
+      if (typeof next !== "boolean") throw new Error("Collection permission must be boolean.");
+      if (localPermission === next && started) {
+        if (!next) await clearCollection();
+        return;
+      }
+      localPermission = next;
+      generation++;
+      epoch = crypto.randomUUID();
+      detach();
+      client.cancelPending();
+      if (!next) {
+        await clearCollection();
+        return;
+      }
+      if (starting) await starting;
+      if (destroyed || !localPermission) return;
+      if (!started) {
+        await addon.start();
+        return;
+      }
+      const revision = generation;
+      policyKnown = false;
+      try {
+        await client.refresh(true);
+        await syncCookiePolicy(revision);
+        if (revision !== generation || destroyed || !localPermission) return;
+        lastRefresh = Date.now();
+        policyKnown = true;
+        popup.configure(client.session()?.popup);
+        if (!client.session()?.collection_enabled) await journal.clear();
+        attach();
+        schedule();
+      } catch (error) {
+        if (revision === generation && !destroyed) {
+          lastRefresh = 0;
+          schedule();
+        }
+        throw error;
+      }
+    },
+    flush,
+    /** Submits contact-only data through the explicit identity endpoint, never through autocapture. */
+    async submitContact(input) {
+      const anonymousId = client.session()?.anonymous_id;
+      const result = await client.submitContact(input);
+      if (result.status === "recorded") await completeVisitor(anonymousId);
+      return result;
+    },
+    /** Verifies proof behind a capture fence; buffered anonymous observations remain anonymous. */
+    async verifyContact(challengeId, code) {
+      const anonymousId = client.session()?.anonymous_id;
+      await changeIdentity(() => client.verifyContact(challengeId, code));
+      await completeVisitor(anonymousId);
+    },
+    /** Applies an explicit logout boundary without relabeling earlier observations. */
+    logout() {
+      return changeIdentity(async () => {
+        try {
+          await client.logout();
+        } catch (error) {
+          policyKnown = false;
+          lastRefresh = 0;
+          throw error;
+        }
+      });
+    },
+    refreshConfig,
+    /** Reports bounded operational counters, never contact values, credentials or queued payloads. */
+    diagnostics() {
+      return { ...journal.diagnostics(), enabled: enabled(), rejected_payloads: rejected, collector_dropped: dropped, anonymous_id_storage: anonymousStorage };
+    },
+    /** Stops the runtime and requests; consent revocation is the separate purge operation. */
+    async destroy() {
+      destroyed = true;
+      generation++;
+      detach();
+      if (policyTimer) clearInterval(policyTimer);
+      policyTimer = null;
+      popup.destroy();
+      client.destroy();
+      if (typeof window !== "undefined") window.removeEventListener("online", online);
+      await journal.close();
+      if (instances.get(scope) === addon) instances.delete(scope);
+    }
+  };
+  instances.set(scope, addon);
+  return addon;
+}
+export {
+  createSagepilotWebEvents
+};
+//# sourceMappingURL=index.js.map