@piprail/sdk 2.15.1 → 2.16.0

package/dist/chunk-2CX7XRZK.js

@@ -0,0 +1,649 @@
+// src/indexes.ts
+var DIRECTORY_INFO = Object.freeze({
+  "402index": {
+    source: "402index",
+    review: "probe-sync",
+    auth: "none",
+    chains: null,
+    onSuccess: "pending-review",
+    readByDiscover: true,
+    caveat: "402 Index probes your URL on submit (rejecting anything that does not return a real 402), then lists it \u2014 a self-registered resource becomes searchable once it passes automated health + payment-validity checks, with NO domain verification required (observed live: searchable within ~2 days for a healthy endpoint). Verify your domain on 402index.io for instant, guaranteed approval + a verified badge, which also flips every pending listing on that domain live at once."
+  },
+  x402scan: {
+    source: "x402scan",
+    review: "probe-sync",
+    auth: "siwx",
+    chains: ["eip155:8453", "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"],
+    onSuccess: "live",
+    readByDiscover: false,
+    caveat: "x402scan lists Base/Solana only, needs one wallet signature (SIWX), and requires a resolvable input schema (from /openapi.json or the bazaar extension in the 402 body). It goes live on x402scan.com immediately on success \u2014 but discover() does NOT read x402scan, so the listing won't appear in discover() results."
+  },
+  bazaar: {
+    source: "bazaar",
+    review: "settle-coupled",
+    auth: "facilitator-only",
+    chains: null,
+    onSuccess: "not-listable",
+    readByDiscover: true,
+    caveat: "CDP Bazaar has no register endpoint \u2014 it catalogs a resource only when its own facilitator settles a payment. PipRail verifies locally with no facilitator, so a PipRail resource cannot be listed here (you can still READ Bazaar to find others). List on 402 Index or x402scan instead."
+  }
+});
+function getDirectoryInfo(source) {
+  return DIRECTORY_INFO[source];
+}
+function decorateOutcome(o) {
+  const info = DIRECTORY_INFO[o.source];
+  return { ...o, visibility: o.visibility ?? (o.ok ? info.onSuccess : "not-listable"), note: info.caveat };
+}
+var BAZAAR_URL = "https://api.cdp.coinbase.com/platform/v2/x402/discovery/resources";
+var INDEX402_SEARCH = "https://402index.io/api/v1/services";
+var INDEX402_REGISTER = "https://402index.io/api/v1/register";
+var INDEX402_CLAIM = "https://402index.io/api/v1/claim";
+var INDEX402_VERIFY = "https://402index.io/api/v1/claim/verify";
+var X402SCAN_REGISTER = "https://www.x402scan.com/api/x402/registry/register";
+var USER_AGENT = "@piprail/sdk (+https://piprail.com)";
+function clientHeaders(extra = {}) {
+  return { "user-agent": USER_AGENT, ...extra };
+}
+var SLUG_TO_CAIP2 = {
+  // EVM — every chain we ship a preset for, because an x402 **v1** server names the network by
+  // slug and a slug we can't resolve never matches `net.supports()` (the EVM driver compares
+  // chain ids, so an unresolved 'celo' silently fails to match a Celo client). Chains we don't
+  // preset still fall through to net.supports unchanged.
+  ethereum: "eip155:1",
+  base: "eip155:8453",
+  polygon: "eip155:137",
+  arbitrum: "eip155:42161",
+  optimism: "eip155:10",
+  avalanche: "eip155:43114",
+  bnb: "eip155:56",
+  bsc: "eip155:56",
+  mantle: "eip155:5000",
+  sonic: "eip155:146",
+  linea: "eip155:59144",
+  scroll: "eip155:534352",
+  celo: "eip155:42220",
+  zksync: "eip155:324",
+  unichain: "eip155:130",
+  worldchain: "eip155:480",
+  world: "eip155:480",
+  sei: "eip155:1329",
+  injective: "eip155:1776",
+  hyperevm: "eip155:999",
+  monad: "eip155:143",
+  kaia: "eip155:8217",
+  // non-EVM families — values mirror each driver's bound caip2 exactly
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  ton: "tvm:-239",
+  tron: "tron:mainnet",
+  near: "near:mainnet",
+  sui: "sui:mainnet",
+  aptos: "aptos:1",
+  algorand: "algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
+  stellar: "stellar:pubnet",
+  xrpl: "xrpl:0"
+};
+var ALGORAND_SPEC_CAIP2 = "algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73k";
+var LEGACY_CAIP2_ALIAS = {
+  "ton:-239": "tvm:-239",
+  [ALGORAND_SPEC_CAIP2]: "algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8="
+};
+function normalizeNetwork(network) {
+  const legacy = LEGACY_CAIP2_ALIAS[network];
+  if (legacy) return legacy;
+  if (network.includes(":")) return network;
+  return SLUG_TO_CAIP2[network.toLowerCase()] ?? network;
+}
+async function searchOpenIndexes(opts = {}) {
+  const sources = opts.sources ?? ["bazaar", "402index"];
+  const limit = opts.limit ?? 20;
+  const filters = {
+    ...optionalRaw("category", opts.category),
+    ...optionalRaw("asset", opts.asset),
+    ...optionalRaw("maxPrice", opts.maxPrice),
+    ...optionalRaw("verified", opts.verified),
+    ...optionalRaw("paymentValid", opts.paymentValid),
+    ...optionalRaw("sort", opts.sort),
+    ...optionalRaw("order", opts.order)
+  };
+  const results = await Promise.all(
+    sources.map((source) => {
+      if (source === "bazaar") return safeSearch(() => searchBazaar(opts.query, limit, opts.signal));
+      if (source === "402index") return safeSearch(() => search402Index(opts.query, limit, filters, opts.signal));
+      return Promise.resolve([]);
+    })
+  );
+  const merged = applyClientFilters(dedupeByResource(results.flat()), opts);
+  const wantRelevance = opts.query !== void 0 && (opts.sort ?? "relevance") === "relevance";
+  if (wantRelevance) return rankResources(merged, opts.query);
+  if (opts.sort && opts.sort !== "relevance") return sortResources(merged, opts.sort, opts.order ?? "desc");
+  return merged;
+}
+function optionalRaw(field, value) {
+  return value !== void 0 ? { [field]: value } : {};
+}
+function applyClientFilters(items, opts) {
+  let out = items;
+  if (opts.category) {
+    const want = opts.category.toLowerCase();
+    out = out.filter((r) => r.category !== void 0 && r.category.toLowerCase().startsWith(want));
+  }
+  if (opts.maxPrice !== void 0) {
+    const max = opts.maxPrice;
+    out = out.filter((r) => r.priceUsd === void 0 || r.priceUsd <= max);
+  }
+  if (opts.asset) {
+    const want = opts.asset.toLowerCase();
+    out = out.filter((r) => {
+      const known = r.rails.map((x) => x.symbol ?? x.asset).filter((a) => !!a);
+      return known.length === 0 || known.some((a) => a.toLowerCase() === want);
+    });
+  }
+  if (opts.minReliability !== void 0) {
+    const min = opts.minReliability;
+    out = out.filter((r) => r.reliabilityScore === void 0 || r.reliabilityScore >= min);
+  }
+  return out;
+}
+function tokenize(s) {
+  return (s ?? "").toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+var FIELD_WEIGHTS = { name: 6, category: 4, tags: 4, path: 3, description: 2 };
+function fieldTokens(r) {
+  let pathText = r.resource;
+  try {
+    const u = new URL(r.resource);
+    pathText = `${u.hostname} ${u.pathname}`;
+  } catch {
+  }
+  return [
+    [tokenize(r.name), FIELD_WEIGHTS.name],
+    [tokenize(r.category), FIELD_WEIGHTS.category],
+    [tokenize((r.tags ?? []).join(" ")), FIELD_WEIGHTS.tags],
+    [tokenize(pathText), FIELD_WEIGHTS.path],
+    [tokenize(r.description), FIELD_WEIGHTS.description]
+  ];
+}
+function scoreResource(r, queryTokens) {
+  if (queryTokens.length === 0) return 0;
+  const fields = fieldTokens(r);
+  let score = 0;
+  let matched = 0;
+  for (const qt of queryTokens) {
+    let hit = false;
+    for (const [toks, w] of fields) {
+      if (toks.includes(qt)) {
+        score += w;
+        hit = true;
+      } else if (qt.length >= 4 && toks.some((t) => t.startsWith(qt) || t.length >= 4 && qt.startsWith(t))) {
+        score += w * 0.4;
+        hit = true;
+      }
+    }
+    if (hit) matched++;
+  }
+  if (matched === 0) return 0;
+  if (matched === queryTokens.length) score += 8;
+  if (r.reliabilityScore !== void 0) score += r.reliabilityScore / 1e3;
+  return score;
+}
+function rankResources(items, query) {
+  const qTokens = tokenize(query);
+  if (qTokens.length === 0) return items;
+  return items.map((r, i) => ({ r, i, s: scoreResource(r, qTokens) })).filter((x) => x.s > 0).sort((a, b) => b.s - a.s || a.i - b.i).map((x) => ({ ...x.r, score: x.s }));
+}
+function sortResources(items, sort, order) {
+  const dir = order === "asc" ? 1 : -1;
+  const key = (r) => sort === "reliability" || sort === "uptime" ? r.reliabilityScore : sort === "price" ? r.priceUsd : sort === "name" ? (r.name ?? r.resource).toLowerCase() : void 0;
+  return items.map((r, i) => ({ r, i })).sort((a, b) => {
+    const ka = key(a.r);
+    const kb = key(b.r);
+    if (ka === void 0 && kb === void 0) return a.i - b.i;
+    if (ka === void 0) return 1;
+    if (kb === void 0) return -1;
+    if (ka < kb) return -1 * dir;
+    if (ka > kb) return 1 * dir;
+    return a.i - b.i;
+  }).map((x) => x.r);
+}
+async function safeSearch(run) {
+  try {
+    return await run();
+  } catch {
+    return [];
+  }
+}
+function dedupeByResource(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const it of items) {
+    const key = it.resource;
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(it);
+  }
+  return out;
+}
+async function searchBazaar(query, limit, signal) {
+  const res = await fetch(`${BAZAAR_URL}?limit=${encodeURIComponent(String(limit))}`, {
+    headers: clientHeaders({ accept: "application/json" }),
+    ...signal ? { signal } : {}
+  });
+  if (!res.ok) return [];
+  const body = await res.json();
+  const items = Array.isArray(body.items) ? body.items : [];
+  const mapped = items.map(mapBazaarItem).filter((r) => r !== null);
+  return query ? mapped.filter((r) => matchesQuery(r, query)) : mapped;
+}
+function mapBazaarItem(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  const resource = pickString(o, "resource", "url", "endpoint");
+  if (!resource) return null;
+  const meta = o.metadata && typeof o.metadata === "object" ? o.metadata : {};
+  return {
+    resource,
+    source: "bazaar",
+    rails: mapRails(o.accepts),
+    ...optionalString("name", pickString(meta, "name", "title")),
+    ...optionalString("description", pickString(meta, "description") ?? pickString(o, "description")),
+    ...optionalString("category", pickString(meta, "category"))
+  };
+}
+async function search402Index(query, limit, filters, signal) {
+  const tokens = tokenize(query);
+  const queries = query && tokens.length > 1 ? [.../* @__PURE__ */ new Set([query, ...tokens])].slice(0, 5) : [query];
+  const pages = await Promise.all(queries.map((q) => safeSearch(() => fetch402Page(q, limit, filters, signal))));
+  return dedupeByResource(pages.flat());
+}
+async function fetch402Page(query, limit, filters, signal) {
+  const qs = new URLSearchParams({ limit: String(limit) });
+  if (query) qs.set("q", query);
+  if (filters.category) qs.set("category", filters.category);
+  if (filters.asset) qs.set("payment_asset", filters.asset);
+  if (filters.maxPrice !== void 0) qs.set("max_price_usd", String(filters.maxPrice));
+  if (filters.verified) qs.set("verified", "true");
+  if (filters.paymentValid) qs.set("payment_valid", "true");
+  if (filters.sort && filters.sort !== "relevance") {
+    qs.set("sort", filters.sort);
+    qs.set("order", filters.order ?? "desc");
+  }
+  const res = await fetch(`${INDEX402_SEARCH}?${qs.toString()}`, {
+    headers: clientHeaders({ accept: "application/json" }),
+    ...signal ? { signal } : {}
+  });
+  if (!res.ok) return [];
+  const body = await res.json();
+  const list = firstArray(body, "services", "results", "items", "data");
+  return list.map(map402IndexItem).filter((r) => r !== null).filter((r) => r.rails.length > 0);
+}
+function map402IndexItem(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  const resource = pickString(o, "url", "resource", "endpoint");
+  if (!resource) return null;
+  const protocol = (pickString(o, "protocol") ?? "x402").toLowerCase();
+  if (protocol !== "x402") return null;
+  const rails = Array.isArray(o.accepts) ? mapRails(o.accepts) : railFrom402IndexFields(o);
+  const priceUsd = pickNumber(o, "price_usd", "priceUsd", "price");
+  const reliabilityScore = pickNumber(o, "reliability_score", "reliabilityScore");
+  const tags = pickStringArray(o, "tags", "keywords");
+  return {
+    resource,
+    source: "402index",
+    rails,
+    ...priceUsd !== void 0 ? { priceUsd } : {},
+    ...reliabilityScore !== void 0 ? { reliabilityScore } : {},
+    ...tags ? { tags } : {},
+    ...optionalString("name", pickString(o, "name", "title")),
+    ...optionalString("description", pickString(o, "description")),
+    ...optionalString("category", pickString(o, "category", "tag")),
+    ...optionalString("health", pickString(o, "health_status", "health")),
+    // 402 Index reports domain_verified as 0/1; surface a boolean only when the field is present.
+    ...o.domain_verified !== void 0 || o.verified !== void 0 ? { verified: isTruthyFlag(o.domain_verified) || isTruthyFlag(o.verified) } : {}
+  };
+}
+function isTruthyFlag(v) {
+  return v === 1 || v === true || v === "1" || v === "true";
+}
+function railFrom402IndexFields(o) {
+  const network = pickString(o, "payment_network", "network");
+  const asset = pickString(o, "payment_asset", "asset", "token");
+  if (!network && !asset) return [];
+  return [
+    {
+      scheme: "exact",
+      network: network ?? "unknown",
+      ...asset ? { asset } : {},
+      ...optionalString("symbol", asset)
+    }
+  ];
+}
+async function register402Index(input) {
+  try {
+    const attributionOn = input.attribution !== false;
+    const withTags = appendKeywords(input.description, input.tags);
+    const description = attributionOn ? appendAttribution(withTags) : withTags;
+    const payload = {
+      url: input.url,
+      name: input.name ?? hostOf(input.url),
+      protocol: "x402",
+      ...description ? { description } : {},
+      ...typeof input.priceUsd === "number" ? { price_usd: input.priceUsd } : {},
+      ...input.asset ? { payment_asset: input.asset } : {},
+      ...input.network ? { payment_network: input.network } : {},
+      ...input.method ? { http_method: input.method.toUpperCase() } : {},
+      ...input.category ? { category: input.category } : {},
+      ...input.tags && input.tags.length > 0 ? { tags: input.tags } : {},
+      ...input.provider ? { provider: input.provider } : {},
+      ...input.contactEmail ? { contact_email: input.contactEmail } : {},
+      ...input.probeBody !== void 0 ? { probe_body: input.probeBody } : {},
+      ...attributionOn ? { via: "@piprail/sdk" } : {}
+    };
+    const res = await fetch(INDEX402_REGISTER, {
+      method: "POST",
+      headers: clientHeaders({ "content-type": "application/json", accept: "application/json" }),
+      body: JSON.stringify(payload)
+    });
+    if (res.ok) {
+      const body = await res.json().catch(() => ({}));
+      const msg = typeof body.message === "string" && body.message.length > 0 ? body.message : void 0;
+      const live = body.service?.status === "active";
+      return {
+        source: "402index",
+        ok: true,
+        status: res.status,
+        ...live ? { visibility: "live" } : {},
+        detail: msg ?? (live ? "Registered + live on 402 Index (domain verified)." : "Registered on 402 Index \u2014 probed on submit, then searchable once it passes automated health + payment checks (verify your domain on 402index.io for instant approval + a verified badge).")
+      };
+    }
+    const why = await readIndexError(res);
+    return {
+      source: "402index",
+      ok: false,
+      status: res.status,
+      detail: why ? `402 Index rejected it (HTTP ${res.status}): ${why}` : `402 Index returned HTTP ${res.status}.`
+    };
+  } catch (err) {
+    return { source: "402index", ok: false, detail: errMsg(err) };
+  }
+}
+async function readIndexError(res) {
+  try {
+    const body = await res.json();
+    const parts = [body.error, body.detail, body.message].filter(
+      (p) => typeof p === "string" && p.length > 0
+    );
+    return parts.length ? [...new Set(parts)].join(" \u2014 ") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function registerX402Scan(input, signer) {
+  try {
+    const challengeRes = await fetch(X402SCAN_REGISTER, {
+      method: "POST",
+      headers: clientHeaders({ "content-type": "application/json", accept: "application/json" }),
+      body: JSON.stringify({ url: input.url })
+    });
+    if (challengeRes.status !== 402) {
+      return {
+        source: "x402scan",
+        ok: challengeRes.ok,
+        status: challengeRes.status,
+        detail: challengeRes.ok ? "Listed on x402scan." : `x402scan returned HTTP ${challengeRes.status} (expected a SIWX 402 challenge).`
+      };
+    }
+    const info = await readSiwxInfo(challengeRes);
+    if (!info) {
+      return { source: "x402scan", ok: false, status: 402, detail: "x402scan SIWX challenge was unparseable." };
+    }
+    const resolvedInfo = { ...info, issuedAt: info.issuedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+    const message = formatSiweMessage(resolvedInfo, signer.address);
+    const signature = await signer.signMessage(message);
+    const header = encodeBase64(
+      JSON.stringify({ ...resolvedInfo, address: signer.address, type: "eip191", message, signature })
+    );
+    const res = await fetch(X402SCAN_REGISTER, {
+      method: "POST",
+      headers: clientHeaders({
+        "content-type": "application/json",
+        accept: "application/json",
+        "sign-in-with-x": header
+      }),
+      body: JSON.stringify({ url: input.url })
+    });
+    if (res.ok) {
+      return { source: "x402scan", ok: true, status: res.status, detail: "Listed on x402scan (SIWX)." };
+    }
+    const why = await readIndexError(res);
+    return {
+      source: "x402scan",
+      ok: false,
+      status: res.status,
+      detail: why ? `x402scan rejected it (HTTP ${res.status}): ${why}` : `x402scan returned HTTP ${res.status} after signing.`
+    };
+  } catch (err) {
+    return { source: "x402scan", ok: false, detail: errMsg(err) };
+  }
+}
+async function claim402IndexDomain(domainOrUrl, opts = {}) {
+  const domain = hostOf(domainOrUrl);
+  try {
+    const res = await fetch(INDEX402_CLAIM, {
+      method: "POST",
+      headers: clientHeaders({ "content-type": "application/json", accept: "application/json" }),
+      body: JSON.stringify({ domain, ...opts.contactEmail ? { contact_email: opts.contactEmail } : {} })
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return { ok: false, domain, httpStatus: res.status, detail: pickString(body, "error", "detail", "message") ?? `402 Index claim returned HTTP ${res.status}.` };
+    }
+    const verificationToken = pickString(body, "verification_token");
+    const verificationHash = pickString(body, "verification_hash") ?? (verificationToken ? await sha256Hex(verificationToken) : void 0);
+    return {
+      ok: true,
+      domain,
+      httpStatus: res.status,
+      ...optionalString("verificationHash", verificationHash),
+      ...optionalString("verificationToken", verificationToken),
+      ...optionalString("verificationUrl", pickString(body, "verification_url")),
+      ...optionalString("instructions", pickString(body, "instructions"))
+    };
+  } catch (err) {
+    return { ok: false, domain, detail: errMsg(err) };
+  }
+}
+async function sha256Hex(input) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verify402IndexDomain(domainOrUrl) {
+  const domain = hostOf(domainOrUrl);
+  try {
+    const res = await fetch(INDEX402_VERIFY, {
+      method: "POST",
+      headers: clientHeaders({ "content-type": "application/json", accept: "application/json" }),
+      body: JSON.stringify({ domain })
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return { ok: false, domain, httpStatus: res.status, detail: pickString(body, "error", "detail", "message") ?? `402 Index verify returned HTTP ${res.status}.` };
+    }
+    return {
+      ok: true,
+      domain,
+      httpStatus: res.status,
+      ...optionalString("status", pickString(body, "status")),
+      ...typeof body.services_count === "number" ? { servicesCount: body.services_count } : {}
+    };
+  } catch (err) {
+    return { ok: false, domain, detail: errMsg(err) };
+  }
+}
+async function readSiwxInfo(res) {
+  try {
+    const body = await res.json();
+    const ext = body.extensions;
+    const siwx = ext?.["sign-in-with-x"];
+    const info = siwx?.info ?? siwx;
+    if (info && info.chainId == null && Array.isArray(siwx?.supportedChains)) {
+      const evm = siwx.supportedChains.find(
+        (c) => typeof c?.chainId === "string" && c.chainId.startsWith("eip155:")
+      );
+      if (evm && typeof evm.chainId === "string") info.chainId = evm.chainId;
+    }
+    if (info && typeof info.domain === "string" && info.domain.length > 0 && typeof info.nonce === "string" && info.nonce.length > 0 && typeof info.uri === "string" && info.uri.length > 0) {
+      return info;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatSiweMessage(info, address) {
+  const chainId = info.chainId ? caip2ToChainId(info.chainId) : 1;
+  const statement = info.statement && info.statement.trim() ? info.statement : void 0;
+  const lines = [
+    `${info.domain} wants you to sign in with your Ethereum account:`,
+    address,
+    "",
+    ...statement ? [statement, ""] : [""],
+    `URI: ${info.uri}`,
+    "Version: 1",
+    `Chain ID: ${chainId}`,
+    `Nonce: ${info.nonce}`,
+    `Issued At: ${info.issuedAt}`,
+    ...info.expirationTime ? [`Expiration Time: ${info.expirationTime}`] : []
+  ];
+  return lines.join("\n");
+}
+function caip2ToChainId(caip2) {
+  const m = /^eip155:(\d+)$/.exec(caip2);
+  const n = m ? Number(m[1]) : Number(caip2);
+  return Number.isSafeInteger(n) && n > 0 ? n : 1;
+}
+function mapRails(accepts) {
+  if (!Array.isArray(accepts)) return [];
+  const out = [];
+  for (const raw of accepts) {
+    if (!raw || typeof raw !== "object") continue;
+    const a = raw;
+    const network = pickString(a, "network");
+    if (!network) continue;
+    const extra = a.extra && typeof a.extra === "object" ? a.extra : {};
+    out.push({
+      scheme: pickString(a, "scheme") ?? "exact",
+      network,
+      ...optionalString("asset", pickString(a, "asset")),
+      ...optionalString("amount", pickString(a, "amount", "maxAmountRequired")),
+      ...optionalString("payTo", pickString(a, "payTo")),
+      ...optionalString("symbol", pickString(extra, "symbol"))
+    });
+  }
+  return out;
+}
+function matchesQuery(r, query) {
+  const haystack = [r.name, r.description, r.category, (r.tags ?? []).join(" "), r.resource].filter(Boolean).join(" ").toLowerCase();
+  if (haystack.includes(query.toLowerCase())) return true;
+  const qTokens = tokenize(query);
+  const hayTokens = new Set(tokenize(haystack));
+  return qTokens.some((t) => hayTokens.has(t));
+}
+function pickStringArray(o, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (Array.isArray(v)) {
+      const arr = v.filter((x) => typeof x === "string" && x.length > 0);
+      if (arr.length) return arr;
+    } else if (typeof v === "string" && v.trim()) {
+      const arr = v.split(/[,\s]+/).filter((x) => x.length > 0);
+      if (arr.length) return arr;
+    }
+  }
+  return void 0;
+}
+function pickString(o, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function pickNumber(o, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (typeof v === "string" && /^\d+(\.\d+)?$/.test(v.trim())) {
+      const n = Number(v.trim());
+      if (Number.isFinite(n)) return n;
+    }
+  }
+  return void 0;
+}
+function optionalString(field, value) {
+  return value !== void 0 ? { [field]: value } : {};
+}
+function firstArray(o, ...keys) {
+  for (const k of keys) {
+    if (Array.isArray(o[k])) return o[k];
+  }
+  return Array.isArray(o) ? o : [];
+}
+function hostOf(url) {
+  try {
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`;
+    return new URL(withScheme).hostname || url;
+  } catch {
+    return url;
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var REGISTER_ATTRIBUTION = "\xB7 Built with @piprail/sdk";
+function appendAttribution(description) {
+  if (!description) return description;
+  if (/piprail/i.test(description)) return description;
+  const next = `${description.trimEnd()} ${REGISTER_ATTRIBUTION}`;
+  return next.length <= 500 ? next : description;
+}
+function appendKeywords(description, tags) {
+  const clean = (tags ?? []).map((t) => t.trim()).filter((t) => t.length > 0);
+  if (clean.length === 0) return description;
+  const have = (description ?? "").toLowerCase();
+  const fresh = [...new Set(clean.filter((t) => !have.includes(t.toLowerCase())))];
+  if (fresh.length === 0) return description;
+  const tail = `Keywords: ${fresh.join(", ")}`;
+  if (!description) return tail;
+  const next = `${description.trimEnd()} \xB7 ${tail}`;
+  return next.length <= 500 ? next : description;
+}
+function encodeBase64(str) {
+  if (typeof Buffer !== "undefined") return Buffer.from(str, "utf8").toString("base64");
+  if (typeof btoa === "function" && typeof TextEncoder !== "undefined") {
+    const bytes = new TextEncoder().encode(str);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoder available in this runtime.");
+}
+
+export {
+  DIRECTORY_INFO,
+  getDirectoryInfo,
+  decorateOutcome,
+  ALGORAND_SPEC_CAIP2,
+  normalizeNetwork,
+  searchOpenIndexes,
+  scoreResource,
+  rankResources,
+  register402Index,
+  registerX402Scan,
+  claim402IndexDomain,
+  verify402IndexDomain,
+  REGISTER_ATTRIBUTION,
+  appendAttribution,
+  appendKeywords
+};