@aoxborrow/registrar-client 0.8.0 → 0.9.1

package/dist/index.js

@@ -1076,8 +1076,8 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
           message: `${domainName} is not a zone in this account; DNS is managed via the Zones API`
         };
       }
-      const dnsPath = `/zones/${encodeURIComponent(zone.id)}/dns_records`;
-      const list = await this.http.request({ path: dnsPath, ...opts });
+      const dnsPath2 = `/zones/${encodeURIComponent(zone.id)}/dns_records`;
+      const list = await this.http.request({ path: dnsPath2, ...opts });
       if (!list.success) {
         return {
           success: false,
@@ -1088,7 +1088,7 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
         if (!rec.id) continue;
         const del = await this.http.request({
           method: "DELETE",
-          path: `${dnsPath}/${encodeURIComponent(rec.id)}`,
+          path: `${dnsPath2}/${encodeURIComponent(rec.id)}`,
           ...opts
         });
         if (!del.success) {
@@ -1104,7 +1104,7 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
         if (type === "NS" && name === zone.name) continue;
         const create = await this.http.request({
           method: "POST",
-          path: dnsPath,
+          path: dnsPath2,
           body: toCfDnsBody(record, type, name),
           ...opts
         });
@@ -1773,6 +1773,539 @@ function toContact(c) {
   return contact;
 }
 
+// src/registrars/domain101.ts
+var Domain101HttpClient = class extends HttpClient {
+  async request(req) {
+    try {
+      return await super.request(req);
+    } catch (error) {
+      if (error instanceof AuthorizationError) {
+        const scope = requiredScope(req);
+        if (!scope || error.providerCode !== "INSUFFICIENT_PERMISSIONS") throw error;
+        const scoped = new AuthorizationError(
+          `101domain: this API key does not have the ${scope} scope. Create a key with ${scope} to ${SCOPE_PURPOSE[scope]}.`
+        );
+        scoped.providerCode = error.providerCode;
+        throw scoped;
+      }
+      if (error instanceof OutcomeUnknownError)
+        throw new OutcomeUnknownError(
+          "101domain: the registrar did not confirm this change. Re-read the domain before trying again.",
+          { feature: error.feature }
+        );
+      if (error instanceof ParsingError) throw new ParsingError("101domain: invalid JSON response");
+      if (error instanceof ConnectionError)
+        throw new ConnectionError("101domain: network request failed", { notSent: error.notSent });
+      throw error;
+    }
+  }
+  async toStatusError(response, url) {
+    const detail = await errorDetail(response);
+    const error = await super.toStatusError(
+      new Response(null, { status: response.status, headers: response.headers }),
+      url
+    );
+    if (detail) {
+      error.message = `101domain: ${detail.message}`;
+      error.providerCode = detail.code;
+    } else if (response.status === 403) {
+      error.message = "101domain: the request was refused before reaching the API (403 without an API error)";
+    }
+    return error;
+  }
+};
+var SCOPE_PURPOSE = {
+  domains_read: "read the domain portfolio",
+  domains_write: "change URL forwarding",
+  dns_read: "read DNS records and nameservers",
+  dns_write: "change DNS records and nameservers"
+};
+function requiredScope(req) {
+  const write = !REST_SAFE_METHODS.includes((req.method ?? "GET").toUpperCase());
+  if (req.path.startsWith("/dns/")) return write ? "dns_write" : "dns_read";
+  if (req.path === "/domains" || /^\/domains\/[^/]+(?:\/forwarding)?$/.test(req.path))
+    return write ? "domains_write" : "domains_read";
+  return void 0;
+}
+async function errorDetail(response) {
+  try {
+    const body = await response.json();
+    if (typeof body?.code !== "string" || typeof body.message !== "string" || !body.message)
+      return null;
+    return { code: body.code, message: body.message.replace(/\s+/g, " ").slice(0, 200) };
+  } catch {
+    return null;
+  }
+}
+var Domain101Registrar = class extends BaseRegistrar {
+  name = "101domain";
+  static safeMethods = REST_SAFE_METHODS;
+  static displayName = "101domain";
+  static website = "101domain.com";
+  static supportsSandbox = false;
+  static configFields = [
+    { name: "apiKey", label: "API key", type: "password", required: true }
+  ];
+  static helpText = "Create a Bearer API key under My Account > Developer Tools - API & MCP. Use domains_read and dns_read for reads; dns_write for DNS/nameservers and domains_write for forwarding. Only a primary account with 2FA or SSO can create keys. Keys expire after at most one year. Registration, renewal, auto-renew, privacy, lock, contacts and transfers are not available through this API.";
+  static extendedFeatures = [
+    Feature.GetDomainForwarding,
+    Feature.SetDomainForwarding
+  ];
+  constructor(credentials, options) {
+    const apiKey = credentials.apiKey?.trim() ?? "";
+    if (/[\r\n]/.test(apiKey)) throw new ConfigurationError("101domain: invalid API key format");
+    const config = {
+      baseUrl: selectBaseUrl("101domain", options?.environment, {
+        production: "https://api.101domain.com/v1"
+      }),
+      headers: { Authorization: `Bearer ${apiKey}` }
+    };
+    super(credentials, config, options);
+    this.http = new Domain101HttpClient({
+      ...config,
+      safeMethods: REST_SAFE_METHODS,
+      options: this.options
+    });
+  }
+  async testConnection(opts) {
+    try {
+      await this.request({
+        path: "/domains",
+        query: { page: 1, per_page: 1 },
+        ...opts
+      });
+      return { success: true, message: "Connection successful" };
+    } catch (error) {
+      return { success: false, message: toRegistrarError(error).message };
+    }
+  }
+  async listDomains(opts) {
+    const { search, detailed: _detailed, ...requestOpts } = opts ?? {};
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let page = 1; ; page++) {
+      const response = await this.request({
+        path: "/domains",
+        query: { page, per_page: 50 },
+        ...requestOpts
+      });
+      if (!Array.isArray(response.data)) throw invalid("domain list");
+      const pagination = response.meta?.pagination;
+      if (!pagination || pagination.current_page !== page || !Number.isInteger(pagination.total_pages) || pagination.total_pages < 0 || pagination.total_pages > 1e5 || !Number.isInteger(pagination.total) || pagination.total < 0)
+        throw invalid("pagination");
+      for (const raw of response.data) {
+        const domain = toDomain(raw);
+        if (seen.has(domain.domainName)) throw invalid("duplicate domain across pages");
+        seen.add(domain.domainName);
+        result.push(domain);
+      }
+      if (page >= pagination.total_pages) {
+        if (result.length !== pagination.total) throw invalid("incomplete portfolio");
+        return filterDomains(
+          result.filter((d) => !d.deleted),
+          search
+        );
+      }
+      if (!response.data.length) throw invalid("empty intermediate page");
+    }
+  }
+  async getDomain(domainName, opts) {
+    const domain = toDomain(
+      (await this.request({ path: domainPath(domainName), ...opts })).data
+    );
+    if (domain.domainName !== normalizeDomain(domainName)) throw invalid("domain identity");
+    return domain;
+  }
+  async getNameservers(domainName, opts) {
+    const raw = (await this.request({ path: `${dnsPath(domainName)}/nameservers`, ...opts })).data;
+    if (!Array.isArray(raw) || raw.some((n) => typeof n !== "string")) throw invalid("nameservers");
+    return raw.map((n) => n.toLowerCase());
+  }
+  async updateNameservers(domainName, nameservers, opts) {
+    const normalized = nameservers.map((n) => n.trim().toLowerCase());
+    if (normalized.length < 2 || normalized.length > 13 || new Set(normalized).size !== normalized.length || normalized.some((n) => !/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9-]+$/.test(n)))
+      throw new ConfigurationError("101domain: provide 2\u201313 distinct nameserver hostnames");
+    try {
+      const response = await this.request({
+        ...opts,
+        method: "PUT",
+        path: `${dnsPath(domainName)}/nameservers`,
+        body: { nameservers: normalized }
+      });
+      if (response.data?.change_status === "pending")
+        return {
+          success: true,
+          pending: true,
+          message: "Nameserver change submitted; pending registry processing. Re-read nameservers to confirm completion."
+        };
+      if (response.data?.change_status === "failed")
+        return { success: false, message: "101domain rejected the nameserver change" };
+      if (response.data?.change_status !== "completed")
+        throw new OutcomeUnknownError(
+          "101domain: invalid nameserver change confirmation. Re-read nameservers before trying again."
+        );
+      return { success: true, message: "Nameservers already configured as requested" };
+    } catch (error) {
+      return failed(error);
+    }
+  }
+  async checkAvailability(domainNames, opts) {
+    const names = [...new Set(domainNames.map(normalizeDomain))];
+    const result = [];
+    for (const domains of chunks(names, 50)) {
+      const response = await this.request({
+        ...opts,
+        method: "POST",
+        path: "/domains/bulk-search",
+        body: { domains, pricing_term: 1 }
+      });
+      if (!Array.isArray(response.data) || (response.invalid?.length ?? 0) > 0)
+        throw invalid("availability results");
+      const found = /* @__PURE__ */ new Set();
+      for (const raw of response.data) {
+        if (typeof raw.domain_name !== "string" || typeof raw.available !== "boolean")
+          throw invalid("availability result");
+        const domainName = normalizeDomain(raw.domain_name);
+        if (!domains.includes(domainName) || found.has(domainName))
+          throw invalid("availability identity");
+        found.add(domainName);
+        const price2 = oneYear(raw.pricing);
+        result.push({
+          domainName,
+          available: raw.available,
+          premium: price2?.premium,
+          price: amount(price2?.register),
+          renewalPrice: amount(price2?.renew),
+          currency: price2?.currency,
+          period: 1
+        });
+      }
+      if (found.size !== domains.length) throw invalid("incomplete availability results");
+    }
+    return result;
+  }
+  async getPricing(tldOrDomain, opts) {
+    const name = normalizeDomain(tldOrDomain);
+    if (name.startsWith(".") || !name.includes(".")) {
+      const tld = name.replace(/^\./, "");
+      const response2 = await this.request({
+        path: `/tlds/${encodeURIComponent("." + tld)}`,
+        query: { pricing_terms: "1" },
+        ...opts
+      });
+      const price3 = oneYear(response2.data?.pricing);
+      if (!price3) throw new NotFoundError("101domain: no one-year pricing for this TLD");
+      return {
+        tld,
+        currency: price3.currency,
+        registration: amount(price3.register),
+        renewal: amount(price3.renew),
+        transfer: amount(price3.transfer)
+      };
+    }
+    const response = await this.request({
+      path: "/domains/search",
+      query: { domain_name: name, pricing_terms: "1" },
+      ...opts
+    });
+    const raw = response.data;
+    if (!raw || normalizeDomain(raw.domain_name) !== name) throw invalid("pricing identity");
+    const price2 = oneYear(raw.pricing);
+    if (!price2) throw new NotFoundError("101domain: pricing unavailable for this domain");
+    return {
+      tld: name.slice(name.indexOf(".") + 1),
+      currency: price2.currency,
+      registration: amount(price2.register),
+      renewal: amount(price2.renew),
+      transfer: amount(price2.transfer)
+    };
+  }
+  async getDnsRecords(domainName, opts) {
+    return (await this.rawRecords(domainName, opts)).map(fromRecord);
+  }
+  // Reconcile by content-derived IDs. Preserve unchanged records, edit by ID, create additions
+  // before removing stale records, and stop on any failed batch. Never retry an
+  // uncertain write. This replaces the custom records, not the apex NS delegation.
+  async setDnsRecords(domainName, records, opts) {
+    const desired = records.map((r) => recordSpec(r, domainName));
+    const unique = desired.filter(
+      (r, i) => desired.findIndex((other) => recordSignature(other) === recordSignature(r)) === i
+    );
+    let changed = false;
+    try {
+      const stale = (await this.rawRecords(domainName, opts)).map((raw) => ({ raw, spec: recordSpec(fromRecord(raw), domainName, false) })).filter(({ spec }) => !(spec.type === "NS" && spec.name === ""));
+      const additions = [];
+      const edits = [];
+      for (const record of unique) {
+        const index = stale.findIndex(
+          ({ spec }) => recordSignature(spec) === recordSignature(record)
+        );
+        if (index >= 0) stale.splice(index, 1);
+        else {
+          const priorIndex = stale.findIndex(
+            ({ spec }) => spec.type === record.type && spec.name === record.name
+          );
+          const prior = priorIndex >= 0 ? stale.splice(priorIndex, 1)[0].raw : void 0;
+          if (prior?.proxied) record.proxied = true;
+          if (record.ttl === 1 && record.proxied !== true)
+            throw new ConfigurationError(
+              "101domain: automatic TTL requires an existing proxied SWA record"
+            );
+          if (prior) {
+            const edit = { ...record, id: prior.id };
+            delete edit.name;
+            delete edit.type;
+            edits.push(edit);
+          } else additions.push(record);
+        }
+      }
+      for (const batch of chunks(edits, 25)) {
+        const response = await this.request({
+          ...opts,
+          method: "PATCH",
+          path: `${dnsPath(domainName)}/records`,
+          body: { records: batch }
+        });
+        if (!Array.isArray(response.data) || response.data.length !== batch.length || new Set(response.data.map((r) => r?.old_id)).size !== batch.length || response.data.some(
+          (r) => !r || !batch.some((edit) => edit.id === r.old_id) || typeof r.id !== "string" || !r.id
+        ))
+          throw new OutcomeUnknownError(
+            "101domain: invalid DNS edit confirmation. Re-read the zone before trying again."
+          );
+        changed = true;
+      }
+      for (const batch of chunks(additions, 25)) {
+        await this.request({
+          ...opts,
+          method: "POST",
+          path: `${dnsPath(domainName)}/records`,
+          body: { records: batch }
+        });
+        changed = true;
+      }
+      for (const batch of chunks(stale, 25)) {
+        await this.request({
+          ...opts,
+          method: "DELETE",
+          path: `${dnsPath(domainName)}/records`,
+          body: { ids: batch.map(({ raw }) => raw.id) }
+        });
+        changed = true;
+      }
+      return { success: true, message: "DNS records updated successfully" };
+    } catch (error) {
+      const result = failed(error);
+      if (!changed && !result.outcome) return result;
+      return {
+        ...result,
+        message: `${result.message}. DNS replacement is not atomic; read the zone before retrying.`
+      };
+    }
+  }
+  async getDomainForwarding(domainName, opts) {
+    const raw = (await this.request({
+      path: domainPath(domainName),
+      ...opts
+    })).data;
+    if (!raw || normalizeDomain(raw.domain_name) !== normalizeDomain(domainName))
+      throw invalid("domain identity");
+    const forward = raw.web_forwarding;
+    if (forward === null || forward?.destination === null && forward.type === null) return [];
+    if (!forward || typeof forward.destination !== "string" || forward.type !== "301" && forward.type !== "cloak")
+      throw invalid("forwarding");
+    return [
+      {
+        host: "@",
+        url: forward.destination,
+        type: forward.type === "301" ? "permanent" : "masked"
+      }
+    ];
+  }
+  async setDomainForwarding(domainName, forwards, opts) {
+    if (forwards.length > 1 || forwards.some((f) => f.host !== "@" || f.type !== "permanent"))
+      throw new ConfigurationError(
+        "101domain: only one permanent apex forwarding rule is supported"
+      );
+    if (forwards.length) {
+      let url;
+      try {
+        url = new URL(forwards[0].url);
+      } catch {
+        throw new ConfigurationError("101domain: forwarding needs a valid HTTP(S) URL");
+      }
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+        throw new ConfigurationError("101domain: forwarding needs a valid HTTP(S) URL");
+    }
+    try {
+      const existing = await this.getDomainForwarding(domainName, opts);
+      const path = `${domainPath(domainName)}/forwarding`;
+      if (!forwards.length) {
+        if (existing.length) await this.request({ ...opts, method: "DELETE", path });
+      } else if (existing[0]?.url !== forwards[0].url || existing[0]?.type !== "permanent") {
+        await this.request({
+          ...opts,
+          method: existing.length ? "PATCH" : "POST",
+          path,
+          body: { destination: forwards[0].url, type: "301" }
+        });
+      }
+      return {
+        success: true,
+        message: forwards.length ? "URL forwarding updated" : "URL forwarding cleared"
+      };
+    } catch (error) {
+      return failed(error);
+    }
+  }
+  async request(req) {
+    const raw = await this.http.request(req);
+    if (!raw || typeof raw !== "object" || raw.status !== "success" || !("data" in raw)) {
+      if (req.call?.intent === "write" && !REST_SAFE_METHODS.includes(req.method ?? "GET"))
+        throw new OutcomeUnknownError(
+          "101domain: invalid write confirmation. Re-read the domain before trying again."
+        );
+      throw invalid("response envelope");
+    }
+    return raw;
+  }
+  async rawRecords(domainName, opts) {
+    const raw = (await this.request({ path: `${dnsPath(domainName)}/records`, ...opts })).data;
+    if (!Array.isArray(raw) || raw.some(
+      (r) => !r || typeof r.id !== "string" || !r.id || typeof r.name !== "string" || typeof r.value !== "string" || typeof r.type !== "string" || !Number.isInteger(r.ttl)
+    ))
+      throw invalid("DNS records");
+    if (new Set(raw.map((r) => r.id)).size !== raw.length) throw invalid("duplicate DNS ids");
+    return raw;
+  }
+};
+function invalid(part) {
+  return new InvalidResponseError(`101domain: invalid ${part}`);
+}
+function failed(error) {
+  return {
+    success: false,
+    message: toRegistrarError(error).message,
+    ...error instanceof OutcomeUnknownError ? { outcome: "unknown" } : {}
+  };
+}
+function domainPath(name) {
+  return `/domains/${encodeURIComponent(normalizeDomain(name))}`;
+}
+function dnsPath(name) {
+  return `/dns/${encodeURIComponent(normalizeDomain(name))}`;
+}
+function chunks(items, size) {
+  const result = [];
+  for (let i = 0; i < items.length; i += size) result.push(items.slice(i, i + size));
+  return result;
+}
+function oneYear(pricing) {
+  if (pricing == null) return void 0;
+  if (!Array.isArray(pricing)) throw invalid("pricing");
+  return pricing.find((p) => p?.term_years === 1);
+}
+function amount(raw) {
+  if (raw == null) return void 0;
+  if (!/^\d+(?:\.\d+)?$/.test(raw)) throw invalid("price");
+  const value = Number(raw);
+  if (!Number.isFinite(value)) throw invalid("price");
+  return value;
+}
+function toDomain(raw) {
+  if (!raw || typeof raw.domain_name !== "string" || !raw.domain_name.trim())
+    throw invalid("domain");
+  return createDomain({
+    domainName: normalizeDomain(raw.domain_name),
+    registrar: "101domain",
+    status: raw.status,
+    createdDate: raw.registered_at,
+    expirationDate: raw.expires_at,
+    autoRenew: raw.auto_renew,
+    locked: raw.registry_statuses?.some((s) => /^clientTransferProhibited$/i.test(s)),
+    nameservers: raw.nameservers,
+    deleted: !isHeld(raw)
+  });
+}
+var GONE = /* @__PURE__ */ new Set(["DELETED", "CANCELLED", "DENIED", "XFER_AWAY"]);
+function isHeld(raw) {
+  const status = raw.status?.toUpperCase() ?? "";
+  return !GONE.has(status) && !status.startsWith("XFER_IN_") && raw.registered_at != null;
+}
+function fromRecord(raw) {
+  const common = { name: raw.name || "@", type: raw.type, ttl: raw.ttl };
+  if (raw.type === "MX") {
+    const match = /^(\d+)\s+(.+)$/.exec(raw.value);
+    if (!match) throw invalid("MX record");
+    return { ...common, value: canonicalValue("MX", match[2]), priority: Number(match[1]) };
+  }
+  if (raw.type === "SRV") {
+    const match = /^(\d+)\s+(\d+)\s+(\d+)\s+(.+)$/.exec(raw.value);
+    if (!match) throw invalid("SRV record");
+    return {
+      ...common,
+      value: canonicalValue("SRV", match[4]),
+      priority: Number(match[1]),
+      weight: Number(match[2]),
+      port: Number(match[3])
+    };
+  }
+  return { ...common, value: canonicalValue(raw.type, raw.value) };
+}
+function canonicalValue(type, value) {
+  const kind = type.toUpperCase();
+  if (kind === "TXT") return unquoteTxt(value);
+  if (["CNAME", "NS", "MX", "SRV"].includes(kind))
+    return value === "." ? "." : value.replace(/\.$/, "");
+  return value;
+}
+function unquoteTxt(value) {
+  const chunk = /"((?:[^"\\]|\\.)*)"/g;
+  if (!/^\s*"(?:[^"\\]|\\.)*"(?:\s+"(?:[^"\\]|\\.)*")*\s*$/.test(value)) return value;
+  return [...value.matchAll(chunk)].map((m) => m[1].replace(/\\(.)/g, "$1")).join("");
+}
+function recordSpec(record, domain, strict = true) {
+  const type = record.type.toUpperCase();
+  const zone = normalizeDomain(domain);
+  let name = record.name.trim().toLowerCase().replace(/\.$/, "");
+  if (name === zone || name === "@") name = "";
+  else if (name.endsWith("." + zone)) name = name.slice(0, -zone.length - 1);
+  const reject = (message) => {
+    if (strict) throw new ConfigurationError(`101domain: ${message}`);
+  };
+  if (!["A", "AAAA", "CNAME", "NS", "MX", "TXT", "SRV", "CAA"].includes(type) || type === "NS" && !name)
+    reject("unsupported DNS type or apex NS record");
+  const ttl = record.ttl ?? 3600;
+  if (!Number.isInteger(ttl) || ttl !== 1 && ttl < 300)
+    reject("DNS TTL must be at least 300 seconds");
+  const result = { name, type, ttl };
+  if (type === "MX" || type === "SRV") {
+    if (!Number.isInteger(record.priority) || record.priority < 0 || record.priority > 65535)
+      reject("MX/SRV priority is required");
+    result.priority = record.priority;
+    result.target = canonicalValue(type, record.value);
+    if (type === "SRV") {
+      if (![record.weight, record.port].every((n) => Number.isInteger(n) && n >= 0 && n <= 65535))
+        reject("SRV weight and port are required");
+      result.weight = record.weight;
+      result.port = record.port;
+    }
+  } else if (type === "CAA") {
+    const match = /^(\d+)\s+(\w+)\s+"([\s\S]*)"$/.exec(record.value);
+    if (!match || Number(match[1]) > 255) {
+      reject("CAA needs flags, tag and quoted value");
+      result.value = record.value;
+    } else {
+      result.flag = Number(match[1]);
+      result.tag = match[2];
+      result.value = match[3];
+    }
+  } else result.value = canonicalValue(type, record.value);
+  return result;
+}
+function recordSignature(record) {
+  return JSON.stringify(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+
 // src/registrars/dynadot.ts
 var DYNADOT_DEFAULT_NS = ["ns1.dynadot.com", "ns2.dynadot.com"];
 var SEARCH_BATCH_SIZE = 100;
@@ -2450,12 +2983,12 @@ function isPrivacyOn(privacy) {
 }
 function oneYearPrice(prices) {
   if (!prices?.length) return void 0;
-  const oneYear = prices.find((p) => /\b1\s*year\b/i.test(p.unit ?? "")) ?? prices[0];
+  const oneYear2 = prices.find((p) => /\b1\s*year\b/i.test(p.unit ?? "")) ?? prices[0];
   return {
-    currency: oneYear.currency,
-    registration: toNumber(oneYear.registration_price),
-    renewal: toNumber(oneYear.renewal_price),
-    transfer: toNumber(oneYear.transfer_price)
+    currency: oneYear2.currency,
+    registration: toNumber(oneYear2.registration_price),
+    renewal: toNumber(oneYear2.renewal_price),
+    transfer: toNumber(oneYear2.transfer_price)
   };
 }
 function extractNameservers(glue) {
@@ -2745,8 +3278,8 @@ var GandiRegistrar = class extends BaseRegistrar {
         available: status.startsWith("available"),
         premium: status.includes("premium") || price2?.type === "premium"
       };
-      const amount = pickPrice(price2);
-      if (amount != null) result.price = amount;
+      const amount2 = pickPrice(price2);
+      if (amount2 != null) result.price = amount2;
       if (resp.currency) result.currency = resp.currency;
       if (price2?.duration_unit === "y" && price2.min_duration != null) {
         result.period = price2.min_duration;
@@ -5259,7 +5792,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   }
   async getAuthCode(domainName, opts) {
     const result = await this.http.request({
-      path: `${domainPath(domainName)}:getAuthCode`,
+      path: `${domainPath2(domainName)}:getAuthCode`,
       ...opts
     });
     if (!result?.authCode) throw new InvalidResponseError("namecom: missing authorization code");
@@ -5354,7 +5887,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
     validYears(years);
     const pricing = await this.domainPricing(domainName, years, opts);
     return this.purchase(
-      `${domainPath(domainName)}:renew`,
+      `${domainPath2(domainName)}:renew`,
       {
         years,
         purchasePrice: purchaseQuote(pricing, "renewalPrice")
@@ -5399,7 +5932,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   }
   updateNameservers(domainName, nameservers, opts) {
     return this.mutate(
-      { method: "POST", path: `${domainPath(domainName)}:setNameservers`, body: { nameservers } },
+      { method: "POST", path: `${domainPath2(domainName)}:setNameservers`, body: { nameservers } },
       opts
     );
   }
@@ -5430,14 +5963,14 @@ var NamecomRegistrar = class extends BaseRegistrar {
     return this.mutate(
       {
         method: "POST",
-        path: `${domainPath(domainName)}:setContacts`,
+        path: `${domainPath2(domainName)}:setContacts`,
         body: { contacts: toContacts(contacts) }
       },
       opts
     );
   }
   async getDnsRecords(domainName, opts) {
-    return (await this.pages(`${domainPath(domainName)}/records`, "records", opts)).map(fromRecord);
+    return (await this.pages(`${domainPath2(domainName)}/records`, "records", opts)).map(fromRecord2);
   }
   // No bulk replace endpoint. Reconcile by id: preserve identical records, update
   // existing type/host pairs, create additions, then delete stale records. This
@@ -5445,7 +5978,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   async setDnsRecords(domainName, records, opts) {
     const desired = records.map(toRecord).filter((record, index, all) => all.findIndex((other) => sameRecord(other, record)) === index);
     try {
-      const path = `${domainPath(domainName)}/records`;
+      const path = `${domainPath2(domainName)}/records`;
       const existing = await this.pages(path, "records", opts);
       if (existing.some((r) => !Number.isInteger(r.id) || r.id <= 0))
         throw new InvalidResponseError("namecom: DNS response missing record ids");
@@ -5482,14 +6015,14 @@ var NamecomRegistrar = class extends BaseRegistrar {
     }
   }
   patchDomain(domainName, body, opts) {
-    return this.mutate({ method: "PATCH", path: domainPath(domainName), body }, opts);
+    return this.mutate({ method: "PATCH", path: domainPath2(domainName), body }, opts);
   }
   rawDomain(domainName, opts) {
-    return this.http.request({ path: domainPath(domainName), ...opts });
+    return this.http.request({ path: domainPath2(domainName), ...opts });
   }
   domainPricing(domainName, years, opts) {
     return this.http.request({
-      path: `${domainPath(domainName)}:getPricing`,
+      path: `${domainPath2(domainName)}:getPricing`,
       query: { years },
       ...opts
     });
@@ -5605,7 +6138,7 @@ function toContacts(contacts) {
     throw new ConfigurationError("namecom: at least one contact is required");
   return result;
 }
-function domainPath(domainName) {
+function domainPath2(domainName) {
   return `/domains/${encodeURIComponent(normalizeDomain(domainName))}`;
 }
 function validYears(years) {
@@ -5645,7 +6178,7 @@ function toRecord(r) {
     ...["MX", "SRV"].includes(type) ? { priority: r.priority ?? 0 } : {}
   };
 }
-function fromRecord(r) {
+function fromRecord2(r) {
   const type = r.type.toUpperCase();
   const record = { type, name: r.host || "@", value: r.answer, ttl: r.ttl };
   if (type === "MX" || type === "SRV") record.priority = r.priority ?? 0;
@@ -7466,22 +7999,347 @@ function toSpaceshipContact(c) {
 
 // src/registrars/index.ts
 var registrars = {
-  cloudflare: CloudflareRegistrar,
-  dynadot: DynadotRegistrar,
-  gandi: GandiRegistrar,
-  godaddy: GoDaddyRegistrar,
-  namebright: NameBrightRegistrar,
-  namecheap: NamecheapRegistrar,
-  namecom: NamecomRegistrar,
-  namesilo: NameSiloRegistrar,
-  porkbun: PorkbunRegistrar,
-  spaceship: SpaceshipRegistrar
+  "101domain": Domain101Registrar,
+  "cloudflare": CloudflareRegistrar,
+  "dynadot": DynadotRegistrar,
+  "gandi": GandiRegistrar,
+  "godaddy": GoDaddyRegistrar,
+  "namebright": NameBrightRegistrar,
+  "namecheap": NamecheapRegistrar,
+  "namecom": NamecomRegistrar,
+  "namesilo": NameSiloRegistrar,
+  "porkbun": PorkbunRegistrar,
+  "spaceship": SpaceshipRegistrar
 };
 function createRegistrar(name, credentials, options) {
   const RegistrarClass = registrars[name];
   return new RegistrarClass(credentials, options);
 }
 
-export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, isCoreFeature, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, registrars, requireConsent, selectBaseUrl, settableForwards, sleep, toRegistrarError, wasNotSent };
+// src/dns-records.ts
+var DnsSyntaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DnsSyntaxError";
+  }
+};
+var NAME_LIMIT = 253;
+var LABEL_LIMIT = 63;
+var TTL_LIMIT = 2147483647;
+var TEXT_OCTETS = 255;
+var TEXT_TOTAL_OCTETS = 65535 - Math.ceil(65535 / (TEXT_OCTETS + 1));
+var UINT16_MAX = 65535;
+var DIGEST_HEX_LENGTH = {
+  1: 40,
+  2: 64,
+  3: 64,
+  4: 96
+};
+var KINDS_ALLOWED_BESIDE_CNAME = /* @__PURE__ */ new Set(["CNAME", "RRSIG", "NSEC", "NSEC3"]);
+function mapAsciiLabel(label) {
+  const folded = label.toLowerCase();
+  if (folded.length < 1 || folded.length > LABEL_LIMIT) return null;
+  if (!/^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?$/.test(folded)) return null;
+  return folded;
+}
+var labelMapper = mapAsciiLabel;
+function useLabelMapper(mapper) {
+  labelMapper = mapper;
+}
+function resetLabelMapper() {
+  labelMapper = mapAsciiLabel;
+}
+function prepareName(input, role = "owner") {
+  const trimmed = input.trim();
+  if (!trimmed) throw new DnsSyntaxError("Name is empty");
+  const bare = trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+  if (!bare) throw new DnsSyntaxError("Name is empty");
+  if (bare === "@") {
+    if (role === "target") throw new DnsSyntaxError("Origin token @ cannot be a record target");
+    return "@";
+  }
+  const labels = bare.split(".");
+  if (labels.some((label) => label.length === 0)) {
+    throw new DnsSyntaxError("Name contains an empty label");
+  }
+  const starLabels = labels.filter((label) => label.includes("*"));
+  if (starLabels.length > 0) {
+    if (role !== "owner") {
+      throw new DnsSyntaxError("A wildcard is only valid as an owner name");
+    }
+    const starCount = starLabels.reduce(
+      (count, label) => count + (label.match(/\*/g)?.length ?? 0),
+      0
+    );
+    if (starCount > 1) throw new DnsSyntaxError("A name can contain only one wildcard");
+    if (labels[0] !== "*") throw new DnsSyntaxError("A wildcard must be its own leftmost label");
+  }
+  const mapped = labels.map((label) => {
+    if (label === "*") return "*";
+    const ascii = labelMapper(label);
+    if (!ascii) throw new DnsSyntaxError(`Label is not a valid DNS label: ${label}`);
+    return ascii.toLowerCase();
+  });
+  const name = mapped.join(".");
+  if (name.length > NAME_LIMIT) throw new DnsSyntaxError("Name is longer than 253 characters");
+  return name;
+}
+function isIpv4(text2) {
+  const octets = text2.split(".");
+  if (octets.length !== 4) return false;
+  return octets.every((octet) => {
+    if (!/^\d{1,3}$/.test(octet)) return false;
+    const value = Number(octet);
+    return value >= 0 && value <= 255 && String(value) === octet;
+  });
+}
+function isIpv6(text2) {
+  let body = text2;
+  const embedded = text2.match(/^(.+):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+  if (embedded) {
+    if (!isIpv4(embedded[2])) return false;
+    body = `${embedded[1]}:0:0`;
+  }
+  const compressedAt = body.indexOf("::");
+  if (compressedAt !== -1) {
+    if (body.indexOf("::", compressedAt + 1) !== -1) return false;
+    const groupsOf = (side) => side === "" ? [] : side.split(":");
+    const head = groupsOf(body.slice(0, compressedAt));
+    const tail = groupsOf(body.slice(compressedAt + 2));
+    if (head.length + tail.length > 7) return false;
+    return [...head, ...tail].every((group) => /^[0-9a-fA-F]{1,4}$/.test(group));
+  }
+  const groups = body.split(":");
+  return groups.length === 8 && groups.every((group) => /^[0-9a-fA-F]{1,4}$/.test(group));
+}
+function utf8OctetCount(text2) {
+  let count = 0;
+  for (const char of text2) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code <= 127) count += 1;
+    else if (code <= 2047) count += 2;
+    else if (code <= 65535) count += 3;
+    else count += 4;
+  }
+  return count;
+}
+function decimalInRange(token, limit) {
+  if (!/^(0|[1-9][0-9]*)$/.test(token)) return null;
+  const value = Number(token);
+  if (value > limit) return null;
+  return value;
+}
+function prepareIpv4(text2) {
+  if (!isIpv4(text2)) throw new DnsSyntaxError("IPv4 address is invalid");
+  return text2;
+}
+function prepareIpv6(text2) {
+  if (!isIpv6(text2)) throw new DnsSyntaxError("IPv6 address is invalid");
+  return text2.toLowerCase();
+}
+function prepareHostTarget(text2, owner, rejectSelf) {
+  const withoutDot = text2.endsWith(".") ? text2.slice(0, -1) : text2;
+  if (isIpv4(withoutDot) || isIpv6(withoutDot)) {
+    throw new DnsSyntaxError("Target must be a domain name, not an address");
+  }
+  const target = prepareName(text2, "target");
+  if (rejectSelf && owner !== void 0 && prepareName(owner, "owner") === target) {
+    throw new DnsSyntaxError("CNAME target is the same name as its owner");
+  }
+  return target;
+}
+function prepareMailExchange(text2) {
+  const parts = text2.split(/\s+/);
+  if (parts.length !== 2) {
+    throw new DnsSyntaxError('MX data must be "<priority> <mail host>"');
+  }
+  const priority = decimalInRange(parts[0], UINT16_MAX);
+  if (priority === null) throw new DnsSyntaxError("MX priority must be an integer from 0 to 65535");
+  return `${priority} ${prepareServiceHost(parts[1])}`;
+}
+function prepareServiceHost(text2) {
+  return text2 === "." ? "." : prepareHostTarget(text2, void 0, false);
+}
+function prepareService(text2) {
+  const parts = text2.split(/\s+/);
+  if (parts.length !== 4) {
+    throw new DnsSyntaxError('SRV data must be "<priority> <weight> <port> <target>"');
+  }
+  const [priority, weight, port] = parts.slice(0, 3).map((part) => decimalInRange(part, UINT16_MAX));
+  if (priority === null)
+    throw new DnsSyntaxError("SRV priority must be an integer from 0 to 65535");
+  if (weight === null) throw new DnsSyntaxError("SRV weight must be an integer from 0 to 65535");
+  if (port === null) throw new DnsSyntaxError("SRV port must be an integer from 0 to 65535");
+  return `${priority} ${weight} ${port} ${prepareServiceHost(parts[3])}`;
+}
+function prepareAuthorization(text2) {
+  const match = /^(\S+)\s+(\S+)\s+([\s\S]+)$/.exec(text2);
+  if (!match) throw new DnsSyntaxError('CAA data must be "<flags> <tag> <value>"');
+  const flags = decimalInRange(match[1], 255);
+  if (flags === null) throw new DnsSyntaxError("CAA flags must be an integer from 0 to 255");
+  if (!/^[a-z0-9]{1,15}$/i.test(match[2])) {
+    throw new DnsSyntaxError("CAA tag must be 1 to 15 letters or digits");
+  }
+  const quoted = /^"((?:[^"\\]|\\.)*)"$/.exec(match[3]);
+  const value = quoted ? quoted[1] : match[3];
+  if (!quoted && value.includes('"')) {
+    throw new DnsSyntaxError("CAA value must be one quoted or unquoted string");
+  }
+  return `${flags} ${match[2].toLowerCase()} "${value}"`;
+}
+function prepareText(text2) {
+  if (utf8OctetCount(text2) > TEXT_TOTAL_OCTETS) {
+    throw new DnsSyntaxError(`TXT data is longer than ${TEXT_TOTAL_OCTETS} octets`);
+  }
+  return text2;
+}
+function readSignerFields(text2) {
+  const parts = text2.trim().split(/\s+/);
+  if (parts.length !== 4)
+    throw new DnsSyntaxError('DS data must be "<key tag> <algorithm> <digest type> <digest>"');
+  const keyTag = decimalInRange(parts[0], UINT16_MAX);
+  const algorithm = decimalInRange(parts[1], 255);
+  const digestType = decimalInRange(parts[2], 255);
+  if (keyTag === null || algorithm === null || digestType === null || !parts[3]) {
+    throw new DnsSyntaxError('DS data must be "<key tag> <algorithm> <digest type> <digest>"');
+  }
+  const digest = parts[3].toLowerCase();
+  if (!/^[0-9a-f]+$/.test(digest)) throw new DnsSyntaxError("DS digest must be hexadecimal");
+  const expectedLength = DIGEST_HEX_LENGTH[digestType];
+  if (expectedLength !== void 0 && digest.length !== expectedLength) {
+    throw new DnsSyntaxError(
+      `DS digest must be ${expectedLength} hex characters for digest type ${digestType}`
+    );
+  }
+  return { keyTag, algorithm, digestType, digest };
+}
+function readDelegationSigner(rdata) {
+  return readSignerFields(rdata);
+}
+function prepareSignerText(text2) {
+  const signer = readSignerFields(text2);
+  return `${signer.keyTag} ${signer.algorithm} ${signer.digestType} ${signer.digest}`;
+}
+function prepareRdata(kind, rdata, owner) {
+  const token = kind.trim().toUpperCase();
+  const text2 = rdata.trim();
+  if (!text2) throw new DnsSyntaxError("Record data is empty");
+  switch (token) {
+    case "A":
+      return prepareIpv4(text2);
+    case "AAAA":
+      return prepareIpv6(text2);
+    case "CNAME":
+      return prepareHostTarget(text2, owner, true);
+    case "NS":
+      return prepareHostTarget(text2, void 0, false);
+    case "MX":
+      return prepareMailExchange(text2);
+    case "TXT":
+      return prepareText(text2);
+    case "SRV":
+      return prepareService(text2);
+    case "CAA":
+      return prepareAuthorization(text2);
+    case "DS":
+      return prepareSignerText(text2);
+    default:
+      return text2;
+  }
+}
+function prepareEntry(entry) {
+  if (!Number.isInteger(entry.ttl) || entry.ttl < 0 || entry.ttl > TTL_LIMIT) {
+    throw new DnsSyntaxError("TTL must be an integer from 0 to 2147483647");
+  }
+  const kind = entry.kind.trim().toUpperCase();
+  if (!kind) throw new DnsSyntaxError("Record type is empty");
+  return {
+    owner: prepareName(entry.owner, "owner"),
+    kind,
+    ttl: entry.ttl,
+    rdata: prepareRdata(kind, entry.rdata, entry.owner)
+  };
+}
+function syntaxClash(entry, error) {
+  const detail = error instanceof Error ? error.message : "Invalid record";
+  return { owner: entry.owner, kind: entry.kind, detail };
+}
+function findCnameConflicts(entries) {
+  const clashes = [];
+  const byOwner = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let owner;
+    let kind;
+    try {
+      owner = prepareName(entry.owner, "owner");
+      kind = entry.kind.trim().toUpperCase();
+      if (!kind) throw new DnsSyntaxError("Record type is empty");
+    } catch (error) {
+      clashes.push(syntaxClash(entry, error));
+      continue;
+    }
+    const group = byOwner.get(owner) ?? [];
+    group.push({ ...entry, owner, kind });
+    byOwner.set(owner, group);
+  }
+  for (const [owner, group] of byOwner) {
+    const aliasCount = group.filter((entry) => entry.kind === "CNAME").length;
+    if (aliasCount === 0) continue;
+    if (aliasCount > 1) {
+      clashes.push({
+        owner,
+        kind: "CNAME",
+        detail: "A name can have only one CNAME target"
+      });
+    }
+    const others = [...new Set(group.map((entry) => entry.kind))].filter(
+      (kind) => !KINDS_ALLOWED_BESIDE_CNAME.has(kind)
+    );
+    if (others.length > 0) {
+      clashes.push({
+        owner,
+        kind: "CNAME",
+        detail: `A CNAME cannot share a name with ${others.join(", ")}`
+      });
+    }
+  }
+  return clashes;
+}
+function findRepeatedRecords(entries) {
+  const clashes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    let prepared;
+    try {
+      prepared = prepareEntry(entry);
+    } catch (error) {
+      clashes.push(syntaxClash(entry, error));
+      continue;
+    }
+    if (prepared.kind === "CNAME") continue;
+    const key = `${prepared.owner}\0${prepared.kind}\0${prepared.rdata}`;
+    if (seen.has(key)) {
+      clashes.push({
+        owner: prepared.owner,
+        kind: prepared.kind,
+        detail: `Repeated ${prepared.kind} data at this name`
+      });
+    }
+    seen.add(key);
+  }
+  return clashes;
+}
+function toDnsEntry(record, defaultTtl = 3600) {
+  const kind = record.type.trim().toUpperCase();
+  const numbers = kind === "MX" ? [record.priority] : kind === "SRV" ? [record.priority, record.weight, record.port] : [];
+  return {
+    owner: record.name,
+    kind,
+    ttl: record.ttl ?? defaultTtl,
+    rdata: [...numbers.map((n) => n === void 0 ? "" : String(n)), record.value.trim()].join(" ")
+  };
+}
+
+export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DnsSyntaxError, Domain101Registrar, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, useLabelMapper, wasNotSent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map