@otskit/client 0.5.0 → 0.6.1

package/dist/browser.js

@@ -0,0 +1,742 @@
+// src/errors.ts
+var OpenTimestampsClientError = class extends Error {
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    if (options?.cause !== void 0)
+      this.cause = options.cause;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var ValidationError = class extends OpenTimestampsClientError {
+};
+var StampError = class extends OpenTimestampsClientError {
+  successfulSubmissions;
+  failedSubmissions;
+  constructor(message, successful, failed, options) {
+    super(message, options);
+    this.successfulSubmissions = successful;
+    this.failedSubmissions = failed;
+  }
+};
+var NetworkError = class extends OpenTimestampsClientError {
+  /** HTTP status code when the failure originates from an HTTP response. */
+  status;
+  constructor(message, options) {
+    super(message, options);
+    if (options?.status !== void 0) this.status = options.status;
+  }
+};
+var CircuitBreakerError = class extends NetworkError {
+  constructor(calendar) {
+    super(`Circuit breaker open for calendar: ${calendar}`);
+  }
+};
+var CommitmentNotFoundError = class extends NetworkError {
+};
+var CalendarResponseTooLargeError = class extends NetworkError {
+};
+var SizeLimitExceededError = class extends NetworkError {
+  maxBytes;
+  actualBytes;
+  constructor(maxBytes, actualBytes, options) {
+    super(
+      actualBytes === void 0 ? `Response size exceeds limit of ${maxBytes} bytes` : `Response size ${actualBytes} bytes exceeds limit of ${maxBytes} bytes`,
+      options
+    );
+    this.maxBytes = maxBytes;
+    if (actualBytes !== void 0) this.actualBytes = actualBytes;
+  }
+};
+
+// src/network/circuit-breaker.ts
+var CircuitBreaker = class {
+  constructor(options, logger) {
+    this.options = options;
+    this.logger = logger;
+  }
+  options;
+  logger;
+  circuits = /* @__PURE__ */ new Map();
+  /**
+   * Execute a request through the circuit breaker
+   */
+  async execute(key, fn) {
+    if (!this.options.enabled) {
+      return fn();
+    }
+    const circuit = this.getOrCreateCircuit(key);
+    if (circuit.state === "OPEN" /* OPEN */) {
+      const shouldAttemptRecovery = this.shouldAttemptRecovery(circuit);
+      if (shouldAttemptRecovery) {
+        this.logger?.info(`Circuit breaker for ${key} entering HALF_OPEN state`);
+        circuit.state = "HALF_OPEN" /* HALF_OPEN */;
+        circuit.stats.halfOpenAttempts = 0;
+      } else {
+        throw new CircuitBreakerError(key);
+      }
+    }
+    if (circuit.state === "HALF_OPEN" /* HALF_OPEN */) {
+      const maxAttempts = this.options.halfOpenMaxAttempts || 1;
+      if (circuit.stats.halfOpenAttempts >= maxAttempts) {
+        this.logger?.warn(`Circuit breaker for ${key} reopening after failed HALF_OPEN attempts`);
+        circuit.state = "OPEN" /* OPEN */;
+        circuit.stats.lastFailureTime = Date.now();
+        throw new CircuitBreakerError(key);
+      }
+      circuit.stats.halfOpenAttempts++;
+    }
+    try {
+      const result = await fn();
+      this.onSuccess(key, circuit);
+      return result;
+    } catch (error) {
+      const is4xx = error instanceof Error && error.retryable === false;
+      if (!is4xx) {
+        this.onFailure(key, circuit);
+      }
+      throw error;
+    }
+  }
+  getOrCreateCircuit(key) {
+    let circuit = this.circuits.get(key);
+    if (!circuit) {
+      circuit = {
+        state: "CLOSED" /* CLOSED */,
+        stats: {
+          consecutiveFailures: 0,
+          halfOpenAttempts: 0
+        }
+      };
+      this.circuits.set(key, circuit);
+    }
+    return circuit;
+  }
+  shouldAttemptRecovery(circuit) {
+    if (!circuit.stats.lastFailureTime) return false;
+    const elapsed = Date.now() - circuit.stats.lastFailureTime;
+    return elapsed >= this.options.recoveryTimeoutMs;
+  }
+  onSuccess(key, circuit) {
+    if (circuit.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.logger?.info(`Circuit breaker for ${key} closing after successful HALF_OPEN attempt`);
+      circuit.state = "CLOSED" /* CLOSED */;
+    }
+    circuit.stats.consecutiveFailures = 0;
+    circuit.stats.halfOpenAttempts = 0;
+  }
+  onFailure(key, circuit) {
+    circuit.stats.consecutiveFailures++;
+    circuit.stats.lastFailureTime = Date.now();
+    if (circuit.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.logger?.warn(`Circuit breaker for ${key} reopening after failed HALF_OPEN attempt`);
+      circuit.state = "OPEN" /* OPEN */;
+      return;
+    }
+    if (circuit.stats.consecutiveFailures >= this.options.failureThreshold) {
+      this.logger?.warn(
+        `Circuit breaker for ${key} opening after ${circuit.stats.consecutiveFailures} consecutive failures`
+      );
+      circuit.state = "OPEN" /* OPEN */;
+    }
+  }
+  /** Get current state for debugging/monitoring */
+  getState(key) {
+    return this.circuits.get(key)?.state;
+  }
+  /** Reset a specific circuit */
+  reset(key) {
+    this.circuits.delete(key);
+  }
+  /** Reset all circuits */
+  resetAll() {
+    this.circuits.clear();
+  }
+};
+
+// src/network/retry.ts
+function calculateDelay(attempt, options) {
+  const { strategy, initialDelayMs, maxDelayMs, jitter } = options.backoff;
+  let delay;
+  switch (strategy) {
+    case "exponential":
+      delay = initialDelayMs * Math.pow(2, attempt - 1);
+      break;
+    case "linear":
+      delay = initialDelayMs * attempt;
+      break;
+    case "constant":
+      delay = initialDelayMs;
+      break;
+  }
+  if (maxDelayMs && delay > maxDelayMs) {
+    delay = maxDelayMs;
+  }
+  switch (jitter) {
+    case "full":
+      delay = Math.random() * delay;
+      break;
+    case "equal":
+      delay = delay / 2 + Math.random() * (delay / 2);
+      break;
+    case "none":
+    default:
+      break;
+  }
+  return Math.floor(delay);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted"));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(new Error("Aborted"));
+    };
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function withRetry(fn, options, logger, signal) {
+  if (!options.enabled) {
+    return fn();
+  }
+  let lastError;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+    try {
+      logger?.debug(`Attempt ${attempt}/${options.maxAttempts}`);
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (signal?.aborted) {
+        throw lastError;
+      }
+      if (error.retryable === false) {
+        logger?.debug("Error is not retryable (4xx client error), failing immediately");
+        throw lastError;
+      }
+      if (attempt === options.maxAttempts) {
+        logger?.warn(`All ${options.maxAttempts} attempts failed`);
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, options);
+      logger?.debug(`Retry attempt ${attempt} failed, waiting ${delay}ms before next attempt`);
+      try {
+        await sleep(delay, signal);
+      } catch {
+        throw lastError;
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+
+// src/adapters/fetch-adapter.ts
+function getDeclaredContentLength(response) {
+  const value = response.headers.get("content-length");
+  if (value === null || !/^\d+$/.test(value)) return void 0;
+  const n = Number(value);
+  return Number.isSafeInteger(n) ? n : void 0;
+}
+async function readStreamLimited(body, maxBytes, status) {
+  const reader = body.getReader();
+  const buffer = new Uint8Array(maxBytes);
+  let received = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return buffer.subarray(0, received);
+      const next = received + value.byteLength;
+      if (next > maxBytes) {
+        await reader.cancel();
+        throw new SizeLimitExceededError(maxBytes, next, { status });
+      }
+      buffer.set(value, received);
+      received = next;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readResponseBody(response, maxBytes) {
+  const contentLength = getDeclaredContentLength(response);
+  if (contentLength !== void 0 && contentLength > maxBytes) {
+    throw new SizeLimitExceededError(maxBytes, contentLength, { status: response.status });
+  }
+  if (response.body === null) {
+    const ab = await response.arrayBuffer();
+    if (ab.byteLength > maxBytes) {
+      throw new SizeLimitExceededError(maxBytes, ab.byteLength, { status: response.status });
+    }
+    return new Uint8Array(ab);
+  }
+  return readStreamLimited(response.body, maxBytes, response.status);
+}
+async function executeRequest(request, maxBytes) {
+  try {
+    const response = await globalThis.fetch(request.url, {
+      method: request.method,
+      headers: { "Content-Type": "application/octet-stream", ...request.headers },
+      ...request.body !== void 0 ? { body: request.body } : {},
+      ...request.signal !== void 0 ? { signal: request.signal } : {},
+      redirect: "error"
+    });
+    const data = await readResponseBody(response, maxBytes);
+    return { ok: response.ok, status: response.status, statusText: response.statusText, data };
+  } catch (error) {
+    if (error instanceof SizeLimitExceededError) throw error;
+    if (error instanceof NetworkError) throw error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") throw new NetworkError("Request aborted", { cause: error });
+      if (error.message.includes("timeout"))
+        throw new NetworkError("Request timeout", { cause: error });
+      throw new NetworkError(`Network request failed: ${error.message}`, { cause: error });
+    }
+    throw new NetworkError("Unknown network error");
+  }
+}
+function createTimeoutController(timeoutMs, parentSignal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(new Error("Timeout")), timeoutMs);
+  const onParentAbort = () => {
+    clearTimeout(timeout);
+    parentSignal?.removeEventListener("abort", onParentAbort);
+    controller.abort(parentSignal?.reason);
+  };
+  controller.signal.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timeout);
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    },
+    { once: true }
+  );
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      clearTimeout(timeout);
+      controller.abort(parentSignal.reason);
+    } else {
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+  return controller;
+}
+
+// src/network/resilience.ts
+var ResilientNetworkLayer = class {
+  constructor(options, logger) {
+    this.options = options;
+    this.logger = logger;
+    this.circuitBreaker = new CircuitBreaker(options.circuitBreaker, logger);
+  }
+  options;
+  logger;
+  circuitBreaker;
+  /**
+   * Execute a request with full resilience pipeline
+   */
+  async request(calendarUrl, request, parentSignal) {
+    const startTime = Date.now();
+    const totalController = createTimeoutController(
+      this.options.totalTimeoutMs,
+      parentSignal
+    );
+    try {
+      return await this.circuitBreaker.execute(calendarUrl, async () => {
+        return await withRetry(
+          async () => {
+            const attemptController = createTimeoutController(
+              this.options.connectTimeoutMs,
+              totalController.signal
+            );
+            try {
+              const response = await executeRequest(
+                { ...request, signal: attemptController.signal },
+                this.options.maxResponseBytes ?? 1e5
+              );
+              const elapsed = Date.now() - startTime;
+              this.logger?.debug(`Request to ${calendarUrl} succeeded in ${elapsed}ms`);
+              if (!response.ok) {
+                if (response.status >= 400 && response.status < 500) {
+                  const error = new NetworkError(
+                    `HTTP ${response.status}: ${response.statusText}`,
+                    { status: response.status }
+                  );
+                  error.retryable = false;
+                  throw error;
+                }
+                throw new NetworkError(
+                  `HTTP ${response.status}: ${response.statusText}`,
+                  { status: response.status }
+                );
+              }
+              return response;
+            } finally {
+              attemptController.abort(new Error("Attempt complete"));
+            }
+          },
+          this.options.retries,
+          this.logger,
+          totalController.signal
+        );
+      });
+    } catch (error) {
+      const elapsed = Date.now() - startTime;
+      this.logger?.error(`Request to ${calendarUrl} failed after ${elapsed}ms`, error);
+      throw error;
+    } finally {
+      totalController.abort(new Error("Request complete"));
+    }
+  }
+  /** Get circuit breaker state for a calendar */
+  getCircuitState(calendarUrl) {
+    return this.circuitBreaker.getState(calendarUrl);
+  }
+  /** Reset circuit breaker for a calendar */
+  resetCircuit(calendarUrl) {
+    this.circuitBreaker.reset(calendarUrl);
+  }
+  /** Reset all circuit breakers */
+  resetAllCircuits() {
+    this.circuitBreaker.resetAll();
+  }
+};
+
+// src/core/stamp.ts
+import { DetachedTimestampFile, OpSHA256, OpAppend, makeMerkleTree } from "@otskit/core";
+
+// src/network/calendar.ts
+import {
+  Timestamp,
+  StreamDeserializationContext,
+  bytesToHex,
+  TRUSTED_CALENDAR_WHITELIST_PATTERNS,
+  DEFAULT_AGGREGATOR_URLS
+} from "@otskit/core";
+var MAX_CALENDAR_RESPONSE_SIZE = 1e4;
+function assertCommitment(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError("commitment must be a Uint8Array");
+  }
+  if (bytes.length === 0 || bytes.length > 64) {
+    throw new RangeError(`commitment length ${bytes.length} is out of range (1..64)`);
+  }
+}
+var OTS_HEADERS = {
+  Accept: "application/vnd.opentimestamps.v1",
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function joinUrl(base, path) {
+  return base.replace(/\/+$/, "") + path;
+}
+var CalendarClient = class {
+  constructor(url, networkLayer, logger) {
+    this.url = url;
+    this.networkLayer = networkLayer;
+    this.logger = logger;
+  }
+  url;
+  networkLayer;
+  logger;
+  /** Submits a digest to the calendar and returns the Timestamp that commits to it. */
+  async submit(digest, signal) {
+    assertCommitment(digest);
+    this.logger?.debug(`Submitting digest to ${this.url}/digest`);
+    const response = await this.networkLayer.request(
+      this.url,
+      { url: joinUrl(this.url, "/digest"), method: "POST", headers: OTS_HEADERS, body: digest },
+      signal
+    );
+    return this.#parseTimestamp(response.data, digest);
+  }
+  /** Asks the calendar for a more complete Timestamp for `commitment` (upgrade). */
+  async getTimestamp(commitment, signal) {
+    assertCommitment(commitment);
+    const path = `/timestamp/${bytesToHex(commitment)}`;
+    this.logger?.debug(`Querying ${this.url}${path}`);
+    let response;
+    try {
+      response = await this.networkLayer.request(
+        this.url,
+        { url: joinUrl(this.url, path), method: "GET", headers: OTS_HEADERS },
+        signal
+      );
+    } catch (err) {
+      if (err instanceof NetworkError && err.status === 404) {
+        throw new CommitmentNotFoundError(`calendar ${this.url} has no timestamp for the commitment yet`, {
+          cause: err
+        });
+      }
+      throw err;
+    }
+    return this.#parseTimestamp(response.data, commitment);
+  }
+  /** Deserializes the calendar response as a Timestamp committed to `commitment`. */
+  #parseTimestamp(data, commitment) {
+    if (data.length > MAX_CALENDAR_RESPONSE_SIZE) {
+      throw new CalendarResponseTooLargeError(
+        `calendar response of ${data.length} bytes exceeds limit ${MAX_CALENDAR_RESPONSE_SIZE}`
+      );
+    }
+    const ctx = new StreamDeserializationContext(data);
+    const timestamp = Timestamp.deserialize(ctx, commitment);
+    ctx.assertEof();
+    return timestamp;
+  }
+};
+function parseWhitelistPattern(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return void 0;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return void 0;
+  const hostname = parsed.hostname.toLowerCase();
+  const wildcardSuffix = hostname.startsWith("*.") ? hostname.slice(2) : void 0;
+  if (hostname.includes("*") && wildcardSuffix === void 0) return void 0;
+  if (wildcardSuffix !== void 0 && (wildcardSuffix.length === 0 || wildcardSuffix.includes("*"))) return void 0;
+  return {
+    protocol: parsed.protocol,
+    hostname,
+    port: parsed.port,
+    pathname: parsed.pathname,
+    ...wildcardSuffix !== void 0 ? { wildcardSuffix } : {}
+  };
+}
+function hostnameMatchesPattern(hostname, pattern) {
+  if (pattern.wildcardSuffix === void 0) return hostname === pattern.hostname;
+  if (!hostname.endsWith("." + pattern.wildcardSuffix)) return false;
+  const label = hostname.slice(0, -pattern.wildcardSuffix.length - 1);
+  return label.length > 0 && !label.includes(".");
+}
+var UrlWhitelist = class {
+  #patterns = /* @__PURE__ */ new Map();
+  constructor(urls) {
+    if (urls) {
+      for (const u of urls) this.add(u);
+    }
+  }
+  /**
+   * Adds a pattern. If the URL has no scheme, both http:// and https:// variants are added.
+   * Throws TypeError if the pattern is not a valid string or is structurally invalid.
+   */
+  add(url) {
+    if (typeof url !== "string") {
+      throw new TypeError("UrlWhitelist: URL must be a string");
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      const pattern = parseWhitelistPattern(url);
+      if (pattern === void 0) {
+        throw new TypeError(`UrlWhitelist: invalid or unsupported pattern: "${url}"`);
+      }
+      this.#patterns.set(url, pattern);
+    } else {
+      this.add("http://" + url);
+      this.add("https://" + url);
+    }
+  }
+  /** Returns true if `url` matches any pattern in the allowlist. */
+  contains(url) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return false;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+    if (parsed.search !== "" || parsed.hash !== "") return false;
+    const hostname = parsed.hostname.toLowerCase();
+    for (const pattern of this.#patterns.values()) {
+      if (parsed.protocol !== pattern.protocol || parsed.port !== pattern.port) continue;
+      if (parsed.pathname !== pattern.pathname) continue;
+      if (hostnameMatchesPattern(hostname, pattern)) return true;
+    }
+    return false;
+  }
+  toString() {
+    return `UrlWhitelist([${[...this.#patterns.keys()].join(", ")}])`;
+  }
+};
+var DEFAULT_CALENDAR_WHITELIST = new UrlWhitelist([...TRUSTED_CALENDAR_WHITELIST_PATTERNS]);
+var DEFAULT_AGGREGATORS = [...DEFAULT_AGGREGATOR_URLS];
+
+// src/utils/hex.ts
+function hexToBytes(hex) {
+  const clean = hex.trim().toLowerCase();
+  if (clean.length % 2 !== 0 || !/^[0-9a-f]*$/.test(clean)) throw new Error("Invalid hex string");
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToHex2(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+
+// src/core/shared.ts
+function validateHash(hash) {
+  if (typeof hash === "string") {
+    const hex = hash.trim().toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(hex)) {
+      throw new ValidationError("Hash must be a 64-character hex string (SHA-256)");
+    }
+    return hexToBytes(hex);
+  }
+  if (hash.length !== 32) {
+    throw new ValidationError("Hash must be exactly 32 bytes (SHA-256)");
+  }
+  return Uint8Array.from(hash);
+}
+function secureNonce(n) {
+  const bytes = new Uint8Array(n);
+  if (!globalThis.crypto?.getRandomValues) {
+    throw new Error("secure RNG unavailable: globalThis.crypto.getRandomValues is required");
+  }
+  globalThis.crypto.getRandomValues(bytes);
+  return bytes;
+}
+
+// src/core/stamp.ts
+async function orchestrateStamp(hash, calendars, networkLayer, validateCalendarUrl, logger, signal, minimumSuccessfulSubmissions = 2) {
+  if (calendars.length === 0) {
+    throw new ValidationError("at least one calendar is required to stamp");
+  }
+  if (!Number.isInteger(minimumSuccessfulSubmissions) || minimumSuccessfulSubmissions < 1) {
+    throw new ValidationError("minimumSuccessfulSubmissions must be an integer >= 1");
+  }
+  if (minimumSuccessfulSubmissions > calendars.length) {
+    throw new ValidationError(
+      `minimumSuccessfulSubmissions (${minimumSuccessfulSubmissions}) cannot exceed the number of calendars (${calendars.length})`
+    );
+  }
+  await Promise.all(calendars.map((url) => validateCalendarUrl(url)));
+  const digest = validateHash(hash);
+  logger?.info(`Starting stamp for ${bytesToHex2(digest)}`);
+  const detached = DetachedTimestampFile.fromHash(new OpSHA256(), digest);
+  const nonceAppended = detached.timestamp.add(new OpAppend(secureNonce(16)));
+  const merkleRoot = nonceAppended.add(new OpSHA256());
+  const merkleTip = makeMerkleTree([merkleRoot]);
+  const results = await Promise.allSettled(
+    calendars.map(
+      (url) => new CalendarClient(url, networkLayer, logger).submit(merkleTip.getDigest(), signal)
+    )
+  );
+  const successful = [];
+  const failed = [];
+  results.forEach((r, i) => {
+    const calendar = calendars[i];
+    if (r.status === "fulfilled") {
+      merkleTip.merge(r.value);
+      successful.push({ calendar });
+      logger?.info(`Submitted to ${calendar}`);
+    } else {
+      const error = r.reason instanceof Error ? r.reason : new Error(String(r.reason));
+      failed.push({ calendar, error });
+      logger?.warn(`Failed to submit to ${calendar}: ${error.message}`);
+    }
+  });
+  if (successful.length < minimumSuccessfulSubmissions) {
+    throw new StampError(
+      `Insufficient successful submissions (${successful.length}/${minimumSuccessfulSubmissions} required)`,
+      successful,
+      failed
+    );
+  }
+  return detached.serializeToBytes();
+}
+
+// src/security/ssrf-web.ts
+async function assertSafeCalendarUrlStructural(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ValidationError(`Calendar URL is not valid: "${url}"`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new ValidationError(`Calendar URL must use https: "${url}"`);
+  }
+  if (parsed.username || parsed.password) {
+    throw new ValidationError(`Calendar URL must not contain embedded credentials: "${url}"`);
+  }
+}
+
+// src/types.ts
+import { DEFAULT_CALENDAR_URLS } from "@otskit/core";
+var DEFAULT_CALENDARS = [...DEFAULT_CALENDAR_URLS];
+var DEFAULT_RESILIENCE = {
+  totalTimeoutMs: 3e4,
+  connectTimeoutMs: 5e3,
+  retries: {
+    enabled: true,
+    maxAttempts: 3,
+    backoff: {
+      strategy: "exponential",
+      initialDelayMs: 200,
+      maxDelayMs: 5e3,
+      jitter: "full"
+    }
+  },
+  circuitBreaker: {
+    enabled: true,
+    failureThreshold: 5,
+    recoveryTimeoutMs: 15e3,
+    halfOpenMaxAttempts: 1
+  }
+};
+
+// src/utils/hash-web.ts
+async function hashBytes(data) {
+  return new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", data));
+}
+async function hashBlob(blob) {
+  return hashBytes(new Uint8Array(await blob.arrayBuffer()));
+}
+
+// src/browser.ts
+var BROWSER_CALENDARS = [
+  "https://a.pool.opentimestamps.org",
+  "https://b.pool.opentimestamps.org",
+  "https://a.pool.eternitywall.com"
+];
+var OpenTimestampsBrowserClient = class {
+  // Immutable allowlist: no arbitrary-URL option is exposed on purpose. An attacker-supplied URL
+  // could make a visitor's browser fire requests into their own local network (CORS blocks
+  // reading the response, not sending the request).
+  calendars = [...BROWSER_CALENDARS];
+  minSubs;
+  layer;
+  logger;
+  constructor(options = {}) {
+    this.minSubs = options.minimumSuccessfulSubmissions ?? 2;
+    if (options.logger !== void 0) this.logger = options.logger;
+    this.layer = new ResilientNetworkLayer(DEFAULT_RESILIENCE, this.logger);
+  }
+  /** hash: 32-byte Uint8Array or 64-char hex. Returns the pending .ots as Uint8Array. */
+  stamp(hash) {
+    return orchestrateStamp(
+      hash,
+      this.calendars,
+      this.layer,
+      assertSafeCalendarUrlStructural,
+      this.logger,
+      void 0,
+      this.minSubs
+    );
+  }
+};
+export {
+  BROWSER_CALENDARS,
+  OpenTimestampsBrowserClient,
+  bytesToHex2 as bytesToHex,
+  hashBlob,
+  hashBytes
+};