@usethrottle/catalog 0.1.1 → 1.1.0

package/dist/admin.js

@@ -0,0 +1,681 @@
+import {
+  CartLineError,
+  CatalogError,
+  CustomerTokenInvalidError,
+  DEFAULT_BASE_URL,
+  FeatureUnavailableError,
+  NetworkError,
+  OriginNotAllowedError,
+  RATE_LIMIT_DEFAULT_RETRY_S,
+  RateLimitedError,
+  TimeoutError,
+  isCatalogError
+} from "./chunk-JK2UY4CD.js";
+import "./chunk-PKBMQBKP.js";
+
+// src/generated/push-types.ts
+var PUSH_ERRORS = {
+  AUTHENTICATION_FAILED: { statuses: [401], retryable: false },
+  VENDOR_PAUSED: { statuses: [403], retryable: false },
+  VENDOR_KEY_NOT_ALLOWED: { statuses: [403], retryable: false },
+  INVALID_REQUEST: { statuses: [400], retryable: false },
+  IDEMPOTENCY_KEY_REQUIRED: { statuses: [400], retryable: false },
+  NOT_FOUND: { statuses: [404], retryable: false },
+  PROFILE_NOT_FOUND: { statuses: [404], retryable: false },
+  VENDOR_NOT_FOUND: { statuses: [404], retryable: false },
+  IDEMPOTENCY_CONFLICT: { statuses: [409], retryable: false },
+  RUN_IN_PROGRESS: { statuses: [409], retryable: true },
+  JOB_CLOSED: { statuses: [409], retryable: false },
+  JOB_FULL: { statuses: [409], retryable: false },
+  TOO_MANY_OPEN_JOBS: { statuses: [409], retryable: true },
+  REPORT_TOO_LARGE: { statuses: [409], retryable: false },
+  HANDLE_TAKEN: { statuses: [409], retryable: false },
+  IDENTIFIER_LOCKED: { statuses: [409], retryable: false },
+  REPORT_EXPIRED: { statuses: [410], retryable: false },
+  REQUEST_BODY_TOO_LARGE: { statuses: [413], retryable: false },
+  MAPPING_INVALID: { statuses: [422], retryable: false },
+  RATE_LIMITED: { statuses: [429], retryable: true },
+  PUSH_QUEUE_FULL: { statuses: [429], retryable: true },
+  INTERNAL_ERROR: { statuses: [500], retryable: true },
+  INFRASTRUCTURE_UNAVAILABLE: { statuses: [503], retryable: true }
+};
+
+// src/admin/http.ts
+var MAX_IDEMPOTENCY_KEY = 200;
+var HEADER_SAFE = /^[\x21-\x7e]+$/u;
+var MAX_RETRY_AFTER_S = 86400;
+function invalidRequest(message) {
+  return new CatalogError({
+    code: "INVALID_REQUEST",
+    message,
+    statusCode: 0,
+    source: "client",
+    retryable: false
+  });
+}
+function clientError(code, message) {
+  return new CatalogError({
+    code,
+    message,
+    statusCode: 0,
+    source: "client",
+    retryable: false
+  });
+}
+function resolveIdempotencyKey(key) {
+  if (key === void 0) return globalThis.crypto.randomUUID();
+  if (typeof key !== "string" || key.length === 0 || key.length > MAX_IDEMPOTENCY_KEY || !HEADER_SAFE.test(key))
+    throw invalidRequest(
+      `idempotencyKey must be 1 to ${MAX_IDEMPOTENCY_KEY} visible characters with no spaces.`
+    );
+  return key;
+}
+function queryString(pairs) {
+  if (pairs === void 0 || pairs.length === 0) return "";
+  return `?${pairs.map(
+    ([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`
+  ).join("&")}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function issuesOf(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap(
+    (issue) => isRecord(issue) && typeof issue.path === "string" && typeof issue.message === "string" ? [{ path: issue.path, message: issue.message }] : []
+  );
+}
+function retryAfterOf(headers) {
+  const value = headers.get("retry-after")?.trim() ?? "";
+  if (!/^\d{1,6}$/u.test(value)) return null;
+  const seconds = Number(value);
+  return seconds <= MAX_RETRY_AFTER_S ? seconds : null;
+}
+function isPushCode(code) {
+  return Object.prototype.hasOwnProperty.call(PUSH_ERRORS, code);
+}
+function toError(status, headers, text) {
+  const body = parseJson(text);
+  const envelope = isRecord(body) && isRecord(body.error) ? body.error : void 0;
+  const code = typeof envelope?.code === "string" && envelope.code !== "" ? envelope.code : void 0;
+  const retryAfter = retryAfterOf(headers);
+  const requestId = typeof envelope?.requestId === "string" && envelope.requestId !== "" ? envelope.requestId : headers.get("x-request-id") ?? void 0;
+  const init = envelope !== void 0 && code !== void 0 ? {
+    code,
+    message: typeof envelope.message === "string" && envelope.message !== "" ? envelope.message : `Request failed with status ${status}.`,
+    statusCode: status,
+    source: "catalog",
+    retryable: isPushCode(code) ? PUSH_ERRORS[code].retryable : status === 429 || status === 503,
+    retryAfterSeconds: retryAfter,
+    issues: issuesOf(envelope.issues),
+    body,
+    requestId
+  } : {
+    code: "INVALID_RESPONSE",
+    message: `The server answered ${status} with an unreadable body.`,
+    statusCode: status,
+    source: "catalog",
+    retryAfterSeconds: retryAfter,
+    requestId
+  };
+  if (status === 429) {
+    return new RateLimitedError({
+      ...init,
+      retryable: true,
+      retryAfterSeconds: retryAfter !== null && retryAfter >= 1 ? retryAfter : RATE_LIMIT_DEFAULT_RETRY_S
+    });
+  }
+  return new CatalogError(init);
+}
+function guarded(work, callerSignal, timeoutMs) {
+  if (callerSignal?.aborted) return Promise.reject(callerSignal.reason);
+  const controller = new AbortController();
+  return new Promise((resolve, reject) => {
+    const finish = () => {
+      clearTimeout(timer);
+      callerSignal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      finish();
+      const reason = callerSignal?.reason;
+      controller.abort(reason);
+      reject(reason);
+    };
+    const timer = setTimeout(() => {
+      finish();
+      controller.abort();
+      reject(new TimeoutError({ timeoutMs }));
+    }, timeoutMs);
+    callerSignal?.addEventListener("abort", onAbort, { once: true });
+    work(controller.signal).then(
+      (value) => {
+        finish();
+        resolve(value);
+      },
+      (error) => {
+        finish();
+        reject(error);
+      }
+    );
+  });
+}
+function createHttp(key, baseUrl, fetchFn, timeoutMs) {
+  async function exchange(spec, accept) {
+    const headers = {
+      authorization: `Bearer ${key}`,
+      accept
+    };
+    let body;
+    if (spec.body !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(spec.body);
+    }
+    if (spec.idempotencyKey !== void 0)
+      headers["idempotency-key"] = spec.idempotencyKey;
+    const url = baseUrl + spec.path + queryString(spec.query);
+    const attempts = spec.idempotencyKey === void 0 ? 1 : 2;
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        return await guarded(
+          async (signal) => {
+            let response;
+            try {
+              response = await fetchFn(url, {
+                method: spec.method,
+                headers,
+                ...body === void 0 ? {} : { body },
+                signal
+              });
+            } catch (cause) {
+              throw new NetworkError({ cause });
+            }
+            try {
+              return {
+                status: response.status,
+                headers: response.headers,
+                text: await response.text()
+              };
+            } catch (cause) {
+              throw new NetworkError({ cause });
+            }
+          },
+          spec.signal,
+          timeoutMs
+        );
+      } catch (error) {
+        if (error instanceof NetworkError && attempt < attempts) continue;
+        throw error;
+      }
+    }
+  }
+  return {
+    keyKind: key.startsWith("pc_sk_") ? "store" : "vendor",
+    async json(spec) {
+      const answer = await exchange(spec, "application/json");
+      if (answer.status < 200 || answer.status >= 300)
+        throw toError(answer.status, answer.headers, answer.text);
+      const parsed = parseJson(answer.text);
+      if (parsed === void 0)
+        throw new CatalogError({
+          code: "INVALID_RESPONSE",
+          message: "The server answered with a body that is not JSON.",
+          statusCode: answer.status,
+          source: "catalog"
+        });
+      return parsed;
+    },
+    async text(spec) {
+      const answer = await exchange(spec, "text/csv");
+      if (answer.status < 200 || answer.status >= 300)
+        throw toError(answer.status, answer.headers, answer.text);
+      return answer.text;
+    }
+  };
+}
+
+// src/admin/inventory.ts
+function createInventory(http) {
+  return {
+    set: (rows) => http.json({
+      method: "PATCH",
+      path: "/v1/catalog/inventory",
+      body: { rows }
+    }),
+    async adjust(rows, options) {
+      const idempotencyKey = resolveIdempotencyKey(options?.idempotencyKey);
+      const adjusted = rows.map((row) => ({
+        ...row,
+        quantityMode: "adjust"
+      }));
+      return http.json({
+        method: "PATCH",
+        path: "/v1/catalog/inventory",
+        body: { rows: adjusted },
+        idempotencyKey
+      });
+    }
+  };
+}
+
+// src/admin/products.ts
+var REF_FIELDS = ["externalId", "sku", "handle"];
+function refQuery(ref) {
+  const record = ref;
+  const present = REF_FIELDS.filter((field2) => record[field2] !== void 0);
+  const [field] = present;
+  const value = field === void 0 ? void 0 : record[field];
+  if (present.length !== 1 || field === void 0 || typeof value !== "string" || value === "")
+    throw invalidRequest(
+      "A product ref is exactly one of externalId, sku or handle, as a non-empty string."
+    );
+  return [[field, value]];
+}
+function unreadable() {
+  return new CatalogError({
+    code: "INVALID_RESPONSE",
+    message: "The server answered with an unexpected shape.",
+    statusCode: 200,
+    source: "catalog"
+  });
+}
+function createProducts(http) {
+  const op = (name) => (refs) => http.json({
+    method: "POST",
+    path: `/v1/catalog/products/${name}`,
+    body: { products: refs }
+  });
+  return {
+    async get(ref) {
+      const answer = await http.json({
+        method: "GET",
+        path: "/v1/catalog/products",
+        query: refQuery(ref)
+      });
+      if ("product" in answer) return answer.product;
+      throw unreadable();
+    },
+    async list(options = {}) {
+      const query = [];
+      if (options.cursor !== void 0) query.push(["cursor", options.cursor]);
+      if (options.limit !== void 0)
+        query.push(["limit", String(options.limit)]);
+      const answer = await http.json({
+        method: "GET",
+        path: "/v1/catalog/products",
+        query
+      });
+      if ("products" in answer)
+        return { products: answer.products, nextCursor: answer.nextCursor };
+      throw unreadable();
+    },
+    archive: op("archive"),
+    restore: op("restore"),
+    async rename(ref, handle) {
+      const body = { product: ref, handle };
+      const answer = await http.json({
+        method: "POST",
+        path: "/v1/catalog/products/rename",
+        body
+      });
+      return answer.product;
+    }
+  };
+}
+
+// src/admin/runs.ts
+var MAX_BATCH_ROWS = 1e3;
+var MAX_BATCH_BYTES = 5e6;
+var ENVELOPE_BYTES = '{"rows":[]}'.length;
+var STOCK_PAGE_LIMIT = 500;
+var QUEUE_RETRIES = 3;
+var DEFAULT_INTERVAL_MS = 5e3;
+var DEFAULT_WAIT_MS = 864e5;
+function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function checkMode(mode) {
+  if (mode !== void 0 && mode !== "merge" && mode !== "replace")
+    throw invalidRequest("mode must be 'merge' or 'replace'.");
+}
+async function pollUntil(read, done, options = {}) {
+  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_MS;
+  if (!(intervalMs >= 0 && Number.isFinite(intervalMs)))
+    throw invalidRequest("intervalMs must be a finite number of 0 or more.");
+  if (!(timeoutMs > 0 && Number.isFinite(timeoutMs)))
+    throw invalidRequest("timeoutMs must be a finite number above 0.");
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const value = await read(options.signal);
+    if (done(value)) return value;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) throw new TimeoutError({ timeoutMs });
+    await sleep(Math.min(intervalMs, remaining), options.signal);
+  }
+}
+async function* stockRows(http, base) {
+  let cursor = null;
+  do {
+    const query = [];
+    if (cursor !== null) query.push(["cursor", cursor]);
+    query.push(["limit", String(STOCK_PAGE_LIMIT)]);
+    const page = await http.json({
+      method: "GET",
+      path: `${base}/stock`,
+      query
+    });
+    yield* page.rows;
+    cursor = page.nextCursor;
+  } while (cursor !== null);
+}
+var encode = (id) => encodeURIComponent(id);
+function createHandle(http, jobId) {
+  const base = `/v1/catalog/jobs/${encode(jobId)}`;
+  const read = async (options = {}, signal) => (await http.json({
+    method: "GET",
+    path: base,
+    ...options.includeBatches === true ? { query: [["include", "batches"]] } : {},
+    signal
+  })).job;
+  return {
+    jobId,
+    async send(rows, options) {
+      return http.json({
+        method: "POST",
+        path: `${base}/batches`,
+        body: { rows },
+        idempotencyKey: resolveIdempotencyKey(options?.idempotencyKey)
+      });
+    },
+    async close() {
+      return (await http.json({
+        method: "POST",
+        path: `${base}/close`
+      })).job;
+    },
+    get: (options) => read(options),
+    wait: (options) => pollUntil(
+      (signal) => read({}, signal),
+      (job) => job.finishedAt !== null || job.state === "expired",
+      options
+    ),
+    errorsCsv: () => http.text({ method: "GET", path: `${base}/errors.csv` }),
+    stockResults: () => stockRows(http, base),
+    stockCsv: () => http.text({ method: "GET", path: `${base}/stock.csv` })
+  };
+}
+function productKey(row) {
+  const record = row;
+  for (const field of ["productHandle", "externalId"]) {
+    const value = record[field];
+    if (typeof value === "string" && value !== "") return `${field}:${value}`;
+  }
+  return `sku:${String(record.sku)}`;
+}
+var utf8 = new TextEncoder();
+function createJobs(http) {
+  const open = async (options = {}) => {
+    checkMode(options.mode);
+    const body = {
+      ...options.mode === void 0 ? {} : { mode: options.mode },
+      ...options.fullSync === void 0 ? {} : { fullSync: options.fullSync }
+    };
+    const { job } = await http.json({
+      method: "POST",
+      path: "/v1/catalog/jobs",
+      body
+    });
+    return createHandle(http, job.jobId);
+  };
+  async function sendBatch(handle, rows, signal) {
+    const idempotencyKey = resolveIdempotencyKey(void 0);
+    for (let retry = 0; ; retry += 1) {
+      try {
+        await handle.send(rows, { idempotencyKey });
+        return;
+      } catch (error) {
+        if (!(error instanceof RateLimitedError) || retry >= QUEUE_RETRIES)
+          throw error;
+        await sleep(error.retryAfterSeconds * 1e3, signal);
+      }
+    }
+  }
+  return {
+    open,
+    async get(jobId) {
+      const handle = createHandle(http, jobId);
+      await handle.get();
+      return handle;
+    },
+    resume: (jobId) => createHandle(http, jobId),
+    async run(rows, options = {}) {
+      checkMode(options.mode);
+      const batchRows = options.batchRows ?? MAX_BATCH_ROWS;
+      if (!Number.isInteger(batchRows) || batchRows < 1 || batchRows > MAX_BATCH_ROWS)
+        throw invalidRequest(
+          "batchRows must be a whole number from 1 to 1,000."
+        );
+      let handle;
+      let batch = [];
+      let batchBytes = ENVELOPE_BYTES;
+      let group = [];
+      let groupBytes = 0;
+      let groupKey = "";
+      const flush = async () => {
+        if (batch.length === 0) return;
+        handle ?? (handle = await open({
+          ...options.mode === void 0 ? {} : { mode: options.mode },
+          ...options.fullSync === void 0 ? {} : { fullSync: options.fullSync }
+        }));
+        const sending = batch;
+        batch = [];
+        batchBytes = ENVELOPE_BYTES;
+        await sendBatch(handle, sending, options.signal);
+      };
+      const place = async () => {
+        if (batch.length > 0 && (batch.length + group.length > batchRows || batchBytes + groupBytes > MAX_BATCH_BYTES))
+          await flush();
+        batch.push(...group);
+        batchBytes += groupBytes;
+        group = [];
+        groupBytes = 0;
+      };
+      for await (const row of rows) {
+        const key = productKey(row);
+        if (group.length > 0 && key !== groupKey) await place();
+        groupKey = key;
+        group.push(row);
+        groupBytes += utf8.encode(JSON.stringify(row)).length + 1;
+        if (group.length > MAX_BATCH_ROWS)
+          throw invalidRequest(
+            `A product may have at most ${MAX_BATCH_ROWS} rows in a job.`
+          );
+      }
+      if (group.length > 0) await place();
+      await flush();
+      if (handle === void 0)
+        throw invalidRequest("jobs.run needs at least one row.");
+      await handle.close();
+      return handle;
+    }
+  };
+}
+function createBatches(http) {
+  return {
+    async send(rows, options = {}) {
+      checkMode(options.mode);
+      if (options.mode !== void 0 && http.keyKind === "store")
+        throw invalidRequest(
+          "batches.send ignores mode for a store key (pc_sk_): the store's /variants route has no replace. Use jobs.run({ mode }) or a vendor key (pc_vk_)."
+        );
+      return http.json({
+        method: "POST",
+        path: "/v1/catalog/variants",
+        ...options.mode === void 0 ? {} : { query: [["mode", options.mode]] },
+        body: { rows },
+        idempotencyKey: resolveIdempotencyKey(options.idempotencyKey)
+      });
+    }
+  };
+}
+function createRuns(http) {
+  const path = (runId) => `/v1/catalog/runs/${encode(runId)}`;
+  const get = async (runId, signal) => (await http.json({
+    method: "GET",
+    path: path(runId),
+    signal
+  })).run;
+  return {
+    get: (runId) => get(runId),
+    wait: (runId, options) => pollUntil(
+      (signal) => get(runId, signal),
+      (run) => run.status === "completed" || run.status === "failed",
+      options
+    ),
+    errorsCsv: (runId) => http.text({ method: "GET", path: `${path(runId)}/errors.csv` }),
+    stockResults: (runId) => stockRows(http, path(runId)),
+    stockCsv: (runId) => http.text({ method: "GET", path: `${path(runId)}/stock.csv` })
+  };
+}
+
+// src/admin/client.ts
+var ADMIN_DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_TIMEOUT_MS = 2147483647;
+function checkKey(key) {
+  if (typeof key === "string" && key.startsWith("pc_pk_")) {
+    throw clientError(
+      "INVALID_ADMIN_KEY",
+      "Publishable keys (pc_pk_) cannot use the admin API. Use a secret key (pc_sk_) or a vendor key (pc_vk_)."
+    );
+  }
+  if (typeof key !== "string" || !HEADER_SAFE.test(key) || !(key.startsWith("pc_sk_") || key.startsWith("pc_vk_"))) {
+    throw clientError(
+      "INVALID_ADMIN_KEY",
+      "key must be a secret key (pc_sk_) or a vendor key (pc_vk_), with no spaces."
+    );
+  }
+  return key;
+}
+function checkTimeout(timeoutMs) {
+  if (!(timeoutMs > 0 && Number.isFinite(timeoutMs)))
+    throw invalidRequest("timeoutMs must be a finite number above 0.");
+  return Math.min(timeoutMs, MAX_TIMEOUT_MS);
+}
+function assertServer() {
+  if (Reflect.get(globalThis, "window") !== void 0 && Reflect.get(globalThis, "document") !== void 0)
+    throw clientError(
+      "SERVER_ONLY",
+      "The admin client is server-only: it holds a secret or vendor key, which must never reach a browser."
+    );
+}
+function createCatalogAdmin(options) {
+  assertServer();
+  const key = checkKey(options.key);
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/u, "");
+  if (!/^https?:\/\/[^\s/]+/iu.test(baseUrl))
+    throw invalidRequest("baseUrl must be an absolute http or https URL.");
+  const http = createHttp(
+    key,
+    baseUrl,
+    options.fetch ?? globalThis.fetch.bind(globalThis),
+    checkTimeout(options.timeoutMs ?? ADMIN_DEFAULT_TIMEOUT_MS)
+  );
+  const jobs = createJobs(http);
+  return {
+    jobs,
+    batches: createBatches(http),
+    runs: createRuns(http),
+    products: createProducts(http),
+    inventory: createInventory(http)
+  };
+}
+
+// src/admin/webhooks.ts
+var HEX_SHA256 = /^[0-9a-fA-F]{64}$/u;
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var MAX_V1 = 8;
+var MAX_HEADER_BYTES = 1024;
+var encoder = new TextEncoder();
+async function hmac(secret, payload) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return new Uint8Array(
+    await crypto.subtle.sign("HMAC", key, encoder.encode(payload))
+  );
+}
+function fromHex(hex) {
+  return Uint8Array.from(
+    { length: hex.length / 2 },
+    (_, i) => Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16)
+  );
+}
+function constantTimeEqual(left, right) {
+  const length = Math.max(left.length, right.length);
+  let difference = left.length ^ right.length;
+  for (let i = 0; i < length; i += 1)
+    difference |= (left[i] ?? 0) ^ (right[i] ?? 0);
+  return difference === 0;
+}
+async function verifyCatalogWebhook(input) {
+  try {
+    const { secret, rawBody, signature } = input;
+    const now = input.now ?? Math.floor(Date.now() / 1e3);
+    const tolerance = input.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
+    if (secret.length === 0 || rawBody.length === 0 || signature.length === 0 || encoder.encode(signature).byteLength > MAX_HEADER_BYTES || !Number.isSafeInteger(now) || !Number.isSafeInteger(tolerance) || tolerance < 0)
+      return false;
+    const parts = signature.split(",").map((part) => part.split("="));
+    if (parts.some((part) => part.length !== 2)) return false;
+    const timestamps = parts.filter(([k]) => k === "t").map(([, v]) => v ?? "");
+    const digests = parts.filter(([k]) => k === "v1").map(([, v]) => v ?? "");
+    if (parts.some(([k]) => k !== "t" && k !== "v1") || timestamps.length !== 1 || digests.length === 0 || digests.length > MAX_V1 || digests.some((d) => !HEX_SHA256.test(d)))
+      return false;
+    const timestampText = timestamps[0] ?? "";
+    if (!/^(?:0|[1-9][0-9]*)$/u.test(timestampText)) return false;
+    const timestamp = Number(timestampText);
+    if (!Number.isSafeInteger(timestamp) || Math.abs(now - timestamp) > tolerance)
+      return false;
+    const expected = await hmac(secret, `${timestampText}.${rawBody}`);
+    let matched = false;
+    for (const digest of digests)
+      matched = constantTimeEqual(expected, fromHex(digest)) || matched;
+    return matched;
+  } catch {
+    return false;
+  }
+}
+export {
+  CartLineError,
+  CatalogError,
+  CustomerTokenInvalidError,
+  FeatureUnavailableError,
+  NetworkError,
+  OriginNotAllowedError,
+  RateLimitedError,
+  TimeoutError,
+  createCatalogAdmin,
+  isCatalogError,
+  verifyCatalogWebhook
+};

