@decdn/client 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1409 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DecdnClient: () => DecdnClient,
+  DecdnError: () => DecdnError,
+  DecdnResponse: () => DecdnResponse,
+  LoopbackApi: () => LoopbackApi,
+  MAX_MANIFEST_BYTES: () => MAX_MANIFEST_BYTES,
+  PointerApi: () => PointerApi,
+  SCHEME: () => SCHEME,
+  base32ToHash: () => base32ToHash,
+  blake3Hex: () => blake3Hex,
+  createBlake3: () => createBlake3,
+  formatUri: () => formatUri,
+  hashToBase32: () => hashToBase32,
+  parseCapability: () => parseCapability,
+  parseManifest: () => parseManifest,
+  parseUri: () => parseUri,
+  pointerSigningHash: () => pointerSigningHash,
+  pointerTypedData: () => pointerTypedData,
+  recoverPointerSigner: () => recoverPointerSigner,
+  signPointer: () => signPointer
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/errors.ts
+var DecdnError = class extends Error {
+  name = "DecdnError";
+  code;
+  status;
+  retryAfterSecs;
+  fallbackUri;
+  size;
+  seq;
+  body;
+  constructor(code, message, details = {}) {
+    super(
+      message,
+      details.cause === void 0 ? void 0 : { cause: details.cause }
+    );
+    this.code = code;
+    if (details.status !== void 0) this.status = details.status;
+    if (details.retryAfterSecs !== void 0)
+      this.retryAfterSecs = details.retryAfterSecs;
+    if (details.fallbackUri !== void 0)
+      this.fallbackUri = details.fallbackUri;
+    if (details.size !== void 0) this.size = details.size;
+    if (details.seq !== void 0) this.seq = details.seq;
+    if (details.body !== void 0) this.body = details.body;
+  }
+};
+
+// src/hex.ts
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function fromHex(hex) {
+  if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) return void 0;
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++)
+    out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+  return out;
+}
+function isHash(s) {
+  return /^[0-9a-fA-F]{64}$/.test(s);
+}
+
+// src/uri.ts
+var SCHEME = "decdn:";
+var U64_MAX = (1n << 64n) - 1n;
+function bad(message) {
+  return new DecdnError("BAD_URI", message);
+}
+function isPchar(b) {
+  return b >= 48 && b <= 57 || b >= 65 && b <= 90 || b >= 97 && b <= 122 || "-._~!$&'()*+,;=:@".includes(String.fromCharCode(b));
+}
+function hexValue(c) {
+  return c !== void 0 && /^[0-9a-fA-F]$/.test(c) ? parseInt(c, 16) : void 0;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function decodeSegment(segment) {
+  const out = [];
+  for (let i = 0; i < segment.length; i++) {
+    const c = segment.charCodeAt(i);
+    if (c === 37) {
+      const hi = hexValue(segment[i + 1]);
+      const lo = hexValue(segment[i + 2]);
+      if (hi === void 0 || lo === void 0) {
+        throw bad("invalid bundle entry path in decdn URI: bad `%` escape");
+      }
+      out.push(hi << 4 | lo);
+      i += 2;
+    } else if (c < 128 && isPchar(c)) {
+      out.push(c);
+    } else {
+      throw bad(
+        `invalid bundle entry path in decdn URI: character ${JSON.stringify(segment[i])} must be percent-encoded`
+      );
+    }
+  }
+  try {
+    return utf8.decode(new Uint8Array(out));
+  } catch {
+    throw bad("invalid bundle entry path in decdn URI: not UTF-8 once decoded");
+  }
+}
+function decodePath(raw) {
+  const segments = raw.split("/").map((segment) => {
+    const decoded = decodeSegment(segment);
+    let why;
+    if (decoded === "")
+      why = "empty segment (a leading, trailing or doubled `/` inside the path)";
+    else if (decoded === "." || decoded === "..")
+      why = `\`${decoded}\` segment`;
+    else if (decoded.includes("/")) why = "encoded `/` (`%2F`) in a segment";
+    else if (decoded.includes("\0")) why = "NUL byte";
+    if (why !== void 0)
+      throw bad(`invalid bundle entry path in decdn URI: ${why}`);
+    return decoded;
+  });
+  return segments.join("/");
+}
+function badNamespace(why) {
+  return bad(
+    `invalid namespace in decdn URI (${why}): expected \`ns=<id>\` with a decimal id of at least 1; omit \`ns\` for no namespace`
+  );
+}
+function badQuery(why) {
+  return bad(`invalid query in decdn URI (${why}): the only key is \`ns\``);
+}
+function parseQuery(query) {
+  let namespace;
+  for (const pair of query.split("&")) {
+    const eq = pair.indexOf("=");
+    if (eq < 0) throw badQuery(`\`${pair}\` is not \`key=value\``);
+    const key = pair.slice(0, eq);
+    const value = pair.slice(eq + 1);
+    if (key !== "ns") throw badQuery(`unknown key \`${key}\``);
+    if (namespace !== void 0) throw badQuery("`ns` given twice");
+    if (!/^[0-9]+$/.test(value))
+      throw badNamespace(`\`${value}\` is not a decimal id`);
+    const id = BigInt(value);
+    if (id > U64_MAX) throw badNamespace(`\`${value}\` is out of range`);
+    if (id === 0n) throw badNamespace("0 means no namespace");
+    namespace = id;
+  }
+  if (namespace === void 0) throw badQuery("empty query");
+  return namespace;
+}
+function parseUri(s) {
+  if (!s.startsWith(SCHEME))
+    throw bad("not a decdn URI: expected `decdn:<hash>`");
+  const rest = s.slice(SCHEME.length);
+  if (rest.startsWith("//")) {
+    throw bad(
+      "a decdn URI has no `//`: write `decdn:<hash>`, not `decdn://<hash>`"
+    );
+  }
+  const q = rest.indexOf("?");
+  const body = q < 0 ? rest : rest.slice(0, q);
+  const query = q < 0 ? void 0 : rest.slice(q + 1);
+  const slash = body.indexOf("/");
+  const hash = slash < 0 ? body : body.slice(0, slash);
+  const path = slash < 0 ? void 0 : body.slice(slash + 1);
+  if (!isHash(hash)) {
+    const why = hash.length !== 64 ? `${hash.length} characters` : "not hex";
+    throw bad(
+      `invalid hash in decdn URI (${why}): expected 64 hex characters with no \`b3:\` or \`0x\` prefix`
+    );
+  }
+  const uri = { hash: hash.toLowerCase(), kind: "blob" };
+  if (path === "") uri.kind = "bundle";
+  else if (path !== void 0) {
+    uri.kind = "entry";
+    uri.path = decodePath(path);
+  }
+  if (query !== void 0) uri.namespace = parseQuery(query);
+  return uri;
+}
+function encodeSegment(segment) {
+  let out = "";
+  for (const b of new TextEncoder().encode(segment)) {
+    out += isPchar(b) ? String.fromCharCode(b) : `%${b.toString(16).toUpperCase().padStart(2, "0")}`;
+  }
+  return out;
+}
+function formatUri(uri) {
+  let out = SCHEME + uri.hash.toLowerCase();
+  if (uri.kind === "bundle") out += "/";
+  else if (uri.kind === "entry") {
+    for (const segment of (uri.path ?? "").split("/"))
+      out += `/${encodeSegment(segment)}`;
+  }
+  if (uri.namespace !== void 0) out += `?ns=${uri.namespace}`;
+  return out;
+}
+
+// src/base32.ts
+var ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+var LABEL_LEN = 52;
+function hashToBase32(hash) {
+  const bytes = isHash(hash) ? fromHex(hash) : void 0;
+  if (bytes === void 0)
+    throw new DecdnError("BAD_URI", `not a 64-hex-character hash: ${hash}`);
+  let out = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const b of bytes) {
+    buffer = buffer << 8 | b;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      out += ALPHABET[buffer >> bits & 31];
+    }
+  }
+  if (bits > 0) out += ALPHABET[buffer << 5 - bits & 31];
+  return out;
+}
+function base32ToHash(label) {
+  if (label.length !== LABEL_LEN || !/^[a-z2-7]+$/.test(label))
+    return void 0;
+  const out = new Uint8Array(32);
+  let buffer = 0;
+  let bits = 0;
+  let n = 0;
+  for (const c of label) {
+    buffer = (buffer << 5 | ALPHABET.indexOf(c)) & 4095;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      out[n++] = buffer >> bits & 255;
+    }
+  }
+  if ((buffer & (1 << bits) - 1) !== 0) return void 0;
+  return toHex(out);
+}
+
+// src/hash.ts
+var import_blake3 = require("@noble/hashes/blake3.js");
+function blake3Hex(bytes) {
+  return toHex((0, import_blake3.blake3)(bytes));
+}
+function createBlake3() {
+  const state = import_blake3.blake3.create();
+  return {
+    update(chunk) {
+      state.update(chunk);
+    },
+    hex() {
+      return toHex(state.digest());
+    }
+  };
+}
+
+// src/manifest.ts
+var MAX_MANIFEST_BYTES = 64 * 1024 * 1024;
+function malformed(message) {
+  return new DecdnError("MALFORMED_MANIFEST", message);
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSize(v) {
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+}
+function parseHash(s) {
+  if (typeof s !== "string") return void 0;
+  const hex = s.startsWith("0x") ? s.slice(2) : s.startsWith("b3:") ? s.slice(3) : s;
+  return isHash(hex) ? hex.toLowerCase() : void 0;
+}
+function parseEntry(raw, i) {
+  if (!isRecord(raw) || typeof raw.path !== "string") {
+    throw malformed(`bundle entry ${i} has no string \`path\``);
+  }
+  const path = raw.path;
+  const named = JSON.stringify(path);
+  const hash = parseHash(raw.hash);
+  if (hash === void 0) {
+    throw malformed(
+      `bundle entry ${named} has a malformed hash: ${JSON.stringify(raw.hash)}`
+    );
+  }
+  const entry = { path, hash };
+  if (raw.size !== void 0 && raw.size !== null) {
+    if (!isSize(raw.size))
+      throw malformed(`bundle entry ${named} has a malformed size`);
+    entry.size = raw.size;
+  }
+  if (raw.chunks !== void 0 && raw.chunks !== null) {
+    if (!Array.isArray(raw.chunks))
+      throw malformed(`bundle entry ${named} has malformed chunks`);
+    entry.chunks = raw.chunks.map((c, n) => {
+      const chunkHash = isRecord(c) ? parseHash(c.hash) : void 0;
+      if (!isRecord(c) || chunkHash === void 0) {
+        throw malformed(
+          `bundle entry ${named} has a malformed chunk ${n} hash`
+        );
+      }
+      if (!isSize(c.size))
+        throw malformed(
+          `bundle entry ${named} has a malformed chunk ${n} size`
+        );
+      return { hash: chunkHash, size: c.size };
+    });
+  }
+  return entry;
+}
+function parseManifest(bytes, expectedHash) {
+  const hash = blake3Hex(bytes);
+  if (expectedHash !== void 0 && hash !== expectedHash.toLowerCase()) {
+    throw new DecdnError(
+      "HASH_MISMATCH",
+      `bundle manifest hashes to ${hash}, not ${expectedHash.toLowerCase()}`
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch (e) {
+    throw new DecdnError(
+      "MALFORMED_MANIFEST",
+      "parse bundle JSON (expected v1 manifest)",
+      {
+        cause: e
+      }
+    );
+  }
+  if (!isRecord(json) || typeof json.version !== "number" || !Array.isArray(json.entries)) {
+    throw malformed(
+      "parse bundle JSON (expected v1 manifest): missing `version` or `entries`"
+    );
+  }
+  if (json.version !== 1) {
+    throw malformed(
+      `unsupported bundle version ${json.version} (this SDK supports v1)`
+    );
+  }
+  return { hash, entries: json.entries.map(parseEntry) };
+}
+
+// src/capability.ts
+var PREFIX = "dcap1:";
+var B64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function bad2(message) {
+  return new DecdnError("BAD_CAPABILITY", message);
+}
+function fromBase64Url(body) {
+  const out = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const c of body) {
+    const v = B64URL.indexOf(c);
+    if (v < 0) throw bad2("capability token body is not valid base64url");
+    buffer = (buffer << 6 | v) & 65535;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out.push(buffer >> bits & 255);
+    }
+  }
+  if (body.length % 4 === 1 || (buffer & (1 << bits) - 1) !== 0) {
+    throw bad2("capability token body is not valid base64url");
+  }
+  return new Uint8Array(out);
+}
+var Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  bytes;
+  at = 0;
+  varint() {
+    let value = 0n;
+    for (let shift = 0n; shift < 70n; shift += 7n) {
+      const b = this.bytes[this.at++];
+      if (b === void 0) throw truncated();
+      value |= BigInt(b & 127) << shift;
+      if ((b & 128) === 0) {
+        if (value >= 1n << 64n) throw truncated();
+        return value;
+      }
+    }
+    throw truncated();
+  }
+  bytesOf(len) {
+    const n = Number(this.varint());
+    if (len !== void 0 && n !== len) throw truncated();
+    if (this.at + n > this.bytes.length) throw truncated();
+    const out = this.bytes.subarray(this.at, this.at + n);
+    this.at += n;
+    return out;
+  }
+  done() {
+    return this.at === this.bytes.length;
+  }
+};
+function truncated() {
+  return bad2("capability token payload is malformed (truncated or corrupt)");
+}
+function parseCapability(token) {
+  if (!token.startsWith(PREFIX)) {
+    throw bad2("not a dcap1 capability token (missing the `dcap1:` prefix)");
+  }
+  const r = new Reader(fromBase64Url(token.slice(PREFIX.length)));
+  const capability = {
+    poolId: `0x${toHex(r.bytesOf(32))}`,
+    signer: `0x${toHex(r.bytesOf(20))}`,
+    spendingCap: r.varint(),
+    expiry: r.varint(),
+    ownerSignature: `0x${toHex(r.bytesOf())}`
+  };
+  if (!r.done()) throw truncated();
+  return capability;
+}
+
+// src/http.ts
+var CODES = {
+  400: "BAD_URI",
+  401: "UNAUTHORIZED",
+  402: "PAYMENT_REQUIRED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  409: "CONFLICT",
+  413: "PAYLOAD_TOO_LARGE",
+  416: "RANGE_NOT_SATISFIABLE",
+  422: "UNPROCESSABLE",
+  429: "RATE_LIMITED",
+  502: "UPSTREAM",
+  503: "POOL_UNFUNDED"
+};
+async function send(fetch, url, init) {
+  try {
+    return await fetch(url, init);
+  } catch (e) {
+    if (init.signal?.aborted) throw init.signal.reason ?? e;
+    throw new DecdnError(
+      "NETWORK",
+      `cannot reach ${new URL(url).origin}: ${e.message}`,
+      {
+        cause: e
+      }
+    );
+  }
+}
+function linkUri(link) {
+  if (link === null) return void 0;
+  const m = /<(decdn:[^>]+)>\s*;\s*rel="?alternate"?/.exec(link);
+  return m?.[1];
+}
+async function errorOf(response) {
+  const status = response.status;
+  const code = CODES[status] ?? "HTTP";
+  let body = "";
+  try {
+    body = await response.text();
+  } catch {
+  }
+  const details = { status };
+  let message = body.trim();
+  if (message !== "") details.body = message;
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter !== null && /^\d+$/.test(retryAfter.trim()))
+    details.retryAfterSecs = Number(retryAfter.trim());
+  const link = linkUri(response.headers.get("link"));
+  if (link !== void 0) details.fallbackUri = link;
+  if ((response.headers.get("content-type") ?? "").startsWith("application/json")) {
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed === "object" && parsed !== null) {
+        const o = parsed;
+        if (typeof o.error === "string") message = o.error;
+        if (typeof o.uri === "string") details.fallbackUri = o.uri;
+        if (typeof o.retry_after_secs === "number")
+          details.retryAfterSecs = o.retry_after_secs;
+      }
+      const seq = /"seq"\s*:\s*(\d+)/.exec(body)?.[1];
+      if (seq !== void 0) details.seq = BigInt(seq);
+    } catch {
+    }
+  }
+  if (status === 416) {
+    const size = /^bytes \*\/(\d+)$/.exec(
+      response.headers.get("content-range") ?? ""
+    )?.[1];
+    if (size !== void 0) details.size = Number(size);
+  }
+  return new DecdnError(
+    code,
+    message === "" ? `gateway answered ${status}` : message,
+    details
+  );
+}
+function parseWithBigInts(text, fields) {
+  const names = fields.join("|");
+  const quoted = text.replace(
+    new RegExp(`("(?:${names})"\\s*:\\s*)(\\d+)`, "g"),
+    '$1"$2"'
+  );
+  return JSON.parse(
+    quoted,
+    (key, value) => fields.includes(key) && typeof value === "string" && /^\d+$/.test(value) ? BigInt(value) : value
+  );
+}
+
+// src/loopback.ts
+var LoopbackApi = class {
+  /** @internal */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async call(method, path, body) {
+    if (this.client.context !== "loopback") {
+      throw new DecdnError(
+        "CONFIG",
+        "the delegate and capability API is a loopback gateway's alone"
+      );
+    }
+    const init = {
+      method,
+      headers: { ...this.client.authHeaders() }
+    };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+      init.headers["content-type"] = "application/json";
+    }
+    const response = await send(
+      this.client.fetch,
+      `${this.client.origin}${path}`,
+      init
+    );
+    if (response.status < 200 || response.status > 299)
+      throw await errorOf(response);
+    return response.text();
+  }
+  /** A fresh delegate key the gateway holds for 15 minutes unless a capability claims it. */
+  async delegate() {
+    const parsed = JSON.parse(await this.call("GET", "/_delegate"));
+    return { address: parsed.address };
+  }
+  /** Register `capability` (a `dcap1:` issued to a delegate) for `scope`: `example.com`, `*.example.com` or `*`. */
+  async registerCapability(args) {
+    const text = await this.call("PUT", "/_capability", {
+      capability: args.capability,
+      scope: args.scope
+    });
+    return parseWithBigInts(text, ["expiry"]);
+  }
+  /** The capabilities the gateway holds. Needs the token. */
+  async capabilities() {
+    const text = await this.call("GET", "/_capability");
+    return parseWithBigInts(text, ["cap", "expiry"]);
+  }
+};
+
+// src/mime.ts
+var REWRITTEN = /\.(html?|hxt|shtml|css)$/i;
+function rewritten(path) {
+  return REWRITTEN.test(path);
+}
+var TYPES = {
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  json: "application/json",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  xml: "text/xml",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  wasm: "application/wasm",
+  pdf: "application/pdf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  ogg: "audio/ogg",
+  woff: "font/woff",
+  woff2: "font/woff2"
+};
+function siteType(path) {
+  const ext = /\.([^./]+)$/.exec(path)?.[1]?.toLowerCase() ?? "";
+  const t = TYPES[ext] ?? "application/octet-stream";
+  return t.startsWith("text/") ? `${t}; charset=utf-8` : t;
+}
+
+// src/pointer.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_sha3 = require("@noble/hashes/sha3.js");
+var N = import_secp256k1.secp256k1.Point.CURVE().n;
+var U64_MAX2 = (1n << 64n) - 1n;
+var U256_MAX = (1n << 256n) - 1n;
+var enc = new TextEncoder();
+function integer(value, what) {
+  if (typeof value === "number" && !Number.isSafeInteger(value))
+    throw bad3(`${what} is an integer below 2^53, or a bigint: got ${value}`);
+  return BigInt(value);
+}
+function chainIdOf(domain) {
+  const id = integer(domain.chainId, "a chain id");
+  if (id < 1n || id > U256_MAX)
+    throw bad3("a chain id is a uint256 of at least 1");
+  return id;
+}
+function word(n) {
+  const bytes = n >= 0n && n <= U256_MAX ? fromHex(n.toString(16).padStart(64, "0")) : void 0;
+  if (bytes === void 0) throw bad3(`${n} does not fit a uint256`);
+  return bytes;
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+var DOMAIN_TYPE = (0, import_sha3.keccak_256)(
+  enc.encode(
+    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+  )
+);
+var POINTER_TYPE = (0, import_sha3.keccak_256)(
+  enc.encode("Pointer(uint256 namespaceId,bytes32 root,uint64 seq)")
+);
+function bad3(message) {
+  return new DecdnError("CONFIG", message);
+}
+function address(s) {
+  const bytes = /^0x[0-9a-fA-F]{40}$/.test(s) ? fromHex(s.slice(2)) : void 0;
+  if (bytes === void 0) throw bad3(`not an address: ${s}`);
+  return bytes;
+}
+function checked(p) {
+  if (p.namespace < 1n || p.namespace > U64_MAX2)
+    throw bad3("a namespace id is a u64 of at least 1");
+  if (p.seq < 0n || p.seq > U64_MAX2) throw bad3("a pointer seq is a u64");
+  const root = p.root.startsWith("0x") ? p.root.slice(2) : p.root;
+  const bytes = isHash(root) ? fromHex(root) : void 0;
+  if (bytes === void 0) throw bad3(`not a manifest hash: ${p.root}`);
+  return bytes;
+}
+function pointerTypedData(domain, pointer) {
+  const root = checked(pointer);
+  address(domain.publisherRegistry);
+  return {
+    domain: {
+      name: "decdn-pointer",
+      version: "1",
+      chainId: chainIdOf(domain),
+      verifyingContract: domain.publisherRegistry
+    },
+    types: {
+      Pointer: [
+        { name: "namespaceId", type: "uint256" },
+        { name: "root", type: "bytes32" },
+        { name: "seq", type: "uint64" }
+      ]
+    },
+    primaryType: "Pointer",
+    message: {
+      namespaceId: pointer.namespace,
+      root: `0x${toHex(root)}`,
+      seq: pointer.seq
+    }
+  };
+}
+function digest(domain, pointer) {
+  const root = checked(pointer);
+  const separator = (0, import_sha3.keccak_256)(
+    concat(
+      DOMAIN_TYPE,
+      (0, import_sha3.keccak_256)(enc.encode("decdn-pointer")),
+      (0, import_sha3.keccak_256)(enc.encode("1")),
+      word(chainIdOf(domain)),
+      concat(new Uint8Array(12), address(domain.publisherRegistry))
+    )
+  );
+  const struct = (0, import_sha3.keccak_256)(
+    concat(POINTER_TYPE, word(pointer.namespace), root, word(pointer.seq))
+  );
+  return (0, import_sha3.keccak_256)(concat(Uint8Array.of(25, 1), separator, struct));
+}
+function pointerSigningHash(domain, pointer) {
+  return `0x${toHex(digest(domain, pointer))}`;
+}
+function normalised(signature) {
+  const hex = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (!/^[0-9a-fA-F]{130}$/.test(hex))
+    throw new DecdnError("CONFIG", "the signer returned no 65-byte signature");
+  const r = hex.slice(0, 64);
+  let s = BigInt(`0x${hex.slice(64, 128)}`);
+  let parity = parseInt(hex.slice(128), 16);
+  parity = parity >= 27 ? parity - 27 : parity;
+  if (parity !== 0 && parity !== 1)
+    throw new DecdnError("CONFIG", "the signature's v is not 0, 1, 27 or 28");
+  if (s > N / 2n) {
+    s = N - s;
+    parity ^= 1;
+  }
+  return `0x${r.toLowerCase()}${s.toString(16).padStart(64, "0")}${(27 + parity).toString(16)}`;
+}
+async function signPointer(domain, pointer, signer) {
+  if ("privateKey" in signer) {
+    const key = typeof signer.privateKey === "string" ? fromHex(
+      signer.privateKey.startsWith("0x") ? signer.privateKey.slice(2) : signer.privateKey
+    ) : signer.privateKey;
+    if (key === void 0 || key.length !== 32)
+      throw bad3("a private key is 32 bytes");
+    const sig = import_secp256k1.secp256k1.sign(digest(domain, pointer), key, {
+      prehash: false,
+      lowS: true,
+      format: "recovered"
+    });
+    return normalised(`${toHex(sig.subarray(1))}${toHex(sig.subarray(0, 1))}`);
+  }
+  return normalised(
+    await signer.signTypedData(pointerTypedData(domain, pointer))
+  );
+}
+function recoverPointerSigner(domain, pointer, signature) {
+  const hex = signature.startsWith("0x") ? signature.slice(2) : signature;
+  const bytes = /^[0-9a-fA-F]{130}$/.test(hex) ? fromHex(hex) : void 0;
+  const v = bytes?.[64];
+  const malformed2 = () => new DecdnError("UNPROCESSABLE", "the pointer signature is malformed");
+  if (bytes === void 0 || v === void 0 || v !== 27 && v !== 28)
+    throw malformed2();
+  if (BigInt(`0x${hex.slice(64, 128)}`) > N / 2n) throw malformed2();
+  try {
+    const recovered = concat(Uint8Array.of(v - 27), bytes.subarray(0, 64));
+    const key = import_secp256k1.secp256k1.recoverPublicKey(recovered, digest(domain, pointer), {
+      prehash: false
+    });
+    const point = import_secp256k1.secp256k1.Point.fromBytes(key).toBytes(false);
+    return `0x${toHex((0, import_sha3.keccak_256)(point.subarray(1)).subarray(12))}`;
+  } catch {
+    throw malformed2();
+  }
+}
+var PointerApi = class {
+  /** @internal */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Sign a pointer from `namespace` to the bundle `root` (`decdn:<hash>/` or
+   * its manifest hash) and `PUT` it. `seq` defaults to the current Unix
+   * second; the gateway takes only a `seq` above the one it holds from the
+   * same signer. The signer must own the namespace on the `PublisherRegistry`
+   * of `open({ pointer })`.
+   */
+  async set(args) {
+    const domain = this.client.pointerDomain;
+    if (this.client.context !== "public")
+      throw bad3("namespace pointers live on a public gateway");
+    if (domain === void 0) {
+      throw bad3(
+        "pointer.set needs open({ pointer: { chainId, publisherRegistry } })"
+      );
+    }
+    let root = args.root.startsWith("0x") ? args.root.slice(2) : args.root;
+    if (root.startsWith(SCHEME)) {
+      const uri = parseUri(root);
+      if (uri.kind !== "bundle") {
+        throw new DecdnError(
+          "BAD_URI",
+          "a pointer names a bundle: pass `decdn:<hash>/`, the manifest hash with its trailing slash"
+        );
+      }
+      root = uri.hash;
+    } else if (!isHash(root)) {
+      throw new DecdnError("BAD_URI", `not a manifest hash: ${args.root}`);
+    }
+    const pointer = {
+      namespace: integer(args.namespace, "a namespace id"),
+      root: root.toLowerCase(),
+      seq: args.seq === void 0 ? BigInt(Math.floor(Date.now() / 1e3)) : integer(args.seq, "a pointer seq")
+    };
+    const signature = await signPointer(domain, pointer, args.signer);
+    const init = {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: `{"namespace":${pointer.namespace},"root":"0x${pointer.root}","seq":${pointer.seq},"signature":"${signature}"}`
+    };
+    if (args.signal !== void 0) init.signal = args.signal;
+    const response = await send(
+      this.client.fetch,
+      `${this.client.origin}/_pointer`,
+      init
+    );
+    if (response.status < 200 || response.status > 299)
+      throw await errorOf(response);
+    return parseWithBigInts(await response.text(), [
+      "namespace",
+      "seq"
+    ]);
+  }
+};
+
+// src/verify.ts
+function guard(body, opts) {
+  const reader = body?.getReader();
+  const hasher = opts.hash === void 0 ? void 0 : createBlake3();
+  let delivered = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      let chunk;
+      try {
+        chunk = reader === void 0 ? { done: true, value: void 0 } : await reader.read();
+      } catch (e) {
+        controller.error(
+          e instanceof DecdnError ? e : opts.signal?.aborted === true ? opts.signal.reason : new DecdnError("TRUNCATED", "the body ended early", {
+            cause: e
+          })
+        );
+        return;
+      }
+      if (!chunk.done) {
+        delivered += chunk.value.length;
+        if (opts.max !== void 0 && delivered > opts.max) {
+          controller.error(
+            new DecdnError(
+              "TRUNCATED",
+              `the body ran past the ${opts.max} bytes it may hold`
+            )
+          );
+          reader?.cancel().catch(() => void 0);
+          return;
+        }
+        hasher?.update(chunk.value);
+        controller.enqueue(chunk.value);
+        return;
+      }
+      if (opts.length !== void 0 && delivered < opts.length) {
+        controller.error(
+          new DecdnError(
+            "TRUNCATED",
+            `the body ended after ${delivered} of ${opts.length} bytes`
+          )
+        );
+        return;
+      }
+      if (hasher !== void 0 && opts.hash !== void 0) {
+        const got = hasher.hex();
+        if (got !== opts.hash) {
+          controller.error(
+            new DecdnError(
+              "HASH_MISMATCH",
+              `the body hashes to ${got}, not ${opts.hash}`
+            )
+          );
+          return;
+        }
+      }
+      controller.close();
+    },
+    cancel(reason) {
+      return reader?.cancel(reason);
+    }
+  });
+}
+async function collect(stream, limit) {
+  const reader = stream.getReader();
+  const parts = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.length;
+    if (limit !== void 0 && total > limit) {
+      await reader.cancel();
+      throw new DecdnError(
+        "MALFORMED_MANIFEST",
+        `the body is larger than ${limit} bytes`
+      );
+    }
+    parts.push(value);
+  }
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+
+// src/client.ts
+var DecdnResponse = class {
+  status;
+  headers;
+  url;
+  contentType;
+  contentLength;
+  contentRange;
+  /**
+   * `true`: the body is hashed as it streams, and ends with `HASH_MISMATCH`
+   * instead of `done` unless it hashes to the hash that names it.
+   * `"skipped"`: the bytes cannot be verified (a range, a rewritten page, a
+   * bundle listing). `false`: verification was turned off.
+   */
+  verified;
+  body;
+  /** @internal */
+  constructor(response, body, verified, contentType) {
+    this.status = response.status;
+    this.headers = response.headers;
+    this.url = response.url;
+    this.contentType = contentType ?? response.headers.get("content-type") ?? "application/octet-stream";
+    const length = response.headers.get("content-length");
+    if (length !== null && /^\d+$/.test(length))
+      this.contentLength = Number(length);
+    const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(
+      response.headers.get("content-range") ?? ""
+    );
+    if (range !== null) {
+      const [, a = "0", b = "0", size = "0"] = range;
+      this.contentRange = {
+        offset: Number(a),
+        length: Number(b) - Number(a) + 1,
+        size: Number(size)
+      };
+    }
+    this.verified = verified;
+    this.body = body;
+  }
+  /** The whole body. Rejects with `HASH_MISMATCH` or `TRUNCATED`. */
+  bytes() {
+    return collect(this.body);
+  }
+  async text() {
+    return new TextDecoder().decode(await this.bytes());
+  }
+  async json() {
+    return JSON.parse(await this.text());
+  }
+};
+var NAMESPACE_LABEL = /^[1-9][0-9]*$/;
+function siteOf(protocol, host, gatewayHost) {
+  const labels = host.split(".");
+  const origin = `${protocol}//${host}`;
+  const first = labels[0] ?? "";
+  const hash = base32ToHash(first);
+  if (hash !== void 0 && labels.length > 1) {
+    return { origin, protocol, suffix: labels.slice(1).join("."), hash };
+  }
+  const second = base32ToHash(labels[1] ?? "");
+  if (second !== void 0 && NAMESPACE_LABEL.test(first) && labels.length > 2) {
+    return {
+      origin,
+      protocol,
+      suffix: labels.slice(2).join("."),
+      hash: second,
+      namespace: BigInt(first)
+    };
+  }
+  if (gatewayHost !== void 0 && NAMESPACE_LABEL.test(first) && labels.slice(1).join(".") === gatewayHost) {
+    return { origin, protocol, suffix: gatewayHost, namespace: BigInt(first) };
+  }
+  return void 0;
+}
+function isLoopbackHost(hostname) {
+  return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "[::1]" || hostname === "::1";
+}
+function config(message) {
+  return new DecdnError("CONFIG", message);
+}
+function sleep(ms, signal) {
+  if (signal?.aborted === true) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function untilAborted(promise, signal) {
+  if (signal === void 0) return promise;
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+function tail(uri) {
+  return formatUri(uri).slice(SCHEME.length + 64);
+}
+function isRewrittenType(contentType) {
+  const essence = (contentType ?? "").split(";")[0]?.trim().toLowerCase();
+  return essence === "text/html" || essence === "text/css";
+}
+var DecdnClient = class _DecdnClient {
+  context;
+  /** Namespace pointers (public gateway). */
+  pointer = new PointerApi(this);
+  /** The delegate and capability API (loopback gateway). */
+  loopback = new LoopbackApi(this);
+  /** @internal */
+  fetch;
+  /** @internal The bare origin: the gateway URL's, or the site's own. */
+  origin;
+  /** @internal */
+  pointerDomain;
+  gateway;
+  site;
+  token;
+  host;
+  verify;
+  cacheSize;
+  manifests = /* @__PURE__ */ new Map();
+  constructor(context, opts, gateway, site) {
+    this.context = context;
+    this.fetch = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.verify = opts.verify ?? "auto";
+    this.cacheSize = opts.manifestCacheSize ?? 64;
+    if (gateway !== void 0) this.gateway = gateway;
+    if (site !== void 0) this.site = site;
+    if (opts.token !== void 0) this.token = opts.token;
+    if (opts.host !== void 0) this.host = opts.host;
+    if (opts.pointer !== void 0) this.pointerDomain = opts.pointer;
+    this.origin = site?.origin ?? gateway?.origin ?? "";
+  }
+  /**
+   * A client for the gateway at `gatewayUrl`, or, in a page served from a
+   * site origin (`[<ns>.]<hash32>.<host>`, or `<ns>.<host>` under the
+   * configured gateway), for that site. A loopback `gatewayUrl` opens the
+   * loopback gateway from any page; a page, which cannot send the token,
+   * reaches its delegate and capability API alone.
+   */
+  static async open(opts = {}) {
+    let gateway;
+    if (opts.gatewayUrl !== void 0) {
+      try {
+        gateway = new URL(opts.gatewayUrl);
+      } catch (e) {
+        throw new DecdnError(
+          "CONFIG",
+          `not a gateway URL: ${opts.gatewayUrl}`,
+          { cause: e }
+        );
+      }
+    }
+    const loopback = gateway !== void 0 && (opts.token !== void 0 || isLoopbackHost(gateway.hostname));
+    const loc = globalThis.location;
+    if (!loopback && loc?.host !== void 0 && loc.host !== "" && loc.protocol !== void 0) {
+      const site = siteOf(loc.protocol, loc.host, gateway?.host);
+      if (site !== void 0)
+        return new _DecdnClient("site", opts, gateway, site);
+    }
+    if (gateway === void 0) {
+      throw config("no gatewayUrl, and the page is not on a site origin");
+    }
+    if (opts.token !== void 0 && (opts.host === void 0 || opts.host === "")) {
+      throw config(
+        "a loopback token needs `host`: the host whose capability pays, sent as x-decdn-host"
+      );
+    }
+    return new _DecdnClient(loopback ? "loopback" : "public", opts, gateway);
+  }
+  /** @internal Headers every bare-host request carries. */
+  authHeaders() {
+    if (this.token === void 0 || this.host === void 0) return {};
+    return { "x-decdn-token": this.token, "x-decdn-host": this.host };
+  }
+  parse(uri) {
+    return typeof uri === "string" ? parseUri(uri) : uri;
+  }
+  /** The URI on the bare host, or under `/_decdn/` on a site. */
+  bareUrl(uri) {
+    const rest = `${uri.hash}${tail(uri)}`;
+    return this.site !== void 0 ? `${this.site.origin}/_decdn/${rest}` : `${this.origin}/${rest}`;
+  }
+  /** The site URL of a bundle or an entry. */
+  siteUrl(uri) {
+    const u = this.parse(uri);
+    if (u.kind === "blob")
+      throw config("a blob has no site: only a bundle or an entry does");
+    const label = hashToBase32(u.hash);
+    const host = u.namespace === void 0 ? label : `${u.namespace}.${label}`;
+    const path = tail({
+      hash: u.hash,
+      kind: u.kind,
+      ...u.path === void 0 ? {} : { path: u.path }
+    });
+    if (this.site !== void 0)
+      return `${this.site.protocol}//${host}.${this.site.suffix}${path}`;
+    const gw = this.gateway;
+    if (this.context === "loopback") {
+      const port = gw.port !== "" ? gw.port : gw.protocol === "https:" ? "443" : "80";
+      return `${gw.protocol}//${host}.localhost:${port}${path}`;
+    }
+    return `${gw.protocol}//${host}.${gw.host}${path}`;
+  }
+  /** The host a namespace's pointer serves at on a public gateway: `https://<ns>.<host>/`. */
+  namespaceUrl(namespace) {
+    const ns = integer(namespace, "a namespace id");
+    if (ns <= 0n) throw config("a namespace id is at least 1");
+    if (this.site !== void 0)
+      return `${this.site.protocol}//${ns}.${this.site.suffix}/`;
+    if (this.context === "loopback")
+      throw config("a loopback gateway holds no namespace pointers");
+    const gw = this.gateway;
+    return `${gw.protocol}//${ns}.${gw.host}/`;
+  }
+  /** The hash a manifest call names, or the site's own. */
+  manifestHash(hashOrUri) {
+    if (hashOrUri === void 0) {
+      if (this.site?.hash !== void 0) return this.site.hash;
+      throw config(
+        this.site === void 0 ? "manifest needs a hash outside a site page" : "the manifest hash is unknown on a namespace host"
+      );
+    }
+    if (typeof hashOrUri === "string" && isHash(hashOrUri))
+      return hashOrUri.toLowerCase();
+    return this.parse(hashOrUri).hash;
+  }
+  /** The bundle manifest a hash or URI names, parsed and verified; cached per client by hash. */
+  async manifest(hashOrUri, signal) {
+    const hash = this.manifestHash(hashOrUri);
+    const cached = this.manifests.get(hash);
+    if (cached !== void 0) {
+      this.manifests.delete(hash);
+      this.manifests.set(hash, cached);
+      return untilAborted(cached, signal);
+    }
+    const pending = (async () => {
+      const response = await this.request(
+        this.bareUrl({ hash, kind: "blob" }),
+        "GET",
+        {}
+      );
+      return parseManifest(
+        await collect(guard(response.body, {}), MAX_MANIFEST_BYTES),
+        hash
+      );
+    })();
+    this.manifests.set(hash, pending);
+    pending.catch(() => {
+      if (this.manifests.get(hash) === pending) this.manifests.delete(hash);
+    });
+    while (this.manifests.size > this.cacheSize) {
+      const oldest = this.manifests.keys().next().value;
+      if (oldest === void 0) break;
+      this.manifests.delete(oldest);
+    }
+    return untilAborted(pending, signal);
+  }
+  /** The manifest entry `uri` names; `NOT_FOUND` when the bundle has none. */
+  async entryOf(uri, signal) {
+    const manifest = await this.manifest(uri.hash, signal);
+    const entry = manifest.entries.find((e) => e.path === uri.path);
+    if (entry === void 0) {
+      throw new DecdnError(
+        "NOT_FOUND",
+        `bundle ${uri.hash} has no entry ${JSON.stringify(uri.path)}`
+      );
+    }
+    return entry;
+  }
+  /** What `uri` names: for a bundle or an entry, after reading its manifest. */
+  async resolve(uri) {
+    const u = this.parse(uri);
+    const out = {
+      kind: u.kind,
+      hash: u.hash,
+      bareUrl: this.bareUrl(u)
+    };
+    if (u.kind === "blob") return out;
+    out.siteUrl = this.siteUrl(u);
+    if (u.kind === "bundle") await this.manifest(u.hash);
+    else out.entry = await this.entryOf(u);
+    return out;
+  }
+  /** A request to the gateway; a non-2xx answer is thrown as a `DecdnError`. */
+  async request(url, method, headers, signal) {
+    const bare = this.site === void 0 && url.startsWith(`${this.origin}/`);
+    const init = {
+      method,
+      headers: bare ? { ...this.authHeaders(), ...headers } : headers
+    };
+    if (signal !== void 0) init.signal = signal;
+    const response = await send(this.fetch, url, init);
+    if (response.status < 200 || response.status > 299)
+      throw await errorOf(response);
+    return response;
+  }
+  /** An entry by its own hash, as a blob: the bytes the manifest names, unrewritten. */
+  entryBlobUrl(uri, entry) {
+    return this.bareUrl({
+      hash: entry.hash,
+      kind: "blob",
+      ...uri.namespace === void 0 ? {} : { namespace: uri.namespace }
+    });
+  }
+  /**
+   * Where an entry comes from, given its manifest entry (when verifying).
+   * `own` holds the query of a path on the site's own bundle: the site serves
+   * by path alone and leaves the query to the page, and its host already
+   * names the namespace.
+   */
+  entryUrl(uri, own, entry) {
+    if (entry !== void 0 && rewritten(uri.path ?? "") && this.context !== "loopback") {
+      return this.entryBlobUrl(uri, entry);
+    }
+    if (this.site !== void 0)
+      return own !== void 0 ? `${this.site.origin}${tail({
+        hash: uri.hash,
+        kind: "entry",
+        ...uri.path === void 0 ? {} : { path: uri.path }
+      })}${own}` : this.bareUrl(uri);
+    return this.context === "loopback" ? this.bareUrl(uri) : this.siteUrl(uri);
+  }
+  async plan(target, mode, ranged, signal) {
+    const off = mode === false ? false : "skipped";
+    const unverifiable = (why) => {
+      if (mode === true) throw config(`verify: true, but ${why}`);
+    };
+    if (typeof target === "string" && target.startsWith("/")) {
+      if (this.site === void 0)
+        throw config(
+          "a path is relative to a site: open the client on a site page"
+        );
+      const path = target.split(/[?#]/)[0] ?? "/";
+      const query = target.slice(path.length).split("#")[0] ?? "";
+      if (this.site.hash === void 0 || path === "/") {
+        unverifiable(
+          this.site.hash === void 0 ? "the bundle is unknown on a namespace host" : "a bundle listing is not content"
+        );
+        return { url: `${this.site.origin}${target}`, verified: off };
+      }
+      const entry = path.endsWith("/") ? `${path}index.html` : path;
+      const uri2 = parseUri(`${SCHEME}${this.site.hash}${entry}`);
+      if (this.site.namespace !== void 0)
+        uri2.namespace = this.site.namespace;
+      return this.planEntry(uri2, query, mode, ranged, signal);
+    }
+    const uri = this.parse(target);
+    if (uri.kind === "blob") {
+      if (ranged)
+        throw config(
+          "a blob has no declared size to range: fetch it whole, or range a bundle entry"
+        );
+      return mode === false ? { url: this.bareUrl(uri), verified: false } : { url: this.bareUrl(uri), hash: uri.hash, verified: true };
+    }
+    if (uri.kind === "bundle") {
+      unverifiable("a bundle's index is a page the gateway rewrites");
+      const own2 = this.site !== void 0 && this.site.hash === uri.hash;
+      const url = this.site !== void 0 ? own2 ? `${this.site.origin}/` : this.bareUrl(uri) : this.context === "loopback" ? this.bareUrl(uri) : this.siteUrl(uri);
+      return { url, verified: off };
+    }
+    const own = this.site !== void 0 && this.site.hash === uri.hash;
+    return this.planEntry(uri, own ? "" : void 0, mode, ranged, signal);
+  }
+  async planEntry(uri, own, mode, ranged, signal) {
+    if (mode === false || ranged) {
+      if (ranged && mode === true)
+        throw config("verify: true, but a range cannot be verified");
+      return {
+        url: this.entryUrl(uri, own),
+        verified: mode === false ? false : "skipped"
+      };
+    }
+    const entry = await this.entryOf(uri, signal);
+    const plan = {
+      url: this.entryUrl(uri, own, entry),
+      hash: entry.hash,
+      verified: true
+    };
+    if (entry.size !== void 0) plan.length = entry.size;
+    const blobUrl = this.entryBlobUrl(uri, entry);
+    if (plan.url !== blobUrl && this.context !== "loopback")
+      plan.blobUrl = blobUrl;
+    return plan;
+  }
+  /**
+   * Fetch what `uri` names: a `decdn:` URI, or on a site page a path of its
+   * own bundle. Verification follows `verify` (see {@link DecdnResponse.verified}).
+   */
+  async get(uri, opts = {}) {
+    const mode = opts.verify ?? this.verify;
+    const plan = await this.plan(
+      uri,
+      mode,
+      opts.range !== void 0,
+      opts.signal
+    );
+    const headers = {};
+    if (opts.range !== void 0) {
+      const { offset, length: length2 } = opts.range;
+      if (!Number.isSafeInteger(offset) || offset < 0 || length2 !== void 0 && (!Number.isSafeInteger(length2) || length2 < 1)) {
+        throw config("a range is a non-negative offset and a positive length");
+      }
+      headers.range = `bytes=${offset}-${length2 === void 0 ? "" : offset + length2 - 1}`;
+    }
+    let response = await this.fetchRetrying(plan.url, headers, opts);
+    let contentType;
+    if (plan.blobUrl !== void 0 && isRewrittenType(response.headers.get("content-type"))) {
+      contentType = response.headers.get("content-type") ?? void 0;
+      response.body?.cancel().catch(() => void 0);
+      response = await this.fetchRetrying(plan.blobUrl, headers, opts);
+    }
+    const whole = opts.range === void 0 || response.status === 200;
+    const verified = plan.verified === true && !whole ? "skipped" : plan.verified;
+    const length = response.headers.get("content-length");
+    const guardOpts = {};
+    if (verified === true && plan.hash !== void 0)
+      guardOpts.hash = plan.hash;
+    if (whole && plan.length !== void 0) {
+      guardOpts.length = plan.length;
+      guardOpts.max = plan.length;
+    } else {
+      if (length !== null && /^\d+$/.test(length))
+        guardOpts.length = Number(length);
+      if (!whole && opts.range?.length !== void 0)
+        guardOpts.max = opts.range.length;
+    }
+    if (opts.signal !== void 0) guardOpts.signal = opts.signal;
+    return new DecdnResponse(
+      response,
+      guard(response.body, guardOpts),
+      verified,
+      contentType
+    );
+  }
+  /** A `GET` of `url`, once more after one `Retry-After` when `opts.retry` asks. */
+  async fetchRetrying(url, headers, opts) {
+    try {
+      return await this.request(url, "GET", headers, opts.signal);
+    } catch (e) {
+      const retryable = e instanceof DecdnError && ["PAYMENT_REQUIRED", "POOL_UNFUNDED", "RATE_LIMITED"].includes(e.code);
+      if (!opts.retry || !retryable || e.retryAfterSecs === void 0) throw e;
+      await sleep(e.retryAfterSecs * 1e3, opts.signal);
+      return this.request(url, "GET", headers, opts.signal);
+    }
+  }
+  /**
+   * What is known about `uri` without its bytes: on a public gateway from
+   * `HEAD`, elsewhere (where `HEAD` would cost a pull) from the manifest. A
+   * public `HEAD` of a raw blob whose size the gateway does not know yet
+   * pays for one chunk group, the proof of its size, and is refused or fails
+   * as its `GET` would be.
+   */
+  async head(uri) {
+    const u = this.parse(uri);
+    if (this.context === "public") {
+      const url = u.kind === "blob" ? this.bareUrl(u) : this.siteUrl(u);
+      const response = await this.request(url, "HEAD", {});
+      const info2 = {};
+      const length = response.headers.get("content-length");
+      if (length !== null && /^\d+$/.test(length)) info2.size = Number(length);
+      const etag = /^"?([0-9a-fA-F]{64})"?$/.exec(
+        response.headers.get("etag") ?? ""
+      )?.[1];
+      if (etag !== void 0) info2.hash = etag.toLowerCase();
+      const type = response.headers.get("content-type");
+      if (type !== null) info2.contentType = type;
+      return info2;
+    }
+    if (u.kind !== "entry") return { hash: u.hash };
+    const entry = await this.entryOf(u);
+    const info = {
+      hash: entry.hash,
+      contentType: siteType(entry.path)
+    };
+    if (entry.size !== void 0) info.size = entry.size;
+    return info;
+  }
+};
+//# sourceMappingURL=index.cjs.map