@ixo/openhands-sdk 0.6.0 → 0.8.0

package/dist/cjs/names/client.js

@@ -0,0 +1,757 @@
+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);
+
+// ../../node_modules/.pnpm/@ixo+names-client@0.2.1_react@19.2.8/node_modules/@ixo/names-client/dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  BACKOFF_JITTER: () => BACKOFF_JITTER,
+  BUDGET_STEP_MS: () => BUDGET_STEP_MS,
+  DEFAULT_BACKOFF_BASE_MS: () => DEFAULT_BACKOFF_BASE_MS,
+  DEFAULT_BACKOFF_MAX_MS: () => DEFAULT_BACKOFF_MAX_MS,
+  DEFAULT_BACKOFF_MAX_RETRY_AFTER_MS: () => DEFAULT_BACKOFF_MAX_RETRY_AFTER_MS,
+  DEFAULT_BATCH_DELAY_MS: () => DEFAULT_BATCH_DELAY_MS,
+  DEFAULT_BATCH_MAX_IDS: () => DEFAULT_BATCH_MAX_IDS,
+  DEFAULT_CACHE_MAX_ENTRIES: () => DEFAULT_CACHE_MAX_ENTRIES,
+  DEFAULT_CLIENT_INCLUDE: () => DEFAULT_CLIENT_INCLUDE,
+  DEFAULT_MAX_CONCURRENT_REQUESTS: () => DEFAULT_MAX_CONCURRENT_REQUESTS,
+  DEFAULT_MAX_TTL_MS: () => DEFAULT_MAX_TTL_MS,
+  DEFAULT_MIN_TTL_MS: () => DEFAULT_MIN_TTL_MS,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS,
+  GET_MAX_IDS: () => GET_MAX_IDS,
+  GET_MAX_URL_LENGTH: () => GET_MAX_URL_LENGTH,
+  INCLUDE_GROUPS: () => INCLUDE_GROUPS,
+  MAX_BATCH_MAX_IDS: () => MAX_BATCH_MAX_IDS,
+  MAX_IDENTIFIER_LENGTH: () => MAX_IDENTIFIER_LENGTH,
+  MIN_RESPONSE_BUDGET_MS: () => MIN_RESPONSE_BUDGET_MS,
+  NAMES_CLIENT_VERSION: () => NAMES_CLIENT_VERSION,
+  NamesClientError: () => NamesClientError,
+  abbreviate: () => abbreviate,
+  classifyIdentifier: () => classifyIdentifier,
+  createNamesClient: () => createNamesClient,
+  parseRetryAfterMs: () => parseRetryAfterMs,
+  syntheticResult: () => syntheticResult
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.pnpm/@ixo+names-client@0.2.1_react@19.2.8/node_modules/@ixo/names-client/dist/types.js
+var INCLUDE_GROUPS = ["name", "facts", "image", "matrix", "room", "cache"];
+var MIN_RESPONSE_BUDGET_MS = 250;
+var MAX_IDENTIFIER_LENGTH = 256;
+
+// ../../node_modules/.pnpm/@ixo+names-client@0.2.1_react@19.2.8/node_modules/@ixo/names-client/dist/abbreviate.js
+var BECH32 = "[02-9ac-hj-np-z]";
+var ACCOUNT = new RegExp(`^ixo1${BECH32}{38}$`);
+var CONTRACT = new RegExp(`^ixo1${BECH32}{58}$`);
+var VALIDATOR = new RegExp(`^ixovaloper1${BECH32}{38}$`);
+var ENTITY_HEX = /^[0-9a-f]{32}$/i;
+var COLLECTION_ID = /^(?:0|[1-9][0-9]*)$/;
+var DENOM = /^[\x21-\x7e]+$/;
+var IBC_DENOM = /^ibc\/[0-9a-f]{64}$/i;
+var MATRIX_USER_ID = /^@did-ixo-(ixo1[^:]*):(.+)$/;
+var MATRIX_SERVER_NAME = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[[0-9a-f:.]+\])(?::[0-9]{1,5})?$/i;
+var ENTITY_PREFIX = "did:ixo:entity:";
+var WASM_DID_PREFIX = "did:ixo:wasm:";
+var ACCOUNT_DID_PREFIX = "did:ixo:";
+var VALOPER_PREFIX = "ixovaloper1";
+var COLLECTION_PREFIX = "collection:";
+var DENOM_PREFIX = "denom:";
+var MATRIX_USER_PREFIX = "@did-ixo-ixo1";
+var MAX_MATRIX_USER_ID_LENGTH = 255;
+var MAX_COLLECTION_DIGITS = 20;
+var MAX_DENOM_LENGTH = 128;
+var ELLIPSIS = "\u2026";
+var SHORT_UNKNOWN_MAX = 20;
+var UNKNOWN = { kind: "unknown", normalized: null };
+var BECH32_VALUES = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function hasBech32Checksum(address) {
+  const separator = address.lastIndexOf("1");
+  const hrp = Array.from(address.slice(0, separator), (char) => char.charCodeAt(0));
+  const data = Array.from(address.slice(separator + 1), (char) => BECH32_VALUES.indexOf(char));
+  let checksum = 1;
+  for (const value of [...hrp.map((code) => code >>> 5), 0, ...hrp.map((code) => code & 31), ...data]) {
+    const top = checksum >>> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    BECH32_GENERATOR.forEach((generator, bit) => {
+      if (top >>> bit & 1)
+        checksum ^= generator;
+    });
+  }
+  return checksum >>> 0 === 1;
+}
+function singleCaseLower(raw) {
+  const lower = raw.toLowerCase();
+  return raw === lower || raw === raw.toUpperCase() ? lower : null;
+}
+function classifyAddress(raw) {
+  const address = singleCaseLower(raw);
+  if (address === null)
+    return UNKNOWN;
+  if (ACCOUNT.test(address))
+    return { kind: "account", normalized: address };
+  if (CONTRACT.test(address))
+    return { kind: "contract", normalized: address };
+  return UNKNOWN;
+}
+function classifyMatrixUserId(value) {
+  if (value.length > MAX_MATRIX_USER_ID_LENGTH)
+    return UNKNOWN;
+  const match = MATRIX_USER_ID.exec(value);
+  if (!match || !MATRIX_SERVER_NAME.test(match[2] ?? ""))
+    return UNKNOWN;
+  return classifyAddress(match[1] ?? "");
+}
+function isMatrixUserId(id) {
+  if (typeof id !== "string")
+    return false;
+  const value = id.trim();
+  if (!value.startsWith(MATRIX_USER_PREFIX))
+    return false;
+  const { normalized } = classifyMatrixUserId(value);
+  return normalized !== null && hasBech32Checksum(normalized);
+}
+function classifyIdentifier(id) {
+  if (typeof id !== "string" || id.length > MAX_IDENTIFIER_LENGTH)
+    return UNKNOWN;
+  const value = id.trim();
+  if (value === "")
+    return UNKNOWN;
+  if (value.startsWith(ENTITY_PREFIX)) {
+    const hex = value.slice(ENTITY_PREFIX.length);
+    return ENTITY_HEX.test(hex) ? { kind: "entity", normalized: `${ENTITY_PREFIX}${hex.toLowerCase()}` } : UNKNOWN;
+  }
+  if (value.startsWith(WASM_DID_PREFIX))
+    return classifyAddress(value.slice(WASM_DID_PREFIX.length));
+  if (value.startsWith(ACCOUNT_DID_PREFIX))
+    return classifyAddress(value.slice(ACCOUNT_DID_PREFIX.length));
+  if (/^ixovaloper1/i.test(value)) {
+    const valoper = singleCaseLower(value);
+    return valoper !== null && VALIDATOR.test(valoper) ? { kind: "validator", normalized: valoper } : UNKNOWN;
+  }
+  if (/^ixo1/i.test(value))
+    return classifyAddress(value);
+  if (value.startsWith(MATRIX_USER_PREFIX))
+    return classifyMatrixUserId(value);
+  if (value.startsWith(COLLECTION_PREFIX)) {
+    const digits = value.slice(COLLECTION_PREFIX.length);
+    return digits.length <= MAX_COLLECTION_DIGITS && COLLECTION_ID.test(digits) ? { kind: "collection", normalized: digits } : UNKNOWN;
+  }
+  if (value.startsWith(DENOM_PREFIX)) {
+    const denom = value.slice(DENOM_PREFIX.length).trim();
+    if (denom.length === 0 || denom.length > MAX_DENOM_LENGTH || !DENOM.test(denom))
+      return UNKNOWN;
+    return { kind: "denom", normalized: IBC_DENOM.test(denom) ? `ibc/${denom.slice(4).toUpperCase()}` : denom };
+  }
+  return UNKNOWN;
+}
+function middleEllipsis(text, head, tail) {
+  const chars = Array.from(text);
+  return `${chars.slice(0, head).join("")}${ELLIPSIS}${chars.slice(chars.length - tail).join("")}`;
+}
+function abbreviate(id) {
+  const text = typeof id === "string" ? id : String(id);
+  const { kind, normalized } = classifyIdentifier(text);
+  if (kind === "unknown" || normalized === null) {
+    return Array.from(text).length <= SHORT_UNKNOWN_MAX ? text : middleEllipsis(text, 12, 4);
+  }
+  switch (kind) {
+    case "account":
+    case "contract":
+      return middleEllipsis(normalized, 9, 4);
+    case "entity":
+      return `${ENTITY_PREFIX}${middleEllipsis(normalized.slice(ENTITY_PREFIX.length), 4, 4)}`;
+    case "validator":
+      return `${VALOPER_PREFIX}${middleEllipsis(normalized.slice(VALOPER_PREFIX.length), 4, 4)}`;
+    case "collection":
+      return `Collection #${normalized}`;
+    case "denom":
+      return normalized;
+  }
+}
+
+// ../../node_modules/.pnpm/@ixo+names-client@0.2.1_react@19.2.8/node_modules/@ixo/names-client/dist/client.js
+var NamesClientError = class extends Error {
+  constructor(code, message, details) {
+    super(message, details.cause === void 0 ? void 0 : { cause: details.cause });
+    this.name = "NamesClientError";
+    this.code = code;
+    this.ids = details.ids;
+    this.status = details.status;
+    this.response = details.response;
+    this.blockedUntil = details.blockedUntil;
+  }
+};
+var DEFAULT_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_CONCURRENT_REQUESTS = 4;
+var DEFAULT_BACKOFF_BASE_MS = 500;
+var DEFAULT_BACKOFF_MAX_MS = 6e4;
+var DEFAULT_BACKOFF_MAX_RETRY_AFTER_MS = 15 * 60 * 1e3;
+var BACKOFF_JITTER = 0.2;
+var DEFAULT_CACHE_MAX_ENTRIES = 5e3;
+var DEFAULT_MIN_TTL_MS = 3e4;
+var DEFAULT_MAX_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_BATCH_MAX_IDS = 40;
+var MAX_BATCH_MAX_IDS = 40;
+var DEFAULT_BATCH_DELAY_MS = 10;
+var BUDGET_STEP_MS = 250;
+var GET_MAX_IDS = 20;
+var GET_MAX_URL_LENGTH = 2e3;
+var DEFAULT_CLIENT_INCLUDE = ["cache", "name"];
+var NAME_INCLUDE = ["cache", "name"];
+var MATRIX_INCLUDE = ["cache", "matrix", "name"];
+var ROOM_INCLUDE = ["cache", "name", "room"];
+var isIncludeGroup = (value) => typeof value === "string" && INCLUDE_GROUPS.includes(value);
+function normalizeInclude(groups) {
+  const set = /* @__PURE__ */ new Set(["cache"]);
+  for (const group of groups)
+    if (isIncludeGroup(group))
+      set.add(group);
+  return [...set].sort();
+}
+function normalizeBudget(budgetMs) {
+  if (typeof budgetMs !== "number" || !Number.isFinite(budgetMs))
+    return void 0;
+  const stepped = Math.floor(budgetMs / BUDGET_STEP_MS) * BUDGET_STEP_MS;
+  return Math.min(Number.MAX_SAFE_INTEGER, Math.max(MIN_RESPONSE_BUDGET_MS, stepped));
+}
+function localResult(id, include, base) {
+  const result = {
+    id,
+    kind: base.kind,
+    normalized: null,
+    display: abbreviate(id),
+    status: base.status,
+    complete: base.complete
+  };
+  if (include.includes("name")) {
+    result.name = null;
+    result.source = null;
+    result.selfChosen = false;
+  }
+  if (include.includes("cache"))
+    result.cache = { hit: "none", freshUntil: null };
+  if (base.error !== void 0)
+    result.error = base.error;
+  return result;
+}
+function syntheticResult(id, include = DEFAULT_CLIENT_INCLUDE) {
+  return localResult(id, include, { kind: classifyIdentifier(id).kind, status: "partial", complete: false });
+}
+function finalUnknown(id, include, message) {
+  return localResult(id, include, { kind: "unknown", status: "unresolved", complete: true, error: { code: "unsupported_identifier", message } });
+}
+function invalidIdentifierResult(id, include) {
+  return finalUnknown(id, include, `identifier must be 1..${MAX_IDENTIFIER_LENGTH} characters`);
+}
+function isBrowser() {
+  return typeof document !== "undefined" || typeof globalThis.WorkerNavigator !== "undefined";
+}
+function isSendable(id) {
+  return typeof id === "string" && id.length >= 1 && id.length <= MAX_IDENTIFIER_LENGTH;
+}
+var fitsGetQuery = (id) => !id.includes(",") && id === id.trim();
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function cutByBudget(payload, budgetMs) {
+  if (budgetMs === void 0 || !isRecord(payload) || !isRecord(payload.meta))
+    return false;
+  const { durationMs } = payload.meta;
+  return typeof durationMs === "number" && durationMs >= budgetMs;
+}
+function isResolvedName(v, id, include) {
+  if (!isRecord(v) || v.id !== id)
+    return false;
+  if (typeof v.kind !== "string" || typeof v.display !== "string" || typeof v.status !== "string")
+    return false;
+  if (typeof v.complete !== "boolean")
+    return false;
+  if (!(v.normalized === null || typeof v.normalized === "string"))
+    return false;
+  if (include.includes("name")) {
+    if (typeof v.selfChosen !== "boolean")
+      return false;
+    if (!(v.name === null || typeof v.name === "string"))
+      return false;
+  }
+  const cache = v.cache;
+  if (!isRecord(cache) || typeof cache.hit !== "string")
+    return false;
+  return cache.freshUntil === null || typeof cache.freshUntil === "number" && Number.isFinite(cache.freshUntil);
+}
+function isErrorResponse(v) {
+  return isRecord(v) && isRecord(v.error) && typeof v.error.code === "string" && typeof v.error.message === "string";
+}
+function positiveInt(value, fallback, name, min) {
+  const v = value ?? fallback;
+  if (!Number.isInteger(v) || v < min)
+    throw new RangeError(`${name} must be an integer \u2265 ${min}, got ${String(value)}`);
+  return v;
+}
+function timeoutSignal(ms) {
+  const signals = AbortSignal;
+  if (typeof signals.timeout === "function")
+    return { signal: signals.timeout(ms), clear: () => void 0 };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), ms);
+  return { signal: controller.signal, clear: () => clearTimeout(timer) };
+}
+function parseRetryAfterMs(value, now) {
+  if (value === null)
+    return void 0;
+  const text = value.trim();
+  if (/^\d+$/.test(text))
+    return Number(text) * 1e3;
+  if (!/^[A-Za-z]{3}/.test(text))
+    return void 0;
+  const at = Date.parse(text);
+  return Number.isFinite(at) ? Math.max(0, at - now) : void 0;
+}
+var compareIds = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+var memoKey = (id, includeKey) => `${id}|${includeKey}`;
+var errorName = (v) => typeof v === "object" && v !== null && typeof v.name === "string" ? v.name : void 0;
+function isTimeout(error, signal) {
+  if (errorName(error) === "TimeoutError")
+    return true;
+  return signal.aborted && errorName(signal.reason) === "TimeoutError";
+}
+var Memo = class {
+  constructor(maxEntries) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.maxEntries = maxEntries;
+  }
+  get(key, now) {
+    const entry = this.entries.get(key);
+    if (!entry)
+      return void 0;
+    this.entries.delete(key);
+    if (entry.expiresAt <= now)
+      return void 0;
+    this.entries.set(key, entry);
+    return entry.result;
+  }
+  set(key, result, expiresAt) {
+    this.entries.delete(key);
+    this.entries.set(key, { result, expiresAt });
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next();
+      if (oldest.done)
+        break;
+      this.entries.delete(oldest.value);
+    }
+  }
+  delete(key) {
+    this.entries.delete(key);
+  }
+};
+function createNamesClient(options) {
+  if (typeof options.baseUrl !== "string" || options.baseUrl.trim() === "") {
+    throw new TypeError("baseUrl is required");
+  }
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const endpoint = `${baseUrl}/v1/resolve`;
+  const getEndpoint = `${baseUrl}/v1/names`;
+  const useGet = options.get !== false;
+  const inBrowser = isBrowser();
+  let getMaxIds = GET_MAX_IDS;
+  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const timeoutMs = positiveInt(options.timeoutMs, DEFAULT_TIMEOUT_MS, "timeoutMs", 1);
+  const maxConcurrent = positiveInt(options.maxConcurrentRequests, DEFAULT_MAX_CONCURRENT_REQUESTS, "maxConcurrentRequests", 1);
+  const backoffBaseMs = positiveInt(options.backoff?.baseMs, DEFAULT_BACKOFF_BASE_MS, "backoff.baseMs", 1);
+  const backoffMaxMs = positiveInt(options.backoff?.maxMs, DEFAULT_BACKOFF_MAX_MS, "backoff.maxMs", 1);
+  const maxRetryAfterMs = positiveInt(options.backoff?.maxRetryAfterMs, DEFAULT_BACKOFF_MAX_RETRY_AFTER_MS, "backoff.maxRetryAfterMs", 0);
+  const extraHeaders = { ...options.headers ?? {} };
+  for (const group of options.include ?? []) {
+    if (!isIncludeGroup(group))
+      throw new RangeError(`include: unknown group ${JSON.stringify(group)}; expected one of ${INCLUDE_GROUPS.join(", ")}`);
+  }
+  const clientInclude = normalizeInclude(options.include ?? DEFAULT_CLIENT_INCLUDE);
+  const onError = options.onError;
+  const cacheOpts = options.cache === false ? null : options.cache ?? {};
+  const minTtlMs = positiveInt(cacheOpts?.minTtlMs, DEFAULT_MIN_TTL_MS, "cache.minTtlMs", 0);
+  const maxTtlMs = positiveInt(cacheOpts?.maxTtlMs, DEFAULT_MAX_TTL_MS, "cache.maxTtlMs", 0);
+  if (maxTtlMs < minTtlMs)
+    throw new RangeError("cache.maxTtlMs must be \u2265 cache.minTtlMs");
+  const memo = cacheOpts ? new Memo(positiveInt(cacheOpts.maxEntries, DEFAULT_CACHE_MAX_ENTRIES, "cache.maxEntries", 1)) : null;
+  const batchOpts = options.batch === false ? null : options.batch ?? {};
+  const maxIds = positiveInt(batchOpts?.maxIds, DEFAULT_BATCH_MAX_IDS, "batch.maxIds", 1);
+  if (maxIds > MAX_BATCH_MAX_IDS)
+    throw new RangeError(`batch.maxIds must be \u2264 ${MAX_BATCH_MAX_IDS} (the worker's per-request limit), got ${maxIds}`);
+  const delayMs = batchOpts ? positiveInt(batchOpts.delayMs, DEFAULT_BATCH_DELAY_MS, "batch.delayMs", 0) : 0;
+  const lanes = /* @__PURE__ */ new Map();
+  const includeKeys = /* @__PURE__ */ new Set();
+  const laneFor = (fresh, include, budgetMs) => {
+    const includeKey = include.join(",");
+    const key = `${fresh ? "fresh" : "normal"}|${includeKey}|${budgetMs ?? ""}`;
+    let lane = lanes.get(key);
+    if (!lane) {
+      includeKeys.add(includeKey);
+      lane = { key, fresh, budgetMs, include, includeKey, inflight: /* @__PURE__ */ new Map(), queue: /* @__PURE__ */ new Map(), scheduled: false };
+      lanes.set(key, lane);
+    }
+    return lane;
+  };
+  const dropIfIdle = (lane) => {
+    if (lane.budgetMs === void 0 || lane.scheduled || lane.queue.size > 0 || lane.inflight.size > 0)
+      return;
+    if (lanes.get(lane.key) === lane)
+      lanes.delete(lane.key);
+  };
+  const report = (error) => {
+    if (!onError)
+      return;
+    try {
+      onError(error);
+    } catch {
+    }
+  };
+  let failures = 0;
+  let blockedUntil = 0;
+  let blockReported = false;
+  const isBlocked = (now) => now < blockedUntil;
+  const recordFailure = (retryAfterMs) => {
+    const now = Date.now();
+    const jitter = 1 - BACKOFF_JITTER + Math.random() * 2 * BACKOFF_JITTER;
+    if (isBlocked(now)) {
+      if (retryAfterMs !== void 0) {
+        blockedUntil = Math.max(blockedUntil, now + Math.min(retryAfterMs, maxRetryAfterMs) * jitter);
+      }
+      return;
+    }
+    const base = retryAfterMs !== void 0 ? Math.min(retryAfterMs, maxRetryAfterMs) : Math.min(backoffMaxMs, backoffBaseMs * 2 ** Math.min(failures, 30));
+    failures += 1;
+    blockedUntil = now + base * jitter;
+    blockReported = false;
+  };
+  const recordSuccess = () => {
+    failures = 0;
+    blockedUntil = 0;
+    blockReported = false;
+  };
+  const reportBlocked = (ids) => {
+    if (blockReported || ids.length === 0)
+      return;
+    blockReported = true;
+    report(new NamesClientError("backoff", `names requests paused until ${new Date(blockedUntil).toISOString()} after a failure`, {
+      ids,
+      blockedUntil
+    }));
+  };
+  let active = 0;
+  const waiting = [];
+  const acquire = () => {
+    if (active < maxConcurrent) {
+      active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve2) => waiting.push(resolve2));
+  };
+  const release = () => {
+    const next = waiting.shift();
+    if (next)
+      next();
+    else
+      active -= 1;
+  };
+  const ttlFor = (result, now) => {
+    if (!result.complete || result.cache === void 0)
+      return minTtlMs;
+    const freshUntil = result.cache.freshUntil;
+    const ttl = freshUntil === null ? maxTtlMs : freshUntil * 1e3 - now;
+    return Math.min(maxTtlMs, Math.max(minTtlMs, ttl));
+  };
+  const finish = (lane, pending, result, fromServer, cut = false) => {
+    if (lane.inflight.get(pending.id) === pending)
+      lane.inflight.delete(pending.id);
+    const keep = result.complete || !cut;
+    if (fromServer && memo && !pending.skipMemo && keep) {
+      const now = Date.now();
+      memo.set(memoKey(pending.id, lane.includeKey), result, now + ttlFor(result, now));
+    }
+    pending.settle(result);
+    dropIfIdle(lane);
+  };
+  const failAll = (lane, batch, error, retryAfterMs) => {
+    recordFailure(retryAfterMs);
+    report(error);
+    for (const p of batch)
+      finish(lane, p, syntheticResult(p.id, lane.include), false);
+  };
+  const answerBlocked = (lane, batch) => {
+    const now = Date.now();
+    for (const p of batch) {
+      const hit = memo?.get(memoKey(p.id, lane.includeKey), now);
+      finish(lane, p, hit ?? syntheticResult(p.id, lane.include), false);
+    }
+    reportBlocked(batch.map((p) => p.id));
+  };
+  const retryAfterOf = (response) => response.status === 429 || response.status === 503 ? parseRetryAfterMs(response.headers.get("retry-after"), Date.now()) : void 0;
+  const getUrlFor = (lane, ids) => {
+    if (!useGet || lane.fresh || lane.budgetMs !== void 0)
+      return void 0;
+    if (ids.length > getMaxIds || !ids.every(fitsGetQuery))
+      return void 0;
+    let query;
+    try {
+      query = ids.map((id) => encodeURIComponent(id)).join(",");
+    } catch {
+      return void 0;
+    }
+    const url = `${getEndpoint}?ids=${query}&include=${lane.includeKey}`;
+    return url.length <= GET_MAX_URL_LENGTH ? url : void 0;
+  };
+  const send = async (lane, batch) => {
+    const ids = batch.map((p) => p.id);
+    const getUrl = getUrlFor(lane, ids);
+    const headers = new Headers(getUrl !== void 0 && inBrowser ? void 0 : extraHeaders);
+    headers.set("accept", "application/json");
+    if (getUrl === void 0)
+      headers.set("content-type", "application/json");
+    else
+      headers.delete("content-type");
+    const timer = timeoutSignal(timeoutMs);
+    const body = {
+      ids,
+      options: {
+        include: [...lane.include],
+        ...lane.fresh ? { fresh: true } : {},
+        ...lane.budgetMs === void 0 ? {} : { budgetMs: lane.budgetMs }
+      }
+    };
+    let response;
+    try {
+      response = await doFetch(getUrl ?? endpoint, getUrl === void 0 ? { method: "POST", headers, body: JSON.stringify(body), signal: timer.signal } : { method: "GET", headers, signal: timer.signal });
+    } catch (cause) {
+      timer.clear();
+      const timedOut = isTimeout(cause, timer.signal);
+      failAll(lane, batch, new NamesClientError(timedOut ? "timeout" : "network", timedOut ? `names request timed out after ${timeoutMs} ms` : "names request failed", { ids, cause }));
+      return;
+    }
+    if (getUrl !== void 0 && response.status === 400) {
+      timer.clear();
+      void response.body?.cancel().catch(() => void 0);
+      getMaxIds = Math.min(getMaxIds, ids.length - 1);
+      await send(lane, batch);
+      return;
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (cause) {
+      timer.clear();
+      if (!response.ok) {
+        failAll(lane, batch, new NamesClientError("http", `names request failed with HTTP ${response.status}`, { ids, status: response.status, cause }), retryAfterOf(response));
+      } else {
+        const timedOut = isTimeout(cause, timer.signal);
+        failAll(lane, batch, new NamesClientError(timedOut ? "timeout" : "invalid_response", timedOut ? `names request timed out after ${timeoutMs} ms` : "names response is not JSON", { ids, cause }));
+      }
+      return;
+    }
+    timer.clear();
+    if (!response.ok) {
+      const envelope = isErrorResponse(payload) ? payload : void 0;
+      const detail = envelope ? `: ${envelope.error.code}` : "";
+      failAll(lane, batch, new NamesClientError("http", `names request failed with HTTP ${response.status}${detail}`, {
+        ids,
+        status: response.status,
+        ...envelope ? { response: envelope } : {}
+      }), retryAfterOf(response));
+      return;
+    }
+    const results = isRecord(payload) && isRecord(payload.results) ? payload.results : null;
+    if (!results) {
+      failAll(lane, batch, new NamesClientError("invalid_response", "names response has no results object", { ids }));
+      return;
+    }
+    recordSuccess();
+    const cut = cutByBudget(payload, lane.budgetMs);
+    const missing = [];
+    for (const p of batch) {
+      const candidate = Object.prototype.hasOwnProperty.call(results, p.id) ? results[p.id] : void 0;
+      if (!isResolvedName(candidate, p.id, lane.include)) {
+        missing.push(p.id);
+        finish(lane, p, syntheticResult(p.id, lane.include), false);
+      } else if (candidate.kind === "unknown" && isMatrixUserId(p.id)) {
+        finish(lane, p, syntheticResult(p.id, lane.include), true);
+      } else {
+        finish(lane, p, candidate, true, cut);
+      }
+    }
+    if (missing.length > 0) {
+      report(new NamesClientError("invalid_response", `names response lacks a valid result for ${missing.length} id(s)`, { ids: missing }));
+    }
+  };
+  const run = async (lane, batch) => {
+    await acquire();
+    try {
+      if (isBlocked(Date.now())) {
+        answerBlocked(lane, batch);
+        return;
+      }
+      await send(lane, batch);
+    } catch (cause) {
+      failAll(lane, batch, new NamesClientError("network", "names request failed", { ids: batch.map((p) => p.id), cause }));
+    } finally {
+      release();
+    }
+  };
+  const dispatch = (lane, pendings) => {
+    for (const p of pendings)
+      p.sent = true;
+    const sorted = [...pendings].sort(compareIds);
+    for (let i = 0; i < sorted.length; i += maxIds) {
+      void run(lane, sorted.slice(i, i + maxIds));
+    }
+  };
+  const flush = (lane) => {
+    lane.scheduled = false;
+    const pendings = [...lane.queue.values()];
+    lane.queue.clear();
+    dispatch(lane, pendings);
+  };
+  const schedule = (lane) => {
+    if (lane.scheduled)
+      return;
+    lane.scheduled = true;
+    if (delayMs === 0)
+      queueMicrotask(() => flush(lane));
+    else
+      setTimeout(() => flush(lane), delayMs);
+  };
+  const newPending = (id) => {
+    let settle;
+    const promise = new Promise((resolve2) => {
+      settle = resolve2;
+    });
+    return { id, promise, settle, sent: false, skipMemo: false };
+  };
+  const resolve = async (ids, callOptions = {}) => {
+    const lane = laneFor(callOptions.fresh === true, normalizeInclude(callOptions.include ?? clientInclude), normalizeBudget(callOptions.budgetMs));
+    const now = Date.now();
+    const answers = /* @__PURE__ */ new Map();
+    const created = [];
+    const blocked = isBlocked(now);
+    const unsent = [];
+    for (const id of ids) {
+      if (answers.has(id))
+        continue;
+      if (!isSendable(id)) {
+        answers.set(id, invalidIdentifierResult(id, lane.include));
+        continue;
+      }
+      const key = memoKey(id, lane.includeKey);
+      if (!lane.fresh) {
+        const hit = memo?.get(key, now);
+        if (hit) {
+          answers.set(id, hit);
+          continue;
+        }
+      }
+      const existing = lane.inflight.get(id);
+      if (existing) {
+        answers.set(id, existing.promise);
+        continue;
+      }
+      if (blocked) {
+        answers.set(id, (lane.fresh ? memo?.get(key, now) : void 0) ?? syntheticResult(id, lane.include));
+        unsent.push(id);
+        continue;
+      }
+      const pending = newPending(id);
+      lane.inflight.set(id, pending);
+      created.push(pending);
+      answers.set(id, pending.promise);
+    }
+    reportBlocked(unsent);
+    if (created.length > 0) {
+      if (batchOpts) {
+        for (const p of created)
+          lane.queue.set(p.id, p);
+        schedule(lane);
+      } else {
+        dispatch(lane, created);
+      }
+    }
+    dropIfIdle(lane);
+    const entries = await Promise.all([...answers.entries()].map(async ([id, answer]) => [id, await answer]));
+    return Object.fromEntries(entries);
+  };
+  const one = async (id, include) => {
+    try {
+      const results = await resolve([id], { include });
+      return results[id] ?? syntheticResult(id, normalizeInclude(include));
+    } catch {
+      return syntheticResult(id, normalizeInclude(include));
+    }
+  };
+  return {
+    resolve,
+    async name(id) {
+      return (await one(id, NAME_INCLUDE)).name ?? null;
+    },
+    async display(id) {
+      try {
+        return (await one(id, NAME_INCLUDE)).display;
+      } catch {
+        return abbreviate(id);
+      }
+    },
+    async matrix(id) {
+      try {
+        return (await one(id, MATRIX_INCLUDE)).matrix ?? null;
+      } catch {
+        return null;
+      }
+    },
+    async room(id) {
+      try {
+        return (await one(id, ROOM_INCLUDE)).room ?? null;
+      } catch {
+        return null;
+      }
+    },
+    async prefetch(ids, prefetchOptions) {
+      try {
+        await resolve(ids, prefetchOptions);
+      } catch {
+      }
+    },
+    peek(id, include) {
+      return memo?.get(memoKey(id, normalizeInclude(include ?? clientInclude).join(",")), Date.now());
+    },
+    invalidate(ids) {
+      for (const id of ids) {
+        for (const includeKey of includeKeys)
+          memo?.delete(memoKey(id, includeKey));
+        for (const lane of lanes.values()) {
+          const p = lane.inflight.get(id);
+          if (p?.sent) {
+            p.skipMemo = true;
+            lane.inflight.delete(id);
+          }
+        }
+      }
+    },
+    blockedUntil() {
+      return isBlocked(Date.now()) ? blockedUntil : 0;
+    },
+    abbreviate
+  };
+}
+
+// ../../node_modules/.pnpm/@ixo+names-client@0.2.1_react@19.2.8/node_modules/@ixo/names-client/dist/index.js
+var NAMES_CLIENT_VERSION = "0.2.1";
+//# sourceMappingURL=client.js.map