package/dist/{catalog-error-BWUoZCzY.d.ts → catalog-error-C_zLOtYA.d.ts}

@@ -1,4 +1,4 @@
-import { p as CatalogContractErrorCode } from './types-DYfIvIaI.js';
+import { g as CatalogContractErrorCode } from './contract-types-DhiThMEr.js';
 
 /**
  * Shared error type for every Throttle SDK.
@@ -239,5 +239,5 @@ declare class FeatureUnavailableError extends CatalogError {
 /** True for a `CatalogError` from this or any other copy of the SDK. */
 declare function isCatalogError(value: unknown): value is CatalogError;
 
-export { CartLineError as C, FeatureUnavailableError as F, NetworkError as N, OriginNotAllowedError as O, RateLimitedError as R, CatalogError as b, CustomerTokenInvalidError as h, TimeoutError as i, isCatalogError as j };
-export type { ThrottleCartCode as T, CartLineProblem as a, CatalogErrorCode as c, CatalogErrorInit as d, CatalogErrorIssue as e, CatalogErrorSource as f, ClientErrorCode as g };
+export { CartLineError as C, FeatureUnavailableError as F, NetworkError as N, OriginNotAllowedError as O, RateLimitedError as R, TimeoutError as T, CatalogError as b, CustomerTokenInvalidError as h, isCatalogError as i };
+export type { CartLineProblem as a, CatalogErrorCode as c, CatalogErrorInit as d, CatalogErrorIssue as e, CatalogErrorSource as f, ClientErrorCode as g, ThrottleCartCode as j };